diff --git a/.changeset/cool-grapes-attend.md b/.changeset/cool-grapes-attend.md
new file mode 100644
index 00000000000..8f6d8b289b6
--- /dev/null
+++ b/.changeset/cool-grapes-attend.md
@@ -0,0 +1,6 @@
+---
+'@firebase/firestore': patch
+'firebase': patch
+---
+
+Fix Firestore failing to raise initial snapshot from empty local cache result
diff --git a/.changeset/cool-seas-confess.md b/.changeset/cool-seas-confess.md
new file mode 100644
index 00000000000..14cd3fd3f9c
--- /dev/null
+++ b/.changeset/cool-seas-confess.md
@@ -0,0 +1,5 @@
+---
+"@firebase/database": patch
+---
+
+Fixed `endBefore` and `push` documentation typos in RTDB
diff --git a/.changeset/large-lamps-reflect.md b/.changeset/large-lamps-reflect.md
new file mode 100644
index 00000000000..25bbb80bfb7
--- /dev/null
+++ b/.changeset/large-lamps-reflect.md
@@ -0,0 +1,6 @@
+---
+"@firebase/storage": patch
+---
+
+Fixed bug where upload status wasn't being checked after an upload failure.
+Implemented exponential backoff and max retry strategy.
diff --git a/.changeset/metal-goats-unite.md b/.changeset/metal-goats-unite.md
new file mode 100644
index 00000000000..bc810b44630
--- /dev/null
+++ b/.changeset/metal-goats-unite.md
@@ -0,0 +1,8 @@
+---
+'@firebase/firestore': minor
+'@firebase/firestore-compat': minor
+'@firebase/webchannel-wrapper': minor
+'firebase': minor
+---
+
+Set withCredentials=true when making requests via non-streaming RPCs, like is done for streaming RPCs.
diff --git a/.changeset/slow-forks-tease.md b/.changeset/slow-forks-tease.md
new file mode 100644
index 00000000000..24b8cb953e9
--- /dev/null
+++ b/.changeset/slow-forks-tease.md
@@ -0,0 +1,5 @@
+---
+'@firebase/analytics': patch
+---
+
+Update to allow for multiple instance of gtag with different datalayer names
diff --git a/.changeset/strong-squids-dress.md b/.changeset/strong-squids-dress.md
new file mode 100644
index 00000000000..dc68a002421
--- /dev/null
+++ b/.changeset/strong-squids-dress.md
@@ -0,0 +1,5 @@
+---
+'@firebase/util': patch
+---
+
+Remove `__FIREBASE_DEFAULTS_PATH__` option for now, as the current implementation causes Webpack warnings. Also fix `process.env` check to work in environments where `process` exists but `process.env` does not.
diff --git a/README.md b/README.md
index 25b95289b9b..58f7547b254 100644
--- a/README.md
+++ b/README.md
@@ -113,6 +113,26 @@ database. When prompted to select the set of initial security rules, select
 any option (e.g. "Start in Production Mode") since these permission settings
 will be overwritten below.
 
+#### Storage Setup
+
+Visit the "Storage" section of the console and create a storage bucket. In 
+order to run the tests, you will need to update your bucket's CORS rules.
+
+1. Create a new file called `cors.json` with the contents:
+```json
+[
+    {
+        "origin": ["http://localhost:8089"],
+        "method": ["GET"],
+        "maxAgeSeconds": 3600
+    }
+]
+```
+2. Install `gsutil` from https://cloud.google.com/storage/docs/gsutil_install
+3. Run `gsutil cors set cors.json gs://<your-cloud-storage-bucket>`
+
+For more information, visit https://firebase.google.com/docs/storage/web/download-files#cors_configuration
+
 #### Authentication Support
 
 Visit the authentication config in your project and enable the `Anonymous`
diff --git a/common/api-review/storage.api.md b/common/api-review/storage.api.md
index 4715253d510..04df972b727 100644
--- a/common/api-review/storage.api.md
+++ b/common/api-review/storage.api.md
@@ -83,7 +83,7 @@ export class _FirebaseStorageImpl implements FirebaseStorage {
     // Warning: (ae-forgotten-export) The symbol "Request" needs to be exported by the entry point index.d.ts
     //
     // (undocumented)
-    _makeRequest<I extends ConnectionType, O>(requestInfo: RequestInfo_2<I, O>, requestFactory: () => Connection<I>, authToken: string | null, appCheckToken: string | null): Request_2<O>;
+    _makeRequest<I extends ConnectionType, O>(requestInfo: RequestInfo_2<I, O>, requestFactory: () => Connection<I>, authToken: string | null, appCheckToken: string | null, retry?: boolean): Request_2<O>;
     // (undocumented)
     makeRequestWithTokens<I extends ConnectionType, O>(requestInfo: RequestInfo_2<I, O>, requestFactory: () => Connection<I>): Promise<O>;
     _makeStorageReference(loc: _Location): _Reference;
@@ -319,11 +319,13 @@ export class _UploadTask {
     _blob: _FbsBlob;
     cancel(): boolean;
     catch<T>(onRejected: (p1: StorageError_2) => T | Promise<T>): Promise<T>;
+    // (undocumented)
+    isExponentialBackoffExpired(): boolean;
     // Warning: (ae-forgotten-export) The symbol "Metadata" needs to be exported by the entry point index.d.ts
     _metadata: Metadata | null;
     // Warning: (ae-forgotten-export) The symbol "Unsubscribe" needs to be exported by the entry point index.d.ts
     // Warning: (ae-forgotten-export) The symbol "Subscribe" needs to be exported by the entry point index.d.ts
-    on(type: _TaskEvent, nextOrObserver?: StorageObserver<UploadTaskSnapshot> | null | ((snapshot: UploadTaskSnapshot) => unknown), error?: ((a: StorageError_2) => unknown) | null, completed?: Unsubscribe_2 | null): Unsubscribe_2 | Subscribe_2<UploadTaskSnapshot>;
+    on(type: _TaskEvent, nextOrObserver?: StorageObserver<UploadTaskSnapshot> | null | ((snapshot: UploadTaskSnapshot) => unknown), error?: ((a: StorageError_2) => unknown) | null, completed?: CompleteFn | null): Unsubscribe_2 | Subscribe_2<UploadTaskSnapshot>;
     pause(): boolean;
     resume(): boolean;
     get snapshot(): UploadTaskSnapshot;
diff --git a/packages/analytics/src/helpers.test.ts b/packages/analytics/src/helpers.test.ts
index 0a67fafcf60..1175ff0f61e 100644
--- a/packages/analytics/src/helpers.test.ts
+++ b/packages/analytics/src/helpers.test.ts
@@ -29,6 +29,7 @@ import {
 import { GtagCommand } from './constants';
 import { Deferred } from '@firebase/util';
 import { ConsentSettings } from './public-types';
+import { removeGtagScripts } from '../testing/gtag-script-util';
 
 const fakeMeasurementId = 'abcd-efgh-ijkl';
 const fakeAppId = 'my-test-app-1234';
@@ -46,6 +47,10 @@ const fakeDynamicConfig: DynamicConfig = {
 const fakeDynamicConfigPromises = [Promise.resolve(fakeDynamicConfig)];
 
 describe('Gtag wrapping functions', () => {
+  afterEach(() => {
+    removeGtagScripts();
+  });
+
   it('getOrCreateDataLayer is able to create a new data layer if none exists', () => {
     delete window['dataLayer'];
     expect(getOrCreateDataLayer('dataLayer')).to.deep.equal([]);
@@ -57,14 +62,24 @@ describe('Gtag wrapping functions', () => {
   });
 
   it('insertScriptIfNeeded inserts script tag', () => {
-    expect(findGtagScriptOnPage()).to.be.null;
-    insertScriptTag('customDataLayerName', fakeMeasurementId);
-    const scriptTag = findGtagScriptOnPage();
+    const customDataLayerName = 'customDataLayerName';
+    expect(findGtagScriptOnPage(customDataLayerName)).to.be.null;
+    insertScriptTag(customDataLayerName, fakeMeasurementId);
+    const scriptTag = findGtagScriptOnPage(customDataLayerName);
     expect(scriptTag).to.not.be.null;
     expect(scriptTag!.src).to.contain(`l=customDataLayerName`);
     expect(scriptTag!.src).to.contain(`id=${fakeMeasurementId}`);
   });
 
+  // The test above essentially already touches this functionality but it is still valuable
+  it('findGtagScriptOnPage returns gtag instance with matching data layer name', () => {
+    const defaultDataLayerName = 'dataLayer';
+    insertScriptTag(defaultDataLayerName, fakeMeasurementId);
+    const scriptTag = findGtagScriptOnPage(defaultDataLayerName);
+    expect(scriptTag!.src).to.contain(`l=${defaultDataLayerName}`);
+    expect(findGtagScriptOnPage('NON_EXISTENT_DATA_LAYER_ID')).to.be.null;
+  });
+
   describe('wrapOrCreateGtag() when user has not previously inserted a gtag script tag on this page', () => {
     afterEach(() => {
       delete window['gtag'];
diff --git a/packages/analytics/src/helpers.ts b/packages/analytics/src/helpers.ts
index be713c2c8a0..1fb8a38319c 100644
--- a/packages/analytics/src/helpers.ts
+++ b/packages/analytics/src/helpers.ts
@@ -318,12 +318,19 @@ export function wrapOrCreateGtag(
 }
 
 /**
- * Returns first script tag in DOM matching our gtag url pattern.
+ * Returns the script tag in the DOM matching both the gtag url pattern
+ * and the provided data layer name.
  */
-export function findGtagScriptOnPage(): HTMLScriptElement | null {
+export function findGtagScriptOnPage(
+  dataLayerName: string
+): HTMLScriptElement | null {
   const scriptTags = window.document.getElementsByTagName('script');
   for (const tag of Object.values(scriptTags)) {
-    if (tag.src && tag.src.includes(GTAG_URL)) {
+    if (
+      tag.src &&
+      tag.src.includes(GTAG_URL) &&
+      tag.src.includes(dataLayerName)
+    ) {
       return tag;
     }
   }
diff --git a/packages/analytics/src/index.test.ts b/packages/analytics/src/index.test.ts
index 607c2e74a5d..e83eb7f9a77 100644
--- a/packages/analytics/src/index.test.ts
+++ b/packages/analytics/src/index.test.ts
@@ -26,7 +26,7 @@ import {
 import { FirebaseApp } from '@firebase/app';
 import { GtagCommand } from './constants';
 import { findGtagScriptOnPage } from './helpers';
-import { removeGtagScript } from '../testing/gtag-script-util';
+import { removeGtagScripts } from '../testing/gtag-script-util';
 import { Deferred } from '@firebase/util';
 import { AnalyticsError } from './errors';
 import { logEvent } from './api';
@@ -150,7 +150,7 @@ describe('FirebaseAnalytics instance tests', () => {
     after(() => {
       delete window['gtag'];
       delete window['dataLayer'];
-      removeGtagScript();
+      removeGtagScripts();
       fetchStub.restore();
       clock.restore();
       idbOpenStub.restore();
@@ -208,7 +208,7 @@ describe('FirebaseAnalytics instance tests', () => {
     afterEach(() => {
       delete window['gtag'];
       delete window['dataLayer'];
-      removeGtagScript();
+      removeGtagScripts();
       fetchStub.restore();
       clock.restore();
       warnStub.restore();
@@ -304,7 +304,7 @@ describe('FirebaseAnalytics instance tests', () => {
     after(() => {
       delete window[customGtagName];
       delete window[customDataLayerName];
-      removeGtagScript();
+      removeGtagScripts();
       fetchStub.restore();
       clock.restore();
       idbOpenStub.restore();
@@ -349,13 +349,13 @@ describe('FirebaseAnalytics instance tests', () => {
       // Successfully resolves fake IDB open request.
       fakeRequest.onsuccess();
       await initializationPromisesMap[fakeAppParams.appId];
-      expect(findGtagScriptOnPage()).to.not.be.null;
+      expect(findGtagScriptOnPage('dataLayer')).to.not.be.null;
       expect(typeof window['gtag']).to.equal('function');
       expect(Array.isArray(window['dataLayer'])).to.be.true;
 
       delete window['gtag'];
       delete window['dataLayer'];
-      removeGtagScript();
+      removeGtagScripts();
       fetchStub.restore();
       idbOpenStub.restore();
     });
diff --git a/packages/analytics/src/initialize-analytics.test.ts b/packages/analytics/src/initialize-analytics.test.ts
index da2c8f964b6..8760a63b2f1 100644
--- a/packages/analytics/src/initialize-analytics.test.ts
+++ b/packages/analytics/src/initialize-analytics.test.ts
@@ -28,7 +28,7 @@ import { DynamicConfig } from './types';
 import { FirebaseApp } from '@firebase/app';
 import { Deferred } from '@firebase/util';
 import { _FirebaseInstallationsInternal } from '@firebase/installations';
-import { removeGtagScript } from '../testing/gtag-script-util';
+import { removeGtagScripts } from '../testing/gtag-script-util';
 import { setDefaultEventParameters } from './api';
 import {
   defaultConsentSettingsForInit,
@@ -68,7 +68,7 @@ describe('initializeAnalytics()', () => {
   });
   afterEach(() => {
     fetchStub.restore();
-    removeGtagScript();
+    removeGtagScripts();
   });
   it('gets FID and measurement ID and calls gtag config with them', async () => {
     stubFetch();
diff --git a/packages/analytics/src/initialize-analytics.ts b/packages/analytics/src/initialize-analytics.ts
index f89fcf1ddf7..da79ad9108b 100644
--- a/packages/analytics/src/initialize-analytics.ts
+++ b/packages/analytics/src/initialize-analytics.ts
@@ -119,8 +119,9 @@ export async function _initializeAnalytics(
     fidPromise
   ]);
 
-  // Detect if user has already put the gtag <script> tag on this page.
-  if (!findGtagScriptOnPage()) {
+  // Detect if user has already put the gtag <script> tag on this page with the passed in
+  // data layer name.
+  if (!findGtagScriptOnPage(dataLayerName)) {
     insertScriptTag(dataLayerName, dynamicConfig.measurementId);
   }
 
diff --git a/packages/analytics/testing/gtag-script-util.ts b/packages/analytics/testing/gtag-script-util.ts
index e26109cc0f2..acc3dd61642 100644
--- a/packages/analytics/testing/gtag-script-util.ts
+++ b/packages/analytics/testing/gtag-script-util.ts
@@ -16,7 +16,7 @@
  */
 import { GTAG_URL } from '../src/constants';
 
-export function removeGtagScript(): void {
+export function removeGtagScripts(): void {
   const scriptTags = window.document.getElementsByTagName('script');
   for (const tag of Object.values(scriptTags)) {
     if (tag.src) {
diff --git a/packages/auth/src/platform_browser/strategies/redirect.ts b/packages/auth/src/platform_browser/strategies/redirect.ts
index 8a479e50cc7..ea1897f1f44 100644
--- a/packages/auth/src/platform_browser/strategies/redirect.ts
+++ b/packages/auth/src/platform_browser/strategies/redirect.ts
@@ -218,8 +218,7 @@ export async function _linkWithRedirect(
  *
  * @remarks
  * If sign-in succeeded, returns the signed in user. If sign-in was unsuccessful, fails with an
- * error. If no redirect operation was called, returns a {@link UserCredential}
- * with a null `user`.
+ * error. If no redirect operation was called, returns `null`.
  *
  * @example
  * ```javascript
diff --git a/packages/database/src/api/Reference_impl.ts b/packages/database/src/api/Reference_impl.ts
index ef98380d0d1..eec1b1afafe 100644
--- a/packages/database/src/api/Reference_impl.ts
+++ b/packages/database/src/api/Reference_impl.ts
@@ -578,8 +578,8 @@ export interface ThenableReferenceImpl
  * resulting list of items is chronologically sorted. The keys are also
  * designed to be unguessable (they contain 72 random bits of entropy).
  *
- * See {@link https://firebase.google.com/docs/database/web/lists-of-data#append_to_a_list_of_data | Append to a list of data}
- * </br>See {@link ttps://firebase.googleblog.com/2015/02/the-2120-ways-to-ensure-unique_68.html | The 2^120 Ways to Ensure Unique Identifiers}
+ * See {@link https://firebase.google.com/docs/database/web/lists-of-data#append_to_a_list_of_data | Append to a list of data}.
+ * See {@link https://firebase.googleblog.com/2015/02/the-2120-ways-to-ensure-unique_68.html | The 2^120 Ways to Ensure Unique Identifiers}.
  *
  * @param parent - The parent location.
  * @param value - Optional value to be written at the generated location.
@@ -1782,8 +1782,8 @@ class QueryEndBeforeConstraint extends QueryConstraint {
  *
  * The ending point is exclusive. If only a value is provided, children
  * with a value less than the specified value will be included in the query.
- * If a key is specified, then children must have a value lesss than or equal
- * to the specified value and a a key name less than the specified key.
+ * If a key is specified, then children must have a value less than or equal
+ * to the specified value and a key name less than the specified key.
  *
  * @param value - The value to end before. The argument type depends on which
  * `orderBy*()` function was used in this query. Specify a value that matches
diff --git a/packages/firebase/compat/index.d.ts b/packages/firebase/compat/index.d.ts
index e5035011416..aa9281fc588 100644
--- a/packages/firebase/compat/index.d.ts
+++ b/packages/firebase/compat/index.d.ts
@@ -2613,8 +2613,7 @@ declare namespace firebase.auth {
      * Returns a UserCredential from the redirect-based sign-in flow.
      *
      * If sign-in succeeded, returns the signed in user. If sign-in was
-     * unsuccessful, fails with an error. If no redirect operation was called,
-     * returns a UserCredential with a null User.
+     * unsuccessful, fails with an error. If no redirect operation was called, returns `null`.
      *
      * <h4>Error Codes</h4>
      * <dl>
diff --git a/packages/firestore-compat/src/index.console.ts b/packages/firestore-compat/src/index.console.ts
index 9adfdefdfd2..23d5da739db 100644
--- a/packages/firestore-compat/src/index.console.ts
+++ b/packages/firestore-compat/src/index.console.ts
@@ -22,8 +22,11 @@ import {
   Firestore as FirestoreExp,
   FirestoreError,
   _EmptyAuthCredentialsProvider,
-  _EmptyAppCheckTokenProvider
+  _EmptyAppCheckTokenProvider,
+  Query as ExpQuery,
+  getCountFromServer
 } from '@firebase/firestore';
+import { Compat } from '@firebase/util';
 
 import {
   Firestore as FirestoreCompat,
@@ -98,6 +101,15 @@ export class Firestore extends FirestoreCompat {
       new MemoryPersistenceProvider()
     );
   }
+
+  INTERNAL = {
+    delete: () => this.terminate(),
+    count: (query: Compat<ExpQuery<unknown>>) => {
+      return getCountFromServer(query._delegate).then(response => {
+        return response.data().count;
+      });
+    }
+  };
 }
 
 function databaseIdFromFirestoreDatabase(
diff --git a/packages/firestore/src/core/event_manager.ts b/packages/firestore/src/core/event_manager.ts
index ecce1109150..1723abd15d9 100644
--- a/packages/firestore/src/core/event_manager.ts
+++ b/packages/firestore/src/core/event_manager.ts
@@ -307,7 +307,8 @@ export class QueryListener {
         snap.mutatedKeys,
         snap.fromCache,
         snap.syncStateChanged,
-        /* excludesMetadataChanges= */ true
+        /* excludesMetadataChanges= */ true,
+        snap.hasCachedResults
       );
     }
     let raisedEvent = false;
@@ -371,8 +372,13 @@ export class QueryListener {
       return false;
     }
 
-    // Raise data from cache if we have any documents or we are offline
-    return !snap.docs.isEmpty() || onlineState === OnlineState.Offline;
+    // Raise data from cache if we have any documents, have cached results before,
+    // or we are offline.
+    return (
+      !snap.docs.isEmpty() ||
+      snap.hasCachedResults ||
+      onlineState === OnlineState.Offline
+    );
   }
 
   private shouldRaiseEvent(snap: ViewSnapshot): boolean {
@@ -405,7 +411,8 @@ export class QueryListener {
       snap.query,
       snap.docs,
       snap.mutatedKeys,
-      snap.fromCache
+      snap.fromCache,
+      snap.hasCachedResults
     );
     this.raisedInitialEvent = true;
     this.queryObserver.next(snap);
diff --git a/packages/firestore/src/core/sync_engine_impl.ts b/packages/firestore/src/core/sync_engine_impl.ts
index 67405db0b1b..cbe66dce8c4 100644
--- a/packages/firestore/src/core/sync_engine_impl.ts
+++ b/packages/firestore/src/core/sync_engine_impl.ts
@@ -64,6 +64,7 @@ import {
 import { debugAssert, debugCast, fail, hardAssert } from '../util/assert';
 import { wrapInUserErrorIfRecoverable } from '../util/async_queue';
 import { BundleReader } from '../util/bundle_reader';
+import { ByteString } from '../util/byte_string';
 import { Code, FirestoreError } from '../util/error';
 import { logDebug, logWarn } from '../util/log';
 import { primitiveComparator } from '../util/misc';
@@ -327,7 +328,8 @@ export async function syncEngineListen(
       syncEngineImpl,
       query,
       targetId,
-      status === 'current'
+      status === 'current',
+      targetData.resumeToken
     );
   }
 
@@ -342,7 +344,8 @@ async function initializeViewAndComputeSnapshot(
   syncEngineImpl: SyncEngineImpl,
   query: Query,
   targetId: TargetId,
-  current: boolean
+  current: boolean,
+  resumeToken: ByteString
 ): Promise<ViewSnapshot> {
   // PORTING NOTE: On Web only, we inject the code that registers new Limbo
   // targets based on view changes. This allows us to only depend on Limbo
@@ -360,7 +363,8 @@ async function initializeViewAndComputeSnapshot(
   const synthesizedTargetChange =
     TargetChange.createSynthesizedTargetChangeForCurrentChange(
       targetId,
-      current && syncEngineImpl.onlineState !== OnlineState.Offline
+      current && syncEngineImpl.onlineState !== OnlineState.Offline,
+      resumeToken
     );
   const viewChange = view.applyChanges(
     viewDocChanges,
@@ -1385,7 +1389,8 @@ async function synchronizeQueryViewsAndRaiseSnapshots(
         syncEngineImpl,
         synthesizeTargetToQuery(target!),
         targetId,
-        /*current=*/ false
+        /*current=*/ false,
+        targetData.resumeToken
       );
     }
 
@@ -1457,7 +1462,8 @@ export async function syncEngineApplyTargetState(
         const synthesizedRemoteEvent =
           RemoteEvent.createSynthesizedRemoteEventForCurrentChange(
             targetId,
-            state === 'current'
+            state === 'current',
+            ByteString.EMPTY_BYTE_STRING
           );
         await syncEngineEmitNewSnapsAndNotifyLocalStore(
           syncEngineImpl,
@@ -1512,7 +1518,8 @@ export async function syncEngineApplyActiveTargetsChange(
       syncEngineImpl,
       synthesizeTargetToQuery(target),
       targetData.targetId,
-      /*current=*/ false
+      /*current=*/ false,
+      targetData.resumeToken
     );
     remoteStoreListen(syncEngineImpl.remoteStore, targetData);
   }
diff --git a/packages/firestore/src/core/view.ts b/packages/firestore/src/core/view.ts
index 21ab049b9af..de66d883ac3 100644
--- a/packages/firestore/src/core/view.ts
+++ b/packages/firestore/src/core/view.ts
@@ -72,6 +72,7 @@ export interface ViewChange {
  */
 export class View {
   private syncState: SyncState | null = null;
+  private hasCachedResults: boolean = false;
   /**
    * A flag whether the view is current with the backend. A view is considered
    * current after it has seen the current flag from the backend and did not
@@ -319,7 +320,10 @@ export class View {
         docChanges.mutatedKeys,
         newSyncState === SyncState.Local,
         syncStateChanged,
-        /* excludesMetadataChanges= */ false
+        /* excludesMetadataChanges= */ false,
+        targetChange
+          ? targetChange.resumeToken.approximateByteSize() > 0
+          : false
       );
       return {
         snapshot: snap,
@@ -468,7 +472,8 @@ export class View {
       this.query,
       this.documentSet,
       this.mutatedKeys,
-      this.syncState === SyncState.Local
+      this.syncState === SyncState.Local,
+      this.hasCachedResults
     );
   }
 }
diff --git a/packages/firestore/src/core/view_snapshot.ts b/packages/firestore/src/core/view_snapshot.ts
index e631a3dcac0..f15c5ccb409 100644
--- a/packages/firestore/src/core/view_snapshot.ts
+++ b/packages/firestore/src/core/view_snapshot.ts
@@ -146,7 +146,8 @@ export class ViewSnapshot {
     readonly mutatedKeys: DocumentKeySet,
     readonly fromCache: boolean,
     readonly syncStateChanged: boolean,
-    readonly excludesMetadataChanges: boolean
+    readonly excludesMetadataChanges: boolean,
+    readonly hasCachedResults: boolean
   ) {}
 
   /** Returns a view snapshot as if all documents in the snapshot were added. */
@@ -154,7 +155,8 @@ export class ViewSnapshot {
     query: Query,
     documents: DocumentSet,
     mutatedKeys: DocumentKeySet,
-    fromCache: boolean
+    fromCache: boolean,
+    hasCachedResults: boolean
   ): ViewSnapshot {
     const changes: DocumentViewChange[] = [];
     documents.forEach(doc => {
@@ -169,7 +171,8 @@ export class ViewSnapshot {
       mutatedKeys,
       fromCache,
       /* syncStateChanged= */ true,
-      /* excludesMetadataChanges= */ false
+      /* excludesMetadataChanges= */ false,
+      hasCachedResults
     );
   }
 
@@ -180,6 +183,7 @@ export class ViewSnapshot {
   isEqual(other: ViewSnapshot): boolean {
     if (
       this.fromCache !== other.fromCache ||
+      this.hasCachedResults !== other.hasCachedResults ||
       this.syncStateChanged !== other.syncStateChanged ||
       !this.mutatedKeys.isEqual(other.mutatedKeys) ||
       !queryEquals(this.query, other.query) ||
diff --git a/packages/firestore/src/platform/browser/webchannel_connection.ts b/packages/firestore/src/platform/browser/webchannel_connection.ts
index aa4e7081062..0e9d25c9547 100644
--- a/packages/firestore/src/platform/browser/webchannel_connection.ts
+++ b/packages/firestore/src/platform/browser/webchannel_connection.ts
@@ -72,6 +72,7 @@ export class WebChannelConnection extends RestConnection {
   ): Promise<Resp> {
     return new Promise((resolve: Resolver<Resp>, reject: Rejecter) => {
       const xhr = new XhrIo();
+      xhr.setWithCredentials(true);
       xhr.listenOnce(EventType.COMPLETE, () => {
         try {
           switch (xhr.getLastErrorCode()) {
diff --git a/packages/firestore/src/remote/remote_event.ts b/packages/firestore/src/remote/remote_event.ts
index e35e1dbae12..5d48d32bb3f 100644
--- a/packages/firestore/src/remote/remote_event.ts
+++ b/packages/firestore/src/remote/remote_event.ts
@@ -67,14 +67,16 @@ export class RemoteEvent {
   // PORTING NOTE: Multi-tab only
   static createSynthesizedRemoteEventForCurrentChange(
     targetId: TargetId,
-    current: boolean
+    current: boolean,
+    resumeToken: ByteString
   ): RemoteEvent {
     const targetChanges = new Map<TargetId, TargetChange>();
     targetChanges.set(
       targetId,
       TargetChange.createSynthesizedTargetChangeForCurrentChange(
         targetId,
-        current
+        current,
+        resumeToken
       )
     );
     return new RemoteEvent(
@@ -134,10 +136,11 @@ export class TargetChange {
    */
   static createSynthesizedTargetChangeForCurrentChange(
     targetId: TargetId,
-    current: boolean
+    current: boolean,
+    resumeToken: ByteString
   ): TargetChange {
     return new TargetChange(
-      ByteString.EMPTY_BYTE_STRING,
+      resumeToken,
       current,
       documentKeySet(),
       documentKeySet(),
diff --git a/packages/firestore/test/integration/api/query.test.ts b/packages/firestore/test/integration/api/query.test.ts
index 66397ed179c..85e21c024e3 100644
--- a/packages/firestore/test/integration/api/query.test.ts
+++ b/packages/firestore/test/integration/api/query.test.ts
@@ -1281,13 +1281,52 @@ apiDescribe('Queries', (persistence: boolean) => {
     };
 
     return withTestCollection(persistence, testDocs, async coll => {
-      await getDocs(query(coll)); // Populate the cache
+      await getDocs(query(coll)); // Populate the cache.
       const snapshot = await getDocs(
         query(coll, where('map.nested', '==', 'foo'))
       );
       expect(toDataArray(snapshot)).to.deep.equal([{ map: { nested: 'foo' } }]);
     });
   });
+
+  // Reproduces https://github.com/firebase/firebase-js-sdk/issues/5873
+  // eslint-disable-next-line no-restricted-properties
+  (persistence ? describe : describe.skip)('Caching empty results', () => {
+    it('can raise initial snapshot from cache, even if it is empty', () => {
+      return withTestCollection(persistence, {}, async coll => {
+        const snapshot1 = await getDocs(coll); // Populate the cache.
+        expect(snapshot1.metadata.fromCache).to.be.false;
+        expect(toDataArray(snapshot1)).to.deep.equal([]); // Precondition check.
+
+        // Add a snapshot listener whose first event should be raised from cache.
+        const storeEvent = new EventsAccumulator<QuerySnapshot>();
+        onSnapshot(coll, storeEvent.storeEvent);
+        const snapshot2 = await storeEvent.awaitEvent();
+        expect(snapshot2.metadata.fromCache).to.be.true;
+        expect(toDataArray(snapshot2)).to.deep.equal([]);
+      });
+    });
+
+    it('can raise initial snapshot from cache, even if it has become empty', () => {
+      const testDocs = {
+        a: { key: 'a' }
+      };
+      return withTestCollection(persistence, testDocs, async coll => {
+        // Populate the cache.
+        const snapshot1 = await getDocs(coll);
+        expect(snapshot1.metadata.fromCache).to.be.false;
+        expect(toDataArray(snapshot1)).to.deep.equal([{ key: 'a' }]);
+        // Empty the collection.
+        void deleteDoc(doc(coll, 'a'));
+
+        const storeEvent = new EventsAccumulator<QuerySnapshot>();
+        onSnapshot(coll, storeEvent.storeEvent);
+        const snapshot2 = await storeEvent.awaitEvent();
+        expect(snapshot2.metadata.fromCache).to.be.true;
+        expect(toDataArray(snapshot2)).to.deep.equal([]);
+      });
+    });
+  });
 });
 
 function verifyDocumentChange<T>(
diff --git a/packages/firestore/test/integration/api_internal/aggregation.test.ts b/packages/firestore/test/integration/api_internal/aggregation.test.ts
index 88d6caf17fd..47a4dbdf860 100644
--- a/packages/firestore/test/integration/api_internal/aggregation.test.ts
+++ b/packages/firestore/test/integration/api_internal/aggregation.test.ts
@@ -37,90 +37,86 @@ import {
   withTestCollection,
   withTestDb
 } from '../util/helpers';
-import { USE_EMULATOR } from '../util/settings';
 
-(USE_EMULATOR ? apiDescribe : apiDescribe.skip)(
-  'Count quries',
-  (persistence: boolean) => {
-    it('can run count query getCountFromServer', () => {
-      const testDocs = {
-        a: { author: 'authorA', title: 'titleA' },
-        b: { author: 'authorB', title: 'titleB' }
-      };
-      return withTestCollection(persistence, testDocs, async coll => {
-        const snapshot = await getCountFromServer(coll);
-        expect(snapshot.data().count).to.equal(2);
-      });
+apiDescribe('Count quries', (persistence: boolean) => {
+  it('can run count query getCountFromServer', () => {
+    const testDocs = {
+      a: { author: 'authorA', title: 'titleA' },
+      b: { author: 'authorB', title: 'titleB' }
+    };
+    return withTestCollection(persistence, testDocs, async coll => {
+      const snapshot = await getCountFromServer(coll);
+      expect(snapshot.data().count).to.equal(2);
     });
+  });
 
-    it("count query doesn't use converter", () => {
-      const testDocs = {
-        a: { author: 'authorA', title: 'titleA' },
-        b: { author: 'authorB', title: 'titleB' }
-      };
-      const throwingConverter = {
-        toFirestore(obj: never): DocumentData {
-          throw new Error('should never be called');
-        },
-        fromFirestore(snapshot: QueryDocumentSnapshot): never {
-          throw new Error('should never be called');
-        }
-      };
-      return withTestCollection(persistence, testDocs, async coll => {
-        const query_ = query(
-          coll,
-          where('author', '==', 'authorA')
-        ).withConverter(throwingConverter);
-        const snapshot = await getCountFromServer(query_);
-        expect(snapshot.data().count).to.equal(1);
-      });
+  it("count query doesn't use converter", () => {
+    const testDocs = {
+      a: { author: 'authorA', title: 'titleA' },
+      b: { author: 'authorB', title: 'titleB' }
+    };
+    const throwingConverter = {
+      toFirestore(obj: never): DocumentData {
+        throw new Error('should never be called');
+      },
+      fromFirestore(snapshot: QueryDocumentSnapshot): never {
+        throw new Error('should never be called');
+      }
+    };
+    return withTestCollection(persistence, testDocs, async coll => {
+      const query_ = query(
+        coll,
+        where('author', '==', 'authorA')
+      ).withConverter(throwingConverter);
+      const snapshot = await getCountFromServer(query_);
+      expect(snapshot.data().count).to.equal(1);
     });
+  });
 
-    it('count query supports collection groups', () => {
-      return withTestDb(persistence, async db => {
-        const collectionGroupId = doc(collection(db, 'aggregateQueryTest')).id;
-        const docPaths = [
-          `${collectionGroupId}/cg-doc1`,
-          `abc/123/${collectionGroupId}/cg-doc2`,
-          `zzz${collectionGroupId}/cg-doc3`,
-          `abc/123/zzz${collectionGroupId}/cg-doc4`,
-          `abc/123/zzz/${collectionGroupId}`
-        ];
-        const batch = writeBatch(db);
-        for (const docPath of docPaths) {
-          batch.set(doc(db, docPath), { x: 1 });
-        }
-        await batch.commit();
-        const snapshot = await getCountFromServer(
-          collectionGroup(db, collectionGroupId)
-        );
-        expect(snapshot.data().count).to.equal(2);
-      });
+  it('count query supports collection groups', () => {
+    return withTestDb(persistence, async db => {
+      const collectionGroupId = doc(collection(db, 'aggregateQueryTest')).id;
+      const docPaths = [
+        `${collectionGroupId}/cg-doc1`,
+        `abc/123/${collectionGroupId}/cg-doc2`,
+        `zzz${collectionGroupId}/cg-doc3`,
+        `abc/123/zzz${collectionGroupId}/cg-doc4`,
+        `abc/123/zzz/${collectionGroupId}`
+      ];
+      const batch = writeBatch(db);
+      for (const docPath of docPaths) {
+        batch.set(doc(db, docPath), { x: 1 });
+      }
+      await batch.commit();
+      const snapshot = await getCountFromServer(
+        collectionGroup(db, collectionGroupId)
+      );
+      expect(snapshot.data().count).to.equal(2);
     });
+  });
 
-    it('getCountFromServer fails if firestore is terminated', () => {
-      return withEmptyTestCollection(persistence, async (coll, firestore) => {
-        await terminate(firestore);
-        expect(() => getCountFromServer(coll)).to.throw(
-          'The client has already been terminated.'
-        );
-      });
+  it('getCountFromServer fails if firestore is terminated', () => {
+    return withEmptyTestCollection(persistence, async (coll, firestore) => {
+      await terminate(firestore);
+      expect(() => getCountFromServer(coll)).to.throw(
+        'The client has already been terminated.'
+      );
     });
+  });
 
-    it("terminate doesn't crash when there is count query in flight", () => {
-      return withEmptyTestCollection(persistence, async (coll, firestore) => {
-        void getCountFromServer(coll);
-        await terminate(firestore);
-      });
+  it("terminate doesn't crash when there is count query in flight", () => {
+    return withEmptyTestCollection(persistence, async (coll, firestore) => {
+      void getCountFromServer(coll);
+      await terminate(firestore);
     });
+  });
 
-    it('getCountFromServer fails if user is offline', () => {
-      return withEmptyTestCollection(persistence, async (coll, firestore) => {
-        await disableNetwork(firestore);
-        await expect(getCountFromServer(coll)).to.be.eventually.rejectedWith(
-          'Failed to get count result because the client is offline'
-        );
-      });
+  it('getCountFromServer fails if user is offline', () => {
+    return withEmptyTestCollection(persistence, async (coll, firestore) => {
+      await disableNetwork(firestore);
+      await expect(getCountFromServer(coll)).to.be.eventually.rejectedWith(
+        'Failed to get count result because the client is offline'
+      );
     });
-  }
-);
+  });
+});
diff --git a/packages/firestore/test/lite/integration.test.ts b/packages/firestore/test/lite/integration.test.ts
index 823d0b524b6..a2188b3e460 100644
--- a/packages/firestore/test/lite/integration.test.ts
+++ b/packages/firestore/test/lite/integration.test.ts
@@ -83,8 +83,7 @@ import { runTransaction } from '../../src/lite-api/transaction';
 import { writeBatch } from '../../src/lite-api/write_batch';
 import {
   DEFAULT_PROJECT_ID,
-  DEFAULT_SETTINGS,
-  USE_EMULATOR
+  DEFAULT_SETTINGS
 } from '../integration/util/settings';
 
 import {
@@ -2120,7 +2119,7 @@ describe('withConverter() support', () => {
 });
 
 // eslint-disable-next-line no-restricted-properties
-(USE_EMULATOR ? describe : describe.skip)('Count quries', () => {
+describe('Count quries', () => {
   it('AggregateQuerySnapshot inherits the original query', () => {
     return withTestCollection(async coll => {
       const query_ = query(coll);
@@ -2151,9 +2150,7 @@ describe('withConverter() support', () => {
   it('run count query fails on invalid collection reference', () => {
     return withTestDb(async db => {
       const queryForRejection = collection(db, '__badpath__');
-      await expect(getCount(queryForRejection)).to.eventually.be.rejectedWith(
-        'Request failed with error: Bad Request'
-      );
+      await expect(getCount(queryForRejection)).to.eventually.be.rejected;
     });
   });
 
diff --git a/packages/firestore/test/unit/api/database.test.ts b/packages/firestore/test/unit/api/database.test.ts
index 71b798282f5..edc1a520f07 100644
--- a/packages/firestore/test/unit/api/database.test.ts
+++ b/packages/firestore/test/unit/api/database.test.ts
@@ -177,6 +177,51 @@ describe('QuerySnapshot', () => {
         querySnapshot('foo', {}, { a: { a: 1 } }, keys('foo/a'), false, true)
       )
     ).to.be.false;
+    // hasCachedResults should affect querySnapshot equality
+    expect(
+      snapshotEqual(
+        querySnapshot(
+          'foo',
+          {},
+          { a: { a: 1 } },
+          keys('foo/a'),
+          false,
+          false,
+          true
+        ),
+        querySnapshot(
+          'foo',
+          {},
+          { a: { a: 1 } },
+          keys('foo/a'),
+          false,
+          false,
+          true
+        )
+      )
+    ).to.be.true;
+    expect(
+      snapshotEqual(
+        querySnapshot(
+          'foo',
+          {},
+          { a: { a: 1 } },
+          keys('foo/a'),
+          false,
+          false,
+          true
+        ),
+        querySnapshot(
+          'foo',
+          {},
+          { a: { a: 1 } },
+          keys('foo/a'),
+          false,
+          false,
+          false
+        )
+      )
+    ).to.be.false;
   });
 
   it('JSON.stringify() does not throw', () => {
diff --git a/packages/firestore/test/unit/core/event_manager.test.ts b/packages/firestore/test/unit/core/event_manager.test.ts
index 8fab4653bd7..293514ceb6d 100644
--- a/packages/firestore/test/unit/core/event_manager.test.ts
+++ b/packages/firestore/test/unit/core/event_manager.test.ts
@@ -224,7 +224,8 @@ describe('QueryListener', () => {
       docChanges: [change1, change4],
       fromCache: snap2.fromCache,
       syncStateChanged: true,
-      mutatedKeys: keys()
+      mutatedKeys: keys(),
+      hasCachedResults: snap2.hasCachedResults
     };
     expect(otherEvents).to.deep.equal([expectedSnap2]);
   });
@@ -396,7 +397,8 @@ describe('QueryListener', () => {
         docChanges: [change3],
         fromCache: snap2.fromCache,
         syncStateChanged: snap2.syncStateChanged,
-        mutatedKeys: snap2.mutatedKeys
+        mutatedKeys: snap2.mutatedKeys,
+        hasCachedResults: snap2.hasCachedResults
       };
       expect(filteredEvents).to.deep.equal([snap1, expectedSnap2]);
     }
@@ -482,7 +484,8 @@ describe('QueryListener', () => {
       ],
       fromCache: false,
       syncStateChanged: true,
-      mutatedKeys: keys()
+      mutatedKeys: keys(),
+      hasCachedResults: snap3.hasCachedResults
     };
     expect(events).to.deep.equal([expectedSnap]);
   });
@@ -517,7 +520,8 @@ describe('QueryListener', () => {
       docChanges: [{ type: ChangeType.Added, doc: doc1 }],
       fromCache: true,
       syncStateChanged: true,
-      mutatedKeys: keys()
+      mutatedKeys: keys(),
+      hasCachedResults: snap1.hasCachedResults
     };
     const expectedSnap2 = {
       query: query1,
@@ -526,7 +530,8 @@ describe('QueryListener', () => {
       docChanges: [{ type: ChangeType.Added, doc: doc2 }],
       fromCache: true,
       syncStateChanged: false,
-      mutatedKeys: keys()
+      mutatedKeys: keys(),
+      hasCachedResults: snap2.hasCachedResults
     };
     expect(events).to.deep.equal([expectedSnap1, expectedSnap2]);
   });
@@ -552,7 +557,8 @@ describe('QueryListener', () => {
       docChanges: [],
       fromCache: true,
       syncStateChanged: true,
-      mutatedKeys: keys()
+      mutatedKeys: keys(),
+      hasCachedResults: snap1.hasCachedResults
     };
     expect(events).to.deep.equal([expectedSnap]);
   });
@@ -577,7 +583,8 @@ describe('QueryListener', () => {
       docChanges: [],
       fromCache: true,
       syncStateChanged: true,
-      mutatedKeys: keys()
+      mutatedKeys: keys(),
+      hasCachedResults: snap1.hasCachedResults
     };
     expect(events).to.deep.equal([expectedSnap]);
   });
diff --git a/packages/firestore/test/unit/specs/listen_spec.test.ts b/packages/firestore/test/unit/specs/listen_spec.test.ts
index 8ebf5d7cbc0..8bc62391838 100644
--- a/packages/firestore/test/unit/specs/listen_spec.test.ts
+++ b/packages/firestore/test/unit/specs/listen_spec.test.ts
@@ -351,6 +351,7 @@ describeSpec('Listens:', [], () => {
         // (the document falls out) and send us a snapshot that's ahead of
         // docAv3 (which is already in our cache).
         .userListens(visibleQuery, { resumeToken: 'resume-token-1000' })
+        .expectEvents(visibleQuery, { fromCache: true })
         .watchAcks(visibleQuery)
         .watchSends({ removed: [visibleQuery] }, docAv2)
         .watchCurrents(visibleQuery, 'resume-token-5000')
@@ -396,6 +397,7 @@ describeSpec('Listens:', [], () => {
         // (the document falls out) and send us a snapshot that's ahead of
         // docAv3 (which is already in our cache).
         .userListens(visibleQuery, { resumeToken: 'resume-token-1000' })
+        .expectEvents(visibleQuery, { fromCache: true })
         .watchAcks(visibleQuery)
         .watchSends({ removed: [visibleQuery] }, docAv2)
         .watchCurrents(visibleQuery, 'resume-token-5000')
@@ -405,6 +407,7 @@ describeSpec('Listens:', [], () => {
         .watchRemoves(visibleQuery)
         // Listen to allQuery again and make sure we still get no docs.
         .userListens(allQuery, { resumeToken: 'resume-token-4000' })
+        .expectEvents(allQuery, { fromCache: true })
         .watchAcksFull(allQuery, 6000)
         .expectEvents(allQuery, { fromCache: false })
     );
@@ -1695,4 +1698,115 @@ describeSpec('Listens:', [], () => {
       })
       .expectSnapshotsInSyncEvent(2);
   });
+
+  specTest('Empty initial snapshot is raised from cache', [], () => {
+    const query1 = query('collection');
+    return (
+      spec()
+        // Disable GC so the cache persists across listens.
+        .withGCEnabled(false)
+        // Populate the cache with the empty query results.
+        .userListens(query1)
+        .watchAcksFull(query1, 1000)
+        .expectEvents(query1, { fromCache: false })
+        .userUnlistens(query1)
+        .watchRemoves(query1)
+        // Listen to the query again and verify that the empty snapshot is
+        // raised from cache.
+        .userListens(query1, { resumeToken: 'resume-token-1000' })
+        .expectEvents(query1, { fromCache: true })
+        // Verify that another snapshot is raised once the query result comes
+        // back from Watch.
+        .watchAcksFull(query1, 2000)
+        .expectEvents(query1, { fromCache: false })
+    );
+  });
+
+  specTest(
+    'Empty-due-to-delete initial snapshot is raised from cache',
+    [],
+    () => {
+      const query1 = query('collection');
+      const doc1 = doc('collection/a', 1000, { v: 1 });
+      return (
+        spec()
+          // Disable GC so the cache persists across listens.
+          .withGCEnabled(false)
+          // Populate the cache with the empty query results.
+          .userListens(query1)
+          .watchAcksFull(query1, 1000, doc1)
+          .expectEvents(query1, { added: [doc1] })
+          .userUnlistens(query1)
+          .watchRemoves(query1)
+          // Delete the only document in the result set locally on the client.
+          .userDeletes('collection/a')
+          // Listen to the query again and verify that the empty snapshot is
+          // raised from cache, even though the write is not yet acknowledged.
+          .userListens(query1, { resumeToken: 'resume-token-1000' })
+          .expectEvents(query1, { fromCache: true })
+      );
+    }
+  );
+
+  specTest(
+    'Empty initial snapshot is raised from cache in multiple tabs',
+    ['multi-client'],
+    () => {
+      const query1 = query('collection');
+      return (
+        client(0, /* withGcEnabled= */ false)
+          // Populate the cache with the empty query results.
+          .userListens(query1)
+          .watchAcksFull(query1, 1000)
+          .expectEvents(query1, { fromCache: false })
+          .userUnlistens(query1)
+          .watchRemoves(query1)
+          .client(1)
+          // Re-listen to the query in second client and verify that the empty
+          // snapshot is raised from cache.
+          .userListens(query1)
+          .expectEvents(query1, { fromCache: true })
+          .client(0)
+          .expectListen(query1, { resumeToken: 'resume-token-1000' })
+          // Verify that another snapshot is raised once the query result comes
+          // back from Watch.
+          .watchAcksFull(query1, 2000)
+          .client(1)
+          .expectEvents(query1, { fromCache: false })
+      );
+    }
+  );
+  specTest(
+    'Empty-due-to-delete initial snapshot is raised from cache in multiple tabs',
+    ['multi-client'],
+    () => {
+      const query1 = query('collection');
+      const doc1 = doc('collection/a', 1000, { v: 1 });
+      const doc1Deleted = deletedDoc('collection/a', 2000);
+
+      return (
+        client(0, /* withGcEnabled= */ false)
+          // Populate the cache with the empty query results.
+          .userListens(query1)
+          .watchAcksFull(query1, 1000, doc1)
+          .expectEvents(query1, { added: [doc1] })
+          .userUnlistens(query1)
+          .watchRemoves(query1)
+          // Delete the only document in the result set locally on the client.
+          .userDeletes('collection/a')
+          // Re-listen to the query in second client and verify that the empty
+          // snapshot is raised from cache with local mutation.
+          .client(1)
+          .userListens(query1)
+          .expectEvents(query1, { fromCache: true })
+          // Should get events once stream is caught up.
+          .client(0)
+          .expectListen(query1, { resumeToken: 'resume-token-1000' })
+          .writeAcks('collection/a', 2000)
+          .watchAcksFull(query1, 2000, doc1Deleted)
+          .client(1)
+          .expectEvents(query1, { fromCache: false })
+      );
+    }
+  );
 });
diff --git a/packages/firestore/test/unit/specs/recovery_spec.test.ts b/packages/firestore/test/unit/specs/recovery_spec.test.ts
index f14aa5642c4..3da50a0b556 100644
--- a/packages/firestore/test/unit/specs/recovery_spec.test.ts
+++ b/packages/firestore/test/unit/specs/recovery_spec.test.ts
@@ -489,6 +489,7 @@ describeSpec('Persistence Recovery', ['no-ios', 'no-android'], () => {
           .userUnlistens(query1)
           // No event since the document was removed
           .userListens(query1, { resumeToken: 'resume-token-1000' })
+          .expectEvents(query1, { fromCache: true })
       );
     }
   );
diff --git a/packages/firestore/test/util/api_helpers.ts b/packages/firestore/test/util/api_helpers.ts
index 2dd8a6199e0..762b5258a29 100644
--- a/packages/firestore/test/util/api_helpers.ts
+++ b/packages/firestore/test/util/api_helpers.ts
@@ -130,7 +130,8 @@ export function querySnapshot(
   docsToAdd: { [key: string]: JsonObject<unknown> },
   mutatedKeys: DocumentKeySet,
   fromCache: boolean,
-  syncStateChanged: boolean
+  syncStateChanged: boolean,
+  hasCachedResults?: boolean
 ): QuerySnapshot {
   const query: InternalQuery = newQueryForPath(pathFrom(path));
   let oldDocuments: DocumentSet = new DocumentSet();
@@ -152,7 +153,8 @@ export function querySnapshot(
     mutatedKeys,
     fromCache,
     syncStateChanged,
-    false
+    false,
+    hasCachedResults ?? false
   );
   const db = firestore();
   return new QuerySnapshot(
diff --git a/packages/storage/src/implementation/backoff.ts b/packages/storage/src/implementation/backoff.ts
index 9560870abea..2a44bd85150 100644
--- a/packages/storage/src/implementation/backoff.ts
+++ b/packages/storage/src/implementation/backoff.ts
@@ -24,15 +24,24 @@ type id = (p1: boolean) => void;
 export { id };
 
 /**
- * @param f May be invoked
- *     before the function returns.
- * @param callback Get all the arguments passed to the function
- *     passed to f, including the initial boolean.
+ * Accepts a callback for an action to perform (`doRequest`),
+ * and then a callback for when the backoff has completed (`backoffCompleteCb`).
+ * The callback sent to start requires an argument to call (`onRequestComplete`).
+ * When `start` calls `doRequest`, it passes a callback for when the request has
+ * completed, `onRequestComplete`. Based on this, the backoff continues, with
+ * another call to `doRequest` and the above loop continues until the timeout
+ * is hit, or a successful response occurs.
+ * @description
+ * @param doRequest Callback to perform request
+ * @param backoffCompleteCb Callback to call when backoff has been completed
  */
 export function start(
-  f: (p1: (success: boolean) => void, canceled: boolean) => void,
+  doRequest: (
+    onRequestComplete: (success: boolean) => void,
+    canceled: boolean
+  ) => void,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  callback: (...args: any[]) => unknown,
+  backoffCompleteCb: (...args: any[]) => unknown,
   timeout: number
 ): id {
   // TODO(andysoto): make this code cleaner (probably refactor into an actual
@@ -55,14 +64,14 @@ export function start(
   function triggerCallback(...args: any[]): void {
     if (!triggeredCallback) {
       triggeredCallback = true;
-      callback.apply(null, args);
+      backoffCompleteCb.apply(null, args);
     }
   }
 
   function callWithDelay(millis: number): void {
     retryTimeoutId = setTimeout(() => {
       retryTimeoutId = null;
-      f(handler, canceled());
+      doRequest(responseHandler, canceled());
     }, millis);
   }
 
@@ -72,7 +81,7 @@ export function start(
     }
   }
 
-  function handler(success: boolean, ...args: any[]): void {
+  function responseHandler(success: boolean, ...args: any[]): void {
     if (triggeredCallback) {
       clearGlobalTimeout();
       return;
diff --git a/packages/storage/src/implementation/constants.ts b/packages/storage/src/implementation/constants.ts
index d36e7fbf676..48c6db55c11 100644
--- a/packages/storage/src/implementation/constants.ts
+++ b/packages/storage/src/implementation/constants.ts
@@ -42,6 +42,11 @@ export const DEFAULT_MAX_OPERATION_RETRY_TIME = 2 * 60 * 1000;
  */
 export const DEFAULT_MAX_UPLOAD_RETRY_TIME = 10 * 60 * 1000;
 
+/**
+ * 1 second
+ */
+export const DEFAULT_MIN_SLEEP_TIME_MILLIS = 1000;
+
 /**
  * This is the value of Number.MIN_SAFE_INTEGER, which is not well supported
  * enough for us to use it directly.
diff --git a/packages/storage/src/implementation/error.ts b/packages/storage/src/implementation/error.ts
index cdccfc51053..fa12d76d763 100644
--- a/packages/storage/src/implementation/error.ts
+++ b/packages/storage/src/implementation/error.ts
@@ -34,8 +34,9 @@ export class StorageError extends FirebaseError {
    * @param code - A StorageErrorCode string to be prefixed with 'storage/' and
    *  added to the end of the message.
    * @param message  - Error message.
+   * @param status_ - Corresponding HTTP Status Code
    */
-  constructor(code: StorageErrorCode, message: string) {
+  constructor(code: StorageErrorCode, message: string, private status_ = 0) {
     super(
       prependCode(code),
       `Firebase Storage: ${message} (${prependCode(code)})`
@@ -46,6 +47,14 @@ export class StorageError extends FirebaseError {
     Object.setPrototypeOf(this, StorageError.prototype);
   }
 
+  get status(): number {
+    return this.status_;
+  }
+
+  set status(status: number) {
+    this.status_ = status;
+  }
+
   /**
    * Compares a StorageErrorCode against this error's code, filtering out the prefix.
    */
diff --git a/packages/storage/src/implementation/request.ts b/packages/storage/src/implementation/request.ts
index 226b1ea08de..572562d1528 100644
--- a/packages/storage/src/implementation/request.ts
+++ b/packages/storage/src/implementation/request.ts
@@ -26,6 +26,7 @@ import { ErrorHandler, RequestHandler, RequestInfo } from './requestinfo';
 import { isJustDef } from './type';
 import { makeQueryString } from './url';
 import { Connection, ErrorCode, Headers, ConnectionType } from './connection';
+import { isRetryStatusCode } from './utils';
 
 export interface Request<T> {
   getPromise(): Promise<T>;
@@ -69,7 +70,8 @@ class NetworkRequest<I extends ConnectionType, O> implements Request<O> {
     private errorCallback_: ErrorHandler | null,
     private timeout_: number,
     private progressCallback_: ((p1: number, p2: number) => void) | null,
-    private connectionFactory_: () => Connection<I>
+    private connectionFactory_: () => Connection<I>,
+    private retry = true
   ) {
     this.promise_ = new Promise((resolve, reject) => {
       this.resolve_ = resolve as (value?: O | PromiseLike<O>) => void;
@@ -93,16 +95,15 @@ class NetworkRequest<I extends ConnectionType, O> implements Request<O> {
       const connection = this.connectionFactory_();
       this.pendingConnection_ = connection;
 
-      const progressListener: (progressEvent: ProgressEvent) => void =
-        progressEvent => {
-          const loaded = progressEvent.loaded;
-          const total = progressEvent.lengthComputable
-            ? progressEvent.total
-            : -1;
-          if (this.progressCallback_ !== null) {
-            this.progressCallback_(loaded, total);
-          }
-        };
+      const progressListener: (
+        progressEvent: ProgressEvent
+      ) => void = progressEvent => {
+        const loaded = progressEvent.loaded;
+        const total = progressEvent.lengthComputable ? progressEvent.total : -1;
+        if (this.progressCallback_ !== null) {
+          this.progressCallback_(loaded, total);
+        }
+      };
       if (this.progressCallback_ !== null) {
         connection.addUploadProgressListener(progressListener);
       }
@@ -118,7 +119,11 @@ class NetworkRequest<I extends ConnectionType, O> implements Request<O> {
           this.pendingConnection_ = null;
           const hitServer = connection.getErrorCode() === ErrorCode.NO_ERROR;
           const status = connection.getStatus();
-          if (!hitServer || this.isRetryStatusCode_(status)) {
+          if (
+            (!hitServer ||
+              isRetryStatusCode(status, this.additionalRetryCodes_)) &&
+            this.retry
+          ) {
             const wasCanceled = connection.getErrorCode() === ErrorCode.ABORT;
             backoffCallback(
               false,
@@ -196,22 +201,6 @@ class NetworkRequest<I extends ConnectionType, O> implements Request<O> {
       this.pendingConnection_.abort();
     }
   }
-
-  private isRetryStatusCode_(status: number): boolean {
-    // The codes for which to retry came from this page:
-    // https://cloud.google.com/storage/docs/exponential-backoff
-    const isFiveHundredCode = status >= 500 && status < 600;
-    const extraRetryCodes = [
-      // Request Timeout: web server didn't receive full request in time.
-      408,
-      // Too Many Requests: you're getting rate-limited, basically.
-      429
-    ];
-    const isExtraRetryCode = extraRetryCodes.indexOf(status) !== -1;
-    const isRequestSpecificRetryCode =
-      this.additionalRetryCodes_.indexOf(status) !== -1;
-    return isFiveHundredCode || isExtraRetryCode || isRequestSpecificRetryCode;
-  }
 }
 
 /**
@@ -271,7 +260,8 @@ export function makeRequest<I extends ConnectionType, O>(
   authToken: string | null,
   appCheckToken: string | null,
   requestFactory: () => Connection<I>,
-  firebaseVersion?: string
+  firebaseVersion?: string,
+  retry = true
 ): Request<O> {
   const queryPart = makeQueryString(requestInfo.urlParams);
   const url = requestInfo.url + queryPart;
@@ -291,6 +281,7 @@ export function makeRequest<I extends ConnectionType, O>(
     requestInfo.errorHandler,
     requestInfo.timeout,
     requestInfo.progressCallback,
-    requestFactory
+    requestFactory,
+    retry
   );
 }
diff --git a/packages/storage/src/implementation/requests.ts b/packages/storage/src/implementation/requests.ts
index ab3b4e26827..5b32e05a9b5 100644
--- a/packages/storage/src/implementation/requests.ts
+++ b/packages/storage/src/implementation/requests.ts
@@ -104,7 +104,7 @@ export function sharedErrorHandler(
     xhr: Connection<ConnectionType>,
     err: StorageError
   ): StorageError {
-    let newErr;
+    let newErr: StorageError;
     if (xhr.getStatus() === 401) {
       if (
         // This exact message string is the only consistent part of the
@@ -126,6 +126,7 @@ export function sharedErrorHandler(
         }
       }
     }
+    newErr.status = xhr.getStatus();
     newErr.serverResponse = err.serverResponse;
     return newErr;
   }
@@ -534,8 +535,14 @@ export function continueResumableUpload(
   }
   const startByte = status_.current;
   const endByte = startByte + bytesToUpload;
-  const uploadCommand =
-    bytesToUpload === bytesLeft ? 'upload, finalize' : 'upload';
+  let uploadCommand = '';
+  if (bytesToUpload === 0) {
+    uploadCommand = 'finalize';
+  } else if (bytesLeft === bytesToUpload) {
+    uploadCommand = 'upload, finalize';
+  } else {
+    uploadCommand = 'upload';
+  }
   const headers = {
     'X-Goog-Upload-Command': uploadCommand,
     'X-Goog-Upload-Offset': `${status_.current}`
diff --git a/packages/storage/src/implementation/utils.ts b/packages/storage/src/implementation/utils.ts
new file mode 100644
index 00000000000..155613dde16
--- /dev/null
+++ b/packages/storage/src/implementation/utils.ts
@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Checks the status code to see if the action should be retried.
+ *
+ * @param status Current HTTP status code returned by server.
+ * @param additionalRetryCodes additional retry codes to check against
+ */
+export function isRetryStatusCode(
+  status: number,
+  additionalRetryCodes: number[]
+): boolean {
+  // The codes for which to retry came from this page:
+  // https://cloud.google.com/storage/docs/exponential-backoff
+  const isFiveHundredCode = status >= 500 && status < 600;
+  const extraRetryCodes = [
+    // Request Timeout: web server didn't receive full request in time.
+    408,
+    // Too Many Requests: you're getting rate-limited, basically.
+    429
+  ];
+  const isExtraRetryCode = extraRetryCodes.indexOf(status) !== -1;
+  const isAdditionalRetryCode = additionalRetryCodes.indexOf(status) !== -1;
+  return isFiveHundredCode || isExtraRetryCode || isAdditionalRetryCode;
+}
diff --git a/packages/storage/src/service.ts b/packages/storage/src/service.ts
index 3034543e531..6777cb7b659 100644
--- a/packages/storage/src/service.ts
+++ b/packages/storage/src/service.ts
@@ -302,7 +302,8 @@ export class FirebaseStorageImpl implements FirebaseStorage {
     requestInfo: RequestInfo<I, O>,
     requestFactory: () => Connection<I>,
     authToken: string | null,
-    appCheckToken: string | null
+    appCheckToken: string | null,
+    retry = true
   ): Request<O> {
     if (!this._deleted) {
       const request = makeRequest(
@@ -311,7 +312,8 @@ export class FirebaseStorageImpl implements FirebaseStorage {
         authToken,
         appCheckToken,
         requestFactory,
-        this._firebaseVersion
+        this._firebaseVersion,
+        retry
       );
       this._requests.add(request);
       // Request removes itself from set when complete.
diff --git a/packages/storage/src/task.ts b/packages/storage/src/task.ts
index e35ee579b40..2b428d1be16 100644
--- a/packages/storage/src/task.ts
+++ b/packages/storage/src/task.ts
@@ -22,7 +22,8 @@ import { FbsBlob } from './implementation/blob';
 import {
   canceled,
   StorageErrorCode,
-  StorageError
+  StorageError,
+  retryLimitExceeded
 } from './implementation/error';
 import {
   InternalTaskState,
@@ -53,6 +54,9 @@ import {
 } from './implementation/requests';
 import { Reference } from './reference';
 import { newTextConnection } from './platform/connection';
+import { isRetryStatusCode } from './implementation/utils';
+import { CompleteFn } from '@firebase/util';
+import { DEFAULT_MIN_SLEEP_TIME_MILLIS } from './implementation/constants';
 
 /**
  * Represents a blob being uploaded. Can be used to pause/resume/cancel the
@@ -92,6 +96,14 @@ export class UploadTask {
   private _reject?: (p1: StorageError) => void = undefined;
   private _promise: Promise<UploadTaskSnapshot>;
 
+  private sleepTime: number;
+
+  private maxSleepTime: number;
+
+  isExponentialBackoffExpired(): boolean {
+    return this.sleepTime > this.maxSleepTime;
+  }
+
   /**
    * @param ref - The firebaseStorage.Reference object this task came
    *     from, untyped to avoid cyclic dependencies.
@@ -111,6 +123,20 @@ export class UploadTask {
         this._needToFetchStatus = true;
         this.completeTransitions_();
       } else {
+        const backoffExpired = this.isExponentialBackoffExpired();
+        if (isRetryStatusCode(error.status, [])) {
+          if (backoffExpired) {
+            error = retryLimitExceeded();
+          } else {
+            this.sleepTime = Math.max(
+              this.sleepTime * 2,
+              DEFAULT_MIN_SLEEP_TIME_MILLIS
+            );
+            this._needToFetchStatus = true;
+            this.completeTransitions_();
+            return;
+          }
+        }
         this._error = error;
         this._transition(InternalTaskState.ERROR);
       }
@@ -124,6 +150,8 @@ export class UploadTask {
         this._transition(InternalTaskState.ERROR);
       }
     };
+    this.sleepTime = 0;
+    this.maxSleepTime = this._ref.storage.maxUploadRetryTime;
     this._promise = new Promise((resolve, reject) => {
       this._resolve = resolve;
       this._reject = reject;
@@ -163,7 +191,9 @@ export class UploadTask {
             // Happens if we miss the metadata on upload completion.
             this._fetchMetadata();
           } else {
-            this._continueUpload();
+            setTimeout(() => {
+              this._continueUpload();
+            }, this.sleepTime);
           }
         }
       }
@@ -283,7 +313,8 @@ export class UploadTask {
         requestInfo,
         newTextConnection,
         authToken,
-        appCheckToken
+        appCheckToken,
+        /*retry=*/ false // Upload requests should not be retried as each retry should be preceded by another query request. Which is handled in this file.
       );
       this._request = uploadRequest;
       uploadRequest.getPromise().then((newStatus: ResumableUploadStatus) => {
@@ -304,7 +335,7 @@ export class UploadTask {
     const currentSize = RESUMABLE_UPLOAD_CHUNK_SIZE * this._chunkMultiplier;
 
     // Max chunk size is 32M.
-    if (currentSize < 32 * 1024 * 1024) {
+    if (currentSize * 2 < 32 * 1024 * 1024) {
       this._chunkMultiplier *= 2;
     }
   }
@@ -491,8 +522,9 @@ export class UploadTask {
       | null
       | ((snapshot: UploadTaskSnapshot) => unknown),
     error?: ((a: StorageError) => unknown) | null,
-    completed?: Unsubscribe | null
+    completed?: CompleteFn | null
   ): Unsubscribe | Subscribe<UploadTaskSnapshot> {
+    // Note: `type` isn't being used. Its type is also incorrect. TaskEvent should not be a string.
     const observer = new Observer(
       (nextOrObserver as
         | StorageObserverInternal<UploadTaskSnapshot>
diff --git a/packages/storage/test/unit/requests.test.ts b/packages/storage/test/unit/requests.test.ts
index 8246a507e7d..dd42b1e84d0 100644
--- a/packages/storage/test/unit/requests.test.ts
+++ b/packages/storage/test/unit/requests.test.ts
@@ -632,6 +632,71 @@ describe('Firebase Storage > Requests', () => {
 
     return assertBodyEquals(requestInfo.body, smallBlobString);
   });
+  it('populates requestInfo with the upload command when more chunks are left', () => {
+    const url =
+      'https://this.is.totally.a.real.url.com/hello/upload?whatsgoingon';
+    const requestInfo = continueResumableUpload(
+      locationNormal,
+      storageService,
+      url,
+      bigBlob,
+      RESUMABLE_UPLOAD_CHUNK_SIZE,
+      mappings
+    );
+    assertObjectIncludes(
+      {
+        url,
+        method: 'POST',
+        urlParams: {},
+        headers: {
+          'X-Goog-Upload-Command': 'upload',
+          'X-Goog-Upload-Offset': '0'
+        }
+      },
+      requestInfo
+    );
+
+    assert.deepEqual(
+      requestInfo.body,
+      bigBlob.slice(0, RESUMABLE_UPLOAD_CHUNK_SIZE)!.uploadData()
+    );
+  });
+  it('populates requestInfo with just the finalize command command when no more data needs to be uploaded', () => {
+    const url =
+      'https://this.is.totally.a.real.url.com/hello/upload?whatsgoingon';
+    const blobSize = bigBlob.size();
+    const requestInfo = continueResumableUpload(
+      locationNormal,
+      storageService,
+      url,
+      bigBlob,
+      RESUMABLE_UPLOAD_CHUNK_SIZE,
+      mappings,
+      {
+        current: blobSize,
+        total: blobSize,
+        finalized: false,
+        metadata: null
+      }
+    );
+    assertObjectIncludes(
+      {
+        url,
+        method: 'POST',
+        urlParams: {},
+        headers: {
+          'X-Goog-Upload-Command': 'finalize',
+          'X-Goog-Upload-Offset': blobSize.toString()
+        }
+      },
+      requestInfo
+    );
+
+    assert.deepEqual(
+      requestInfo.body,
+      bigBlob.slice(blobSize, blobSize)!.uploadData()
+    );
+  });
   it('continueResumableUpload handler', () => {
     const url =
       'https://this.is.totally.a.real.url.com/hello/upload?whatsgoingon';
diff --git a/packages/storage/test/unit/task.test.ts b/packages/storage/test/unit/task.test.ts
index cdd57152cb0..16849e13998 100644
--- a/packages/storage/test/unit/task.test.ts
+++ b/packages/storage/test/unit/task.test.ts
@@ -14,22 +14,35 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { assert } from 'chai';
+import { assert, expect } from 'chai';
 import { FbsBlob } from '../../src/implementation/blob';
 import { Location } from '../../src/implementation/location';
 import { Unsubscribe } from '../../src/implementation/observer';
 import { TaskEvent, TaskState } from '../../src/implementation/taskenums';
 import { Reference } from '../../src/reference';
 import { UploadTask } from '../../src/task';
-import { fakeServerHandler, storageServiceWithHandler } from './testshared';
+import {
+  fake503ForFinalizeServerHandler,
+  fakeOneShot503ServerHandler,
+  fake503ForUploadServerHandler,
+  fakeServerHandler,
+  RequestHandler,
+  storageServiceWithHandler
+} from './testshared';
 import { injectTestConnection } from '../../src/platform/connection';
+import { Deferred } from '@firebase/util';
+import { retryLimitExceeded } from '../../src/implementation/error';
+import { SinonFakeTimers, useFakeTimers } from 'sinon';
 
 const testLocation = new Location('bucket', 'object');
 const smallBlob = new FbsBlob(new Uint8Array([97]));
 const bigBlob = new FbsBlob(new ArrayBuffer(1024 * 1024));
 
 describe('Firebase Storage > Upload Task', () => {
-  after(() => injectTestConnection(null));
+  let clock: SinonFakeTimers;
+  after(() => {
+    injectTestConnection(null);
+  });
 
   it('Works for a small upload w/ an observer', done => {
     const storageService = storageServiceWithHandler(fakeServerHandler());
@@ -151,6 +164,12 @@ describe('Firebase Storage > Upload Task', () => {
     });
   });
 
+  /**
+   * Takes a blob, uploads the blob, and tracks the events in the `events` array. It asserts in the `onComplete` callback itself.
+   *
+   * @param blob Blob to upload
+   * @returns resolved/rejected promise
+   */
   function runNormalUploadTest(blob: FbsBlob): Promise<void> {
     const storageService = storageServiceWithHandler(fakeServerHandler());
     const task = new UploadTask(
@@ -272,6 +291,7 @@ describe('Firebase Storage > Upload Task', () => {
       fixedAssertTrue(allTotalsTheSame);
       fixedAssertTrue(lastIsAll);
 
+      // serves as the cancellation task. It will cancel immediately and upon completion, will check that an error occurred
       const task2 = new UploadTask(
         new Reference(storageService, testLocation),
         blob
@@ -284,6 +304,7 @@ describe('Firebase Storage > Upload Task', () => {
           TaskEvent.STATE_CHANGED,
           snapshot => {
             const state = snapshot.state;
+            // TODO: This status update should probably be extracted out in a helper function.
             if (
               lastState !== TaskState.RUNNING &&
               state === TaskState.RUNNING
@@ -298,9 +319,11 @@ describe('Firebase Storage > Upload Task', () => {
             lastState = state;
           },
           () => {
+            // TODO: These assertions should be moved down. Adding them here makes it unclear what the assertions are.
             events2.push('failure');
             fixedAssertEquals(events2.length, 2);
             fixedAssertEquals(events2[0], 'resume');
+            // This is not enough. Simply asserting that there was some failure doesn't validate that the *right* error was thrown.
             fixedAssertEquals(events2[1], 'failure');
             resolve(null);
           },
@@ -316,6 +339,79 @@ describe('Firebase Storage > Upload Task', () => {
 
     return promise;
   }
+  enum StateType {
+    RESUME = 'resume',
+    PAUSE = 'pause',
+    ERROR = 'error',
+    COMPLETE = 'complete'
+  }
+  interface State {
+    type: StateType;
+    data?: Error;
+  }
+  interface Progress {
+    bytesTransferred: number;
+    totalBytes: number;
+  }
+  interface TotalState {
+    events: State[];
+    progress: Progress[];
+  }
+
+  function handleStateChange(
+    requestHandler: RequestHandler,
+    blob: FbsBlob
+  ): Promise<TotalState> {
+    const storageService = storageServiceWithHandler(requestHandler);
+    const task = new UploadTask(
+      new Reference(storageService, testLocation),
+      blob
+    );
+
+    const deferred = new Deferred<TotalState>();
+    let lastState: TaskState;
+
+    const events: State[] = [];
+    const progress: Progress[] = [];
+
+    task.on(
+      TaskEvent.STATE_CHANGED,
+      snapshot => {
+        const { state } = snapshot;
+        if (lastState !== TaskState.RUNNING && state === TaskState.RUNNING) {
+          events.push({ type: StateType.RESUME });
+        } else if (
+          lastState !== TaskState.PAUSED &&
+          state === TaskState.PAUSED
+        ) {
+          events.push({ type: StateType.PAUSE });
+        }
+        const p = {
+          bytesTransferred: snapshot.bytesTransferred,
+          totalBytes: snapshot.totalBytes
+        };
+        progress.push(p);
+
+        lastState = state;
+      },
+      function onError(e) {
+        events.push({ type: StateType.ERROR, data: e });
+        deferred.resolve({
+          events,
+          progress
+        });
+      },
+      function onComplete() {
+        events.push({ type: StateType.COMPLETE });
+        deferred.resolve({
+          events,
+          progress
+        });
+      }
+    );
+
+    return deferred.promise;
+  }
 
   it('Calls callback sequences for small uploads correctly', () => {
     return runNormalUploadTest(smallBlob);
@@ -323,4 +419,84 @@ describe('Firebase Storage > Upload Task', () => {
   it('Calls callback sequences for big uploads correctly', () => {
     return runNormalUploadTest(bigBlob);
   });
+  it('properly times out if large blobs returns a 503 when finalizing', async () => {
+    clock = useFakeTimers();
+    // Kick off upload
+    const promise = handleStateChange(
+      fake503ForFinalizeServerHandler(),
+      bigBlob
+    );
+    // Run all timers
+    await clock.runAllAsync();
+    const { events, progress } = await promise;
+    expect(events.length).to.equal(2);
+    expect(events[0]).to.deep.equal({ type: 'resume' });
+    expect(events[1].type).to.deep.equal('error');
+    const retryLimitError = retryLimitExceeded();
+    expect(events[1].data!.name).to.deep.equal(retryLimitError.name);
+    expect(events[1].data!.message).to.deep.equal(retryLimitError.message);
+    const blobSize = bigBlob.size();
+    expect(progress.length).to.equal(4);
+    expect(progress[0]).to.deep.equal({
+      bytesTransferred: 0,
+      totalBytes: blobSize
+    });
+    expect(progress[1]).to.deep.equal({
+      bytesTransferred: 262144,
+      totalBytes: blobSize
+    });
+    // Upon continueUpload the multiplier becomes * 2, so chunkSize becomes 2 * DEFAULT_CHUNK_SIZE(256 * 1024)
+    expect(progress[2]).to.deep.equal({
+      bytesTransferred: 786432,
+      totalBytes: blobSize
+    });
+    // Chunk size is smaller here since there are less bytes left to upload than the chunkSize.
+    expect(progress[3]).to.deep.equal({
+      bytesTransferred: 1048576,
+      totalBytes: blobSize
+    });
+    clock.restore();
+  });
+  it('properly times out if large blobs returns a 503 when uploading', async () => {
+    clock = useFakeTimers();
+    // Kick off upload
+    const promise = handleStateChange(fake503ForUploadServerHandler(), bigBlob);
+    // Run all timers
+    await clock.runAllAsync();
+    const { events, progress } = await promise;
+    expect(events.length).to.equal(2);
+    expect(events[0]).to.deep.equal({ type: 'resume' });
+    expect(events[1].type).to.deep.equal('error');
+    const retryLimitError = retryLimitExceeded();
+    expect(events[1].data!.name).to.deep.equal(retryLimitError.name);
+    expect(events[1].data!.message).to.deep.equal(retryLimitError.message);
+    const blobSize = bigBlob.size();
+    expect(progress.length).to.equal(1);
+    expect(progress[0]).to.deep.equal({
+      bytesTransferred: 0,
+      totalBytes: blobSize
+    });
+    clock.restore();
+  });
+  it('tests if small requests that respond with 500 retry correctly', async () => {
+    clock = useFakeTimers();
+    // Kick off upload
+    const promise = handleStateChange(fakeOneShot503ServerHandler(), smallBlob);
+    // Run all timers
+    await clock.runAllAsync();
+    const { events, progress } = await promise;
+    expect(events.length).to.equal(2);
+    expect(events[0]).to.deep.equal({ type: 'resume' });
+    expect(events[1].type).to.deep.equal('error');
+    const retryLimitError = retryLimitExceeded();
+    expect(events[1].data!.name).to.deep.equal(retryLimitError.name);
+    expect(events[1].data!.message).to.deep.equal(retryLimitError.message);
+    const blobSize = smallBlob.size();
+    expect(progress.length).to.equal(1);
+    expect(progress[0]).to.deep.equal({
+      bytesTransferred: 0,
+      totalBytes: blobSize
+    });
+    clock.restore();
+  });
 });
diff --git a/packages/storage/test/unit/testshared.ts b/packages/storage/test/unit/testshared.ts
index 1aa6a53e32a..c6b07f62c32 100644
--- a/packages/storage/test/unit/testshared.ts
+++ b/packages/storage/test/unit/testshared.ts
@@ -197,7 +197,7 @@ interface Response {
   body: string;
   headers: Headers;
 }
-type RequestHandler = (
+export type RequestHandler = (
   url: string,
   method: string,
   body?: ArrayBufferView | Blob | string | null,
@@ -353,3 +353,232 @@ export function fakeServerHandler(
   }
   return handler;
 }
+
+/**
+ * Responds with a 503 for finalize.
+ * @param fakeMetadata metadata to respond with for query
+ * @returns a handler for requests
+ */
+export function fake503ForFinalizeServerHandler(
+  fakeMetadata: Partial<Metadata> = defaultFakeMetadata
+): RequestHandler {
+  const stats: {
+    [num: number]: {
+      currentSize: number;
+      finalSize: number;
+    };
+  } = {};
+
+  let nextId: number = 0;
+
+  function statusHeaders(status: string, existing?: Headers): Headers {
+    if (existing) {
+      existing['X-Goog-Upload-Status'] = status;
+      return existing;
+    } else {
+      return { 'X-Goog-Upload-Status': status };
+    }
+  }
+
+  function handler(
+    url: string,
+    method: string,
+    content?: ArrayBufferView | Blob | string | null,
+    headers?: Headers
+  ): Response {
+    method = method || 'GET';
+    content = content || '';
+    headers = headers || {};
+
+    // const contentLength =
+    // (content as Blob).size || (content as string).length || 0;
+    if (headers['X-Goog-Upload-Protocol'] === 'resumable') {
+      const thisId = nextId;
+      nextId++;
+      stats[thisId] = {
+        currentSize: 0,
+        finalSize: +headers['X-Goog-Upload-Header-Content-Length']
+      };
+
+      return {
+        status: 200,
+        body: '',
+        headers: statusHeaders('active', {
+          'X-Goog-Upload-URL': 'http://example.com?' + thisId
+        })
+      };
+    }
+
+    const matches = url.match(/^http:\/\/example\.com\?([0-9]+)$/);
+    if (matches === null) {
+      return { status: 400, body: '', headers: {} };
+    }
+
+    const id = +matches[1];
+    if (!stats[id]) {
+      return { status: 400, body: 'Invalid upload id', headers: {} };
+    }
+
+    if (headers['X-Goog-Upload-Command'] === 'query') {
+      return {
+        status: 200,
+        body: '',
+        headers: statusHeaders('active', {
+          'X-Goog-Upload-Size-Received': stats[id].finalSize.toString()
+        })
+      };
+    }
+
+    const commands = (headers['X-Goog-Upload-Command'] as string)
+      .split(',')
+      .map(str => {
+        return str.trim();
+      });
+    const isFinalize = commands.indexOf('finalize') !== -1;
+
+    if (isFinalize) {
+      return {
+        status: 503,
+        body: JSON.stringify(fakeMetadata),
+        headers: statusHeaders('final')
+      };
+    } else {
+      return {
+        status: 200,
+        body: JSON.stringify(fakeMetadata),
+        headers: statusHeaders('active')
+      };
+    }
+  }
+  return handler;
+}
+
+/**
+ * Responds with a 503 for upload.
+ * @param fakeMetadata metadata to respond with for query
+ * @returns a handler for requests
+ */
+export function fake503ForUploadServerHandler(
+  fakeMetadata: Partial<Metadata> = defaultFakeMetadata
+): RequestHandler {
+  const stats: {
+    [num: number]: {
+      currentSize: number;
+      finalSize: number;
+    };
+  } = {};
+
+  let nextId: number = 0;
+
+  function statusHeaders(status: string, existing?: Headers): Headers {
+    if (existing) {
+      existing['X-Goog-Upload-Status'] = status;
+      return existing;
+    } else {
+      return { 'X-Goog-Upload-Status': status };
+    }
+  }
+
+  function handler(
+    url: string,
+    method: string,
+    content?: ArrayBufferView | Blob | string | null,
+    headers?: Headers
+  ): Response {
+    method = method || 'GET';
+    content = content || '';
+    headers = headers || {};
+
+    // const contentLength =
+    // (content as Blob).size || (content as string).length || 0;
+    if (headers['X-Goog-Upload-Protocol'] === 'resumable') {
+      const thisId = nextId;
+      nextId++;
+      stats[thisId] = {
+        currentSize: 0,
+        finalSize: +headers['X-Goog-Upload-Header-Content-Length']
+      };
+
+      return {
+        status: 200,
+        body: '',
+        headers: statusHeaders('active', {
+          'X-Goog-Upload-URL': 'http://example.com?' + thisId
+        })
+      };
+    }
+
+    const matches = url.match(/^http:\/\/example\.com\?([0-9]+)$/);
+    if (matches === null) {
+      return { status: 400, body: '', headers: {} };
+    }
+
+    const id = +matches[1];
+    if (!stats[id]) {
+      return { status: 400, body: 'Invalid upload id', headers: {} };
+    }
+
+    if (headers['X-Goog-Upload-Command'] === 'query') {
+      return {
+        status: 200,
+        body: '',
+        headers: statusHeaders('active', {
+          'X-Goog-Upload-Size-Received': stats[id].currentSize.toString()
+        })
+      };
+    }
+
+    const commands = (headers['X-Goog-Upload-Command'] as string)
+      .split(',')
+      .map(str => {
+        return str.trim();
+      });
+    const isUpload = commands.indexOf('upload') !== -1;
+
+    if (isUpload) {
+      return {
+        status: 503,
+        body: JSON.stringify(fakeMetadata),
+        headers: statusHeaders('active')
+      };
+    } else {
+      return {
+        status: 200,
+        body: JSON.stringify(fakeMetadata),
+        headers: statusHeaders('final')
+      };
+    }
+  }
+  return handler;
+}
+
+export function fakeOneShot503ServerHandler(
+  fakeMetadata: Partial<Metadata> = defaultFakeMetadata
+): RequestHandler {
+  function statusHeaders(status: string, existing?: Headers): Headers {
+    if (existing) {
+      existing['X-Goog-Upload-Status'] = status;
+      return existing;
+    } else {
+      return { 'X-Goog-Upload-Status': status };
+    }
+  }
+
+  function handler(
+    url: string,
+    method: string,
+    content?: ArrayBufferView | Blob | string | null,
+    headers?: Headers
+  ): Response {
+    method = method || 'GET';
+    content = content || '';
+    headers = headers || {};
+
+    return {
+      status: 503,
+      body: JSON.stringify(fakeMetadata),
+      headers: statusHeaders('final')
+    };
+  }
+  return handler;
+}
diff --git a/packages/storage/test/unit/utils.test.ts b/packages/storage/test/unit/utils.test.ts
new file mode 100644
index 00000000000..e02393d13f9
--- /dev/null
+++ b/packages/storage/test/unit/utils.test.ts
@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { expect } from 'chai';
+import { isRetryStatusCode } from '../../src/implementation/utils';
+
+describe('Storage Utils', () => {
+  it('does not deem 400 as a retry status code', () => {
+    const isRetry = isRetryStatusCode(400, []);
+    expect(isRetry).to.be.false;
+  });
+  it('deems extra retry codes as retryable ', () => {
+    let isRetry = isRetryStatusCode(408, []);
+    expect(isRetry).to.be.true;
+    isRetry = isRetryStatusCode(429, []);
+    expect(isRetry).to.be.true;
+  });
+  it('deems error codes beyond 500 as retryable', () => {
+    const isRetry = isRetryStatusCode(503, []);
+    expect(isRetry).to.be.true;
+  });
+  it('deems additional error codes as retryable', () => {
+    const isRetry = isRetryStatusCode(400, [400]);
+    expect(isRetry).to.be.true;
+  });
+});
diff --git a/packages/util/src/defaults.ts b/packages/util/src/defaults.ts
index 6acc5886b5c..185269dc3d4 100644
--- a/packages/util/src/defaults.ts
+++ b/packages/util/src/defaults.ts
@@ -57,33 +57,13 @@ const getDefaultsFromGlobal = (): FirebaseDefaults | undefined =>
  * process.env.__FIREBASE_DEFAULTS_PATH__
  */
 const getDefaultsFromEnvVariable = (): FirebaseDefaults | undefined => {
-  if (typeof process === 'undefined') {
+  if (typeof process === 'undefined' || typeof process.env === 'undefined') {
     return;
   }
   const defaultsJsonString = process.env.__FIREBASE_DEFAULTS__;
-  const defaultsJsonPath = process.env.__FIREBASE_DEFAULTS_PATH__;
   if (defaultsJsonString) {
-    if (defaultsJsonPath) {
-      console.warn(
-        `Values were provided for both __FIREBASE_DEFAULTS__ ` +
-          `and __FIREBASE_DEFAULTS_PATH__. __FIREBASE_DEFAULTS_PATH__ ` +
-          `will be ignored.`
-      );
-    }
     return JSON.parse(defaultsJsonString);
   }
-  if (defaultsJsonPath && typeof require !== 'undefined') {
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const json = require(defaultsJsonPath);
-      return json;
-    } catch (e) {
-      console.warn(
-        `Unable to read defaults from file provided to ` +
-          `__FIREBASE_DEFAULTS_PATH__: ${defaultsJsonPath}`
-      );
-    }
-  }
 };
 
 const getDefaultsFromCookie = (): FirebaseDefaults | undefined => {
diff --git a/packages/webchannel-wrapper/src/index.d.ts b/packages/webchannel-wrapper/src/index.d.ts
index d680a86ece2..4a1f45f1d70 100644
--- a/packages/webchannel-wrapper/src/index.d.ts
+++ b/packages/webchannel-wrapper/src/index.d.ts
@@ -74,6 +74,8 @@ export class XhrIo {
   getResponseJson(): WebChannelError | object;
 
   listenOnce(type: string, cb: (param: unknown) => void): void;
+
+  setWithCredentials(withCredentials: boolean): void;
 }
 
 export interface WebChannelOptions {
diff --git a/packages/webchannel-wrapper/src/index.js b/packages/webchannel-wrapper/src/index.js
index 1cf3d2537d1..c51f7d68ba3 100644
--- a/packages/webchannel-wrapper/src/index.js
+++ b/packages/webchannel-wrapper/src/index.js
@@ -75,6 +75,8 @@ goog.net.XhrIo.prototype['getResponseJson'] =
 goog.net.XhrIo.prototype['getResponseText'] =
   goog.net.XhrIo.prototype.getResponseText;
 goog.net.XhrIo.prototype['send'] = goog.net.XhrIo.prototype.send;
+goog.net.XhrIo.prototype['setWithCredentials'] =
+  goog.net.XhrIo.prototype.setWithCredentials;
 
 module['exports']['createWebChannelTransport'] =
   goog.net.createWebChannelTransport;
diff --git a/scripts/docgen/docgen.ts b/scripts/docgen/docgen.ts
index f1d64cfbec2..5df01925338 100644
--- a/scripts/docgen/docgen.ts
+++ b/scripts/docgen/docgen.ts
@@ -200,8 +200,12 @@ async function generateDocs(
 
   await moveRulesUnitTestingDocs(outputFolder, command);
   await removeExcludedDocs(outputFolder);
+  await removeExcludedPackageEntries(outputFolder);
 }
 
+/**
+ * Remove markdown files generated for excluded packages.
+ */
 async function removeExcludedDocs(mainDocsFolder: string) {
   console.log('Removing excluded docs from', EXCLUDED_PACKAGES.join(', '));
   for (const excludedPackage of EXCLUDED_PACKAGES) {
@@ -211,13 +215,34 @@ async function removeExcludedDocs(mainDocsFolder: string) {
         resolve(paths);
       })
     );
-    console.log('glob pattern', `${mainDocsFolder}/${excludedPackage}.*`);
     for (const excludedMdFile of excludedMdFiles) {
       fs.unlinkSync(excludedMdFile);
     }
   }
 }
 
+/**
+ * Remove lines from index.md that link to excluded packages.
+ */
+async function removeExcludedPackageEntries(mainDocsFolder: string) {
+  console.log(`Removing ${EXCLUDED_PACKAGES.join(', ')} from index page.`);
+  const indexText = fs.readFileSync(`${mainDocsFolder}/index.md`, 'utf-8');
+  const indexTextLines = indexText.split('\n');
+  const newIndexTextLines = indexTextLines.filter(line => {
+    for (const excludedPackage of EXCLUDED_PACKAGES) {
+      if (line.includes(`[@firebase/${excludedPackage}]`)) {
+        return false;
+      }
+    }
+    return true;
+  });
+  fs.writeFileSync(
+    `${mainDocsFolder}/index.md`,
+    newIndexTextLines.join('\n'),
+    'utf-8'
+  );
+}
+
 // Create a docs-rut folder and move rules-unit-testing docs into it.
 async function moveRulesUnitTestingDocs(
   mainDocsFolder: string,