@firebase/messaging 0.12.26 → 0.13.0-20260526192810

package/dist/index.sw.cjs

@@ -29,6 +29,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;
@@ -56,6 +63,7 @@ var MessageType;
 (function (MessageType) {
     MessageType["PUSH_RECEIVED"] = "push-received";
     MessageType["NOTIFICATION_CLICKED"] = "notification-clicked";
+    MessageType["FID_REGISTERED"] = "fid-registered";
 })(MessageType || (MessageType = {}));
 
 /**
@@ -221,6 +229,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 util.ErrorFactory('messaging', 'Messaging', ERROR_MAP);
+
 /**
  * @license
  * Copyright 2019 Google LLC
@@ -237,41 +292,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: idb.openDB, deleteDB: idb.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 = idb.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);
@@ -279,67 +367,61 @@ 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 stores = [TOKEN_OBJECT_STORE_NAME];
+    const hasFidStore = hasObjectStore(db, FID_REGISTRATION_OBJECT_STORE_NAME);
+    if (hasFidStore) {
+        stores.push(FID_REGISTRATION_OBJECT_STORE_NAME);
+    }
+    const tx = db.transaction(stores, 'readwrite');
+    await tx.objectStore(TOKEN_OBJECT_STORE_NAME).put(tokenDetails, key);
+    if (hasFidStore) {
+        await tx.objectStore(FID_REGISTRATION_OBJECT_STORE_NAME).delete(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 dbSetFidRegistration(firebaseDependencies, details) {
+    const key = getKey(firebaseDependencies);
+    const db = await getDbPromise();
+    assertFidRegistrationObjectStore(db);
+    const tx = db.transaction([TOKEN_OBJECT_STORE_NAME, FID_REGISTRATION_OBJECT_STORE_NAME], 'readwrite');
+    await tx.objectStore(FID_REGISTRATION_OBJECT_STORE_NAME).put(details, key);
+    await tx.objectStore(TOKEN_OBJECT_STORE_NAME).delete(key);
+    await tx.done;
+    return details;
+}
+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 util.ErrorFactory('messaging', 'Messaging', ERROR_MAP);
+const version = "0.13.0-20260526192810";
 
 /**
  * @license
@@ -357,9 +439,14 @@ const ERROR_FACTORY = new util.ErrorFactory('messaging', 'Messaging', ERROR_MAP)
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/** Max attempts (initial fetch + retries) when CreateRegistration `fetch()` throws. */
+const FID_REGISTRATION_FETCH_MAX_ATTEMPTS = 3;
+/** Base delay in ms; backoff is `BASE * 2^attempt` after each failed attempt. */
+const FID_REGISTRATION_FETCH_BASE_BACKOFF_MS = 1000;
 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,
@@ -386,9 +473,128 @@ async function requestGetToken(firebaseDependencies, subscriptionOptions) {
     }
     return responseData.token;
 }
+async function requestCreateRegistration(firebaseDependencies, subscriptionOptions) {
+    const headers = await getHeaders(firebaseDependencies);
+    const body = getBody(subscriptionOptions, firebaseDependencies.appConfig.appName, 
+    /* includeSdkVersion= */ true);
+    const subscribeOptions = {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body)
+    };
+    let response;
+    try {
+        response = await fetchWithExponentialRetry(() => fetch(getEndpoint(firebaseDependencies.appConfig), subscribeOptions), FID_REGISTRATION_FETCH_MAX_ATTEMPTS, FID_REGISTRATION_FETCH_BASE_BACKOFF_MS);
+    }
+    catch (err) {
+        throw ERROR_FACTORY.create("fid-registration-failed" /* ErrorCode.FID_REGISTRATION_FAILED */, {
+            errorInfo: err?.toString()
+        });
+    }
+    if (response.ok) {
+        const responseFid = await parseCreateRegistrationSuccessFid(response);
+        return { responseFid };
+    }
+    // `fetch()` succeeded, but the backend returned a non-2xx response.
+    // Best-effort parse the body to extract `error.message`, but always fail with
+    // `FID_REGISTRATION_FAILED` to keep the error surface uniform.
+    // Best-effort extraction of error details; the main signal is response.ok / status.
+    let responseData;
+    try {
+        responseData = (await response.json());
+    }
+    catch (err) {
+        throw ERROR_FACTORY.create("fid-registration-failed" /* ErrorCode.FID_REGISTRATION_FAILED */, {
+            errorInfo: response.statusText
+        });
+    }
+    const message = responseData.error?.message ?? response.statusText;
+    throw ERROR_FACTORY.create("fid-registration-failed" /* ErrorCode.FID_REGISTRATION_FAILED */, {
+        errorInfo: message
+    });
+}
+/**
+ * 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()
+        });
+    }
+}
+/**
+ * Parses a successful CreateRegistration body. The backend must return JSON with a non-empty
+ * string `name`: a resource name `projects/{projectId}/registrations/{fid}`
+ */
+async function parseCreateRegistrationSuccessFid(response) {
+    const text = await response.text();
+    if (!text.trim()) {
+        throw ERROR_FACTORY.create("fid-registration-failed" /* ErrorCode.FID_REGISTRATION_FAILED */, {
+            errorInfo: 'CreateRegistration succeeded but response body is empty'
+        });
+    }
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        throw ERROR_FACTORY.create("fid-registration-failed" /* ErrorCode.FID_REGISTRATION_FAILED */, {
+            errorInfo: 'CreateRegistration succeeded but response body is not valid JSON'
+        });
+    }
+    const name = data.name;
+    if (typeof name !== 'string' || name.length === 0) {
+        throw ERROR_FACTORY.create("fid-registration-failed" /* ErrorCode.FID_REGISTRATION_FAILED */, {
+            errorInfo: 'CreateRegistration succeeded but response did not include a non-empty name'
+        });
+    }
+    return parseFidFromRegistrationResourceName(name);
+}
+const REGISTRATIONS_NAME_SEGMENT = '/registrations/';
+/** Extracts the Firebase Installation ID from CreateRegistration `name` (resource path). */
+function parseFidFromRegistrationResourceName(name) {
+    const segmentIndex = name.indexOf(REGISTRATIONS_NAME_SEGMENT);
+    if (segmentIndex !== -1) {
+        const fid = name.slice(segmentIndex + REGISTRATIONS_NAME_SEGMENT.length);
+        if (fid.length > 0) {
+            return fid;
+        }
+    }
+    throw ERROR_FACTORY.create("fid-registration-failed" /* ErrorCode.FID_REGISTRATION_FAILED */, {
+        errorInfo: 'CreateRegistration succeeded but response name is not a valid registration resource name'
+    });
+}
 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,
@@ -437,6 +643,26 @@ async function requestDeleteToken(firebaseDependencies, token) {
         });
     }
 }
+/**
+ * Re-runs `operation` when it throws, with exponential backoff between attempts.
+ * Rethrows the last error if all attempts fail.
+ */
+async function fetchWithExponentialRetry(operation, maxAttempts, baseBackoffMs) {
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (err) {
+            lastError = err;
+            if (attempt < maxAttempts - 1) {
+                const delayMs = baseBackoffMs * Math.pow(2, attempt);
+                await new Promise(resolve => setTimeout(resolve, delayMs));
+            }
+        }
+    }
+    throw lastError;
+}
 function getEndpoint({ projectId }) {
     return `${ENDPOINT}/projects/${projectId}/registrations`;
 }
@@ -449,14 +675,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;
     }
@@ -482,7 +739,7 @@ function getBody({ p256dh, auth, endpoint, vapidKey }) {
 // UpdateRegistration will be called once every week.
 const TOKEN_EXPIRATION_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
 async function getTokenInternal(messaging) {
-    const pushSubscription = await getPushSubscription(messaging.swRegistration, messaging.vapidKey);
+    const pushSubscription = await getPushSubscription$1(messaging.swRegistration, messaging.vapidKey);
     const subscriptionOptions = {
         vapidKey: messaging.vapidKey,
         swScope: messaging.swRegistration.scope,
@@ -520,14 +777,42 @@ async function getTokenInternal(messaging) {
     }
 }
 /**
- * This method deletes the token from the database, unsubscribes the token from FCM, and unregisters
- * the push subscription if it exists.
+ * 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 deleteTokenInternal(messaging) {
+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);
+    }
+}
+/**
+ * Revokes the app's FCM registration: legacy token (getToken/deleteToken) and/or FID-based
+ * registration (register/unregister), clears local caches, notifies onUnregistered when a stored
+ * FID existed, then unsubscribes the push subscription when present.
+ */
+async function revokeRegistrationInternal(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();
@@ -565,7 +850,7 @@ async function getNewToken(firebaseDependencies, subscriptionOptions) {
 /**
  * Gets a PushSubscription for the current user.
  */
-async function getPushSubscription(swRegistration, vapidKey) {
+async function getPushSubscription$1(swRegistration, vapidKey) {
     const subscription = await swRegistration.pushManager.getSubscription();
     if (subscription) {
         return subscription;
@@ -587,6 +872,169 @@ 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 notifyOnRegistered(messaging, fid) {
+    const handler = messaging.onRegisteredHandler;
+    if (!handler) {
+        return;
+    }
+    if (typeof handler === 'function') {
+        handler(fid);
+    }
+    else {
+        handler.next(fid);
+    }
+}
+function notifyOnUnregistered(messaging, fid) {
+    const handler = messaging.onUnregisteredHandler;
+    if (!handler) {
+        return;
+    }
+    if (typeof handler === 'function') {
+        handler(fid);
+    }
+    else {
+        handler.next(fid);
+    }
+}
+
+/**
+ * @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.
+ */
+async function updateVapidKey(messaging, vapidKey) {
+    if (!!vapidKey) {
+        messaging.vapidKey = vapidKey;
+    }
+    else if (!messaging.vapidKey) {
+        messaging.vapidKey = DEFAULT_VAPID_KEY;
+    }
+}
+
+/**
+ * @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.
+ */
+/** Retries when CreateRegistration echoes an FID that does not match Installations.getId(). */
+const FID_REGISTRATION_FID_MATCH_MAX_ATTEMPTS = 3;
+/**
+ * For the new FID-based register path:
+ * - Create (or refresh) an FCM Web registration in the backend via CreateRegistration.
+ * - Use the FIS auth token produced by the installations instance (implicitly associated with FID).
+ * - CreateRegistration must echo the installation in `name` (e.g.
+ *   `projects/{projectId}/registrations/{fid}`); it must match `expectedFid` from
+ *   Installations.getId(). On mismatch we refresh the auth token and retry, then fail with
+ *   `fid-registration-failed`.
+ */
+async function registerFcmRegistrationWithFid(messaging, expectedFid) {
+    const pushSubscription = await getPushSubscription(messaging.swRegistration, messaging.vapidKey);
+    const subscriptionOptions = {
+        vapidKey: messaging.vapidKey,
+        swScope: messaging.swRegistration.scope,
+        endpoint: pushSubscription.endpoint,
+        auth: arrayToBase64(pushSubscription.getKey('auth')),
+        p256dh: arrayToBase64(pushSubscription.getKey('p256dh'))
+    };
+    const installations = messaging.firebaseDependencies.installations;
+    for (let attempt = 0; attempt < FID_REGISTRATION_FID_MATCH_MAX_ATTEMPTS; attempt++) {
+        const { responseFid } = await requestCreateRegistration(messaging.firebaseDependencies, subscriptionOptions);
+        if (responseFid === expectedFid) {
+            return;
+        }
+        // If CreateRegistration echoes an unexpected FID, the FIS auth token used for the request may
+        // be stale relative to the installation the backend associates with the call. Force-refresh
+        // the token before retrying so the next attempt uses credentials aligned with Installations.
+        if (attempt < FID_REGISTRATION_FID_MATCH_MAX_ATTEMPTS - 1) {
+            await installations.getToken(true);
+        }
+    }
+    throw ERROR_FACTORY.create("fid-registration-failed" /* ErrorCode.FID_REGISTRATION_FAILED */, {
+        errorInfo: 'CreateRegistration response FID does not match Firebase Installation ID'
+    });
+}
+async function getPushSubscription(swRegistration, vapidKey) {
+    const subscription = await swRegistration.pushManager.getSubscription();
+    if (subscription) {
+        return subscription;
+    }
+    // Chrome/Firefox require applicationServerKey to be of type Uint8Array.
+    return swRegistration.pushManager.subscribe({
+        userVisibleOnly: true,
+        // `PushManager.subscribe` expects a `BufferSource`; `base64ToArray` produces a typed array.
+        // Cast to satisfy the lib typing differences across TS DOM versions.
+        applicationServerKey: base64ToArray(vapidKey)
+    });
+}
+
+/**
+ * @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.
+ */
+/**
+ * Re-runs FCM FID registration when push subscription keys change (e.g. `pushsubscriptionchange`
+ * in the service worker). No-op if the app instance was never registered via `register()`.
+ * Best-effort: callers should catch failures when permission or push may be unavailable.
+ */
+async function refreshFidRegistrationIfStored(messaging) {
+    const stored = await dbGetFidRegistration(messaging.firebaseDependencies).catch(() => undefined);
+    if (!stored) {
+        return undefined;
+    }
+    await updateVapidKey(messaging, stored.vapidKey);
+    const fid = await messaging.firebaseDependencies.installations.getId();
+    await registerFcmRegistrationWithFid(messaging, fid);
+    await dbSetFidRegistration(messaging.firebaseDependencies, {
+        fid,
+        lastRegisterTime: Date.now(),
+        vapidKey: messaging.vapidKey
+    });
+    notifyOnRegistered(messaging, fid);
+    return fid;
+}
 
 /**
  * @license
@@ -724,10 +1172,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 = {};
@@ -781,6 +1328,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++) {
@@ -809,14 +1364,32 @@ function _mergeStrings(s1, s2) {
  * limitations under the License.
  */
 async function onSubChange(event, messaging) {
+    if (!messaging.swRegistration) {
+        messaging.swRegistration = self.registration;
+    }
     const { newSubscription } = event;
     if (!newSubscription) {
-        // Subscription revoked, delete token
-        await deleteTokenInternal(messaging);
+        // Subscription revoked: legacy token and FID register/unregister paths both flow through
+        // revokeRegistrationInternal (server revoke + onUnregistered when applicable).
+        await revokeRegistrationInternal(messaging);
+        return;
+    }
+    const storedFid = await dbGetFidRegistration(messaging.firebaseDependencies).catch(() => undefined);
+    if (storedFid) {
+        const fid = await refreshFidRegistrationIfStored(messaging).catch(() => {
+            // Best-effort: push subscription may be unavailable after rotation.
+            return undefined;
+        });
+        if (fid) {
+            const clientList = await getClientList();
+            if (hasVisibleClients(clientList)) {
+                sendFidRegisteredToWindows(clientList, fid);
+            }
+        }
         return;
     }
     const tokenDetails = await dbGet(messaging.firebaseDependencies);
-    await deleteTokenInternal(messaging);
+    await revokeRegistrationInternal(messaging);
     messaging.vapidKey =
         tokenDetails?.subscriptionOptions?.vapidKey ?? DEFAULT_VAPID_KEY;
     await getTokenInternal(messaging);
@@ -827,7 +1400,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);
     }
@@ -950,6 +1527,16 @@ function sendMessagePayloadInternalToWindows(clientList, internalPayload) {
         client.postMessage(internalPayload);
     }
 }
+function sendFidRegisteredToWindows(clientList, fid) {
+    const payload = {
+        isFirebaseMessaging: true,
+        messageType: MessageType.FID_REGISTERED,
+        fid
+    };
+    for (const client of clientList) {
+        client.postMessage(payload);
+    }
+}
 function getClientList() {
     return self.clients.matchAll({
         type: 'window',
@@ -1055,8 +1642,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,
@@ -1066,6 +1670,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();
     }
 }
@@ -1168,6 +1780,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
@@ -1185,8 +1863,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);
+    }
 }
 
 /**
@@ -1236,7 +1920,7 @@ function getMessagingInSw(app$1 = 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
  */
@@ -1244,6 +1928,35 @@ function onBackgroundMessage(messaging, nextOrObserver) {
     messaging = util.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 = util.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 = util.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
@@ -1282,4 +1995,6 @@ exports.experimentalSetDeliveryMetricsExportedToBigQueryEnabled = experimentalSe
 exports.getMessaging = getMessagingInSw;
 exports.isSupported = isSwSupported;
 exports.onBackgroundMessage = onBackgroundMessage;
+exports.onRegistered = onRegistered;
+exports.onUnregistered = onUnregistered;
 //# sourceMappingURL=index.sw.cjs.map