@firebase/messaging 0.12.26-20260505185142 → 0.12.26-eap-crashlytics.3dd4e65d9

package/dist/esm/index.sw.esm.js

@@ -25,6 +25,13 @@ const ENDPOINT = 'https://fcmregistrations.googleapis.com/v1';
 /** Key of FCM Payload in Notification's data field. */
 const FCM_MSG = 'FCM_MSG';
 const CONSOLE_CAMPAIGN_ID = 'google.c.a.c_id';
+const MAX_NUMBER_OF_EVENTS_PER_LOG_REQUEST = 1000;
+const MAX_RETRIES = 3;
+const LOG_INTERVAL_IN_MS = 86400000; //24 hour
+const DEFAULT_BACKOFF_TIME_MS = 5000;
+// FCM log source name registered at Firelog: 'FCM_CLIENT_EVENT_LOGGING'. It uniquely identifies
+// FCM's logging configuration.
+const FCM_LOG_SOURCE = 1249;
 // Defined as in proto/messaging_event.proto. Neglecting fields that are supported.
 const SDK_PLATFORM_WEB = 3;
 const EVENT_MESSAGE_DELIVERED = 1;
@@ -217,6 +224,53 @@ function checkTokenDetails(tokenDetails) {
         subscriptionOptions.vapidKey.length > 0);
 }
 
+/**
+ * @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 ERROR_MAP = {
+    ["missing-app-config-values" /* ErrorCode.MISSING_APP_CONFIG_VALUES */]: 'Missing App configuration value: "{$valueName}"',
+    ["only-available-in-window" /* ErrorCode.AVAILABLE_IN_WINDOW */]: 'This method is available in a Window context.',
+    ["only-available-in-sw" /* ErrorCode.AVAILABLE_IN_SW */]: 'This method is available in a service worker context.',
+    ["permission-default" /* ErrorCode.PERMISSION_DEFAULT */]: 'The notification permission was not granted and dismissed instead.',
+    ["permission-blocked" /* ErrorCode.PERMISSION_BLOCKED */]: 'The notification permission was not granted and blocked instead.',
+    ["unsupported-browser" /* ErrorCode.UNSUPPORTED_BROWSER */]: "This browser doesn't support the API's required to use the Firebase SDK.",
+    ["indexed-db-unsupported" /* ErrorCode.INDEXED_DB_UNSUPPORTED */]: "This browser doesn't support indexedDb.open() (ex. Safari iFrame, Firefox Private Browsing, etc)",
+    ["failed-service-worker-registration" /* ErrorCode.FAILED_DEFAULT_REGISTRATION */]: 'We are unable to register the default service worker. {$browserErrorMessage}',
+    ["token-subscribe-failed" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */]: 'A problem occurred while subscribing the user to FCM: {$errorInfo}',
+    ["token-subscribe-no-token" /* ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN */]: 'FCM returned no token when subscribing the user to push.',
+    ["fid-registration-failed" /* ErrorCode.FID_REGISTRATION_FAILED */]: 'A problem occurred while creating an FCM registration via FID: {$errorInfo}',
+    ["fid-unregister-failed" /* ErrorCode.FID_UNREGISTER_FAILED */]: 'A problem occurred while unregistering the FCM registration via FID: {$errorInfo}',
+    ["fid-registration-idb-schema-unavailable" /* ErrorCode.FID_REGISTRATION_IDB_SCHEMA_UNAVAILABLE */]: 'Unable to read or persist FID registration metadata because the messaging ' +
+        'IndexedDB schema is unavailable (for example, the database could not be ' +
+        'upgraded to the latest version).',
+    ["token-unsubscribe-failed" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */]: 'A problem occurred while unsubscribing the ' +
+        'user from FCM: {$errorInfo}',
+    ["token-update-failed" /* ErrorCode.TOKEN_UPDATE_FAILED */]: 'A problem occurred while updating the user from FCM: {$errorInfo}',
+    ["token-update-no-token" /* ErrorCode.TOKEN_UPDATE_NO_TOKEN */]: 'FCM returned no token when updating the user to push.',
+    ["use-sw-after-get-token" /* ErrorCode.USE_SW_AFTER_GET_TOKEN */]: 'The useServiceWorker() method may only be called once and must be ' +
+        'called before calling getToken() to ensure your service worker is used.',
+    ["invalid-sw-registration" /* ErrorCode.INVALID_SW_REGISTRATION */]: 'The input to useServiceWorker() must be a ServiceWorkerRegistration.',
+    ["invalid-bg-handler" /* ErrorCode.INVALID_BG_HANDLER */]: 'The input to setBackgroundMessageHandler() must be a function.',
+    ["invalid-vapid-key" /* ErrorCode.INVALID_VAPID_KEY */]: 'The public VAPID key must be a string.',
+    ["use-vapid-key-after-get-token" /* ErrorCode.USE_VAPID_KEY_AFTER_GET_TOKEN */]: 'The usePublicVapidKey() method may only be called once and must be ' +
+        'called before calling getToken() to ensure your VAPID key is used.',
+    ["invalid-on-registered-handler" /* ErrorCode.INVALID_ON_REGISTERED_HANDLER */]: 'No onRegistered callback handler was provided or registered. Implement onRegistered() before register().'
+};
+const ERROR_FACTORY = new ErrorFactory('messaging', 'Messaging', ERROR_MAP);
+
 /**
  * @license
  * Copyright 2019 Google LLC
@@ -233,41 +287,74 @@ function checkTokenDetails(tokenDetails) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-// Exported for tests.
 const DATABASE_NAME = 'firebase-messaging-database';
-const DATABASE_VERSION = 1;
-const OBJECT_STORE_NAME = 'firebase-messaging-store';
+const DATABASE_VERSION = 2;
+const TOKEN_OBJECT_STORE_NAME = 'firebase-messaging-store';
+const FID_REGISTRATION_OBJECT_STORE_NAME = 'firebase-messaging-fid-registration-store';
+const defaultIdb = { openDB, deleteDB };
+let idbImpl = defaultIdb;
+// Open v2, but fall back to v1 if upgrade/open fails. Cache as `unknown` and guard store access.
 let dbPromise = null;
+function migrateMessagingDb(upgradeDb, oldVersion, targetSchemaVersion) {
+    // Intentional fall-through for v2: run all intermediate migrations.
+    // eslint-disable-next-line default-case
+    switch (oldVersion) {
+        case 0:
+            upgradeDb.createObjectStore(TOKEN_OBJECT_STORE_NAME);
+            if (targetSchemaVersion === 1) {
+                break;
+            }
+        // fall through
+        case 1:
+            if (targetSchemaVersion === 2) {
+                upgradeDb.createObjectStore(FID_REGISTRATION_OBJECT_STORE_NAME);
+            }
+    }
+}
+function createOpenDbOptions(targetSchemaVersion) {
+    return {
+        upgrade: (upgradeDb, oldVersion) => {
+            migrateMessagingDb(upgradeDb, oldVersion, targetSchemaVersion);
+        },
+        blocked: () => {
+            /* no-op */
+        },
+        blocking: (_currentVersion, _blockedVersion, event) => {
+            dbPromise = null;
+            event.target?.close();
+        },
+        terminated: () => {
+            dbPromise = null;
+        }
+    };
+}
 function getDbPromise() {
     if (!dbPromise) {
-        dbPromise = openDB(DATABASE_NAME, DATABASE_VERSION, {
-            upgrade: (upgradeDb, oldVersion) => {
-                // We don't use 'break' in this switch statement, the fall-through behavior is what we want,
-                // because if there are multiple versions between the old version and the current version, we
-                // want ALL the migrations that correspond to those versions to run, not only the last one.
-                // eslint-disable-next-line default-case
-                switch (oldVersion) {
-                    case 0:
-                        upgradeDb.createObjectStore(OBJECT_STORE_NAME);
-                }
-            }
-        });
+        const openLatest = idbImpl.openDB(DATABASE_NAME, DATABASE_VERSION, createOpenDbOptions(2));
+        // Assign synchronously to avoid concurrent openDB() calls.
+        dbPromise = openLatest.catch(() => idbImpl.openDB(DATABASE_NAME, DATABASE_VERSION - 1, createOpenDbOptions(1)));
     }
     return dbPromise;
 }
-/** Gets record(s) from the objectStore that match the given key. */
+function hasObjectStore(db, storeName) {
+    return db.objectStoreNames.contains(storeName);
+}
+function assertFidRegistrationObjectStore(db) {
+    if (!hasObjectStore(db, FID_REGISTRATION_OBJECT_STORE_NAME)) {
+        throw ERROR_FACTORY.create("fid-registration-idb-schema-unavailable" /* ErrorCode.FID_REGISTRATION_IDB_SCHEMA_UNAVAILABLE */);
+    }
+}
 async function dbGet(firebaseDependencies) {
     const key = getKey(firebaseDependencies);
     const db = await getDbPromise();
     const tokenDetails = (await db
-        .transaction(OBJECT_STORE_NAME)
-        .objectStore(OBJECT_STORE_NAME)
+        .transaction(TOKEN_OBJECT_STORE_NAME)
+        .objectStore(TOKEN_OBJECT_STORE_NAME)
         .get(key));
     if (tokenDetails) {
         return tokenDetails;
     }
     else {
-        // Check if there is a tokenDetails object in the old DB.
         const oldTokenDetails = await migrateOldDatabase(firebaseDependencies.appConfig.senderId);
         if (oldTokenDetails) {
             await dbSet(firebaseDependencies, oldTokenDetails);
@@ -275,67 +362,43 @@ async function dbGet(firebaseDependencies) {
         }
     }
 }
-/** Assigns or overwrites the record for the given key with the given value. */
 async function dbSet(firebaseDependencies, tokenDetails) {
     const key = getKey(firebaseDependencies);
     const db = await getDbPromise();
-    const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');
-    await tx.objectStore(OBJECT_STORE_NAME).put(tokenDetails, key);
+    const tx = db.transaction(TOKEN_OBJECT_STORE_NAME, 'readwrite');
+    await tx.objectStore(TOKEN_OBJECT_STORE_NAME).put(tokenDetails, key);
     await tx.done;
     return tokenDetails;
 }
-/** Removes record(s) from the objectStore that match the given key. */
 async function dbRemove(firebaseDependencies) {
     const key = getKey(firebaseDependencies);
     const db = await getDbPromise();
-    const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');
-    await tx.objectStore(OBJECT_STORE_NAME).delete(key);
+    const tx = db.transaction(TOKEN_OBJECT_STORE_NAME, 'readwrite');
+    await tx.objectStore(TOKEN_OBJECT_STORE_NAME).delete(key);
+    await tx.done;
+}
+async function dbGetFidRegistration(firebaseDependencies) {
+    const key = getKey(firebaseDependencies);
+    const db = await getDbPromise();
+    assertFidRegistrationObjectStore(db);
+    return (await db
+        .transaction(FID_REGISTRATION_OBJECT_STORE_NAME)
+        .objectStore(FID_REGISTRATION_OBJECT_STORE_NAME)
+        .get(key));
+}
+async function dbRemoveFidRegistration(firebaseDependencies) {
+    const key = getKey(firebaseDependencies);
+    const db = await getDbPromise();
+    assertFidRegistrationObjectStore(db);
+    const tx = db.transaction(FID_REGISTRATION_OBJECT_STORE_NAME, 'readwrite');
+    await tx.objectStore(FID_REGISTRATION_OBJECT_STORE_NAME).delete(key);
     await tx.done;
 }
 function getKey({ appConfig }) {
     return appConfig.appId;
 }
 
-/**
- * @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 ERROR_MAP = {
-    ["missing-app-config-values" /* ErrorCode.MISSING_APP_CONFIG_VALUES */]: 'Missing App configuration value: "{$valueName}"',
-    ["only-available-in-window" /* ErrorCode.AVAILABLE_IN_WINDOW */]: 'This method is available in a Window context.',
-    ["only-available-in-sw" /* ErrorCode.AVAILABLE_IN_SW */]: 'This method is available in a service worker context.',
-    ["permission-default" /* ErrorCode.PERMISSION_DEFAULT */]: 'The notification permission was not granted and dismissed instead.',
-    ["permission-blocked" /* ErrorCode.PERMISSION_BLOCKED */]: 'The notification permission was not granted and blocked instead.',
-    ["unsupported-browser" /* ErrorCode.UNSUPPORTED_BROWSER */]: "This browser doesn't support the API's required to use the Firebase SDK.",
-    ["indexed-db-unsupported" /* ErrorCode.INDEXED_DB_UNSUPPORTED */]: "This browser doesn't support indexedDb.open() (ex. Safari iFrame, Firefox Private Browsing, etc)",
-    ["failed-service-worker-registration" /* ErrorCode.FAILED_DEFAULT_REGISTRATION */]: 'We are unable to register the default service worker. {$browserErrorMessage}',
-    ["token-subscribe-failed" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */]: 'A problem occurred while subscribing the user to FCM: {$errorInfo}',
-    ["token-subscribe-no-token" /* ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN */]: 'FCM returned no token when subscribing the user to push.',
-    ["token-unsubscribe-failed" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */]: 'A problem occurred while unsubscribing the ' +
-        'user from FCM: {$errorInfo}',
-    ["token-update-failed" /* ErrorCode.TOKEN_UPDATE_FAILED */]: 'A problem occurred while updating the user from FCM: {$errorInfo}',
-    ["token-update-no-token" /* ErrorCode.TOKEN_UPDATE_NO_TOKEN */]: 'FCM returned no token when updating the user to push.',
-    ["use-sw-after-get-token" /* ErrorCode.USE_SW_AFTER_GET_TOKEN */]: 'The useServiceWorker() method may only be called once and must be ' +
-        'called before calling getToken() to ensure your service worker is used.',
-    ["invalid-sw-registration" /* ErrorCode.INVALID_SW_REGISTRATION */]: 'The input to useServiceWorker() must be a ServiceWorkerRegistration.',
-    ["invalid-bg-handler" /* ErrorCode.INVALID_BG_HANDLER */]: 'The input to setBackgroundMessageHandler() must be a function.',
-    ["invalid-vapid-key" /* ErrorCode.INVALID_VAPID_KEY */]: 'The public VAPID key must be a string.',
-    ["use-vapid-key-after-get-token" /* ErrorCode.USE_VAPID_KEY_AFTER_GET_TOKEN */]: 'The usePublicVapidKey() method may only be called once and must be ' +
-        'called before calling getToken() to ensure your VAPID key is used.'
-};
-const ERROR_FACTORY = new ErrorFactory('messaging', 'Messaging', ERROR_MAP);
+const version = "0.12.26-eap-crashlytics.3dd4e65d9";
 
 /**
  * @license
@@ -355,7 +418,8 @@ const ERROR_FACTORY = new ErrorFactory('messaging', 'Messaging', ERROR_MAP);
  */
 async function requestGetToken(firebaseDependencies, subscriptionOptions) {
     const headers = await getHeaders(firebaseDependencies);
-    const body = getBody(subscriptionOptions);
+    const body = getBody(subscriptionOptions, firebaseDependencies.appConfig.appName, 
+    /* includeSdkVersion= */ false);
     const subscribeOptions = {
         method: 'POST',
         headers,
@@ -382,9 +446,46 @@ async function requestGetToken(firebaseDependencies, subscriptionOptions) {
     }
     return responseData.token;
 }
+/**
+ * Deletes an FCM Web registration via DeleteRegistration using the Firebase Installation ID (FID).
+ */
+async function requestDeleteRegistration(firebaseDependencies, fid) {
+    const headers = await getHeaders(firebaseDependencies);
+    const options = {
+        method: 'DELETE',
+        headers
+    };
+    let response;
+    try {
+        response = await fetch(`${getEndpoint(firebaseDependencies.appConfig)}/${fid}`, options);
+    }
+    catch (err) {
+        throw ERROR_FACTORY.create("fid-unregister-failed" /* ErrorCode.FID_UNREGISTER_FAILED */, {
+            errorInfo: err?.toString()
+        });
+    }
+    if (response.ok) {
+        return;
+    }
+    // Best-effort parse error details; surface uniform error code.
+    try {
+        const responseData = (await response.json());
+        const message = responseData.error?.message ?? response.statusText;
+        throw message;
+    }
+    catch (err) {
+        // If parsing failed, fall back to status text.
+        throw ERROR_FACTORY.create("fid-unregister-failed" /* ErrorCode.FID_UNREGISTER_FAILED */, {
+            errorInfo: (typeof err === 'string' && err) ||
+                response.statusText ||
+                err?.toString()
+        });
+    }
+}
 async function requestUpdateToken(firebaseDependencies, tokenDetails) {
     const headers = await getHeaders(firebaseDependencies);
-    const body = getBody(tokenDetails.subscriptionOptions);
+    const body = getBody(tokenDetails.subscriptionOptions, firebaseDependencies.appConfig.appName, 
+    /* includeSdkVersion= */ false);
     const updateOptions = {
         method: 'PATCH',
         headers,
@@ -445,14 +546,45 @@ async function getHeaders({ appConfig, installations }) {
         'x-goog-firebase-installations-auth': `FIS ${authToken}`
     });
 }
-function getBody({ p256dh, auth, endpoint, vapidKey }) {
+/**
+ * Hostname for the registering web client (e.g. `www.example.com`), or the app name
+ * (`appNameFallback`) when the scope cannot be resolved (e.g. some test environments).
+ */
+function getRegistrationOrigin(swScope, appNameFallback) {
+    try {
+        if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(swScope)) {
+            return new URL(swScope).host;
+        }
+    }
+    catch {
+        // Fall through to relative-scope handling.
+    }
+    try {
+        if (typeof self !== 'undefined' && self.location?.href) {
+            return new URL(swScope, self.location.origin).host;
+        }
+    }
+    catch {
+        // Fall through.
+    }
+    if (typeof self !== 'undefined' && self.location?.host) {
+        return self.location.host;
+    }
+    return appNameFallback;
+}
+function getBody({ p256dh, auth, endpoint, vapidKey, swScope }, appNameFallback, includeSdkVersion) {
     const body = {
         web: {
+            origin: getRegistrationOrigin(swScope, appNameFallback),
             endpoint,
             auth,
             p256dh
         }
     };
+    if (includeSdkVersion) {
+        // eslint-disable-next-line camelcase
+        body.fcm_sdk_version = version;
+    }
     if (vapidKey !== DEFAULT_VAPID_KEY) {
         body.web.applicationPubKey = vapidKey;
     }
@@ -486,6 +618,8 @@ async function getTokenInternal(messaging) {
         auth: arrayToBase64(pushSubscription.getKey('auth')),
         p256dh: arrayToBase64(pushSubscription.getKey('p256dh'))
     };
+    // Best-effort cleanup when switching from FID register/unregister to legacy getToken().
+    await removeFidRegistrationBestEffort(messaging.firebaseDependencies);
     const tokenDetails = await dbGet(messaging.firebaseDependencies);
     if (!tokenDetails) {
         // No token, get a new one.
@@ -515,6 +649,31 @@ async function getTokenInternal(messaging) {
         return tokenDetails.token;
     }
 }
+/**
+ * Legacy getToken() path: there is a token row in IndexedDB. Revoke it with FCM, drop the row, and
+ * clear any leftover FID registration metadata (apps may mix APIs).
+ */
+async function revokeLegacyFcmTokenAndClearCaches(messaging, tokenDetails) {
+    await requestDeleteToken(messaging.firebaseDependencies, tokenDetails.token);
+    await dbRemove(messaging.firebaseDependencies);
+    await removeFidRegistrationBestEffort(messaging.firebaseDependencies);
+}
+/**
+ * No legacy token row: the client may only have FID-based registration (register() flow). If so,
+ * delete that registration on the server, always scrub local FID metadata, then surface
+ * onUnregistered when we actually had an FID.
+ */
+async function revokeFidRegistrationIfStored(messaging) {
+    const stored = await dbGetFidRegistration(messaging.firebaseDependencies).catch(() => undefined);
+    const fid = stored?.fid;
+    if (fid) {
+        await requestDeleteRegistration(messaging.firebaseDependencies, fid);
+    }
+    await removeFidRegistrationBestEffort(messaging.firebaseDependencies);
+    if (fid) {
+        notifyOnUnregistered(messaging, fid);
+    }
+}
 /**
  * This method deletes the token from the database, unsubscribes the token from FCM, and unregisters
  * the push subscription if it exists.
@@ -522,8 +681,10 @@ async function getTokenInternal(messaging) {
 async function deleteTokenInternal(messaging) {
     const tokenDetails = await dbGet(messaging.firebaseDependencies);
     if (tokenDetails) {
-        await requestDeleteToken(messaging.firebaseDependencies, tokenDetails.token);
-        await dbRemove(messaging.firebaseDependencies);
+        await revokeLegacyFcmTokenAndClearCaches(messaging, tokenDetails);
+    }
+    else {
+        await revokeFidRegistrationIfStored(messaging);
     }
     // Unsubscribe from the push subscription.
     const pushSubscription = await messaging.swRegistration.pushManager.getSubscription();
@@ -583,6 +744,27 @@ function isTokenValid(dbOptions, currentOptions) {
     const isP256dhEqual = currentOptions.p256dh === dbOptions.p256dh;
     return isVapidKeyEqual && isEndpointEqual && isAuthEqual && isP256dhEqual;
 }
+/** Clears FID registration metadata; apps may mix legacy getToken() with FID register/unregister. */
+async function removeFidRegistrationBestEffort(firebaseDependencies) {
+    try {
+        await dbRemoveFidRegistration(firebaseDependencies);
+    }
+    catch {
+        // Ignore.
+    }
+}
+function notifyOnUnregistered(messaging, fid) {
+    const handler = messaging.onUnregisteredHandler;
+    if (!handler) {
+        return;
+    }
+    if (typeof handler === 'function') {
+        handler(fid);
+    }
+    else {
+        handler.next(fid);
+    }
+}
 
 /**
  * @license
@@ -720,10 +902,109 @@ function sleep(ms) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-_mergeStrings('AzSCbw63g1R0nCw85jG8', 'Iaya3yLKwmgvh7cF0q4');
+const LOG_ENDPOINT = 'https://play.google.com/log?format=json_proto3';
+/** First flush ASAP (next timer turn); `_dispatchLogEvents` reschedules with `LOG_INTERVAL_IN_MS`. */
+const INITIAL_LOG_FLUSH_DELAY_MS = 0;
+const FCM_TRANSPORT_KEY = _mergeStrings('AzSCbw63g1R0nCw85jG8', 'Iaya3yLKwmgvh7cF0q4');
+function startLoggingService(messaging) {
+    // Start only if not already scheduled/in-flight and there is work to do.
+    if (messaging.logQueue.state === 'stopped' &&
+        messaging.logEvents.length > 0) {
+        _processQueue(messaging, INITIAL_LOG_FLUSH_DELAY_MS);
+    }
+}
+/** Clears queued Firelog events, cancels any pending flush timer, and stops the logging loop. */
+function stopLoggingServiceAndClearQueue(messaging) {
+    if (messaging.logQueue.state === 'scheduled') {
+        clearTimeout(messaging.logQueue.timerId);
+    }
+    messaging.logQueue = { state: 'stopped' };
+    messaging.logEvents = [];
+}
+/**
+ *
+ * @param messaging the messaging instance.
+ * @param offsetInMs this method execute after `offsetInMs` elapsed .
+ */
+function _processQueue(messaging, offsetInMs) {
+    if (messaging.logQueue.state === 'scheduled') {
+        clearTimeout(messaging.logQueue.timerId);
+    }
+    messaging.logQueue = { state: 'stopped' };
+    if (!messaging.deliveryMetricsExportedToBigQueryEnabled) {
+        messaging.logEvents = [];
+        return;
+    }
+    messaging.logQueue = {
+        state: 'scheduled',
+        timerId: setTimeout(async () => {
+            // Mark in-flight so stageLog/startLoggingService won't schedule duplicates mid-dispatch.
+            messaging.logQueue = { state: 'flushing' };
+            if (!messaging.logEvents.length) {
+                return _processQueue(messaging, LOG_INTERVAL_IN_MS);
+            }
+            await _dispatchLogEvents(messaging);
+        }, offsetInMs)
+    };
+}
+async function _dispatchLogEvents(messaging) {
+    // Swap the queue to avoid losing events added during an in-flight dispatch.
+    const eventsToSend = messaging.logEvents;
+    messaging.logEvents = [];
+    for (let i = 0, n = eventsToSend.length; i < n; i += MAX_NUMBER_OF_EVENTS_PER_LOG_REQUEST) {
+        const batch = eventsToSend.slice(i, i + MAX_NUMBER_OF_EVENTS_PER_LOG_REQUEST);
+        if (!batch.length) {
+            break;
+        }
+        const logRequest = _createLogRequest(batch);
+        let retryCount = 0, response = {};
+        do {
+            try {
+                response = await fetch(LOG_ENDPOINT.concat('&key=', FCM_TRANSPORT_KEY), {
+                    method: 'POST',
+                    body: JSON.stringify(logRequest)
+                });
+                // don't retry on 200s or non retriable errors
+                if (response.ok || (!response.ok && !isRetriableError(response))) {
+                    break;
+                }
+                if (!response.ok && isRetriableError(response)) {
+                    // rethrow to retry with quota
+                    throw new Error('a retriable Non-200 code is returned in fetch to Firelog endpoint. Retry');
+                }
+            }
+            catch (error) {
+                const isLastAttempt = retryCount === MAX_RETRIES;
+                if (isLastAttempt) {
+                    // existing the do-while interactive retry logic because retry quota has reached.
+                    break;
+                }
+            }
+            let delayInMs;
+            try {
+                delayInMs = Number((await response.json()).nextRequestWaitMillis);
+            }
+            catch (e) {
+                delayInMs = DEFAULT_BACKOFF_TIME_MS;
+            }
+            await new Promise(resolve => setTimeout(resolve, delayInMs));
+            retryCount++;
+        } while (retryCount < MAX_RETRIES);
+    }
+    // Schedule next flush. If new events arrived during this dispatch, flush ASAP.
+    _processQueue(messaging, messaging.logEvents.length ? INITIAL_LOG_FLUSH_DELAY_MS : LOG_INTERVAL_IN_MS);
+}
+function isRetriableError(response) {
+    const httpStatus = response.status;
+    return (httpStatus === 429 ||
+        httpStatus === 500 ||
+        httpStatus === 503 ||
+        httpStatus === 504);
+}
 async function stageLog(messaging, internalPayload) {
     const fcmEvent = createFcmEvent(internalPayload, await messaging.firebaseDependencies.installations.getId());
     createAndEnqueueLogEvent(messaging, fcmEvent, internalPayload.productId);
+    startLoggingService(messaging);
 }
 function createFcmEvent(internalPayload, fid) {
     const fcmEvent = {};
@@ -777,6 +1058,14 @@ function buildComplianceData(productId) {
     };
     return complianceData;
 }
+function _createLogRequest(logEventQueue) {
+    const logRequest = {};
+    /* eslint-disable camelcase */
+    logRequest.log_source = FCM_LOG_SOURCE.toString();
+    logRequest.log_event = logEventQueue;
+    /* eslint-enable camelcase */
+    return logRequest;
+}
 function _mergeStrings(s1, s2) {
     const resultArray = [];
     for (let i = 0; i < s1.length; i++) {
@@ -823,7 +1112,11 @@ async function onPush(event, messaging) {
         // Failed to get parsed MessagePayload from the PushEvent. Skip handling the push.
         return;
     }
-    // log to Firelog with user consent
+    /*
+     * Log to Firelog based on user consent. Rather than calling startLoggingService once when
+     * deliveryMetricsExportedToBigQueryEnabled is toggled, we now call stageLog for every received push.
+     * This ensures the first telemetry event is uploaded immediately upon enabling the flag, simplifying debugging.
+     */
     if (messaging.deliveryMetricsExportedToBigQueryEnabled) {
         await stageLog(messaging, internalPayload);
     }
@@ -1051,8 +1344,25 @@ class MessagingService {
         this.deliveryMetricsExportedToBigQueryEnabled = false;
         this.onBackgroundMessageHandler = null;
         this.onMessageHandler = null;
+        /** Observer for the event that the app instance is registered with FCM via Firebase Installation ID (FID). */
+        this.onRegisteredHandler = null;
+        /** Observer for the event that the app instance is unregistered from FCM (FID no longer active). */
+        this.onUnregisteredHandler = null;
+        /**
+         * Serializes the FID get + compare + notify step so concurrent register() calls
+         * do not race each other.
+         */
+        this._registerNotifyChain = Promise.resolve();
+        /** Unsubscribe from Installations `onIdChange` when messaging is deleted. */
+        this._fidChangeUnsubscribe = null;
         this.logEvents = [];
-        this.isLogServiceStarted = false;
+        /**
+         * Single source of truth for the logging loop lifecycle.
+         *
+         * `scheduled` holds the active timer id; `flushing` indicates an async dispatch
+         * is in progress (prevents duplicate starts); `stopped` means idle.
+         */
+        this.logQueue = { state: 'stopped' };
         const appConfig = extractAppConfig(app);
         this.firebaseDependencies = {
             app,
@@ -1062,6 +1372,14 @@ class MessagingService {
         };
     }
     _delete() {
+        if (this._fidChangeUnsubscribe) {
+            this._fidChangeUnsubscribe();
+            this._fidChangeUnsubscribe = null;
+        }
+        if (this.logQueue.state === 'scheduled') {
+            clearTimeout(this.logQueue.timerId);
+        }
+        this.logQueue = { state: 'stopped' };
         return Promise.resolve();
     }
 }
@@ -1164,6 +1482,72 @@ function onBackgroundMessage$1(messaging, nextOrObserver) {
     };
 }
 
+/**
+ * @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.
+ */
+/**
+ * Subscribes to an event that the app instance is registered with FCM via Firebase Installation ID (FID).
+ * Use the FID passed to the callback to upload it to your application server.
+ *
+ * @param messaging - The {@link MessagingService} instance.
+ * @param nextOrObserver - A function or observer object called when an FID is registered.
+ * @returns Unsubscribe function to stop listening.
+ */
+function onRegistered$1(messaging, nextOrObserver) {
+    messaging.onRegisteredHandler = nextOrObserver;
+    return () => {
+        if (messaging.onRegisteredHandler === nextOrObserver) {
+            messaging.onRegisteredHandler = null;
+        }
+    };
+}
+
+/**
+ * @license
+ * Copyright 2026 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.
+ */
+/**
+ * Subscribes to an event that the app instance is unregistered from FCM so the FID is no longer active.
+ * Use this to notify your backend to remove this FID to prevent 404 errors on send.
+ *
+ * @param messaging - The {@link MessagingService} instance.
+ * @param nextOrObserver - A function or observer object called with the unregistered FID.
+ * @returns Unsubscribe function to stop listening.
+ */
+function onUnregistered$1(messaging, nextOrObserver) {
+    messaging.onUnregisteredHandler = nextOrObserver;
+    return () => {
+        if (messaging.onUnregisteredHandler === nextOrObserver) {
+            messaging.onUnregisteredHandler = null;
+        }
+    };
+}
+
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -1181,8 +1565,14 @@ function onBackgroundMessage$1(messaging, nextOrObserver) {
  * limitations under the License.
  */
 function _setDeliveryMetricsExportedToBigQueryEnabled(messaging, enable) {
-    messaging.deliveryMetricsExportedToBigQueryEnabled =
-        enable;
+    const messagingService = messaging;
+    messagingService.deliveryMetricsExportedToBigQueryEnabled = enable;
+    if (enable) {
+        startLoggingService(messagingService);
+    }
+    else {
+        stopLoggingServiceAndClearQueue(messagingService);
+    }
 }
 
 /**
@@ -1232,7 +1622,7 @@ function getMessagingInSw(app = getApp()) {
  * @param nextOrObserver - This function, or observer object with `next` defined, is called when a
  * message is received and the app is currently in the background.
  *
- * @returns To stop listening for messages execute this returned function
+ * @returns To stop listening for messages execute this returned function.
  *
  * @public
  */
@@ -1240,6 +1630,35 @@ function onBackgroundMessage(messaging, nextOrObserver) {
     messaging = getModularInstance(messaging);
     return onBackgroundMessage$1(messaging, nextOrObserver);
 }
+/**
+ * Subscribes to an event that the app instance is registered with FCM via Firebase Installation ID (FID).
+ * Use the FID passed to the callback to upload it to your application server. When you receive an FID
+ * after calling {@link register}, instruct your backend to remove any legacy token for this instance.
+ *
+ * @param messaging - The {@link Messaging} instance.
+ * @param nextOrObserver - A function or observer object called when an FID is registered.
+ * @returns Unsubscribe function to stop listening.
+ *
+ * @public
+ */
+function onRegistered(messaging, nextOrObserver) {
+    messaging = getModularInstance(messaging);
+    return onRegistered$1(messaging, nextOrObserver);
+}
+/**
+ * Subscribes to an event that the app instance is unregistered from FCM (FID no longer active).
+ * Use this to notify your backend to remove this FID to prevent 404 errors on send.
+ *
+ * @param messaging - The {@link Messaging} instance.
+ * @param nextOrObserver - A function or observer object called with the unregistered FID.
+ * @returns Unsubscribe function to stop listening.
+ *
+ * @public
+ */
+function onUnregistered(messaging, nextOrObserver) {
+    messaging = getModularInstance(messaging);
+    return onUnregistered$1(messaging, nextOrObserver);
+}
 /**
  * Enables or disables Firebase Cloud Messaging message delivery metrics export to BigQuery. By
  * default, message delivery metrics are not exported to BigQuery. Use this method to enable or
@@ -1274,5 +1693,5 @@ function experimentalSetDeliveryMetricsExportedToBigQueryEnabled(messaging, enab
  */
 registerMessagingInSw();
 
-export { experimentalSetDeliveryMetricsExportedToBigQueryEnabled, getMessagingInSw as getMessaging, isSwSupported as isSupported, onBackgroundMessage };
+export { experimentalSetDeliveryMetricsExportedToBigQueryEnabled, getMessagingInSw as getMessaging, isSwSupported as isSupported, onBackgroundMessage, onRegistered, onUnregistered };
 //# sourceMappingURL=index.sw.esm.js.map