@firebase/firestore 3.4.9-canary.f84cacd70 → 3.4.10

package/dist/index.node.mjs

@@ -8,7 +8,7 @@ import * as grpc from '@grpc/grpc-js';
 import * as protoLoader from '@grpc/proto-loader';
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.9-canary.f84cacd70";
+const version$1 = "3.4.10";
 
 /**
  * @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.8.2-canary.f84cacd70";
+const version = "9.8.3";
 
 /**
  * @license
@@ -768,7 +768,7 @@ function makeAuthCredentialsProvider(credentials) {
 
 /**
  * @license
- * Copyright 2018 Google LLC
+ * Copyright 2020 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -783,32 +783,75 @@ function makeAuthCredentialsProvider(credentials) {
  * limitations under the License.
  */
 /**
- * `ListenSequence` is a monotonic sequence. It is initialized with a minimum value to
- * exceed. All subsequent calls to next will return increasing values. If provided with a
- * `SequenceNumberSyncer`, it will additionally bump its next value when told of a new value, as
- * well as write out sequence numbers that it produces via `next()`.
+ * Generates `nBytes` of random bytes.
+ *
+ * If `nBytes < 0` , an error will be thrown.
  */
-class ListenSequence {
-    constructor(previousValue, sequenceNumberSyncer) {
-        this.previousValue = previousValue;
-        if (sequenceNumberSyncer) {
-            sequenceNumberSyncer.sequenceNumberHandler = sequenceNumber => this.setPreviousValue(sequenceNumber);
-            this.writeNewSequenceNumber = sequenceNumber => sequenceNumberSyncer.writeSequenceNumber(sequenceNumber);
+function randomBytes(nBytes) {
+    return randomBytes$1(nBytes);
+}
+
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class AutoId {
+    static newId() {
+        // Alphanumeric characters
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        // The largest byte value that is a multiple of `char.length`.
+        const maxMultiple = Math.floor(256 / chars.length) * chars.length;
+        let autoId = '';
+        const targetLength = 20;
+        while (autoId.length < targetLength) {
+            const bytes = randomBytes(40);
+            for (let i = 0; i < bytes.length; ++i) {
+                // Only accept values that are [0, maxMultiple), this ensures they can
+                // be evenly mapped to indices of `chars` via a modulo operation.
+                if (autoId.length < targetLength && bytes[i] < maxMultiple) {
+                    autoId += chars.charAt(bytes[i] % chars.length);
+                }
+            }
         }
+        return autoId;
     }
-    setPreviousValue(externalPreviousValue) {
-        this.previousValue = Math.max(externalPreviousValue, this.previousValue);
-        return this.previousValue;
+}
+function primitiveComparator(left, right) {
+    if (left < right) {
+        return -1;
     }
-    next() {
-        const nextValue = ++this.previousValue;
-        if (this.writeNewSequenceNumber) {
-            this.writeNewSequenceNumber(nextValue);
-        }
-        return nextValue;
+    if (left > right) {
+        return 1;
     }
+    return 0;
 }
-ListenSequence.INVALID = -1;
+/** Helper to compare arrays using isEqual(). */
+function arrayEquals(left, right, comparator) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((value, index) => comparator(value, right[index]));
+}
+/**
+ * Returns the immediate lexicographically-following string. This is useful to
+ * construct an inclusive range for indexeddb iterators.
+ */
+function immediateSuccessor(s) {
+    // Return the input string, with an additional NUL byte appended.
+    return s + '\0';
+}
 
 /**
  * @license
@@ -826,75 +869,298 @@ ListenSequence.INVALID = -1;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const DOCUMENT_KEY_NAME = '__name__';
+// The earliest date supported by Firestore timestamps (0001-01-01T00:00:00Z).
+const MIN_SECONDS = -62135596800;
+// Number of nanoseconds in a millisecond.
+const MS_TO_NANOS = 1e6;
 /**
- * Path represents an ordered sequence of string segments.
+ * A `Timestamp` represents a point in time independent of any time zone or
+ * calendar, represented as seconds and fractions of seconds at nanosecond
+ * resolution in UTC Epoch time.
+ *
+ * It is encoded using the Proleptic Gregorian Calendar which extends the
+ * Gregorian calendar backwards to year one. It is encoded assuming all minutes
+ * are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second
+ * table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to
+ * 9999-12-31T23:59:59.999999999Z.
+ *
+ * For examples and further specifications, refer to the
+ * {@link https://github.com/google/protobuf/blob/master/src/google/protobuf/timestamp.proto | Timestamp definition}.
  */
-class BasePath {
-    constructor(segments, offset, length) {
-        if (offset === undefined) {
-            offset = 0;
+class Timestamp {
+    /**
+     * Creates a new timestamp.
+     *
+     * @param seconds - The number of seconds of UTC time since Unix epoch
+     *     1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+     *     9999-12-31T23:59:59Z inclusive.
+     * @param nanoseconds - The non-negative fractions of a second at nanosecond
+     *     resolution. Negative second values with fractions must still have
+     *     non-negative nanoseconds values that count forward in time. Must be
+     *     from 0 to 999,999,999 inclusive.
+     */
+    constructor(
+    /**
+     * The number of seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z.
+     */
+    seconds, 
+    /**
+     * The fractions of a second at nanosecond resolution.*
+     */
+    nanoseconds) {
+        this.seconds = seconds;
+        this.nanoseconds = nanoseconds;
+        if (nanoseconds < 0) {
+            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Timestamp nanoseconds out of range: ' + nanoseconds);
         }
-        else if (offset > segments.length) {
-            fail();
+        if (nanoseconds >= 1e9) {
+            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Timestamp nanoseconds out of range: ' + nanoseconds);
         }
-        if (length === undefined) {
-            length = segments.length - offset;
+        if (seconds < MIN_SECONDS) {
+            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Timestamp seconds out of range: ' + seconds);
         }
-        else if (length > segments.length - offset) {
-            fail();
+        // This will break in the year 10,000.
+        if (seconds >= 253402300800) {
+            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Timestamp seconds out of range: ' + seconds);
         }
-        this.segments = segments;
-        this.offset = offset;
-        this.len = length;
     }
-    get length() {
-        return this.len;
-    }
-    isEqual(other) {
-        return BasePath.comparator(this, other) === 0;
+    /**
+     * Creates a new timestamp with the current date, with millisecond precision.
+     *
+     * @returns a new timestamp representing the current date.
+     */
+    static now() {
+        return Timestamp.fromMillis(Date.now());
     }
-    child(nameOrPath) {
-        const segments = this.segments.slice(this.offset, this.limit());
-        if (nameOrPath instanceof BasePath) {
-            nameOrPath.forEach(segment => {
-                segments.push(segment);
-            });
-        }
-        else {
-            segments.push(nameOrPath);
-        }
-        return this.construct(segments);
+    /**
+     * Creates a new timestamp from the given date.
+     *
+     * @param date - The date to initialize the `Timestamp` from.
+     * @returns A new `Timestamp` representing the same point in time as the given
+     *     date.
+     */
+    static fromDate(date) {
+        return Timestamp.fromMillis(date.getTime());
     }
-    /** The index of one past the last segment of the path. */
-    limit() {
-        return this.offset + this.length;
+    /**
+     * Creates a new timestamp from the given number of milliseconds.
+     *
+     * @param milliseconds - Number of milliseconds since Unix epoch
+     *     1970-01-01T00:00:00Z.
+     * @returns A new `Timestamp` representing the same point in time as the given
+     *     number of milliseconds.
+     */
+    static fromMillis(milliseconds) {
+        const seconds = Math.floor(milliseconds / 1000);
+        const nanos = Math.floor((milliseconds - seconds * 1000) * MS_TO_NANOS);
+        return new Timestamp(seconds, nanos);
     }
-    popFirst(size) {
-        size = size === undefined ? 1 : size;
-        return this.construct(this.segments, this.offset + size, this.length - size);
+    /**
+     * Converts a `Timestamp` to a JavaScript `Date` object. This conversion
+     * causes a loss of precision since `Date` objects only support millisecond
+     * precision.
+     *
+     * @returns JavaScript `Date` object representing the same point in time as
+     *     this `Timestamp`, with millisecond precision.
+     */
+    toDate() {
+        return new Date(this.toMillis());
     }
-    popLast() {
-        return this.construct(this.segments, this.offset, this.length - 1);
+    /**
+     * Converts a `Timestamp` to a numeric timestamp (in milliseconds since
+     * epoch). This operation causes a loss of precision.
+     *
+     * @returns The point in time corresponding to this timestamp, represented as
+     *     the number of milliseconds since Unix epoch 1970-01-01T00:00:00Z.
+     */
+    toMillis() {
+        return this.seconds * 1000 + this.nanoseconds / MS_TO_NANOS;
     }
-    firstSegment() {
-        return this.segments[this.offset];
+    _compareTo(other) {
+        if (this.seconds === other.seconds) {
+            return primitiveComparator(this.nanoseconds, other.nanoseconds);
+        }
+        return primitiveComparator(this.seconds, other.seconds);
     }
-    lastSegment() {
-        return this.get(this.length - 1);
+    /**
+     * Returns true if this `Timestamp` is equal to the provided one.
+     *
+     * @param other - The `Timestamp` to compare against.
+     * @returns true if this `Timestamp` is equal to the provided one.
+     */
+    isEqual(other) {
+        return (other.seconds === this.seconds && other.nanoseconds === this.nanoseconds);
     }
-    get(index) {
-        return this.segments[this.offset + index];
+    /** Returns a textual representation of this `Timestamp`. */
+    toString() {
+        return ('Timestamp(seconds=' +
+            this.seconds +
+            ', nanoseconds=' +
+            this.nanoseconds +
+            ')');
     }
-    isEmpty() {
-        return this.length === 0;
+    /** Returns a JSON-serializable representation of this `Timestamp`. */
+    toJSON() {
+        return { seconds: this.seconds, nanoseconds: this.nanoseconds };
     }
-    isPrefixOf(other) {
-        if (other.length < this.length) {
-            return false;
-        }
-        for (let i = 0; i < this.length; i++) {
-            if (this.get(i) !== other.get(i)) {
+    /**
+     * Converts this object to a primitive string, which allows `Timestamp` objects
+     * to be compared using the `>`, `<=`, `>=` and `>` operators.
+     */
+    valueOf() {
+        // This method returns a string of the form <seconds>.<nanoseconds> where
+        // <seconds> is translated to have a non-negative value and both <seconds>
+        // and <nanoseconds> are left-padded with zeroes to be a consistent length.
+        // Strings with this format then have a lexiographical ordering that matches
+        // the expected ordering. The <seconds> translation is done to avoid having
+        // a leading negative sign (i.e. a leading '-' character) in its string
+        // representation, which would affect its lexiographical ordering.
+        const adjustedSeconds = this.seconds - MIN_SECONDS;
+        // Note: Up to 12 decimal digits are required to represent all valid
+        // 'seconds' values.
+        const formattedSeconds = String(adjustedSeconds).padStart(12, '0');
+        const formattedNanoseconds = String(this.nanoseconds).padStart(9, '0');
+        return formattedSeconds + '.' + formattedNanoseconds;
+    }
+}
+
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * A version of a document in Firestore. This corresponds to the version
+ * timestamp, such as update_time or read_time.
+ */
+class SnapshotVersion {
+    constructor(timestamp) {
+        this.timestamp = timestamp;
+    }
+    static fromTimestamp(value) {
+        return new SnapshotVersion(value);
+    }
+    static min() {
+        return new SnapshotVersion(new Timestamp(0, 0));
+    }
+    static max() {
+        return new SnapshotVersion(new Timestamp(253402300799, 1e9 - 1));
+    }
+    compareTo(other) {
+        return this.timestamp._compareTo(other.timestamp);
+    }
+    isEqual(other) {
+        return this.timestamp.isEqual(other.timestamp);
+    }
+    /** Returns a number representation of the version for use in spec tests. */
+    toMicroseconds() {
+        // Convert to microseconds.
+        return this.timestamp.seconds * 1e6 + this.timestamp.nanoseconds / 1000;
+    }
+    toString() {
+        return 'SnapshotVersion(' + this.timestamp.toString() + ')';
+    }
+    toTimestamp() {
+        return this.timestamp;
+    }
+}
+
+/**
+ * @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.
+ */
+const DOCUMENT_KEY_NAME = '__name__';
+/**
+ * Path represents an ordered sequence of string segments.
+ */
+class BasePath {
+    constructor(segments, offset, length) {
+        if (offset === undefined) {
+            offset = 0;
+        }
+        else if (offset > segments.length) {
+            fail();
+        }
+        if (length === undefined) {
+            length = segments.length - offset;
+        }
+        else if (length > segments.length - offset) {
+            fail();
+        }
+        this.segments = segments;
+        this.offset = offset;
+        this.len = length;
+    }
+    get length() {
+        return this.len;
+    }
+    isEqual(other) {
+        return BasePath.comparator(this, other) === 0;
+    }
+    child(nameOrPath) {
+        const segments = this.segments.slice(this.offset, this.limit());
+        if (nameOrPath instanceof BasePath) {
+            nameOrPath.forEach(segment => {
+                segments.push(segment);
+            });
+        }
+        else {
+            segments.push(nameOrPath);
+        }
+        return this.construct(segments);
+    }
+    /** The index of one past the last segment of the path. */
+    limit() {
+        return this.offset + this.length;
+    }
+    popFirst(size) {
+        size = size === undefined ? 1 : size;
+        return this.construct(this.segments, this.offset + size, this.length - size);
+    }
+    popLast() {
+        return this.construct(this.segments, this.offset, this.length - 1);
+    }
+    firstSegment() {
+        return this.segments[this.offset];
+    }
+    lastSegment() {
+        return this.get(this.length - 1);
+    }
+    get(index) {
+        return this.segments[this.offset + index];
+    }
+    isEmpty() {
+        return this.length === 0;
+    }
+    isPrefixOf(other) {
+        if (other.length < this.length) {
+            return false;
+        }
+        for (let i = 0; i < this.length; i++) {
+            if (this.get(i) !== other.get(i)) {
                 return false;
             }
         }
@@ -1100,109 +1366,64 @@ class FieldPath$1 extends BasePath {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const escapeChar = '\u0001';
-const encodedSeparatorChar = '\u0001';
-const encodedNul = '\u0010';
-const encodedEscape = '\u0011';
 /**
- * Encodes a resource path into a IndexedDb-compatible string form.
+ * @internal
  */
-function encodeResourcePath(path) {
-    let result = '';
-    for (let i = 0; i < path.length; i++) {
-        if (result.length > 0) {
-            result = encodeSeparator(result);
-        }
-        result = encodeSegment(path.get(i), result);
+class DocumentKey {
+    constructor(path) {
+        this.path = path;
     }
-    return encodeSeparator(result);
-}
-/** Encodes a single segment of a resource path into the given result */
-function encodeSegment(segment, resultBuf) {
-    let result = resultBuf;
-    const length = segment.length;
-    for (let i = 0; i < length; i++) {
-        const c = segment.charAt(i);
-        switch (c) {
-            case '\0':
-                result += escapeChar + encodedNul;
-                break;
-            case escapeChar:
-                result += escapeChar + encodedEscape;
-                break;
-            default:
-                result += c;
-        }
+    static fromPath(path) {
+        return new DocumentKey(ResourcePath.fromString(path));
     }
-    return result;
-}
-/** Encodes a path separator into the given result */
-function encodeSeparator(result) {
-    return result + escapeChar + encodedSeparatorChar;
-}
-/**
- * Decodes the given IndexedDb-compatible string form of a resource path into
- * a ResourcePath instance. Note that this method is not suitable for use with
- * decoding resource names from the server; those are One Platform format
- * strings.
- */
-function decodeResourcePath(path) {
-    // Event the empty path must encode as a path of at least length 2. A path
-    // with exactly 2 must be the empty path.
-    const length = path.length;
-    hardAssert(length >= 2);
-    if (length === 2) {
-        hardAssert(path.charAt(0) === escapeChar && path.charAt(1) === encodedSeparatorChar);
-        return ResourcePath.emptyPath();
+    static fromName(name) {
+        return new DocumentKey(ResourcePath.fromString(name).popFirst(5));
     }
-    // Escape characters cannot exist past the second-to-last position in the
-    // source value.
-    const lastReasonableEscapeIndex = length - 2;
-    const segments = [];
-    let segmentBuilder = '';
-    for (let start = 0; start < length;) {
-        // The last two characters of a valid encoded path must be a separator, so
-        // there must be an end to this segment.
-        const end = path.indexOf(escapeChar, start);
-        if (end < 0 || end > lastReasonableEscapeIndex) {
-            fail();
-        }
-        const next = path.charAt(end + 1);
-        switch (next) {
-            case encodedSeparatorChar:
-                const currentPiece = path.substring(start, end);
-                let segment;
-                if (segmentBuilder.length === 0) {
-                    // Avoid copying for the common case of a segment that excludes \0
-                    // and \001
-                    segment = currentPiece;
-                }
-                else {
-                    segmentBuilder += currentPiece;
-                    segment = segmentBuilder;
-                    segmentBuilder = '';
-                }
-                segments.push(segment);
-                break;
-            case encodedNul:
-                segmentBuilder += path.substring(start, end);
-                segmentBuilder += '\0';
-                break;
-            case encodedEscape:
-                // The escape character can be used in the output to encode itself.
-                segmentBuilder += path.substring(start, end + 1);
-                break;
-            default:
-                fail();
-        }
-        start = end + 2;
+    static empty() {
+        return new DocumentKey(ResourcePath.emptyPath());
+    }
+    get collectionGroup() {
+        return this.path.popLast().lastSegment();
+    }
+    /** Returns true if the document is in the specified collectionId. */
+    hasCollectionId(collectionId) {
+        return (this.path.length >= 2 &&
+            this.path.get(this.path.length - 2) === collectionId);
+    }
+    /** Returns the collection group (i.e. the name of the parent collection) for this key. */
+    getCollectionGroup() {
+        return this.path.get(this.path.length - 2);
+    }
+    /** Returns the fully qualified path to the parent collection. */
+    getCollectionPath() {
+        return this.path.popLast();
+    }
+    isEqual(other) {
+        return (other !== null && ResourcePath.comparator(this.path, other.path) === 0);
+    }
+    toString() {
+        return this.path.toString();
+    }
+    static comparator(k1, k2) {
+        return ResourcePath.comparator(k1.path, k2.path);
+    }
+    static isDocumentKey(path) {
+        return path.length % 2 === 0;
+    }
+    /**
+     * Creates and returns a new document key with the given segments.
+     *
+     * @param segments - The segments of the path to the document
+     * @returns A new instance of DocumentKey
+     */
+    static fromSegments(segments) {
+        return new DocumentKey(new ResourcePath(segments.slice()));
     }
-    return new ResourcePath(segments);
 }
 
 /**
  * @license
- * Copyright 2022 Google LLC
+ * Copyright 2021 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -1216,11 +1437,197 @@ function decodeResourcePath(path) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const DbRemoteDocumentStore$1 = 'remoteDocuments';
+/**
+ * The initial mutation batch id for each index. Gets updated during index
+ * backfill.
+ */
+const INITIAL_LARGEST_BATCH_ID = -1;
+/**
+ * The initial sequence number for each index. Gets updated during index
+ * backfill.
+ */
+const INITIAL_SEQUENCE_NUMBER = 0;
+/**
+ * An index definition for field indexes in Firestore.
+ *
+ * Every index is associated with a collection. The definition contains a list
+ * of fields and their index kind (which can be `ASCENDING`, `DESCENDING` or
+ * `CONTAINS` for ArrayContains/ArrayContainsAny queries).
+ *
+ * Unlike the backend, the SDK does not differentiate between collection or
+ * collection group-scoped indices. Every index can be used for both single
+ * collection and collection group queries.
+ */
+class FieldIndex {
+    constructor(
+    /**
+     * The index ID. Returns -1 if the index ID is not available (e.g. the index
+     * has not yet been persisted).
+     */
+    indexId, 
+    /** The collection ID this index applies to. */
+    collectionGroup, 
+    /** The field segments for this index. */
+    fields, 
+    /** Shows how up-to-date the index is for the current user. */
+    indexState) {
+        this.indexId = indexId;
+        this.collectionGroup = collectionGroup;
+        this.fields = fields;
+        this.indexState = indexState;
+    }
+}
+/** An ID for an index that has not yet been added to persistence.  */
+FieldIndex.UNKNOWN_ID = -1;
+/** Returns the ArrayContains/ArrayContainsAny segment for this index. */
+function fieldIndexGetArraySegment(fieldIndex) {
+    return fieldIndex.fields.find(s => s.kind === 2 /* CONTAINS */);
+}
+/** Returns all directional (ascending/descending) segments for this index. */
+function fieldIndexGetDirectionalSegments(fieldIndex) {
+    return fieldIndex.fields.filter(s => s.kind !== 2 /* CONTAINS */);
+}
+/**
+ * Returns the order of the document key component for the given index.
+ *
+ * PORTING NOTE: This is only used in the Web IndexedDb implementation.
+ */
+function fieldIndexGetKeyOrder(fieldIndex) {
+    const directionalSegments = fieldIndexGetDirectionalSegments(fieldIndex);
+    return directionalSegments.length === 0
+        ? 0 /* ASCENDING */
+        : directionalSegments[directionalSegments.length - 1].kind;
+}
+/** Returns a debug representation of the field index */
+function fieldIndexToString(fieldIndex) {
+    return `id=${fieldIndex.indexId}|cg=${fieldIndex.collectionGroup}|f=${fieldIndex.fields.map(f => `${f.fieldPath}:${f.kind}`).join(',')}`;
+}
+/** An index component consisting of field path and index type.  */
+class IndexSegment {
+    constructor(
+    /** The field path of the component. */
+    fieldPath, 
+    /** The fields sorting order. */
+    kind) {
+        this.fieldPath = fieldPath;
+        this.kind = kind;
+    }
+}
+/**
+ * Stores the "high water mark" that indicates how updated the Index is for the
+ * current user.
+ */
+class IndexState {
+    constructor(
+    /**
+     * Indicates when the index was last updated (relative to other indexes).
+     */
+    sequenceNumber, 
+    /** The the latest indexed read time, document and batch id. */
+    offset) {
+        this.sequenceNumber = sequenceNumber;
+        this.offset = offset;
+    }
+    /** The state of an index that has not yet been backfilled. */
+    static empty() {
+        return new IndexState(INITIAL_SEQUENCE_NUMBER, IndexOffset.min());
+    }
+}
+/**
+ * Creates an offset that matches all documents with a read time higher than
+ * `readTime`.
+ */
+function newIndexOffsetSuccessorFromReadTime(readTime, largestBatchId) {
+    // We want to create an offset that matches all documents with a read time
+    // greater than the provided read time. To do so, we technically need to
+    // create an offset for `(readTime, MAX_DOCUMENT_KEY)`. While we could use
+    // Unicode codepoints to generate MAX_DOCUMENT_KEY, it is much easier to use
+    // `(readTime + 1, DocumentKey.empty())` since `> DocumentKey.empty()` matches
+    // all valid document IDs.
+    const successorSeconds = readTime.toTimestamp().seconds;
+    const successorNanos = readTime.toTimestamp().nanoseconds + 1;
+    const successor = SnapshotVersion.fromTimestamp(successorNanos === 1e9
+        ? new Timestamp(successorSeconds + 1, 0)
+        : new Timestamp(successorSeconds, successorNanos));
+    return new IndexOffset(successor, DocumentKey.empty(), largestBatchId);
+}
+/** Creates a new offset based on the provided document. */
+function newIndexOffsetFromDocument(document) {
+    return new IndexOffset(document.readTime, document.key, INITIAL_LARGEST_BATCH_ID);
+}
+/**
+ * Stores the latest read time, document and batch ID that were processed for an
+ * index.
+ */
+class IndexOffset {
+    constructor(
+    /**
+     * The latest read time version that has been indexed by Firestore for this
+     * field index.
+     */
+    readTime, 
+    /**
+     * The key of the last document that was indexed for this query. Use
+     * `DocumentKey.empty()` if no document has been indexed.
+     */
+    documentKey, 
+    /*
+     * The largest mutation batch id that's been processed by Firestore.
+     */
+    largestBatchId) {
+        this.readTime = readTime;
+        this.documentKey = documentKey;
+        this.largestBatchId = largestBatchId;
+    }
+    /** Returns an offset that sorts before all regular offsets. */
+    static min() {
+        return new IndexOffset(SnapshotVersion.min(), DocumentKey.empty(), INITIAL_LARGEST_BATCH_ID);
+    }
+    /** Returns an offset that sorts after all regular offsets. */
+    static max() {
+        return new IndexOffset(SnapshotVersion.max(), DocumentKey.empty(), INITIAL_LARGEST_BATCH_ID);
+    }
+}
+function indexOffsetComparator(left, right) {
+    let cmp = left.readTime.compareTo(right.readTime);
+    if (cmp !== 0) {
+        return cmp;
+    }
+    cmp = DocumentKey.comparator(left.documentKey, right.documentKey);
+    if (cmp !== 0) {
+        return cmp;
+    }
+    return primitiveComparator(left.largestBatchId, right.largestBatchId);
+}
+/**
+ * Schema Version for the Web client:
+ * 1.  Initial version including Mutation Queue, Query Cache, and Remote
+ *     Document Cache
+ * 2.  Used to ensure a targetGlobal object exists and add targetCount to it. No
+ *     longer required because migration 3 unconditionally clears it.
+ * 3.  Dropped and re-created Query Cache to deal with cache corruption related
+ *     to limbo resolution. Addresses
+ *     https://github.com/firebase/firebase-ios-sdk/issues/1548
+ * 4.  Multi-Tab Support.
+ * 5.  Removal of held write acks.
+ * 6.  Create document global for tracking document cache size.
+ * 7.  Ensure every cached document has a sentinel row with a sequence number.
+ * 8.  Add collection-parent index for Collection Group queries.
+ * 9.  Change RemoteDocumentChanges store to be keyed by readTime rather than
+ *     an auto-incrementing ID. This is required for Index-Free queries.
+ * 10. Rewrite the canonical IDs to the explicit Protobuf-based format.
+ * 11. Add bundles and named_queries for bundle support.
+ * 12. Add document overlays.
+ * 13. Rewrite the keys of the remote document cache to allow for efficient
+ *     document lookup via `getAll()`.
+ * 14. Add overlays.
+ * 15. Add indexing support.
+ */
+const SCHEMA_VERSION = 14;
 
 /**
  * @license
- * Copyright 2022 Google LLC
+ * Copyright 2020 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -1234,260 +1641,31 @@ const DbRemoteDocumentStore$1 = 'remoteDocuments';
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+const PRIMARY_LEASE_LOST_ERROR_MSG = 'The current tab is not in the required state to perform this operation. ' +
+    'It might be necessary to refresh the browser tab.';
 /**
- * Name of the IndexedDb object store.
+ * A base class representing a persistence transaction, encapsulating both the
+ * transaction's sequence numbers as well as a list of onCommitted listeners.
  *
- * Note that the name 'owner' is chosen to ensure backwards compatibility with
- * older clients that only supported single locked access to the persistence
- * layer.
- */
-const DbPrimaryClientStore = 'owner';
-/**
- * The key string used for the single object that exists in the
- * DbPrimaryClient store.
+ * When you call Persistence.runTransaction(), it will create a transaction and
+ * pass it to your callback. You then pass it to any method that operates
+ * on persistence.
  */
-const DbPrimaryClientKey = 'owner';
-/** Name of the IndexedDb object store.  */
-const DbMutationQueueStore = 'mutationQueues';
-/** Keys are automatically assigned via the userId property. */
-const DbMutationQueueKeyPath = 'userId';
-/** Name of the IndexedDb object store.  */
-const DbMutationBatchStore = 'mutations';
-/** Keys are automatically assigned via the userId, batchId properties. */
-const DbMutationBatchKeyPath = 'batchId';
-/** The index name for lookup of mutations by user. */
-const DbMutationBatchUserMutationsIndex = 'userMutationsIndex';
-/** The user mutations index is keyed by [userId, batchId] pairs. */
-const DbMutationBatchUserMutationsKeyPath = ['userId', 'batchId'];
-/**
- * Creates a [userId] key for use in the DbDocumentMutations index to iterate
- * over all of a user's document mutations.
- */
-function newDbDocumentMutationPrefixForUser(userId) {
-    return [userId];
-}
-/**
- * Creates a [userId, encodedPath] key for use in the DbDocumentMutations
- * index to iterate over all at document mutations for a given path or lower.
- */
-function newDbDocumentMutationPrefixForPath(userId, path) {
-    return [userId, encodeResourcePath(path)];
-}
-/**
- * Creates a full index key of [userId, encodedPath, batchId] for inserting
- * and deleting into the DbDocumentMutations index.
- */
-function newDbDocumentMutationKey(userId, path, batchId) {
-    return [userId, encodeResourcePath(path), batchId];
-}
-/**
- * Because we store all the useful information for this store in the key,
- * there is no useful information to store as the value. The raw (unencoded)
- * path cannot be stored because IndexedDb doesn't store prototype
- * information.
- */
-const DbDocumentMutationPlaceholder = {};
-const DbDocumentMutationStore = 'documentMutations';
-const DbRemoteDocumentStore = 'remoteDocumentsV14';
-/**
- * The primary key of the remote documents store, which allows for efficient
- * access by collection path and read time.
- */
-const DbRemoteDocumentKeyPath = [
-    'prefixPath',
-    'collectionGroup',
-    'readTime',
-    'documentId'
-];
-/** An index that provides access to documents by key. */
-const DbRemoteDocumentDocumentKeyIndex = 'documentKeyIndex';
-const DbRemoteDocumentDocumentKeyIndexPath = [
-    'prefixPath',
-    'collectionGroup',
-    'documentId'
-];
-/**
- * An index that provides access to documents by collection group and read
- * time.
- *
- * This index is used by the index backfiller.
- */
-const DbRemoteDocumentCollectionGroupIndex = 'collectionGroupIndex';
-const DbRemoteDocumentCollectionGroupIndexPath = [
-    'collectionGroup',
-    'readTime',
-    'prefixPath',
-    'documentId'
-];
-const DbRemoteDocumentGlobalStore = 'remoteDocumentGlobal';
-const DbRemoteDocumentGlobalKey = 'remoteDocumentGlobalKey';
-const DbTargetStore = 'targets';
-/** Keys are automatically assigned via the targetId property. */
-const DbTargetKeyPath = 'targetId';
-/** The name of the queryTargets index. */
-const DbTargetQueryTargetsIndexName = 'queryTargetsIndex';
-/**
- * The index of all canonicalIds to the targets that they match. This is not
- * a unique mapping because canonicalId does not promise a unique name for all
- * possible queries, so we append the targetId to make the mapping unique.
- */
-const DbTargetQueryTargetsKeyPath = ['canonicalId', 'targetId'];
-/** Name of the IndexedDb object store.  */
-const DbTargetDocumentStore = 'targetDocuments';
-/** Keys are automatically assigned via the targetId, path properties. */
-const DbTargetDocumentKeyPath = ['targetId', 'path'];
-/** The index name for the reverse index. */
-const DbTargetDocumentDocumentTargetsIndex = 'documentTargetsIndex';
-/** We also need to create the reverse index for these properties. */
-const DbTargetDocumentDocumentTargetsKeyPath = ['path', 'targetId'];
-/**
- * The key string used for the single object that exists in the
- * DbTargetGlobal store.
- */
-const DbTargetGlobalKey = 'targetGlobalKey';
-const DbTargetGlobalStore = 'targetGlobal';
-/** Name of the IndexedDb object store. */
-const DbCollectionParentStore = 'collectionParents';
-/** Keys are automatically assigned via the collectionId, parent properties. */
-const DbCollectionParentKeyPath = ['collectionId', 'parent'];
-/** Name of the IndexedDb object store. */
-const DbClientMetadataStore = 'clientMetadata';
-/** Keys are automatically assigned via the clientId properties. */
-const DbClientMetadataKeyPath = 'clientId';
-/** Name of the IndexedDb object store. */
-const DbBundleStore = 'bundles';
-const DbBundleKeyPath = 'bundleId';
-/** Name of the IndexedDb object store. */
-const DbNamedQueryStore = 'namedQueries';
-const DbNamedQueryKeyPath = 'name';
-/** Name of the IndexedDb object store. */
-const DbIndexConfigurationStore = 'indexConfiguration';
-const DbIndexConfigurationKeyPath = '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.
- */
-const DbIndexConfigurationCollectionGroupIndex = 'collectionGroupIndex';
-const DbIndexConfigurationCollectionGroupIndexPath = 'collectionGroup';
-/** Name of the IndexedDb object store. */
-const DbIndexStateStore = 'indexState';
-const DbIndexStateKeyPath = ['indexId', 'uid'];
-/**
- * An index that provides access to documents in a collection sorted by last
- * update time. Used by the backfiller.
- *
- * 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.
- */
-const DbIndexStateSequenceNumberIndex = 'sequenceNumberIndex';
-const DbIndexStateSequenceNumberIndexPath = ['uid', 'sequenceNumber'];
-/** Name of the IndexedDb object store. */
-const DbIndexEntryStore = 'indexEntries';
-const DbIndexEntryKeyPath = [
-    'indexId',
-    'uid',
-    'arrayValue',
-    'directionalValue',
-    'orderedDocumentKey',
-    'documentKey'
-];
-const DbIndexEntryDocumentKeyIndex = 'documentKeyIndex';
-const DbIndexEntryDocumentKeyIndexPath = [
-    'indexId',
-    'uid',
-    'orderedDocumentKey'
-];
-/** Name of the IndexedDb object store. */
-const DbDocumentOverlayStore = 'documentOverlays';
-const DbDocumentOverlayKeyPath = [
-    'userId',
-    'collectionPath',
-    'documentId'
-];
-const DbDocumentOverlayCollectionPathOverlayIndex = 'collectionPathOverlayIndex';
-const DbDocumentOverlayCollectionPathOverlayIndexPath = [
-    'userId',
-    'collectionPath',
-    'largestBatchId'
-];
-const DbDocumentOverlayCollectionGroupOverlayIndex = 'collectionGroupOverlayIndex';
-const DbDocumentOverlayCollectionGroupOverlayIndexPath = [
-    'userId',
-    'collectionGroup',
-    'largestBatchId'
-];
-// Visible for testing
-const V1_STORES = [
-    DbMutationQueueStore,
-    DbMutationBatchStore,
-    DbDocumentMutationStore,
-    DbRemoteDocumentStore$1,
-    DbTargetStore,
-    DbPrimaryClientStore,
-    DbTargetGlobalStore,
-    DbTargetDocumentStore
-];
-// Visible for testing
-const V3_STORES = V1_STORES;
-// Note: DbRemoteDocumentChanges is no longer used and dropped with v9.
-const V4_STORES = [...V3_STORES, DbClientMetadataStore];
-const V6_STORES = [...V4_STORES, DbRemoteDocumentGlobalStore];
-const V8_STORES = [...V6_STORES, DbCollectionParentStore];
-const V11_STORES = [...V8_STORES, DbBundleStore, DbNamedQueryStore];
-const V12_STORES = [...V11_STORES, DbDocumentOverlayStore];
-const V13_STORES = [
-    DbMutationQueueStore,
-    DbMutationBatchStore,
-    DbDocumentMutationStore,
-    DbRemoteDocumentStore,
-    DbTargetStore,
-    DbPrimaryClientStore,
-    DbTargetGlobalStore,
-    DbTargetDocumentStore,
-    DbClientMetadataStore,
-    DbRemoteDocumentGlobalStore,
-    DbCollectionParentStore,
-    DbBundleStore,
-    DbNamedQueryStore,
-    DbDocumentOverlayStore
-];
-const V14_STORES = V13_STORES;
-const V15_STORES = [
-    ...V14_STORES,
-    DbIndexConfigurationStore,
-    DbIndexStateStore,
-    DbIndexEntryStore
-];
-/** Returns the object stores for the provided schema. */
-function getObjectStores(schemaVersion) {
-    if (schemaVersion === 15) {
-        return V15_STORES;
-    }
-    else if (schemaVersion === 14) {
-        return V14_STORES;
-    }
-    else if (schemaVersion === 13) {
-        return V13_STORES;
-    }
-    else if (schemaVersion === 12) {
-        return V12_STORES;
+class PersistenceTransaction {
+    constructor() {
+        this.onCommittedListeners = [];
     }
-    else if (schemaVersion === 11) {
-        return V11_STORES;
+    addOnCommittedListener(listener) {
+        this.onCommittedListeners.push(listener);
     }
-    else {
-        fail();
+    raiseOnCommittedEvent() {
+        this.onCommittedListeners.forEach(listener => listener());
     }
 }
 
 /**
  * @license
- * Copyright 2020 Google LLC
+ * 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.
@@ -1501,25 +1679,23 @@ function getObjectStores(schemaVersion) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const PRIMARY_LEASE_LOST_ERROR_MSG = 'The current tab is not in the required state to perform this operation. ' +
-    'It might be necessary to refresh the browser tab.';
 /**
- * A base class representing a persistence transaction, encapsulating both the
- * transaction's sequence numbers as well as a list of onCommitted listeners.
+ * Verifies the error thrown by a LocalStore operation. If a LocalStore
+ * operation fails because the primary lease has been taken by another client,
+ * we ignore the error (the persistence layer will immediately call
+ * `applyPrimaryLease` to propagate the primary state change). All other errors
+ * are re-thrown.
  *
- * When you call Persistence.runTransaction(), it will create a transaction and
- * pass it to your callback. You then pass it to any method that operates
- * on persistence.
+ * @param err - An error returned by a LocalStore operation.
+ * @returns A Promise that resolves after we recovered, or the original error.
  */
-class PersistenceTransaction {
-    constructor() {
-        this.onCommittedListeners = [];
-    }
-    addOnCommittedListener(listener) {
-        this.onCommittedListeners.push(listener);
+async function ignoreIfPrimaryLeaseLoss(err) {
+    if (err.code === Code.FAILED_PRECONDITION &&
+        err.message === PRIMARY_LEASE_LOST_ERROR_MSG) {
+        logDebug('LocalStore', 'Unexpectedly lost primary lease');
     }
-    raiseOnCommittedEvent() {
-        this.onCommittedListeners.forEach(listener => listener());
+    else {
+        throw err;
     }
 }
 
@@ -1704,6 +1880,47 @@ class PersistencePromise {
         });
         return this.waitFor(promises);
     }
+    /**
+     * Concurrently map all array elements through asynchronous function.
+     */
+    static mapArray(array, f) {
+        return new PersistencePromise((resolve, reject) => {
+            const expectedCount = array.length;
+            const results = new Array(expectedCount);
+            let resolvedCount = 0;
+            for (let i = 0; i < expectedCount; i++) {
+                const current = i;
+                f(array[current]).next(result => {
+                    results[current] = result;
+                    ++resolvedCount;
+                    if (resolvedCount === expectedCount) {
+                        resolve(results);
+                    }
+                }, err => reject(err));
+            }
+        });
+    }
+    /**
+     * An alternative to recursive PersistencePromise calls, that avoids
+     * potential memory problems from unbounded chains of promises.
+     *
+     * The `action` will be called repeatedly while `condition` is true.
+     */
+    static doWhile(condition, action) {
+        return new PersistencePromise((resolve, reject) => {
+            const process = () => {
+                if (condition() === true) {
+                    action().next(() => {
+                        process();
+                    }, reject);
+                }
+                else {
+                    resolve();
+                }
+            };
+            process();
+        });
+    }
 }
 
 /**
@@ -1724,7 +1941,7 @@ class PersistencePromise {
  */
 // References to `window` are guarded by SimpleDb.isAvailable()
 /* eslint-disable no-restricted-globals */
-const LOG_TAG$h = 'SimpleDb';
+const LOG_TAG$i = 'SimpleDb';
 /**
  * The maximum number of retry attempts for an IndexedDb transaction that fails
  * with a DOMException.
@@ -1775,7 +1992,7 @@ class SimpleDbTransaction {
             this.completionDeferred.reject(error);
         }
         if (!this.aborted) {
-            logDebug(LOG_TAG$h, 'Aborting transaction:', error ? error.message : 'Client-initiated abort');
+            logDebug(LOG_TAG$i, 'Aborting transaction:', error ? error.message : 'Client-initiated abort');
             this.aborted = true;
             this.transaction.abort();
         }
@@ -1838,7 +2055,7 @@ class SimpleDb {
     }
     /** Deletes the specified database. */
     static delete(name) {
-        logDebug(LOG_TAG$h, 'Removing database:', name);
+        logDebug(LOG_TAG$i, 'Removing database:', name);
         return wrapRequest(window.indexedDB.deleteDatabase(name)).toPromise();
     }
     /** Returns true if IndexedDB is available in the current environment. */
@@ -1917,7 +2134,7 @@ class SimpleDb {
      */
     async ensureDb(action) {
         if (!this.db) {
-            logDebug(LOG_TAG$h, 'Opening database:', this.name);
+            logDebug(LOG_TAG$i, 'Opening database:', this.name);
             this.db = await new Promise((resolve, reject) => {
                 // TODO(mikelehen): Investigate browser compatibility.
                 // https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB
@@ -1953,12 +2170,12 @@ class SimpleDb {
                     }
                 };
                 request.onupgradeneeded = (event) => {
-                    logDebug(LOG_TAG$h, 'Database "' + this.name + '" requires upgrade from version:', event.oldVersion);
+                    logDebug(LOG_TAG$i, 'Database "' + this.name + '" requires upgrade from version:', event.oldVersion);
                     const db = event.target.result;
                     this.schemaConverter
                         .createOrUpgrade(db, request.transaction, event.oldVersion, this.version)
                         .next(() => {
-                        logDebug(LOG_TAG$h, 'Database upgrade to version ' + this.version + ' complete');
+                        logDebug(LOG_TAG$i, 'Database upgrade to version ' + this.version + ' complete');
                     });
                 };
             });
@@ -2016,7 +2233,7 @@ class SimpleDb {
                 // exception is wrapped in a generic error by our async/await handling.
                 const retryable = error.name !== 'FirebaseError' &&
                     attemptNumber < TRANSACTION_RETRY_COUNT;
-                logDebug(LOG_TAG$h, 'Transaction failed with error:', error.message, 'Retrying:', retryable);
+                logDebug(LOG_TAG$i, 'Transaction failed with error:', error.message, 'Retrying:', retryable);
                 this.close();
                 if (!retryable) {
                     return Promise.reject(error);
@@ -2103,11 +2320,11 @@ class SimpleDbStore {
     put(keyOrValue, value) {
         let request;
         if (value !== undefined) {
-            logDebug(LOG_TAG$h, 'PUT', this.store.name, keyOrValue, value);
+            logDebug(LOG_TAG$i, 'PUT', this.store.name, keyOrValue, value);
             request = this.store.put(value, keyOrValue);
         }
         else {
-            logDebug(LOG_TAG$h, 'PUT', this.store.name, '<auto-key>', keyOrValue);
+            logDebug(LOG_TAG$i, 'PUT', this.store.name, '<auto-key>', keyOrValue);
             request = this.store.put(keyOrValue);
         }
         return wrapRequest(request);
@@ -2120,7 +2337,7 @@ class SimpleDbStore {
      * @returns The key of the value to add.
      */
     add(value) {
-        logDebug(LOG_TAG$h, 'ADD', this.store.name, value, value);
+        logDebug(LOG_TAG$i, 'ADD', this.store.name, value, value);
         const request = this.store.add(value);
         return wrapRequest(request);
     }
@@ -2140,12 +2357,12 @@ class SimpleDbStore {
             if (result === undefined) {
                 result = null;
             }
-            logDebug(LOG_TAG$h, 'GET', this.store.name, key, result);
+            logDebug(LOG_TAG$i, 'GET', this.store.name, key, result);
             return result;
         });
     }
     delete(key) {
-        logDebug(LOG_TAG$h, 'DELETE', this.store.name, key);
+        logDebug(LOG_TAG$i, 'DELETE', this.store.name, key);
         const request = this.store.delete(key);
         return wrapRequest(request);
     }
@@ -2156,7 +2373,7 @@ class SimpleDbStore {
      * Returns the number of rows in the store.
      */
     count() {
-        logDebug(LOG_TAG$h, 'COUNT', this.store.name);
+        logDebug(LOG_TAG$i, 'COUNT', this.store.name);
         const request = this.store.count();
         return wrapRequest(request);
     }
@@ -2201,7 +2418,7 @@ class SimpleDbStore {
         });
     }
     deleteAll(indexOrRange, range) {
-        logDebug(LOG_TAG$h, 'DELETE ALL', this.store.name);
+        logDebug(LOG_TAG$i, 'DELETE ALL', this.store.name);
         const options = this.options(indexOrRange, range);
         options.keysOnly = false;
         const cursor = this.cursor(options);
@@ -2364,37 +2581,126 @@ function checkForAndReportiOSError(error) {
     return error;
 }
 
-/**
- * @license
- * Copyright 2020 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class IndexedDbTransaction extends PersistenceTransaction {
-    constructor(simpleDbTransaction, currentSequenceNumber) {
-        super();
-        this.simpleDbTransaction = simpleDbTransaction;
-        this.currentSequenceNumber = currentSequenceNumber;
+const LOG_TAG$h = 'IndexBackiller';
+/** Minimum amount of time between backfill checks, after the first one. */
+const REGULAR_BACKFILL_DELAY_MS = 1;
+/** The maximum number of documents to process each time backfill() is called. */
+const MAX_DOCUMENTS_TO_PROCESS = 50;
+/** This class is responsible for the scheduling of Index Backfiller. */
+class IndexBackfillerScheduler {
+    constructor(asyncQueue, backfiller) {
+        this.asyncQueue = asyncQueue;
+        this.backfiller = backfiller;
+        this.task = null;
+    }
+    start() {
+    }
+    stop() {
+        if (this.task) {
+            this.task.cancel();
+            this.task = null;
+        }
+    }
+    get started() {
+        return this.task !== null;
+    }
+    schedule(delay) {
+        logDebug(LOG_TAG$h, `Scheduled in ${delay}ms`);
+        this.task = this.asyncQueue.enqueueAfterDelay("index_backfill" /* IndexBackfill */, delay, async () => {
+            this.task = null;
+            try {
+                const documentsProcessed = await this.backfiller.backfill();
+                logDebug(LOG_TAG$h, `Documents written: ${documentsProcessed}`);
+            }
+            catch (e) {
+                if (isIndexedDbTransactionError(e)) {
+                    logDebug(LOG_TAG$h, 'Ignoring IndexedDB error during index backfill: ', e);
+                }
+                else {
+                    await ignoreIfPrimaryLeaseLoss(e);
+                }
+            }
+            await this.schedule(REGULAR_BACKFILL_DELAY_MS);
+        });
     }
 }
-function getStore(txn, store) {
-    const indexedDbTransaction = debugCast(txn);
-    return SimpleDb.getStore(indexedDbTransaction.simpleDbTransaction, store);
+/** Implements the steps for backfilling indexes. */
+class IndexBackfiller {
+    constructor(
+    /**
+     * LocalStore provides access to IndexManager and LocalDocumentView.
+     * These properties will update when the user changes. Consequently,
+     * making a local copy of IndexManager and LocalDocumentView will require
+     * updates over time. The simpler solution is to rely on LocalStore to have
+     * an up-to-date references to IndexManager and LocalDocumentStore.
+     */
+    localStore, persistence) {
+        this.localStore = localStore;
+        this.persistence = persistence;
+    }
+    async backfill(maxDocumentsToProcess = MAX_DOCUMENTS_TO_PROCESS) {
+        return this.persistence.runTransaction('Backfill Indexes', 'readwrite-primary', txn => this.writeIndexEntries(txn, maxDocumentsToProcess));
+    }
+    /** Writes index entries until the cap is reached. Returns the number of documents processed. */
+    writeIndexEntries(transation, maxDocumentsToProcess) {
+        const processedCollectionGroups = new Set();
+        let documentsRemaining = maxDocumentsToProcess;
+        let continueLoop = true;
+        return PersistencePromise.doWhile(() => continueLoop === true && documentsRemaining > 0, () => {
+            return this.localStore.indexManager
+                .getNextCollectionGroupToUpdate(transation)
+                .next((collectionGroup) => {
+                if (collectionGroup === null ||
+                    processedCollectionGroups.has(collectionGroup)) {
+                    continueLoop = false;
+                }
+                else {
+                    logDebug(LOG_TAG$h, `Processing collection: ${collectionGroup}`);
+                    return this.writeEntriesForCollectionGroup(transation, collectionGroup, documentsRemaining).next(documentsProcessed => {
+                        documentsRemaining -= documentsProcessed;
+                        processedCollectionGroups.add(collectionGroup);
+                    });
+                }
+            });
+        }).next(() => maxDocumentsToProcess - documentsRemaining);
+    }
+    /**
+     * Writes entries for the provided collection group. Returns the number of documents processed.
+     */
+    writeEntriesForCollectionGroup(transaction, collectionGroup, documentsRemainingUnderCap) {
+        // Use the earliest offset of all field indexes to query the local cache.
+        return this.localStore.indexManager
+            .getMinOffsetFromCollectionGroup(transaction, collectionGroup)
+            .next(existingOffset => this.localStore.localDocuments
+            .getNextDocuments(transaction, collectionGroup, existingOffset, documentsRemainingUnderCap)
+            .next(nextBatch => {
+            const docs = nextBatch.changes;
+            return this.localStore.indexManager
+                .updateIndexEntries(transaction, docs)
+                .next(() => this.getNewOffset(existingOffset, nextBatch))
+                .next(newOffset => {
+                logDebug(LOG_TAG$h, `Updating offset: ${newOffset}`);
+                return this.localStore.indexManager.updateCollectionGroup(transaction, collectionGroup, newOffset);
+            })
+                .next(() => docs.size);
+        }));
+    }
+    /** Returns the next offset based on the provided documents. */
+    getNewOffset(existingOffset, lookupResult) {
+        let maxOffset = existingOffset;
+        lookupResult.changes.forEach((key, document) => {
+            const newOffset = newIndexOffsetFromDocument(document);
+            if (indexOffsetComparator(newOffset, maxOffset) > 0) {
+                maxOffset = newOffset;
+            }
+        });
+        return new IndexOffset(maxOffset.readTime, maxOffset.documentKey, Math.max(lookupResult.batchId, existingOffset.largestBatchId));
+    }
 }
 
 /**
  * @license
- * Copyright 2020 Google LLC
+ * Copyright 2018 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -2409,13 +2715,32 @@ function getStore(txn, store) {
  * limitations under the License.
  */
 /**
- * Generates `nBytes` of random bytes.
- *
- * If `nBytes < 0` , an error will be thrown.
+ * `ListenSequence` is a monotonic sequence. It is initialized with a minimum value to
+ * exceed. All subsequent calls to next will return increasing values. If provided with a
+ * `SequenceNumberSyncer`, it will additionally bump its next value when told of a new value, as
+ * well as write out sequence numbers that it produces via `next()`.
  */
-function randomBytes(nBytes) {
-    return randomBytes$1(nBytes);
-}
+class ListenSequence {
+    constructor(previousValue, sequenceNumberSyncer) {
+        this.previousValue = previousValue;
+        if (sequenceNumberSyncer) {
+            sequenceNumberSyncer.sequenceNumberHandler = sequenceNumber => this.setPreviousValue(sequenceNumber);
+            this.writeNewSequenceNumber = sequenceNumber => sequenceNumberSyncer.writeSequenceNumber(sequenceNumber);
+        }
+    }
+    setPreviousValue(externalPreviousValue) {
+        this.previousValue = Math.max(externalPreviousValue, this.previousValue);
+        return this.previousValue;
+    }
+    next() {
+        const nextValue = ++this.previousValue;
+        if (this.writeNewSequenceNumber) {
+            this.writeNewSequenceNumber(nextValue);
+        }
+        return nextValue;
+    }
+}
+ListenSequence.INVALID = -1;
 
 /**
  * @license
@@ -2433,55 +2758,109 @@ function randomBytes(nBytes) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class AutoId {
-    static newId() {
-        // Alphanumeric characters
-        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-        // The largest byte value that is a multiple of `char.length`.
-        const maxMultiple = Math.floor(256 / chars.length) * chars.length;
-        let autoId = '';
-        const targetLength = 20;
-        while (autoId.length < targetLength) {
-            const bytes = randomBytes(40);
-            for (let i = 0; i < bytes.length; ++i) {
-                // Only accept values that are [0, maxMultiple), this ensures they can
-                // be evenly mapped to indices of `chars` via a modulo operation.
-                if (autoId.length < targetLength && bytes[i] < maxMultiple) {
-                    autoId += chars.charAt(bytes[i] % chars.length);
-                }
-            }
+const escapeChar = '\u0001';
+const encodedSeparatorChar = '\u0001';
+const encodedNul = '\u0010';
+const encodedEscape = '\u0011';
+/**
+ * Encodes a resource path into a IndexedDb-compatible string form.
+ */
+function encodeResourcePath(path) {
+    let result = '';
+    for (let i = 0; i < path.length; i++) {
+        if (result.length > 0) {
+            result = encodeSeparator(result);
         }
-        return autoId;
+        result = encodeSegment(path.get(i), result);
     }
+    return encodeSeparator(result);
 }
-function primitiveComparator(left, right) {
-    if (left < right) {
-        return -1;
-    }
-    if (left > right) {
-        return 1;
+/** Encodes a single segment of a resource path into the given result */
+function encodeSegment(segment, resultBuf) {
+    let result = resultBuf;
+    const length = segment.length;
+    for (let i = 0; i < length; i++) {
+        const c = segment.charAt(i);
+        switch (c) {
+            case '\0':
+                result += escapeChar + encodedNul;
+                break;
+            case escapeChar:
+                result += escapeChar + encodedEscape;
+                break;
+            default:
+                result += c;
+        }
     }
-    return 0;
+    return result;
 }
-/** Helper to compare arrays using isEqual(). */
-function arrayEquals(left, right, comparator) {
-    if (left.length !== right.length) {
-        return false;
-    }
-    return left.every((value, index) => comparator(value, right[index]));
+/** Encodes a path separator into the given result */
+function encodeSeparator(result) {
+    return result + escapeChar + encodedSeparatorChar;
 }
 /**
- * Returns the immediate lexicographically-following string. This is useful to
- * construct an inclusive range for indexeddb iterators.
+ * Decodes the given IndexedDb-compatible string form of a resource path into
+ * a ResourcePath instance. Note that this method is not suitable for use with
+ * decoding resource names from the server; those are One Platform format
+ * strings.
  */
-function immediateSuccessor(s) {
-    // Return the input string, with an additional NUL byte appended.
-    return s + '\0';
+function decodeResourcePath(path) {
+    // Event the empty path must encode as a path of at least length 2. A path
+    // with exactly 2 must be the empty path.
+    const length = path.length;
+    hardAssert(length >= 2);
+    if (length === 2) {
+        hardAssert(path.charAt(0) === escapeChar && path.charAt(1) === encodedSeparatorChar);
+        return ResourcePath.emptyPath();
+    }
+    // Escape characters cannot exist past the second-to-last position in the
+    // source value.
+    const lastReasonableEscapeIndex = length - 2;
+    const segments = [];
+    let segmentBuilder = '';
+    for (let start = 0; start < length;) {
+        // The last two characters of a valid encoded path must be a separator, so
+        // there must be an end to this segment.
+        const end = path.indexOf(escapeChar, start);
+        if (end < 0 || end > lastReasonableEscapeIndex) {
+            fail();
+        }
+        const next = path.charAt(end + 1);
+        switch (next) {
+            case encodedSeparatorChar:
+                const currentPiece = path.substring(start, end);
+                let segment;
+                if (segmentBuilder.length === 0) {
+                    // Avoid copying for the common case of a segment that excludes \0
+                    // and \001
+                    segment = currentPiece;
+                }
+                else {
+                    segmentBuilder += currentPiece;
+                    segment = segmentBuilder;
+                    segmentBuilder = '';
+                }
+                segments.push(segment);
+                break;
+            case encodedNul:
+                segmentBuilder += path.substring(start, end);
+                segmentBuilder += '\0';
+                break;
+            case encodedEscape:
+                // The escape character can be used in the output to encode itself.
+                segmentBuilder += path.substring(start, end + 1);
+                break;
+            default:
+                fail();
+        }
+        start = end + 2;
+    }
+    return new ResourcePath(segments);
 }
 
 /**
  * @license
- * Copyright 2017 Google LLC
+ * Copyright 2022 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -2495,164 +2874,278 @@ function immediateSuccessor(s) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-// The earliest date supported by Firestore timestamps (0001-01-01T00:00:00Z).
-const MIN_SECONDS = -62135596800;
-// Number of nanoseconds in a millisecond.
-const MS_TO_NANOS = 1e6;
+const DbRemoteDocumentStore$1 = 'remoteDocuments';
+
 /**
- * A `Timestamp` represents a point in time independent of any time zone or
- * calendar, represented as seconds and fractions of seconds at nanosecond
- * resolution in UTC Epoch time.
+ * @license
+ * Copyright 2022 Google LLC
  *
- * It is encoded using the Proleptic Gregorian Calendar which extends the
- * Gregorian calendar backwards to year one. It is encoded assuming all minutes
- * are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second
- * table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to
- * 9999-12-31T23:59:59.999999999Z.
+ * 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
  *
- * For examples and further specifications, refer to the
- * {@link https://github.com/google/protobuf/blob/master/src/google/protobuf/timestamp.proto | Timestamp definition}.
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
-class Timestamp {
-    /**
-     * Creates a new timestamp.
-     *
-     * @param seconds - The number of seconds of UTC time since Unix epoch
-     *     1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
-     *     9999-12-31T23:59:59Z inclusive.
-     * @param nanoseconds - The non-negative fractions of a second at nanosecond
-     *     resolution. Negative second values with fractions must still have
-     *     non-negative nanoseconds values that count forward in time. Must be
-     *     from 0 to 999,999,999 inclusive.
-     */
-    constructor(
-    /**
-     * The number of seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z.
-     */
-    seconds, 
-    /**
-     * The fractions of a second at nanosecond resolution.*
-     */
-    nanoseconds) {
-        this.seconds = seconds;
-        this.nanoseconds = nanoseconds;
-        if (nanoseconds < 0) {
-            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Timestamp nanoseconds out of range: ' + nanoseconds);
-        }
-        if (nanoseconds >= 1e9) {
-            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Timestamp nanoseconds out of range: ' + nanoseconds);
-        }
-        if (seconds < MIN_SECONDS) {
-            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Timestamp seconds out of range: ' + seconds);
-        }
-        // This will break in the year 10,000.
-        if (seconds >= 253402300800) {
-            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Timestamp seconds out of range: ' + seconds);
-        }
-    }
-    /**
-     * Creates a new timestamp with the current date, with millisecond precision.
-     *
-     * @returns a new timestamp representing the current date.
-     */
-    static now() {
-        return Timestamp.fromMillis(Date.now());
-    }
-    /**
-     * Creates a new timestamp from the given date.
-     *
-     * @param date - The date to initialize the `Timestamp` from.
-     * @returns A new `Timestamp` representing the same point in time as the given
-     *     date.
-     */
-    static fromDate(date) {
-        return Timestamp.fromMillis(date.getTime());
-    }
-    /**
-     * Creates a new timestamp from the given number of milliseconds.
-     *
-     * @param milliseconds - Number of milliseconds since Unix epoch
-     *     1970-01-01T00:00:00Z.
-     * @returns A new `Timestamp` representing the same point in time as the given
-     *     number of milliseconds.
-     */
-    static fromMillis(milliseconds) {
-        const seconds = Math.floor(milliseconds / 1000);
-        const nanos = Math.floor((milliseconds - seconds * 1000) * MS_TO_NANOS);
-        return new Timestamp(seconds, nanos);
-    }
-    /**
-     * Converts a `Timestamp` to a JavaScript `Date` object. This conversion
-     * causes a loss of precision since `Date` objects only support millisecond
-     * precision.
-     *
-     * @returns JavaScript `Date` object representing the same point in time as
-     *     this `Timestamp`, with millisecond precision.
-     */
-    toDate() {
-        return new Date(this.toMillis());
-    }
-    /**
-     * Converts a `Timestamp` to a numeric timestamp (in milliseconds since
-     * epoch). This operation causes a loss of precision.
-     *
-     * @returns The point in time corresponding to this timestamp, represented as
-     *     the number of milliseconds since Unix epoch 1970-01-01T00:00:00Z.
-     */
-    toMillis() {
-        return this.seconds * 1000 + this.nanoseconds / MS_TO_NANOS;
+/**
+ * Name of the IndexedDb object store.
+ *
+ * Note that the name 'owner' is chosen to ensure backwards compatibility with
+ * older clients that only supported single locked access to the persistence
+ * layer.
+ */
+const DbPrimaryClientStore = 'owner';
+/**
+ * The key string used for the single object that exists in the
+ * DbPrimaryClient store.
+ */
+const DbPrimaryClientKey = 'owner';
+/** Name of the IndexedDb object store.  */
+const DbMutationQueueStore = 'mutationQueues';
+/** Keys are automatically assigned via the userId property. */
+const DbMutationQueueKeyPath = 'userId';
+/** Name of the IndexedDb object store.  */
+const DbMutationBatchStore = 'mutations';
+/** Keys are automatically assigned via the userId, batchId properties. */
+const DbMutationBatchKeyPath = 'batchId';
+/** The index name for lookup of mutations by user. */
+const DbMutationBatchUserMutationsIndex = 'userMutationsIndex';
+/** The user mutations index is keyed by [userId, batchId] pairs. */
+const DbMutationBatchUserMutationsKeyPath = ['userId', 'batchId'];
+/**
+ * Creates a [userId] key for use in the DbDocumentMutations index to iterate
+ * over all of a user's document mutations.
+ */
+function newDbDocumentMutationPrefixForUser(userId) {
+    return [userId];
+}
+/**
+ * Creates a [userId, encodedPath] key for use in the DbDocumentMutations
+ * index to iterate over all at document mutations for a given path or lower.
+ */
+function newDbDocumentMutationPrefixForPath(userId, path) {
+    return [userId, encodeResourcePath(path)];
+}
+/**
+ * Creates a full index key of [userId, encodedPath, batchId] for inserting
+ * and deleting into the DbDocumentMutations index.
+ */
+function newDbDocumentMutationKey(userId, path, batchId) {
+    return [userId, encodeResourcePath(path), batchId];
+}
+/**
+ * Because we store all the useful information for this store in the key,
+ * there is no useful information to store as the value. The raw (unencoded)
+ * path cannot be stored because IndexedDb doesn't store prototype
+ * information.
+ */
+const DbDocumentMutationPlaceholder = {};
+const DbDocumentMutationStore = 'documentMutations';
+const DbRemoteDocumentStore = 'remoteDocumentsV14';
+/**
+ * The primary key of the remote documents store, which allows for efficient
+ * access by collection path and read time.
+ */
+const DbRemoteDocumentKeyPath = [
+    'prefixPath',
+    'collectionGroup',
+    'readTime',
+    'documentId'
+];
+/** An index that provides access to documents by key. */
+const DbRemoteDocumentDocumentKeyIndex = 'documentKeyIndex';
+const DbRemoteDocumentDocumentKeyIndexPath = [
+    'prefixPath',
+    'collectionGroup',
+    'documentId'
+];
+/**
+ * An index that provides access to documents by collection group and read
+ * time.
+ *
+ * This index is used by the index backfiller.
+ */
+const DbRemoteDocumentCollectionGroupIndex = 'collectionGroupIndex';
+const DbRemoteDocumentCollectionGroupIndexPath = [
+    'collectionGroup',
+    'readTime',
+    'prefixPath',
+    'documentId'
+];
+const DbRemoteDocumentGlobalStore = 'remoteDocumentGlobal';
+const DbRemoteDocumentGlobalKey = 'remoteDocumentGlobalKey';
+const DbTargetStore = 'targets';
+/** Keys are automatically assigned via the targetId property. */
+const DbTargetKeyPath = 'targetId';
+/** The name of the queryTargets index. */
+const DbTargetQueryTargetsIndexName = 'queryTargetsIndex';
+/**
+ * The index of all canonicalIds to the targets that they match. This is not
+ * a unique mapping because canonicalId does not promise a unique name for all
+ * possible queries, so we append the targetId to make the mapping unique.
+ */
+const DbTargetQueryTargetsKeyPath = ['canonicalId', 'targetId'];
+/** Name of the IndexedDb object store.  */
+const DbTargetDocumentStore = 'targetDocuments';
+/** Keys are automatically assigned via the targetId, path properties. */
+const DbTargetDocumentKeyPath = ['targetId', 'path'];
+/** The index name for the reverse index. */
+const DbTargetDocumentDocumentTargetsIndex = 'documentTargetsIndex';
+/** We also need to create the reverse index for these properties. */
+const DbTargetDocumentDocumentTargetsKeyPath = ['path', 'targetId'];
+/**
+ * The key string used for the single object that exists in the
+ * DbTargetGlobal store.
+ */
+const DbTargetGlobalKey = 'targetGlobalKey';
+const DbTargetGlobalStore = 'targetGlobal';
+/** Name of the IndexedDb object store. */
+const DbCollectionParentStore = 'collectionParents';
+/** Keys are automatically assigned via the collectionId, parent properties. */
+const DbCollectionParentKeyPath = ['collectionId', 'parent'];
+/** Name of the IndexedDb object store. */
+const DbClientMetadataStore = 'clientMetadata';
+/** Keys are automatically assigned via the clientId properties. */
+const DbClientMetadataKeyPath = 'clientId';
+/** Name of the IndexedDb object store. */
+const DbBundleStore = 'bundles';
+const DbBundleKeyPath = 'bundleId';
+/** Name of the IndexedDb object store. */
+const DbNamedQueryStore = 'namedQueries';
+const DbNamedQueryKeyPath = 'name';
+/** Name of the IndexedDb object store. */
+const DbIndexConfigurationStore = 'indexConfiguration';
+const DbIndexConfigurationKeyPath = '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.
+ */
+const DbIndexConfigurationCollectionGroupIndex = 'collectionGroupIndex';
+const DbIndexConfigurationCollectionGroupIndexPath = 'collectionGroup';
+/** Name of the IndexedDb object store. */
+const DbIndexStateStore = 'indexState';
+const DbIndexStateKeyPath = ['indexId', 'uid'];
+/**
+ * An index that provides access to documents in a collection sorted by last
+ * update time. Used by the backfiller.
+ *
+ * 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.
+ */
+const DbIndexStateSequenceNumberIndex = 'sequenceNumberIndex';
+const DbIndexStateSequenceNumberIndexPath = ['uid', 'sequenceNumber'];
+/** Name of the IndexedDb object store. */
+const DbIndexEntryStore = 'indexEntries';
+const DbIndexEntryKeyPath = [
+    'indexId',
+    'uid',
+    'arrayValue',
+    'directionalValue',
+    'orderedDocumentKey',
+    'documentKey'
+];
+const DbIndexEntryDocumentKeyIndex = 'documentKeyIndex';
+const DbIndexEntryDocumentKeyIndexPath = [
+    'indexId',
+    'uid',
+    'orderedDocumentKey'
+];
+/** Name of the IndexedDb object store. */
+const DbDocumentOverlayStore = 'documentOverlays';
+const DbDocumentOverlayKeyPath = [
+    'userId',
+    'collectionPath',
+    'documentId'
+];
+const DbDocumentOverlayCollectionPathOverlayIndex = 'collectionPathOverlayIndex';
+const DbDocumentOverlayCollectionPathOverlayIndexPath = [
+    'userId',
+    'collectionPath',
+    'largestBatchId'
+];
+const DbDocumentOverlayCollectionGroupOverlayIndex = 'collectionGroupOverlayIndex';
+const DbDocumentOverlayCollectionGroupOverlayIndexPath = [
+    'userId',
+    'collectionGroup',
+    'largestBatchId'
+];
+// Visible for testing
+const V1_STORES = [
+    DbMutationQueueStore,
+    DbMutationBatchStore,
+    DbDocumentMutationStore,
+    DbRemoteDocumentStore$1,
+    DbTargetStore,
+    DbPrimaryClientStore,
+    DbTargetGlobalStore,
+    DbTargetDocumentStore
+];
+// Visible for testing
+const V3_STORES = V1_STORES;
+// Note: DbRemoteDocumentChanges is no longer used and dropped with v9.
+const V4_STORES = [...V3_STORES, DbClientMetadataStore];
+const V6_STORES = [...V4_STORES, DbRemoteDocumentGlobalStore];
+const V8_STORES = [...V6_STORES, DbCollectionParentStore];
+const V11_STORES = [...V8_STORES, DbBundleStore, DbNamedQueryStore];
+const V12_STORES = [...V11_STORES, DbDocumentOverlayStore];
+const V13_STORES = [
+    DbMutationQueueStore,
+    DbMutationBatchStore,
+    DbDocumentMutationStore,
+    DbRemoteDocumentStore,
+    DbTargetStore,
+    DbPrimaryClientStore,
+    DbTargetGlobalStore,
+    DbTargetDocumentStore,
+    DbClientMetadataStore,
+    DbRemoteDocumentGlobalStore,
+    DbCollectionParentStore,
+    DbBundleStore,
+    DbNamedQueryStore,
+    DbDocumentOverlayStore
+];
+const V14_STORES = V13_STORES;
+const V15_STORES = [
+    ...V14_STORES,
+    DbIndexConfigurationStore,
+    DbIndexStateStore,
+    DbIndexEntryStore
+];
+/** Returns the object stores for the provided schema. */
+function getObjectStores(schemaVersion) {
+    if (schemaVersion === 15) {
+        return V15_STORES;
     }
-    _compareTo(other) {
-        if (this.seconds === other.seconds) {
-            return primitiveComparator(this.nanoseconds, other.nanoseconds);
-        }
-        return primitiveComparator(this.seconds, other.seconds);
+    else if (schemaVersion === 14) {
+        return V14_STORES;
     }
-    /**
-     * Returns true if this `Timestamp` is equal to the provided one.
-     *
-     * @param other - The `Timestamp` to compare against.
-     * @returns true if this `Timestamp` is equal to the provided one.
-     */
-    isEqual(other) {
-        return (other.seconds === this.seconds && other.nanoseconds === this.nanoseconds);
+    else if (schemaVersion === 13) {
+        return V13_STORES;
     }
-    /** Returns a textual representation of this `Timestamp`. */
-    toString() {
-        return ('Timestamp(seconds=' +
-            this.seconds +
-            ', nanoseconds=' +
-            this.nanoseconds +
-            ')');
+    else if (schemaVersion === 12) {
+        return V12_STORES;
     }
-    /** Returns a JSON-serializable representation of this `Timestamp`. */
-    toJSON() {
-        return { seconds: this.seconds, nanoseconds: this.nanoseconds };
+    else if (schemaVersion === 11) {
+        return V11_STORES;
     }
-    /**
-     * Converts this object to a primitive string, which allows `Timestamp` objects
-     * to be compared using the `>`, `<=`, `>=` and `>` operators.
-     */
-    valueOf() {
-        // This method returns a string of the form <seconds>.<nanoseconds> where
-        // <seconds> is translated to have a non-negative value and both <seconds>
-        // and <nanoseconds> are left-padded with zeroes to be a consistent length.
-        // Strings with this format then have a lexiographical ordering that matches
-        // the expected ordering. The <seconds> translation is done to avoid having
-        // a leading negative sign (i.e. a leading '-' character) in its string
-        // representation, which would affect its lexiographical ordering.
-        const adjustedSeconds = this.seconds - MIN_SECONDS;
-        // Note: Up to 12 decimal digits are required to represent all valid
-        // 'seconds' values.
-        const formattedSeconds = String(adjustedSeconds).padStart(12, '0');
-        const formattedNanoseconds = String(this.nanoseconds).padStart(9, '0');
-        return formattedSeconds + '.' + formattedNanoseconds;
+    else {
+        fail();
     }
 }
 
 /**
  * @license
- * Copyright 2017 Google LLC
+ * Copyright 2020 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -2666,40 +3159,16 @@ class Timestamp {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/**
- * A version of a document in Firestore. This corresponds to the version
- * timestamp, such as update_time or read_time.
- */
-class SnapshotVersion {
-    constructor(timestamp) {
-        this.timestamp = timestamp;
-    }
-    static fromTimestamp(value) {
-        return new SnapshotVersion(value);
-    }
-    static min() {
-        return new SnapshotVersion(new Timestamp(0, 0));
-    }
-    static max() {
-        return new SnapshotVersion(new Timestamp(253402300799, 1e9 - 1));
-    }
-    compareTo(other) {
-        return this.timestamp._compareTo(other.timestamp);
-    }
-    isEqual(other) {
-        return this.timestamp.isEqual(other.timestamp);
-    }
-    /** Returns a number representation of the version for use in spec tests. */
-    toMicroseconds() {
-        // Convert to microseconds.
-        return this.timestamp.seconds * 1e6 + this.timestamp.nanoseconds / 1000;
-    }
-    toString() {
-        return 'SnapshotVersion(' + this.timestamp.toString() + ')';
-    }
-    toTimestamp() {
-        return this.timestamp;
+class IndexedDbTransaction extends PersistenceTransaction {
+    constructor(simpleDbTransaction, currentSequenceNumber) {
+        super();
+        this.simpleDbTransaction = simpleDbTransaction;
+        this.currentSequenceNumber = currentSequenceNumber;
     }
+}
+function getStore(txn, store) {
+    const indexedDbTransaction = debugCast(txn);
+    return SimpleDb.getStore(indexedDbTransaction.simpleDbTransaction, store);
 }
 
 /**
@@ -3868,104 +4337,33 @@ class DatabaseId {
  * 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.
- */
-/** Sentinel value that sorts before any Mutation Batch ID. */
-const BATCHID_UNKNOWN = -1;
-/**
- * Returns whether a variable is either undefined or null.
- */
-function isNullOrUndefined(value) {
-    return value === null || value === undefined;
-}
-/** Returns whether the value represents -0. */
-function isNegativeZero(value) {
-    // Detect if the value is -0.0. Based on polyfill from
-    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
-    return value === 0 && 1 / value === 1 / -0;
-}
-/**
- * Returns whether a value is an integer and in the safe integer range
- * @param value - The value to test for being an integer and in the safe range
- */
-function isSafeInteger(value) {
-    return (typeof value === 'number' &&
-        Number.isInteger(value) &&
-        !isNegativeZero(value) &&
-        value <= Number.MAX_SAFE_INTEGER &&
-        value >= Number.MIN_SAFE_INTEGER);
-}
-
-/**
- * @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.
- */
-/**
- * @internal
- */
-class DocumentKey {
-    constructor(path) {
-        this.path = path;
-    }
-    static fromPath(path) {
-        return new DocumentKey(ResourcePath.fromString(path));
-    }
-    static fromName(name) {
-        return new DocumentKey(ResourcePath.fromString(name).popFirst(5));
-    }
-    static empty() {
-        return new DocumentKey(ResourcePath.emptyPath());
-    }
-    get collectionGroup() {
-        return this.path.popLast().lastSegment();
-    }
-    /** Returns true if the document is in the specified collectionId. */
-    hasCollectionId(collectionId) {
-        return (this.path.length >= 2 &&
-            this.path.get(this.path.length - 2) === collectionId);
-    }
-    /** Returns the collection group (i.e. the name of the parent collection) for this key. */
-    getCollectionGroup() {
-        return this.path.get(this.path.length - 2);
-    }
-    /** Returns the fully qualified path to the parent collection. */
-    getCollectionPath() {
-        return this.path.popLast();
-    }
-    isEqual(other) {
-        return (other !== null && ResourcePath.comparator(this.path, other.path) === 0);
-    }
-    toString() {
-        return this.path.toString();
-    }
-    static comparator(k1, k2) {
-        return ResourcePath.comparator(k1.path, k2.path);
-    }
-    static isDocumentKey(path) {
-        return path.length % 2 === 0;
-    }
-    /**
-     * Creates and returns a new document key with the given segments.
-     *
-     * @param segments - The segments of the path to the document
-     * @returns A new instance of DocumentKey
-     */
-    static fromSegments(segments) {
-        return new DocumentKey(new ResourcePath(segments.slice()));
-    }
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/** Sentinel value that sorts before any Mutation Batch ID. */
+const BATCHID_UNKNOWN = -1;
+/**
+ * Returns whether a variable is either undefined or null.
+ */
+function isNullOrUndefined(value) {
+    return value === null || value === undefined;
+}
+/** Returns whether the value represents -0. */
+function isNegativeZero(value) {
+    // Detect if the value is -0.0. Based on polyfill from
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+    return value === 0 && 1 / value === 1 / -0;
+}
+/**
+ * Returns whether a value is an integer and in the safe integer range
+ * @param value - The value to test for being an integer and in the safe range
+ */
+function isSafeInteger(value) {
+    return (typeof value === 'number' &&
+        Number.isInteger(value) &&
+        !isNegativeZero(value) &&
+        value <= Number.MAX_SAFE_INTEGER &&
+        value >= Number.MIN_SAFE_INTEGER);
 }
 
 /**
@@ -4586,274 +4984,113 @@ class ObjectValue {
     /**
      * Sets the provided fields to the provided values.
      *
-     * @param data - A map of fields to values (or null for deletes).
-     */
-    setAll(data) {
-        let parent = FieldPath$1.emptyPath();
-        let upserts = {};
-        let deletes = [];
-        data.forEach((value, path) => {
-            if (!parent.isImmediateParentOf(path)) {
-                // Insert the accumulated changes at this parent location
-                const fieldsMap = this.getFieldsMap(parent);
-                this.applyChanges(fieldsMap, upserts, deletes);
-                upserts = {};
-                deletes = [];
-                parent = path.popLast();
-            }
-            if (value) {
-                upserts[path.lastSegment()] = deepClone(value);
-            }
-            else {
-                deletes.push(path.lastSegment());
-            }
-        });
-        const fieldsMap = this.getFieldsMap(parent);
-        this.applyChanges(fieldsMap, upserts, deletes);
-    }
-    /**
-     * Removes the field at the specified path. If there is no field at the
-     * specified path, nothing is changed.
-     *
-     * @param path - The field path to remove.
-     */
-    delete(path) {
-        const nestedValue = this.field(path.popLast());
-        if (isMapValue(nestedValue) && nestedValue.mapValue.fields) {
-            delete nestedValue.mapValue.fields[path.lastSegment()];
-        }
-    }
-    isEqual(other) {
-        return valueEquals(this.value, other.value);
-    }
-    /**
-     * Returns the map that contains the leaf element of `path`. If the parent
-     * entry does not yet exist, or if it is not a map, a new map will be created.
-     */
-    getFieldsMap(path) {
-        let current = this.value;
-        if (!current.mapValue.fields) {
-            current.mapValue = { fields: {} };
-        }
-        for (let i = 0; i < path.length; ++i) {
-            let next = current.mapValue.fields[path.get(i)];
-            if (!isMapValue(next) || !next.mapValue.fields) {
-                next = { mapValue: { fields: {} } };
-                current.mapValue.fields[path.get(i)] = next;
-            }
-            current = next;
-        }
-        return current.mapValue.fields;
-    }
-    /**
-     * Modifies `fieldsMap` by adding, replacing or deleting the specified
-     * entries.
-     */
-    applyChanges(fieldsMap, inserts, deletes) {
-        forEach(inserts, (key, val) => (fieldsMap[key] = val));
-        for (const field of deletes) {
-            delete fieldsMap[field];
-        }
-    }
-    clone() {
-        return new ObjectValue(deepClone(this.value));
-    }
-}
-/**
- * Returns a FieldMask built from all fields in a MapValue.
- */
-function extractFieldMask(value) {
-    const fields = [];
-    forEach(value.fields, (key, value) => {
-        const currentPath = new FieldPath$1([key]);
-        if (isMapValue(value)) {
-            const nestedMask = extractFieldMask(value.mapValue);
-            const nestedFields = nestedMask.fields;
-            if (nestedFields.length === 0) {
-                // Preserve the empty map by adding it to the FieldMask.
-                fields.push(currentPath);
-            }
-            else {
-                // For nested and non-empty ObjectValues, add the FieldPath of the
-                // leaf nodes.
-                for (const nestedPath of nestedFields) {
-                    fields.push(currentPath.child(nestedPath));
-                }
-            }
-        }
-        else {
-            // For nested and non-empty ObjectValues, add the FieldPath of the leaf
-            // nodes.
-            fields.push(currentPath);
-        }
-    });
-    return new FieldMask(fields);
-}
-
-/**
- * @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.
- */
-/**
- * Represents a document in Firestore with a key, version, data and whether it
- * has local mutations applied to it.
- *
- * Documents can transition between states via `convertToFoundDocument()`,
- * `convertToNoDocument()` and `convertToUnknownDocument()`. If a document does
- * not transition to one of these states even after all mutations have been
- * applied, `isValidDocument()` returns false and the document should be removed
- * from all views.
- */
-class MutableDocument {
-    constructor(key, documentType, version, readTime, data, documentState) {
-        this.key = key;
-        this.documentType = documentType;
-        this.version = version;
-        this.readTime = readTime;
-        this.data = data;
-        this.documentState = documentState;
-    }
-    /**
-     * Creates a document with no known version or data, but which can serve as
-     * base document for mutations.
-     */
-    static newInvalidDocument(documentKey) {
-        return new MutableDocument(documentKey, 0 /* INVALID */, SnapshotVersion.min(), SnapshotVersion.min(), ObjectValue.empty(), 0 /* SYNCED */);
-    }
-    /**
-     * Creates a new document that is known to exist with the given data at the
-     * given version.
-     */
-    static newFoundDocument(documentKey, version, value) {
-        return new MutableDocument(documentKey, 1 /* FOUND_DOCUMENT */, version, SnapshotVersion.min(), value, 0 /* SYNCED */);
-    }
-    /** Creates a new document that is known to not exist at the given version. */
-    static newNoDocument(documentKey, version) {
-        return new MutableDocument(documentKey, 2 /* NO_DOCUMENT */, version, SnapshotVersion.min(), ObjectValue.empty(), 0 /* SYNCED */);
-    }
-    /**
-     * Creates a new document that is known to exist at the given version but
-     * whose data is not known (e.g. a document that was updated without a known
-     * base document).
-     */
-    static newUnknownDocument(documentKey, version) {
-        return new MutableDocument(documentKey, 3 /* UNKNOWN_DOCUMENT */, version, SnapshotVersion.min(), ObjectValue.empty(), 2 /* HAS_COMMITTED_MUTATIONS */);
-    }
-    /**
-     * Changes the document type to indicate that it exists and that its version
-     * and data are known.
-     */
-    convertToFoundDocument(version, value) {
-        this.version = version;
-        this.documentType = 1 /* FOUND_DOCUMENT */;
-        this.data = value;
-        this.documentState = 0 /* SYNCED */;
-        return this;
-    }
-    /**
-     * Changes the document type to indicate that it doesn't exist at the given
-     * version.
-     */
-    convertToNoDocument(version) {
-        this.version = version;
-        this.documentType = 2 /* NO_DOCUMENT */;
-        this.data = ObjectValue.empty();
-        this.documentState = 0 /* SYNCED */;
-        return this;
-    }
-    /**
-     * Changes the document type to indicate that it exists at a given version but
-     * that its data is not known (e.g. a document that was updated without a known
-     * base document).
-     */
-    convertToUnknownDocument(version) {
-        this.version = version;
-        this.documentType = 3 /* UNKNOWN_DOCUMENT */;
-        this.data = ObjectValue.empty();
-        this.documentState = 2 /* HAS_COMMITTED_MUTATIONS */;
-        return this;
-    }
-    setHasCommittedMutations() {
-        this.documentState = 2 /* HAS_COMMITTED_MUTATIONS */;
-        return this;
-    }
-    setHasLocalMutations() {
-        this.documentState = 1 /* HAS_LOCAL_MUTATIONS */;
-        this.version = SnapshotVersion.min();
-        return this;
-    }
-    setReadTime(readTime) {
-        this.readTime = readTime;
-        return this;
-    }
-    get hasLocalMutations() {
-        return this.documentState === 1 /* HAS_LOCAL_MUTATIONS */;
-    }
-    get hasCommittedMutations() {
-        return this.documentState === 2 /* HAS_COMMITTED_MUTATIONS */;
-    }
-    get hasPendingWrites() {
-        return this.hasLocalMutations || this.hasCommittedMutations;
-    }
-    isValidDocument() {
-        return this.documentType !== 0 /* INVALID */;
-    }
-    isFoundDocument() {
-        return this.documentType === 1 /* FOUND_DOCUMENT */;
-    }
-    isNoDocument() {
-        return this.documentType === 2 /* NO_DOCUMENT */;
+     * @param data - A map of fields to values (or null for deletes).
+     */
+    setAll(data) {
+        let parent = FieldPath$1.emptyPath();
+        let upserts = {};
+        let deletes = [];
+        data.forEach((value, path) => {
+            if (!parent.isImmediateParentOf(path)) {
+                // Insert the accumulated changes at this parent location
+                const fieldsMap = this.getFieldsMap(parent);
+                this.applyChanges(fieldsMap, upserts, deletes);
+                upserts = {};
+                deletes = [];
+                parent = path.popLast();
+            }
+            if (value) {
+                upserts[path.lastSegment()] = deepClone(value);
+            }
+            else {
+                deletes.push(path.lastSegment());
+            }
+        });
+        const fieldsMap = this.getFieldsMap(parent);
+        this.applyChanges(fieldsMap, upserts, deletes);
     }
-    isUnknownDocument() {
-        return this.documentType === 3 /* UNKNOWN_DOCUMENT */;
+    /**
+     * Removes the field at the specified path. If there is no field at the
+     * specified path, nothing is changed.
+     *
+     * @param path - The field path to remove.
+     */
+    delete(path) {
+        const nestedValue = this.field(path.popLast());
+        if (isMapValue(nestedValue) && nestedValue.mapValue.fields) {
+            delete nestedValue.mapValue.fields[path.lastSegment()];
+        }
     }
     isEqual(other) {
-        return (other instanceof MutableDocument &&
-            this.key.isEqual(other.key) &&
-            this.version.isEqual(other.version) &&
-            this.documentType === other.documentType &&
-            this.documentState === other.documentState &&
-            this.data.isEqual(other.data));
+        return valueEquals(this.value, other.value);
     }
-    mutableCopy() {
-        return new MutableDocument(this.key, this.documentType, this.version, this.readTime, this.data.clone(), this.documentState);
+    /**
+     * Returns the map that contains the leaf element of `path`. If the parent
+     * entry does not yet exist, or if it is not a map, a new map will be created.
+     */
+    getFieldsMap(path) {
+        let current = this.value;
+        if (!current.mapValue.fields) {
+            current.mapValue = { fields: {} };
+        }
+        for (let i = 0; i < path.length; ++i) {
+            let next = current.mapValue.fields[path.get(i)];
+            if (!isMapValue(next) || !next.mapValue.fields) {
+                next = { mapValue: { fields: {} } };
+                current.mapValue.fields[path.get(i)] = next;
+            }
+            current = next;
+        }
+        return current.mapValue.fields;
     }
-    toString() {
-        return (`Document(${this.key}, ${this.version}, ${JSON.stringify(this.data.value)}, ` +
-            `{documentType: ${this.documentType}}), ` +
-            `{documentState: ${this.documentState}})`);
+    /**
+     * Modifies `fieldsMap` by adding, replacing or deleting the specified
+     * entries.
+     */
+    applyChanges(fieldsMap, inserts, deletes) {
+        forEach(inserts, (key, val) => (fieldsMap[key] = val));
+        for (const field of deletes) {
+            delete fieldsMap[field];
+        }
+    }
+    clone() {
+        return new ObjectValue(deepClone(this.value));
     }
 }
 /**
- * Compares the value for field `field` in the provided documents. Throws if
- * the field does not exist in both documents.
+ * Returns a FieldMask built from all fields in a MapValue.
  */
-function compareDocumentsByField(field, d1, d2) {
-    const v1 = d1.data.field(field);
-    const v2 = d2.data.field(field);
-    if (v1 !== null && v2 !== null) {
-        return valueCompare(v1, v2);
-    }
-    else {
-        return fail();
-    }
+function extractFieldMask(value) {
+    const fields = [];
+    forEach(value.fields, (key, value) => {
+        const currentPath = new FieldPath$1([key]);
+        if (isMapValue(value)) {
+            const nestedMask = extractFieldMask(value.mapValue);
+            const nestedFields = nestedMask.fields;
+            if (nestedFields.length === 0) {
+                // Preserve the empty map by adding it to the FieldMask.
+                fields.push(currentPath);
+            }
+            else {
+                // For nested and non-empty ObjectValues, add the FieldPath of the
+                // leaf nodes.
+                for (const nestedPath of nestedFields) {
+                    fields.push(currentPath.child(nestedPath));
+                }
+            }
+        }
+        else {
+            // For nested and non-empty ObjectValues, add the FieldPath of the leaf
+            // nodes.
+            fields.push(currentPath);
+        }
+    });
+    return new FieldMask(fields);
 }
 
 /**
  * @license
- * Copyright 2021 Google LLC
+ * 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.
@@ -4868,166 +5105,148 @@ function compareDocumentsByField(field, d1, d2) {
  * limitations under the License.
  */
 /**
- * The initial mutation batch id for each index. Gets updated during index
- * backfill.
- */
-const INITIAL_LARGEST_BATCH_ID = -1;
-/**
- * The initial sequence number for each index. Gets updated during index
- * backfill.
- */
-const INITIAL_SEQUENCE_NUMBER = 0;
-/**
- * An index definition for field indexes in Firestore.
- *
- * Every index is associated with a collection. The definition contains a list
- * of fields and their index kind (which can be `ASCENDING`, `DESCENDING` or
- * `CONTAINS` for ArrayContains/ArrayContainsAny queries).
- *
- * Unlike the backend, the SDK does not differentiate between collection or
- * collection group-scoped indices. Every index can be used for both single
- * collection and collection group queries.
- */
-class FieldIndex {
-    constructor(
-    /**
-     * The index ID. Returns -1 if the index ID is not available (e.g. the index
-     * has not yet been persisted).
-     */
-    indexId, 
-    /** The collection ID this index applies to. */
-    collectionGroup, 
-    /** The field segments for this index. */
-    fields, 
-    /** Shows how up-to-date the index is for the current user. */
-    indexState) {
-        this.indexId = indexId;
-        this.collectionGroup = collectionGroup;
-        this.fields = fields;
-        this.indexState = indexState;
-    }
-}
-/** An ID for an index that has not yet been added to persistence.  */
-FieldIndex.UNKNOWN_ID = -1;
-/** Returns the ArrayContains/ArrayContainsAny segment for this index. */
-function fieldIndexGetArraySegment(fieldIndex) {
-    return fieldIndex.fields.find(s => s.kind === 2 /* CONTAINS */);
-}
-/** Returns all directional (ascending/descending) segments for this index. */
-function fieldIndexGetDirectionalSegments(fieldIndex) {
-    return fieldIndex.fields.filter(s => s.kind !== 2 /* CONTAINS */);
-}
-/**
- * Returns the order of the document key component for the given index.
+ * Represents a document in Firestore with a key, version, data and whether it
+ * has local mutations applied to it.
  *
- * PORTING NOTE: This is only used in the Web IndexedDb implementation.
+ * Documents can transition between states via `convertToFoundDocument()`,
+ * `convertToNoDocument()` and `convertToUnknownDocument()`. If a document does
+ * not transition to one of these states even after all mutations have been
+ * applied, `isValidDocument()` returns false and the document should be removed
+ * from all views.
  */
-function fieldIndexGetKeyOrder(fieldIndex) {
-    const directionalSegments = fieldIndexGetDirectionalSegments(fieldIndex);
-    return directionalSegments.length === 0
-        ? 0 /* ASCENDING */
-        : directionalSegments[directionalSegments.length - 1].kind;
-}
-/** Returns a debug representation of the field index */
-function fieldIndexToString(fieldIndex) {
-    return `id=${fieldIndex.indexId}|cg=${fieldIndex.collectionGroup}|f=${fieldIndex.fields.map(f => `${f.fieldPath}:${f.kind}`).join(',')}`;
-}
-/** An index component consisting of field path and index type.  */
-class IndexSegment {
-    constructor(
-    /** The field path of the component. */
-    fieldPath, 
-    /** The fields sorting order. */
-    kind) {
-        this.fieldPath = fieldPath;
-        this.kind = kind;
+class MutableDocument {
+    constructor(key, documentType, version, readTime, data, documentState) {
+        this.key = key;
+        this.documentType = documentType;
+        this.version = version;
+        this.readTime = readTime;
+        this.data = data;
+        this.documentState = documentState;
     }
-}
-/**
- * Stores the "high water mark" that indicates how updated the Index is for the
- * current user.
- */
-class IndexState {
-    constructor(
     /**
-     * Indicates when the index was last updated (relative to other indexes).
+     * Creates a document with no known version or data, but which can serve as
+     * base document for mutations.
      */
-    sequenceNumber, 
-    /** The the latest indexed read time, document and batch id. */
-    offset) {
-        this.sequenceNumber = sequenceNumber;
-        this.offset = offset;
-    }
-    /** The state of an index that has not yet been backfilled. */
-    static empty() {
-        return new IndexState(INITIAL_SEQUENCE_NUMBER, IndexOffset.min());
+    static newInvalidDocument(documentKey) {
+        return new MutableDocument(documentKey, 0 /* INVALID */, SnapshotVersion.min(), SnapshotVersion.min(), ObjectValue.empty(), 0 /* SYNCED */);
     }
-}
-/**
- * Creates an offset that matches all documents with a read time higher than
- * `readTime`.
- */
-function newIndexOffsetSuccessorFromReadTime(readTime, largestBatchId) {
-    // We want to create an offset that matches all documents with a read time
-    // greater than the provided read time. To do so, we technically need to
-    // create an offset for `(readTime, MAX_DOCUMENT_KEY)`. While we could use
-    // Unicode codepoints to generate MAX_DOCUMENT_KEY, it is much easier to use
-    // `(readTime + 1, DocumentKey.empty())` since `> DocumentKey.empty()` matches
-    // all valid document IDs.
-    const successorSeconds = readTime.toTimestamp().seconds;
-    const successorNanos = readTime.toTimestamp().nanoseconds + 1;
-    const successor = SnapshotVersion.fromTimestamp(successorNanos === 1e9
-        ? new Timestamp(successorSeconds + 1, 0)
-        : new Timestamp(successorSeconds, successorNanos));
-    return new IndexOffset(successor, DocumentKey.empty(), largestBatchId);
-}
-/** Creates a new offset based on the provided document. */
-function newIndexOffsetFromDocument(document) {
-    return new IndexOffset(document.readTime, document.key, INITIAL_LARGEST_BATCH_ID);
-}
-/**
- * Stores the latest read time, document and batch ID that were processed for an
- * index.
- */
-class IndexOffset {
-    constructor(
     /**
-     * The latest read time version that has been indexed by Firestore for this
-     * field index.
+     * Creates a new document that is known to exist with the given data at the
+     * given version.
      */
-    readTime, 
+    static newFoundDocument(documentKey, version, value) {
+        return new MutableDocument(documentKey, 1 /* FOUND_DOCUMENT */, version, SnapshotVersion.min(), value, 0 /* SYNCED */);
+    }
+    /** Creates a new document that is known to not exist at the given version. */
+    static newNoDocument(documentKey, version) {
+        return new MutableDocument(documentKey, 2 /* NO_DOCUMENT */, version, SnapshotVersion.min(), ObjectValue.empty(), 0 /* SYNCED */);
+    }
     /**
-     * The key of the last document that was indexed for this query. Use
-     * `DocumentKey.empty()` if no document has been indexed.
+     * Creates a new document that is known to exist at the given version but
+     * whose data is not known (e.g. a document that was updated without a known
+     * base document).
      */
-    documentKey, 
-    /*
-     * The largest mutation batch id that's been processed by Firestore.
+    static newUnknownDocument(documentKey, version) {
+        return new MutableDocument(documentKey, 3 /* UNKNOWN_DOCUMENT */, version, SnapshotVersion.min(), ObjectValue.empty(), 2 /* HAS_COMMITTED_MUTATIONS */);
+    }
+    /**
+     * Changes the document type to indicate that it exists and that its version
+     * and data are known.
      */
-    largestBatchId) {
+    convertToFoundDocument(version, value) {
+        this.version = version;
+        this.documentType = 1 /* FOUND_DOCUMENT */;
+        this.data = value;
+        this.documentState = 0 /* SYNCED */;
+        return this;
+    }
+    /**
+     * Changes the document type to indicate that it doesn't exist at the given
+     * version.
+     */
+    convertToNoDocument(version) {
+        this.version = version;
+        this.documentType = 2 /* NO_DOCUMENT */;
+        this.data = ObjectValue.empty();
+        this.documentState = 0 /* SYNCED */;
+        return this;
+    }
+    /**
+     * Changes the document type to indicate that it exists at a given version but
+     * that its data is not known (e.g. a document that was updated without a known
+     * base document).
+     */
+    convertToUnknownDocument(version) {
+        this.version = version;
+        this.documentType = 3 /* UNKNOWN_DOCUMENT */;
+        this.data = ObjectValue.empty();
+        this.documentState = 2 /* HAS_COMMITTED_MUTATIONS */;
+        return this;
+    }
+    setHasCommittedMutations() {
+        this.documentState = 2 /* HAS_COMMITTED_MUTATIONS */;
+        return this;
+    }
+    setHasLocalMutations() {
+        this.documentState = 1 /* HAS_LOCAL_MUTATIONS */;
+        this.version = SnapshotVersion.min();
+        return this;
+    }
+    setReadTime(readTime) {
         this.readTime = readTime;
-        this.documentKey = documentKey;
-        this.largestBatchId = largestBatchId;
+        return this;
     }
-    /** Returns an offset that sorts before all regular offsets. */
-    static min() {
-        return new IndexOffset(SnapshotVersion.min(), DocumentKey.empty(), INITIAL_LARGEST_BATCH_ID);
+    get hasLocalMutations() {
+        return this.documentState === 1 /* HAS_LOCAL_MUTATIONS */;
     }
-    /** Returns an offset that sorts after all regular offsets. */
-    static max() {
-        return new IndexOffset(SnapshotVersion.max(), DocumentKey.empty(), INITIAL_LARGEST_BATCH_ID);
+    get hasCommittedMutations() {
+        return this.documentState === 2 /* HAS_COMMITTED_MUTATIONS */;
+    }
+    get hasPendingWrites() {
+        return this.hasLocalMutations || this.hasCommittedMutations;
+    }
+    isValidDocument() {
+        return this.documentType !== 0 /* INVALID */;
+    }
+    isFoundDocument() {
+        return this.documentType === 1 /* FOUND_DOCUMENT */;
+    }
+    isNoDocument() {
+        return this.documentType === 2 /* NO_DOCUMENT */;
+    }
+    isUnknownDocument() {
+        return this.documentType === 3 /* UNKNOWN_DOCUMENT */;
+    }
+    isEqual(other) {
+        return (other instanceof MutableDocument &&
+            this.key.isEqual(other.key) &&
+            this.version.isEqual(other.version) &&
+            this.documentType === other.documentType &&
+            this.documentState === other.documentState &&
+            this.data.isEqual(other.data));
+    }
+    mutableCopy() {
+        return new MutableDocument(this.key, this.documentType, this.version, this.readTime, this.data.clone(), this.documentState);
+    }
+    toString() {
+        return (`Document(${this.key}, ${this.version}, ${JSON.stringify(this.data.value)}, ` +
+            `{documentType: ${this.documentType}}), ` +
+            `{documentState: ${this.documentState}})`);
     }
 }
-function indexOffsetComparator(left, right) {
-    let cmp = left.readTime.compareTo(right.readTime);
-    if (cmp !== 0) {
-        return cmp;
+/**
+ * Compares the value for field `field` in the provided documents. Throws if
+ * the field does not exist in both documents.
+ */
+function compareDocumentsByField(field, d1, d2) {
+    const v1 = d1.data.field(field);
+    const v2 = d2.data.field(field);
+    if (v1 !== null && v2 !== null) {
+        return valueCompare(v1, v2);
     }
-    cmp = DocumentKey.comparator(left.documentKey, right.documentKey);
-    if (cmp !== 0) {
-        return cmp;
+    else {
+        return fail();
     }
-    return primitiveComparator(left.largestBatchId, right.largestBatchId);
 }
 
 /**
@@ -6140,11 +6359,19 @@ function documentMap(...docs) {
     }
     return map;
 }
+function newOverlayedDocumentMap() {
+    return newDocumentKeyMap();
+}
+function convertOverlayedDocumentMapToDocumentMap(collection) {
+    let documents = EMPTY_DOCUMENT_MAP;
+    collection.forEach((k, v) => (documents = documents.insert(k, v.overlayedDocument)));
+    return documents;
+}
 function newOverlayMap() {
-    return new ObjectMap(key => key.toString(), (l, r) => l.isEqual(r));
+    return newDocumentKeyMap();
 }
 function newMutationMap() {
-    return new ObjectMap(key => key.toString(), (l, r) => l.isEqual(r));
+    return newDocumentKeyMap();
 }
 function newDocumentKeyMap() {
     return new ObjectMap(key => key.toString(), (l, r) => l.isEqual(r));
@@ -9245,15 +9472,13 @@ class IndexedDbDocumentOverlayCache {
     }
     getOverlays(transaction, keys) {
         const result = newOverlayMap();
-        const promises = [];
-        keys.forEach(key => {
-            promises.push(this.getOverlay(transaction, key).next(overlay => {
+        return PersistencePromise.forEach(keys, (key) => {
+            return this.getOverlay(transaction, key).next(overlay => {
                 if (overlay !== null) {
                     result.set(key, overlay);
                 }
-            }));
-        });
-        return PersistencePromise.waitFor(promises).next(() => result);
+            });
+        }).next(() => result);
     }
     saveOverlays(transaction, largestBatchId, overlays) {
         const promises = [];
@@ -10141,6 +10366,9 @@ class MemoryIndexManager {
     getMinOffset(transaction, target) {
         return PersistencePromise.resolve(IndexOffset.min());
     }
+    getMinOffsetFromCollectionGroup(transaction, collectionGroup) {
+        return PersistencePromise.resolve(IndexOffset.min());
+    }
     updateCollectionGroup(transaction, collectionGroup, offset) {
         // Field indices are not supported with memory persistence.
         return PersistencePromise.resolve();
@@ -10276,7 +10504,16 @@ class IndexedDbIndexManager {
         const indexes = indexConfigurationStore(transaction);
         const dbIndex = toDbIndexConfiguration(index);
         delete dbIndex.indexId; // `indexId` is auto-populated by IndexedDb
-        return indexes.add(dbIndex).next();
+        const result = indexes.add(dbIndex);
+        if (index.indexState) {
+            const states = indexStateStore(transaction);
+            return result.next(indexId => {
+                states.put(toDbIndexState(indexId, this.user, index.indexState.sequenceNumber, index.indexState.offset));
+            });
+        }
+        else {
+            return result.next();
+        }
     }
     deleteFieldIndex(transaction, index) {
         const indexes = indexConfigurationStore(transaction);
@@ -10713,19 +10950,11 @@ class IndexedDbIndexManager {
         }
         return ranges;
     }
+    getMinOffsetFromCollectionGroup(transaction, collectionGroup) {
+        return this.getFieldIndexes(transaction, collectionGroup).next(getMinOffsetFromFieldIndexes);
+    }
     getMinOffset(transaction, target) {
-        let offset;
-        return PersistencePromise.forEach(this.getSubTargets(target), (target) => {
-            return this.getFieldIndex(transaction, target).next(index => {
-                if (!index) {
-                    offset = IndexOffset.min();
-                }
-                else if (!offset ||
-                    indexOffsetComparator(index.indexState.offset, offset) < 0) {
-                    offset = index.indexState.offset;
-                }
-            });
-        }).next(() => offset);
+        return PersistencePromise.mapArray(this.getSubTargets(target), (subTarget) => this.getFieldIndex(transaction, subTarget).next(index => index ? index : fail())).next(getMinOffsetFromFieldIndexes);
     }
 }
 /**
@@ -10752,6 +10981,21 @@ function indexConfigurationStore(txn) {
  */
 function indexStateStore(txn) {
     return getStore(txn, DbIndexStateStore);
+}
+function getMinOffsetFromFieldIndexes(fieldIndexes) {
+    hardAssert(fieldIndexes.length !== 0);
+    let minOffset = fieldIndexes[0].indexState.offset;
+    let maxBatchId = minOffset.largestBatchId;
+    for (let i = 1; i < fieldIndexes.length; i++) {
+        const newOffset = fieldIndexes[i].indexState.offset;
+        if (indexOffsetComparator(newOffset, minOffset) < 0) {
+            minOffset = newOffset;
+        }
+        if (maxBatchId < newOffset.largestBatchId) {
+            maxBatchId = newOffset.largestBatchId;
+        }
+    }
+    return new IndexOffset(minOffset.readTime, minOffset.documentKey, maxBatchId);
 }
 
 /**
@@ -11538,42 +11782,6 @@ function documentTargetStore(txn) {
     return getStore(txn, DbTargetDocumentStore);
 }
 
-/**
- * @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.
- */
-/**
- * Verifies the error thrown by a LocalStore operation. If a LocalStore
- * operation fails because the primary lease has been taken by another client,
- * we ignore the error (the persistence layer will immediately call
- * `applyPrimaryLease` to propagate the primary state change). All other errors
- * are re-thrown.
- *
- * @param err - An error returned by a LocalStore operation.
- * @returns A Promise that resolves after we recovered, or the original error.
- */
-async function ignoreIfPrimaryLeaseLoss(err) {
-    if (err.code === Code.FAILED_PRECONDITION &&
-        err.message === PRIMARY_LEASE_LOST_ERROR_MSG) {
-        logDebug('LocalStore', 'Unexpectedly lost primary lease');
-    }
-    else {
-        throw err;
-    }
-}
-
 /**
  * @license
  * Copyright 2018 Google LLC
@@ -11695,16 +11903,16 @@ class RollingSequenceNumberBuffer {
  * whether or not GC is enabled, as well as which delay to use before the next run.
  */
 class LruScheduler {
-    constructor(garbageCollector, asyncQueue) {
+    constructor(garbageCollector, asyncQueue, localStore) {
         this.garbageCollector = garbageCollector;
         this.asyncQueue = asyncQueue;
-        this.hasRun = false;
+        this.localStore = localStore;
         this.gcTask = null;
     }
-    start(localStore) {
+    start() {
         if (this.garbageCollector.params.cacheSizeCollectionThreshold !==
             LRU_COLLECTION_DISABLED) {
-            this.scheduleGC(localStore);
+            this.scheduleGC(INITIAL_GC_DELAY_MS);
         }
     }
     stop() {
@@ -11716,14 +11924,12 @@ class LruScheduler {
     get started() {
         return this.gcTask !== null;
     }
-    scheduleGC(localStore) {
-        const delay = this.hasRun ? REGULAR_GC_DELAY_MS : INITIAL_GC_DELAY_MS;
-        logDebug('LruGarbageCollector', `Garbage collection scheduled in ${delay}ms`);
+    scheduleGC(delay) {
+        logDebug(LOG_TAG$e, `Garbage collection scheduled in ${delay}ms`);
         this.gcTask = this.asyncQueue.enqueueAfterDelay("lru_garbage_collection" /* LruGarbageCollection */, delay, async () => {
             this.gcTask = null;
-            this.hasRun = true;
             try {
-                await localStore.collectGarbage(this.garbageCollector);
+                await this.localStore.collectGarbage(this.garbageCollector);
             }
             catch (e) {
                 if (isIndexedDbTransactionError(e)) {
@@ -11733,7 +11939,7 @@ class LruScheduler {
                     await ignoreIfPrimaryLeaseLoss(e);
                 }
             }
-            await this.scheduleGC(localStore);
+            await this.scheduleGC(REGULAR_GC_DELAY_MS);
         });
     }
 }
@@ -12502,31 +12708,6 @@ function dbKeyComparator(l, r) {
     }
     return primitiveComparator(left[left.length - 1], right[right.length - 1]);
 }
-/**
- * Schema Version for the Web client:
- * 1.  Initial version including Mutation Queue, Query Cache, and Remote
- *     Document Cache
- * 2.  Used to ensure a targetGlobal object exists and add targetCount to it. No
- *     longer required because migration 3 unconditionally clears it.
- * 3.  Dropped and re-created Query Cache to deal with cache corruption related
- *     to limbo resolution. Addresses
- *     https://github.com/firebase/firebase-ios-sdk/issues/1548
- * 4.  Multi-Tab Support.
- * 5.  Removal of held write acks.
- * 6.  Create document global for tracking document cache size.
- * 7.  Ensure every cached document has a sentinel row with a sequence number.
- * 8.  Add collection-parent index for Collection Group queries.
- * 9.  Change RemoteDocumentChanges store to be keyed by readTime rather than
- *     an auto-incrementing ID. This is required for Index-Free queries.
- * 10. Rewrite the canonical IDs to the explicit Protobuf-based format.
- * 11. Add bundles and named_queries for bundle support.
- * 12. Add document overlays.
- * 13. Rewrite the keys of the remote document cache to allow for efficient
- *     document lookup via `getAll()`.
- * 14. Add overlays.
- * 15. Add indexing support.
- */
-const SCHEMA_VERSION = 14;
 
 /**
  * @license
@@ -12657,10 +12838,10 @@ class LocalDocumentsView {
      * if the map does not already contain an entry for the given document key.
      */
     populateOverlays(transaction, overlays, docs) {
-        let missingOverlays = documentKeySet();
+        const missingOverlays = [];
         docs.forEach(key => {
             if (!overlays.has(key)) {
-                missingOverlays = missingOverlays.add(key);
+                missingOverlays.push(key);
             }
         });
         return this.documentOverlayCache
@@ -12686,7 +12867,7 @@ class LocalDocumentsView {
     computeViews(transaction, docs, overlays, existenceStateChanged) {
         let recalculateDocuments = mutableDocumentMap();
         const mutatedFields = newDocumentKeyMap();
-        const results = newDocumentKeyMap();
+        const results = newOverlayedDocumentMap();
         docs.forEach((_, doc) => {
             const overlay = overlays.get(doc.key);
             // Recalculate an overlay if the document's existence state changed due to
@@ -12788,6 +12969,55 @@ class LocalDocumentsView {
             return this.getDocumentsMatchingCollectionQuery(transaction, query, offset);
         }
     }
+    /**
+     * Given a collection group, returns the next documents that follow the provided offset, along
+     * with an updated batch ID.
+     *
+     * <p>The documents returned by this method are ordered by remote version from the provided
+     * offset. If there are no more remote documents after the provided offset, documents with
+     * mutations in order of batch id from the offset are returned. Since all documents in a batch are
+     * returned together, the total number of documents returned can exceed {@code count}.
+     *
+     * @param transaction
+     * @param collectionGroup The collection group for the documents.
+     * @param offset The offset to index into.
+     * @param count The number of documents to return
+     * @return A LocalWriteResult with the documents that follow the provided offset and the last processed batch id.
+     */
+    getNextDocuments(transaction, collectionGroup, offset, count) {
+        return this.remoteDocumentCache
+            .getAllFromCollectionGroup(transaction, collectionGroup, offset, count)
+            .next((originalDocs) => {
+            const overlaysPromise = count - originalDocs.size > 0
+                ? this.documentOverlayCache.getOverlaysForCollectionGroup(transaction, collectionGroup, offset.largestBatchId, count - originalDocs.size)
+                : PersistencePromise.resolve(newOverlayMap());
+            // The callsite will use the largest batch ID together with the latest read time to create
+            // a new index offset. Since we only process batch IDs if all remote documents have been read,
+            // no overlay will increase the overall read time. This is why we only need to special case
+            // the batch id.
+            let largestBatchId = INITIAL_LARGEST_BATCH_ID;
+            let modifiedDocs = originalDocs;
+            return overlaysPromise.next(overlays => {
+                return PersistencePromise.forEach(overlays, (key, overlay) => {
+                    if (largestBatchId < overlay.largestBatchId) {
+                        largestBatchId = overlay.largestBatchId;
+                    }
+                    if (originalDocs.get(key)) {
+                        return PersistencePromise.resolve();
+                    }
+                    return this.getBaseDocument(transaction, key, overlay).next(doc => {
+                        modifiedDocs = modifiedDocs.insert(key, doc);
+                    });
+                })
+                    .next(() => this.populateOverlays(transaction, overlays, originalDocs))
+                    .next(() => this.computeViews(transaction, modifiedDocs, overlays, documentKeySet()))
+                    .next(localDocs => ({
+                    batchId: largestBatchId,
+                    changes: convertOverlayedDocumentMapToDocumentMap(localDocs)
+                }));
+            });
+        });
+    }
     getDocumentsMatchingDocumentQuery(transaction, docPath) {
         // Just do a simple document lookup.
         return this.getDocument(transaction, new DocumentKey(docPath)).next(document => {
@@ -12851,7 +13081,7 @@ class LocalDocumentsView {
     }
     /** Returns a base document that can be used to apply `overlay`. */
     getBaseDocument(transaction, key, overlay) {
-        return overlay === null || overlay.mutation instanceof PatchMutation
+        return overlay === null || overlay.mutation.type === 1 /* Patch */
             ? this.remoteDocumentCache.getEntry(transaction, key)
             : PersistencePromise.resolve(MutableDocument.newInvalidDocument(key));
     }
@@ -12926,15 +13156,13 @@ class MemoryDocumentOverlayCache {
     }
     getOverlays(transaction, keys) {
         const result = newOverlayMap();
-        const promises = [];
-        keys.forEach(key => {
-            promises.push(this.getOverlay(transaction, key).next(overlay => {
+        return PersistencePromise.forEach(keys, (key) => {
+            return this.getOverlay(transaction, key).next(overlay => {
                 if (overlay !== null) {
                     result.set(key, overlay);
                 }
-            }));
-        });
-        return PersistencePromise.waitFor(promises).next(() => result);
+            });
+        }).next(() => result);
     }
     saveOverlays(transaction, largestBatchId, overlays) {
         overlays.forEach((_, mutation) => {
@@ -14098,11 +14326,8 @@ class SchemaConverter {
         const mutationsStore = transaction.store(DbMutationBatchStore);
         const remoteDocumentCache = newIndexedDbRemoteDocumentCache(this.serializer);
         const memoryPersistence = new MemoryPersistence(MemoryEagerDelegate.factory, this.serializer.remoteSerializer);
-        const promises = [];
-        const userToDocumentSet = new Map();
-        return mutationsStore
-            .loadAll()
-            .next(dbBatches => {
+        return mutationsStore.loadAll().next(dbBatches => {
+            const userToDocumentSet = new Map();
             dbBatches.forEach(dbBatch => {
                 var _a;
                 let documentSet = (_a = userToDocumentSet.get(dbBatch.userId)) !== null && _a !== void 0 ? _a : documentKeySet();
@@ -14110,9 +14335,7 @@ class SchemaConverter {
                 batch.keys().forEach(key => (documentSet = documentSet.add(key)));
                 userToDocumentSet.set(dbBatch.userId, documentSet);
             });
-        })
-            .next(() => {
-            userToDocumentSet.forEach((allDocumentKeysForUser, userId) => {
+            return PersistencePromise.forEach(userToDocumentSet, (allDocumentKeysForUser, userId) => {
                 const user = new User(userId);
                 const documentOverlayCache = IndexedDbDocumentOverlayCache.forUser(this.serializer, user);
                 // NOTE: The index manager and the reference delegate are
@@ -14122,10 +14345,11 @@ class SchemaConverter {
                 const indexManager = memoryPersistence.getIndexManager(user);
                 const mutationQueue = IndexedDbMutationQueue.forUser(user, this.serializer, indexManager, memoryPersistence.referenceDelegate);
                 const localDocumentsView = new LocalDocumentsView(remoteDocumentCache, mutationQueue, documentOverlayCache, indexManager);
-                promises.push(localDocumentsView.recalculateAndSaveOverlaysForDocumentKeys(new IndexedDbTransaction(transaction, ListenSequence.INVALID), allDocumentKeysForUser));
+                return localDocumentsView
+                    .recalculateAndSaveOverlaysForDocumentKeys(new IndexedDbTransaction(transaction, ListenSequence.INVALID), allDocumentKeysForUser)
+                    .next();
             });
-        })
-            .next(() => PersistencePromise.waitFor(promises));
+        });
     }
 }
 function sentinelKey(path) {
@@ -15190,7 +15414,7 @@ function localStoreWriteLocally(localStore, mutations) {
             // any additional user-provided writes.
             return localStoreImpl.localDocuments.getOverlayedDocuments(txn, remoteDocs);
         })
-            .next(docs => {
+            .next((docs) => {
             overlayedDocuments = docs;
             // For non-idempotent mutations (such as `FieldValue.increment()`),
             // we record the base state in a separate patch mutation. This is
@@ -15215,11 +15439,10 @@ function localStoreWriteLocally(localStore, mutations) {
             return localStoreImpl.documentOverlayCache.saveOverlays(txn, batch.batchId, overlays);
         });
     })
-        .then(() => {
-        let documents = documentMap();
-        overlayedDocuments.forEach((key, val) => (documents = documents.insert(key, val.overlayedDocument)));
-        return { batchId: mutationBatch.batchId, changes: documents };
-    });
+        .then(() => ({
+        batchId: mutationBatch.batchId,
+        changes: convertOverlayedDocumentMapToDocumentMap(overlayedDocuments)
+    }));
 }
 /**
  * Acknowledges the given batch.
@@ -23603,10 +23826,14 @@ class MemoryOfflineComponentProvider {
         this.sharedClientState = this.createSharedClientState(cfg);
         this.persistence = this.createPersistence(cfg);
         await this.persistence.start();
-        this.gcScheduler = this.createGarbageCollectionScheduler(cfg);
         this.localStore = this.createLocalStore(cfg);
+        this.gcScheduler = this.createGarbageCollectionScheduler(cfg, this.localStore);
+        this.indexBackfillerScheduler = this.createIndexBackfillerScheduler(cfg, this.localStore);
     }
-    createGarbageCollectionScheduler(cfg) {
+    createGarbageCollectionScheduler(cfg, localStore) {
+        return null;
+    }
+    createIndexBackfillerScheduler(cfg, localStore) {
         return null;
     }
     createLocalStore(cfg) {
@@ -23647,7 +23874,11 @@ class IndexedDbOfflineComponentProvider extends MemoryOfflineComponentProvider {
         // set it after localStore / remoteStore are started.
         await this.persistence.setPrimaryStateListener(() => {
             if (this.gcScheduler && !this.gcScheduler.started) {
-                this.gcScheduler.start(this.localStore);
+                this.gcScheduler.start();
+            }
+            if (this.indexBackfillerScheduler &&
+                !this.indexBackfillerScheduler.started) {
+                this.indexBackfillerScheduler.start();
             }
             return Promise.resolve();
         });
@@ -23655,9 +23886,13 @@ class IndexedDbOfflineComponentProvider extends MemoryOfflineComponentProvider {
     createLocalStore(cfg) {
         return newLocalStore(this.persistence, new QueryEngine(), cfg.initialUser, this.serializer);
     }
-    createGarbageCollectionScheduler(cfg) {
+    createGarbageCollectionScheduler(cfg, localStore) {
         const garbageCollector = this.persistence.referenceDelegate.garbageCollector;
-        return new LruScheduler(garbageCollector, cfg.asyncQueue);
+        return new LruScheduler(garbageCollector, cfg.asyncQueue, localStore);
+    }
+    createIndexBackfillerScheduler(cfg, localStore) {
+        const indexBackfiller = new IndexBackfiller(localStore, this.persistence);
+        return new IndexBackfillerScheduler(cfg.asyncQueue, indexBackfiller);
     }
     createPersistence(cfg) {
         const persistenceKey = indexedDbStoragePrefix(cfg.databaseInfo.databaseId, cfg.databaseInfo.persistenceKey);
@@ -23704,12 +23939,20 @@ class MultiTabOfflineComponentProvider extends IndexedDbOfflineComponentProvider
             await syncEngineApplyPrimaryState(this.onlineComponentProvider.syncEngine, isPrimary);
             if (this.gcScheduler) {
                 if (isPrimary && !this.gcScheduler.started) {
-                    this.gcScheduler.start(this.localStore);
+                    this.gcScheduler.start();
                 }
                 else if (!isPrimary) {
                     this.gcScheduler.stop();
                 }
             }
+            if (this.indexBackfillerScheduler) {
+                if (isPrimary && !this.indexBackfillerScheduler.started) {
+                    this.indexBackfillerScheduler.start();
+                }
+                else if (!isPrimary) {
+                    this.indexBackfillerScheduler.stop();
+                }
+            }
         });
     }
     createSharedClientState(cfg) {