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

package/dist/index.cjs.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('@firebase/installations');
+var installations = require('@firebase/installations');
 var component = require('@firebase/component');
 var idb = require('idb');
 var util = require('@firebase/util');
@@ -223,6 +223,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
@@ -239,41 +286,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);
@@ -281,67 +361,53 @@ 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 dbSetFidRegistration(firebaseDependencies, details) {
+    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).put(details, 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 name = "@firebase/messaging";
+const version = "0.12.26-eap-crashlytics.3dd4e65d9";
 
 /**
  * @license
@@ -359,9 +425,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,
@@ -388,9 +459,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,
@@ -439,6 +629,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`;
 }
@@ -451,14 +661,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;
     }
@@ -484,7 +725,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,
@@ -492,6 +733,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.
@@ -521,6 +764,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.
@@ -528,8 +796,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();
@@ -567,7 +837,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;
@@ -589,6 +859,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
@@ -787,8 +1078,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,
@@ -798,6 +1106,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();
     }
 }
@@ -957,6 +1273,193 @@ async function getToken$1(messaging, options) {
     return getTokenInternal(messaging);
 }
 
+/**
+ * @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 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.
+ */
+const FID_REGISTRATION_REFRESH_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+/**
+ * Registers the app instance with FCM using its Firebase Installation ID (FID). The FID is
+ * delivered via the `onRegistered` callback. Call this to establish an FID-based identity.
+ * Once `onRegistered` provides an FID, instruct your backend to remove any legacy token
+ * previously associated with this instance. The backend send API supports FID as a target.
+ *
+ * When called multiple times, `onRegistered` is invoked on each call with the current FID.
+ * Backend registration sync runs on first register, when the FID changes, or on weekly refresh.
+ *
+ * @param messaging - The MessagingService instance.
+ * @param options - Optional. Same options as getToken (vapidKey, serviceWorkerRegistration).
+ */
+async function register$1(messaging, options) {
+    if (!navigator) {
+        throw ERROR_FACTORY.create("only-available-in-window" /* ErrorCode.AVAILABLE_IN_WINDOW */);
+    }
+    if (Notification.permission === 'default') {
+        await Notification.requestPermission();
+    }
+    if (Notification.permission !== 'granted') {
+        throw ERROR_FACTORY.create("permission-blocked" /* ErrorCode.PERMISSION_BLOCKED */);
+    }
+    if (!messaging.onRegisteredHandler) {
+        throw ERROR_FACTORY.create("invalid-on-registered-handler" /* ErrorCode.INVALID_ON_REGISTERED_HANDLER */);
+    }
+    await updateVapidKey(messaging, options?.vapidKey);
+    await updateSwReg(messaging, options?.serviceWorkerRegistration);
+    // Keep the queue alive after a failed register() so future calls can retry.
+    const prev = messaging._registerNotifyChain.catch(() => { });
+    messaging._registerNotifyChain = prev.then(async () => {
+        const fid = await messaging.firebaseDependencies.installations.getId();
+        const stored = await dbGetFidRegistration(messaging.firebaseDependencies);
+        const now = Date.now();
+        const shouldRefresh = !stored ||
+            stored.fid !== fid ||
+            now >= stored.lastRegisterTime + FID_REGISTRATION_REFRESH_MS;
+        if (shouldRefresh) {
+            // Best-effort cleanup of legacy token details, since apps may switch from
+            // getToken() to the FID-based register() API over time.
+            try {
+                await dbRemove(messaging.firebaseDependencies);
+            }
+            catch {
+                // Ignore.
+            }
+            await registerFcmRegistrationWithFid(messaging, fid);
+            await dbSetFidRegistration(messaging.firebaseDependencies, {
+                fid,
+                lastRegisterTime: now
+            });
+        }
+        const handler = messaging.onRegisteredHandler;
+        if (!handler) {
+            throw ERROR_FACTORY.create("invalid-on-registered-handler" /* ErrorCode.INVALID_ON_REGISTERED_HANDLER */);
+        }
+        if (typeof handler === 'function') {
+            handler(fid);
+        }
+        else {
+            handler.next(fid);
+        }
+    });
+    return messaging._registerNotifyChain;
+}
+
+/**
+ * @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.
+ */
+/**
+ * When the Firebase Installation ID changes, re-run `register()` so FCM registration and
+ * onRegistered run for the new FID. No-op if no onRegistered handler is set or the app
+ * instance was never registered with FCM.
+ */
+function subscribeFidChangeRegistration(messaging, installations$1) {
+    return installations.onIdChange(installations$1, () => {
+        void (async () => {
+            if (!messaging.onRegisteredHandler) {
+                return;
+            }
+            const stored = await dbGetFidRegistration(messaging.firebaseDependencies);
+            if (!stored) {
+                return;
+            }
+            await register$1(messaging).catch(() => {
+                // Best-effort: permission may be revoked or SW unavailable after FID rotation.
+            });
+        })();
+    });
+}
+
 /**
  * @license
  * Copyright 2019 Google LLC
@@ -1034,9 +1537,6 @@ async function messageEventListener(messaging, event) {
     }
 }
 
-const name = "@firebase/messaging";
-const version = "0.12.26-20260505185142";
-
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -1056,6 +1556,7 @@ const version = "0.12.26-20260505185142";
 const WindowMessagingFactory = (container) => {
     const messaging = new MessagingService(container.getProvider('app').getImmediate(), container.getProvider('installations-internal').getImmediate(), container.getProvider('analytics-internal'));
     navigator.serviceWorker.addEventListener('message', e => messageEventListener(messaging, e));
+    messaging._fidChangeUnsubscribe = subscribeFidChangeRegistration(messaging, container.getProvider('installations').getImmediate());
     return messaging;
 };
 const WindowMessagingInternalFactory = (container) => {
@@ -1063,7 +1564,8 @@ const WindowMessagingInternalFactory = (container) => {
         .getProvider('messaging')
         .getImmediate();
     const messagingInternal = {
-        getToken: (options) => getToken$1(messaging, options)
+        getToken: (options) => getToken$1(messaging, options),
+        register: (options) => register$1(messaging, options)
     };
     return messagingInternal;
 };
@@ -1172,6 +1674,129 @@ function onMessage$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 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.
+ */
+/**
+ * Unregisters the app instance from FCM by deleting its FID-based registration.
+ *
+ * On success, triggers the `onUnregistered` callback (if set) with the unregistered FID.
+ *
+ * @param messaging - The MessagingService instance.
+ */
+async function unregister$1(messaging) {
+    if (!navigator) {
+        throw ERROR_FACTORY.create("only-available-in-window" /* ErrorCode.AVAILABLE_IN_WINDOW */);
+    }
+    // Prefer the last successfully registered FID from local metadata when available.
+    const stored = await dbGetFidRegistration(messaging.firebaseDependencies).catch(() => undefined);
+    const fid = stored?.fid ?? (await messaging.firebaseDependencies.installations.getId());
+    await requestDeleteRegistration(messaging.firebaseDependencies, fid);
+    // Best-effort local cleanup; still resolve even if schema is unavailable.
+    try {
+        await dbRemoveFidRegistration(messaging.firebaseDependencies);
+    }
+    catch {
+        // Ignore.
+    }
+    // Best-effort cleanup of legacy token details created via getToken().
+    try {
+        await dbRemove(messaging.firebaseDependencies);
+    }
+    catch {
+        // Ignore.
+    }
+    const handler = messaging.onUnregisteredHandler;
+    if (!handler) {
+        return;
+    }
+    if (typeof handler === 'function') {
+        handler(fid);
+    }
+    else {
+        handler.next(fid);
+    }
+}
+
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -1224,6 +1849,9 @@ function getMessagingInWindow(app$1 = app.getApp()) {
  *
  * @returns The promise resolves with an FCM registration token.
  *
+ * @deprecated Use {@link register} together with {@link onRegistered} for Firebase
+ * Installation ID-based messaging instead of retrieving an FCM registration token with this API.
+ *
  * @public
  */
 async function getToken(messaging, options) {
@@ -1234,10 +1862,18 @@ async function getToken(messaging, options) {
  * Deletes the registration token associated with this {@link Messaging} instance and unsubscribes
  * the {@link Messaging} instance from the push subscription.
  *
+ * If there is no legacy registration token but the client has FID-based registration metadata
+ * (from {@link register}), this deletes that registration on the server, clears local metadata, and
+ * invokes {@link onUnregistered} with the removed FID when successful.
+ *
  * @param messaging - The {@link Messaging} instance.
  *
  * @returns The promise resolves when the token has been successfully deleted.
  *
+ * @deprecated Use {@link onUnregistered} to observe when the client is no longer
+ * registered and update your backend accordingly, instead of explicitly deleting the
+ * registration token with this API.
+ *
  * @public
  */
 function deleteToken(messaging) {
@@ -1261,6 +1897,64 @@ function onMessage(messaging, nextOrObserver) {
     messaging = util.getModularInstance(messaging);
     return onMessage$1(messaging, nextOrObserver);
 }
+/**
+ * Registers the app instance with FCM using its Firebase Installation ID (FID). The FID is
+ * delivered via the {@link onRegistered} callback, not as a return value. Call this to establish
+ * an FID-based identity; once {@link onRegistered} provides an FID, instruct your backend to
+ * remove any legacy token previously associated with this instance. The backend send API
+ * supports FID as a target.
+ *
+ * @param messaging - The {@link Messaging} instance.
+ * @param options - Optional. VAPID key and/or service worker registration (same as getToken).
+ * @returns Promise that resolves when registration has been initiated; FID is delivered via onRegistered.
+ *
+ * @public
+ */
+async function register(messaging, options) {
+    messaging = util.getModularInstance(messaging);
+    return register$1(messaging, options);
+}
+/**
+ * Unregisters the app instance from FCM by deleting its FID-based registration.
+ * On success, triggers {@link onUnregistered} (if registered) with the unregistered FID.
+ *
+ * @param messaging - The {@link Messaging} instance.
+ *
+ * @public
+ */
+async function unregister(messaging) {
+    messaging = util.getModularInstance(messaging);
+    return unregister$1(messaging);
+}
+/**
+ * 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);
+}
 
 /**
  * The Firebase Cloud Messaging Web SDK.
@@ -1275,4 +1969,8 @@ exports.getMessaging = getMessagingInWindow;
 exports.getToken = getToken;
 exports.isSupported = isWindowSupported;
 exports.onMessage = onMessage;
+exports.onRegistered = onRegistered;
+exports.onUnregistered = onUnregistered;
+exports.register = register;
+exports.unregister = unregister;
 //# sourceMappingURL=index.cjs.js.map