@newrelic/browser-agent 1.320.0 → 1.320.1-rc.1

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.320.1](https://github.com/newrelic/newrelic-browser-agent/compare/v1.320.0...v1.320.1) (2026-08-12)
+
+
+### Bug Fixes
+
+* Apply hard cap to MFE FCP ([#1828](https://github.com/newrelic/newrelic-browser-agent/issues/1828)) ([095a1d6](https://github.com/newrelic/newrelic-browser-agent/commit/095a1d66a917b5044f64757f61ee57607b2879ae))
+* Avoid obfuscating keys and reserved system vals ([#1817](https://github.com/newrelic/newrelic-browser-agent/issues/1817)) ([1f19198](https://github.com/newrelic/newrelic-browser-agent/commit/1f1919809498e6aa8f1fc2ada0c00c3872cb30b8))
+
 ## [1.320.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.319.0...v1.320.0) (2026-08-07)
 
 

package/dist/cjs/common/config/runtime.js

@@ -44,6 +44,7 @@ const RuntimeModel = {
   disabled: false,
   /** @type {Map<string, {staged: boolean, priority: number}>} */
   drainRegistry: new Map(),
+  connector: undefined,
   harvester: undefined,
   isolatedBacklog: false,
   isRecording: false,

package/dist/cjs/common/constants/env.cdn.js

@@ -17,7 +17,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.RRWEB_PACKAGE_NAME = exports.D
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.320.0";
+const VERSION = exports.VERSION = "1.320.1-rc.1";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/constants/env.npm.js

@@ -17,7 +17,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.RRWEB_PACKAGE_NAME = exports.D
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.320.0";
+const VERSION = exports.VERSION = "1.320.1-rc.1";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/event-listener/event-listener-opts.js

@@ -7,7 +7,7 @@ exports.documentAddEventListener = documentAddEventListener;
 exports.eventListenerOpts = eventListenerOpts;
 exports.windowAddEventListener = windowAddEventListener;
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 function eventListenerOpts(useCapture, abortSignal) {

package/dist/cjs/common/harvest/connector.js

@@ -0,0 +1,200 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Connector = void 0;
+var _runtime = require("../constants/runtime");
+var _send = require("./send");
+var _timeKeeper = require("../timing/time-keeper");
+var _featureFlags = require("../util/feature-flags");
+var _now = require("../timing/now");
+var _console = require("../util/console");
+var _env = require("../constants/env.npm");
+var _features = require("../../loaders/features/features");
+var _handle = require("../event-emitter/handle");
+var _constants = require("../../features/metrics/constants");
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const MAX_CONNECT_ATTEMPTS = 3;
+const CONNECT_RETRY_BASE_MS = 3000; // affects each retry window proportionally (attempt 2: 0-3s, 3: 0-6s, 4: 0-12s, etc)
+
+class Connector {
+  #agentRef;
+  #connectStartTime;
+  #numOfAttempts = 0;
+  constructor(agentRef) {
+    if (!agentRef.init.feature_flags.includes('rum_v2')) return; // the Connector does not run in v1; legacy PVE has its own BCS handling
+    this.#agentRef = agentRef;
+    agentRef.runtime.timeKeeper = new _timeKeeper.TimeKeeper(agentRef.runtime.session);
+    if (_runtime.isBrowserScope) {
+      const cached = agentRef.runtime.session && agentRef.runtime.session.state.cachedRumResponse;
+      if (cached) {
+        // `cachedRumResponse` is stored flat (`{ app, ...flags }`, matching the old v1 RUM response), so re-nest it before applying.
+        const {
+          app,
+          ...config
+        } = cached;
+        this.#applyConnectResponse({
+          app,
+          config
+        });
+        return;
+      }
+    }
+    this.makeConnectRequest();
+  }
+  makeConnectRequest(retryHeaders) {
+    this.#connectStartTime = (0, _now.now)();
+    return (0, _send.send)(this.#agentRef, {
+      endpoint: "browser/connect/2/".concat(this.#agentRef.info.licenseKey),
+      payload: {
+        body: {},
+        qs: {
+          a: this.#agentRef.info.applicationID,
+          v: _env.VERSION,
+          s: this.#agentRef.runtime.session?.state.value || '0'
+        }
+      },
+      localOpts: {
+        sendEmptyBody: true,
+        headers: retryHeaders
+      },
+      raw: true,
+      featureName: _features.CONNECT,
+      cbFinished: this.#processConnectResponse.bind(this)
+    });
+  }
+  #applyConnectResponse({
+    app,
+    config
+  }) {
+    if (!Object.keys(this.#agentRef.runtime.appMetadata).length) this.#agentRef.runtime.appMetadata = app;
+    (0, _featureFlags.activateFeatures)(config, this.#agentRef);
+  }
+  #processConnectResponse({
+    sent,
+    status,
+    retry,
+    xhr,
+    responseText
+  }) {
+    const connectEndTime = (0, _now.now)();
+    const session = this.#agentRef.runtime.session;
+    if (session) {
+      // Double check that there isn't a response saved (e.g. from another agent/browser tab) btwn the async time of the request and now in a race-condition.
+      const cachedResp = session.state.cachedRumResponse;
+      if (cachedResp) {
+        // `cachedRumResponse` is stored flat (`{ app, ...flags }`, matching the old v1 RUM response), so re-nest it before applying.
+        const {
+          app,
+          ...config
+        } = cachedResp;
+        this.#applyConnectResponse({
+          app,
+          config
+        });
+        return;
+      }
+    }
+    const shouldRetry = sent && retry; // important to note: no retry if HTTP status is 0
+    if (shouldRetry && ++this.#numOfAttempts < MAX_CONNECT_ATTEMPTS) {
+      // We use an exponential backoff calculation for the retry to avoid thundering herd, skipping any further processing.
+      const delay = Math.floor(Math.random() * CONNECT_RETRY_BASE_MS * 2 ** (this.#numOfAttempts - 1));
+      const retryHeaders = [{
+        key: 'X-Retry-Count',
+        value: this.#numOfAttempts
+      }, {
+        key: 'X-Previous-Status',
+        value: status
+      }];
+      setTimeout(() => this.makeConnectRequest(retryHeaders), delay);
+      return;
+    }
+    if (status >= 400 || status === 0) {
+      (0, _console.warn)(18, status);
+
+      // Get estimated payload size of our backlog.
+      const textEncoder = new TextEncoder();
+      const payloadSize = Object.values(newrelic.ee.backlog).reduce((acc, value) => {
+        if (!value) return acc;
+        const encoded = textEncoder.encode(value);
+        return acc + encoded.byteLength;
+      }, 0);
+
+      // Send SMs about the (last) failed connect request, then abort agent.
+      const BCSError = 'BCS/Error/';
+      const sm = [{
+        params: {
+          name: BCSError + status
+        },
+        stats: {
+          c: 1
+        }
+      }, {
+        params: {
+          name: BCSError + 'Duration/Ms'
+        },
+        stats: {
+          c: 1,
+          t: connectEndTime - this.#connectStartTime
+        }
+      }, {
+        params: {
+          name: BCSError + 'Dropped/Bytes'
+        },
+        stats: {
+          c: 1,
+          t: payloadSize
+        }
+      }];
+      (0, _send.send)(this.#agentRef, {
+        // note we have to send it this way because the Metrics feature will never be harvested under this branch of code (BCS failure)
+        endpoint: _features.FEATURE_TO_ENDPOINT[_features.FEATURE_NAMES.metrics],
+        payload: {
+          body: {
+            sm
+          }
+        },
+        featureName: _features.FEATURE_NAMES.metrics
+      });
+      this.#agentRef.ee.abort();
+      return;
+    }
+    let resp;
+    try {
+      resp = JSON.parse(responseText);
+    } catch (error) {
+      (0, _console.warn)(53, error);
+      this.#agentRef.ee.abort();
+      return;
+    }
+    // store the response for other pages later in same session or in parallel tabs; flatten `.config` into the old v1 RUM response shape
+    if (session) session.write({
+      cachedRumResponse: {
+        app: resp.app,
+        ...resp.config
+      }
+    });
+    try {
+      const wasReady = this.#agentRef.runtime.timeKeeper.ready;
+      this.#agentRef.runtime.timeKeeper.processRumRequest(xhr, this.#connectStartTime, connectEndTime, resp.app.nrServerTime);
+      if (!this.#agentRef.runtime.timeKeeper.ready) throw new Error('TimeKeeper not ready');
+
+      // If timeKeeper's origin time is ahead of nrServerTime, then the timestamp is invalid. Report a supportability metric.
+      const timeDiff = this.#agentRef.runtime.timeKeeper.correctedOriginTime - resp.app.nrServerTime;
+      if (wasReady && timeDiff > 0) {
+        (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['Generic/TimeKeeper/InvalidTimestamp/Seen', timeDiff], undefined, _features.FEATURE_NAMES.metrics, this.#agentRef.ee);
+      }
+    } catch (error) {
+      (0, _console.warn)(17, error);
+      this.#agentRef.ee.abort();
+      return;
+    }
+    this.#applyConnectResponse(resp);
+  }
+}
+exports.Connector = Connector;

package/dist/cjs/common/harvest/harvester.js

@@ -26,11 +26,13 @@ class Harvester {
   constructor(agentRef) {
     this.agentRef = agentRef;
 
-    // Create obfuscator for harvest metadata (referrer URL, etc.)
     // No event type specified - applies to all harvests regardless of feature
     this.obfuscator = new _obfuscate.Obfuscator(agentRef);
+  }
+  startTimer(harvestInterval = this.agentRef.init.harvest.interval) {
+    if (this.#started) return;
+    this.#started = true;
     (0, _eol.subscribeToEOL)(() => {
-      // do one last harvest round or check
       this.initializedAggregates.forEach(aggregateInst => {
         // let all features wrap up things needed to do before ANY harvest in case there's last minute cross-feature data dependencies
         if (typeof aggregateInst.harvestOpts.beforeUnload === 'function') aggregateInst.harvestOpts.beforeUnload();
@@ -38,12 +40,7 @@ class Harvester {
       this.initializedAggregates.forEach(aggregateInst => this.triggerHarvestFor(aggregateInst, {
         isFinalHarvest: true
       }));
-      /* This callback should run in bubble phase, so that CWV api, like "onLCP", is called before the final harvest so that emitted timings are part of last outgoing. */
-    }, false);
-  }
-  startTimer(harvestInterval = this.agentRef.init.harvest.interval) {
-    if (this.#started) return;
-    this.#started = true;
+    });
     const onHarvestInterval = () => {
       this.initializedAggregates.forEach(aggregateInst => this.triggerHarvestFor(aggregateInst));
       setTimeout(onHarvestInterval, harvestInterval * 1000); // repeat in X seconds

package/dist/cjs/common/harvest/send.js

@@ -37,7 +37,7 @@ function send(agentRef, {
   endpoint,
   payload,
   localOpts = {},
-  submitMethod,
+  submitMethod = (0, _submitData.getSubmitMethod)(),
   cbFinished,
   raw,
   featureName,
@@ -58,13 +58,15 @@ function send(agentRef, {
   }
   const protocol = agentRef.init.ssl === false ? 'http' : 'https';
   const perceivedBeacon = agentRef.init.proxy.beacon || agentRef.info.errorBeacon;
-  const url = raw ? "".concat(protocol, "://").concat(perceivedBeacon, "/").concat(endpoint) : "".concat(protocol, "://").concat(perceivedBeacon).concat(endpoint !== _features.RUM ? '/' + endpoint : '', "/").concat(endpointVersion, "/").concat(agentRef.info.licenseKey);
+  const includeEndpointName = endpoint !== _features.RUM || endpointVersion !== 1;
+  const url = raw ? "".concat(protocol, "://").concat(perceivedBeacon, "/").concat(endpoint) : "".concat(protocol, "://").concat(perceivedBeacon).concat(includeEndpointName ? '/' + endpoint : '', "/").concat(endpointVersion, "/").concat(agentRef.info.licenseKey);
   const baseParams = !raw ? baseQueryString(agentRef, qs, endpoint, harvesterObfuscator) : '';
   let payloadParams = (0, _encode.obj)(qs, agentRef.runtime.maxBytes);
   if (baseParams === '' && payloadParams.startsWith('&')) {
     payloadParams = payloadParams.substring(1);
   }
-  const fullUrl = "".concat(url, "?").concat(baseParams).concat(payloadParams);
+  const queryString = "".concat(baseParams).concat(payloadParams);
+  const fullUrl = queryString ? "".concat(url, "?").concat(queryString) : url; // omit the '?' if there are no query params
   const gzip = !!qs?.attributes?.includes('gzip');
 
   // all gzipped data is already in the correct format and needs no transformation
@@ -79,7 +81,7 @@ function send(agentRef, {
   const headers = [{
     key: 'content-type',
     value: 'text/plain'
-  }];
+  }, ...(localOpts.headers || [])];
 
   /* Since workers don't support sendBeacon right now, they can only use XHR method.
       Because they still do permit synch XHR, the idea is that at final harvest time (worker is closing),
@@ -128,6 +130,7 @@ function send(agentRef, {
     }
     function trackHarvestMetadata() {
       try {
+        if (featureName === _features.CONNECT) return;
         if (featureName === _features.FEATURE_NAMES.jserrors && !body?.err) return;
         const hasReplay = baseParams.includes('hr=1');
         const hasTrace = baseParams.includes('ht=1');
@@ -213,9 +216,7 @@ function baseQueryString(agentRef, qs, endpoint, harvesterObfuscator) {
   const session = agentRef.runtime.session;
   const hr = !!session?.state.sessionReplaySentFirstChunk && session?.state.sessionReplayMode === 1 && endpoint !== _features.JSERRORS;
   const ht = !!session?.state.traceHarvestStarted && session?.state.sessionTraceMode === 1 && ![_features.LOGS, _features.BLOBS].includes(endpoint);
-  const qps = ['a=' + agentRef.info.applicationID, (0, _encode.param)('sa', agentRef.info.sa ? '' + agentRef.info.sa : ''), (0, _encode.param)('v', _env.VERSION), transactionNameParam(), (0, _encode.param)('ct', agentRef.runtime.customTransaction), '&rst=' + (0, _now.now)(), '&ck=0',
-  // ck param DEPRECATED - still expected by backend
-  '&s=' + (session?.state.value || '0'),
+  const qps = ['a=' + agentRef.info.applicationID, (0, _encode.param)('sa', agentRef.info.sa ? '' + agentRef.info.sa : ''), (0, _encode.param)('v', _env.VERSION), transactionNameParam(), (0, _encode.param)('ct', agentRef.runtime.customTransaction), '&rst=' + (0, _now.now)(), '&s=' + (session?.state.value || '0'),
   // the 0 id encaps all untrackable and default traffic
   (0, _encode.param)('ref', ref), (0, _encode.param)('ptid', agentRef.runtime.ptid ? '' + agentRef.runtime.ptid : '')];
   if (hr) qps.push((0, _encode.param)('hr', '1', qs));

package/dist/cjs/common/payloads/payloads.js

@@ -123,11 +123,11 @@ function truncateAsString(data) {
 }
 
 /**
- * Creates string adder functions for BEL serialization with obfuscation and optional truncation.
+ * Creates string adder functions for BEL serialization with obfuscation and optional truncation, as well as raw string.
  * This ensures a single string table is used while providing separate handling for regular vs payload attributes.
  * @param {Function} getAddStringContext - Function that creates a new string table context
  * @param {Object} obfuscator - Optional obfuscator instance for string obfuscation
- * @returns {{addString: Function, addStringWithTruncation: Function}} Object containing both string adder functions
+ * @returns {{addString: Function, addStringRaw: Function, addStringWithTruncation: Function}} Object containing various string adder functions
  */
 function createStringAdders(getAddStringContext, obfuscator) {
   const addStringRaw = getAddStringContext();
@@ -140,6 +140,7 @@ function createStringAdders(getAddStringContext, obfuscator) {
   };
   return {
     addString: str => processString(str, false),
+    addStringRaw: str => addStringRaw(str),
     addStringWithTruncation: str => processString(str, true)
   };
 }

package/dist/cjs/common/serialize/bel-serializer.js

@@ -40,19 +40,32 @@ function getAddStringContext(obfuscator, truncator) {
     }
   }
 }
-function addCustomAttributes(attrs, addString) {
+
+/**
+ * Attributes are serialized according to their types, using the provided serializers.  Only the first 64 attributes will be added to the payload.
+ * @param attrs
+ * @param serializers
+ * @param {function} serializers.addKey -function for serializing attribute keys
+ * @param {function} serializers.addVal - function for serializing attribute values
+ * @returns {*[]}
+ */
+function addCustomAttributes(attrs, serializers) {
+  const {
+    addKey,
+    addVal
+  } = serializers;
   var attrParts = [];
   Object.entries(attrs || {}).forEach(([key, val]) => {
     if (attrParts.length >= MAX_ATTRIBUTES) return;
     var type = 5;
     var serializedValue;
     // add key to string table first
-    key = addString(key, false);
+    key = addKey(key);
     switch (typeof val) {
       case 'object':
         if (val) {
           // serialize objects to strings
-          serializedValue = addString((0, _stringify.stringify)(val));
+          serializedValue = addVal((0, _stringify.stringify)(val));
         } else {
           // null attribute type
           type = 9;
@@ -71,7 +84,7 @@ function addCustomAttributes(attrs, addString) {
         type = 9;
         break;
       default:
-        serializedValue = addString(val);
+        serializedValue = addVal(val);
     }
     attrParts.push([type, key + (serializedValue ? ',' + serializedValue : '')]);
   });

package/dist/cjs/common/timer/interaction-timer.js

@@ -9,7 +9,7 @@ var _pageVisibility = require("../window/page-visibility");
 var _invoke = require("../util/invoke");
 var _runtime = require("../constants/runtime");
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -59,7 +59,7 @@ class InteractionTimer extends _timer.Timer {
         if (state === 'hidden') this.pause();
         // vis change --> visible is treated like a new interaction with the page
         else this.resume();
-      }, false, false, this.abortController?.signal);
+      }, false, this.abortController?.signal);
     }
   }
   abort() {

package/dist/cjs/common/unload/eol.js

@@ -7,7 +7,7 @@ exports.subscribeToEOL = subscribeToEOL;
 var _runtime = require("../constants/runtime");
 var _pageVisibility = require("../window/page-visibility");
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -29,9 +29,9 @@ if (_runtime.isWorkerScope) {
  * This is used, for example, to submit a final harvest and send all remaining data on best-effort.
  * @param {function} cb - func to run before or during the last reliable event or time of an env's life span
  */
-function subscribeToEOL(cb, capturePhase) {
+function subscribeToEOL(cb) {
   if (_runtime.isBrowserScope) {
-    (0, _pageVisibility.subscribeToVisibilityChange)(cb, true, capturePhase); // when user switches tab or hides window, esp. mobile scenario
+    (0, _pageVisibility.subscribeToVisibilityChange)(cb, true); // when user switches tab or hides window, esp. mobile scenario
   } else if (_runtime.isWorkerScope) {
     _runtime.globalScope.cleanupTasks.push(cb); // close() should run these tasks before quitting thread
   }

package/dist/cjs/common/util/console.js

@@ -73,7 +73,7 @@ var _globalEvent = require("../dispatch/global-event");
  * | 50 | Failed to connect. Cannot allow registered API. |
  * | 51 | Container agent is not available to register with. Can not connect. |
  * | 52 | Unexpected problem encountered. There should be at least one app for harvest! |
- * | 53 | Did not receive a valid entityGuid from connection response. |
+ * | 53 | Failed to parse connect response. |
  * | 54 | An experimental feature is being used. Support can not be offered for issues. |
  * | 55 | Register API has been disabled on the container agent. |
  * | 56 | Could not find a matching entity to store data. |
@@ -99,6 +99,7 @@ var _globalEvent = require("../dispatch/global-event");
  * | 76 | Agent rejected post message, could not match with existing entity. |
  * | 77 | Agent rejected post message, could not validate origin. |
  * | 78 | RegisteredIframeEntity could not determine parent origin and will not register, to avoid trusting messages from any origin. |
+ * | 79 | Unable to initialize Connector and/or Harvester. |
  *
  * @param {number} code The warning code to emit, which will be used to link to the warning code documentation
  * @param {*} [secondary] Secondary data to include, usually an extra message, error or object

package/dist/cjs/common/util/feature-flags.js

@@ -25,7 +25,8 @@ function activateFeatures(flags, agentRef) {
   // let any window level subscribers know that the agent is running, per install docs
   (0, _globalEvent.dispatchGlobalEvent)({
     loaded: true,
-    drained: true,
+    drained: !agentRef.init.feature_flags.includes('rum_v2'),
+    // v2 RUM always call activateFeatures before any group is drained (in waitForFlags)
     type: 'lifecycle',
     name: 'load',
     feature: undefined,

package/dist/cjs/common/v2/mfe-vitals.js

@@ -132,25 +132,33 @@ const observePerformance = (observers, config, onEntry) => {
 function trackMFEVitals(target, timings) {
   let fcpObservedAt;
   let lcpObservedAt;
+  // Once disconnect() runs, no further vitals data should be written - even from an observer callback that was
+  // already in flight when disconnect() was called.
+  let disconnected = false;
   const getTimeRelativeToScriptStart = capturedAt => {
     if (capturedAt == null) return capturedAt;
     return capturedAt - (timings?.scriptStart || timings?.registeredAt || 0);
   };
   const vitals = {
     fcp: {
+      // A clock freeze/tab suspend between script registration and first paint can make this value huge once the
+      // tab resumes. Rather than report a multi-hour "FCP", drop it so bad data doesn't reach the backend.
       get value() {
-        return getTimeRelativeToScriptStart(fcpObservedAt);
+        const relative = getTimeRelativeToScriptStart(fcpObservedAt);
+        return relative > _scriptTrackerConstants.CORRELATION_STALE_THRESHOLD_MS ? undefined : relative;
       },
       set value(v) {
-        fcpObservedAt = v;
+        if (!disconnected) fcpObservedAt = v;
       }
     },
     lcp: {
+      // LCP can never occur before FCP, so if FCP was dropped as invalid, LCP is derived from the same untrustworthy clock and must be dropped too.
       get value() {
+        if (vitals.fcp.value === undefined) return undefined;
         return getTimeRelativeToScriptStart(lcpObservedAt);
       },
       set value(v) {
-        lcpObservedAt = v;
+        if (!disconnected) lcpObservedAt = v;
       }
     },
     cls: {
@@ -170,15 +178,22 @@ function trackMFEVitals(target, timings) {
     if (!fcpObservedAt) vitals.disconnect();
   }, _scriptTrackerConstants.CORRELATION_STALE_THRESHOLD_MS);
   const populateVitalMinimums = () => {
-    fcpObservedAt ??= (0, _now.now)();
+    if (disconnected) return;
+    if (fcpObservedAt == null) {
+      const capturedAt = (0, _now.now)();
+      // If the very first observed render already exceeds the window, the clock is untrustworthy for this
+      // MFE (e.g. tab was frozen/suspended between registration and paint) - shut everything down instead
+      // of seeding vitals with data derived from it.
+      if (getTimeRelativeToScriptStart(capturedAt) > _scriptTrackerConstants.CORRELATION_STALE_THRESHOLD_MS) {
+        vitals.disconnect();
+        return;
+      }
+      fcpObservedAt = capturedAt;
+    }
     lcpObservedAt ??= (0, _now.now)();
     vitals.cls.value ??= 0;
   };
 
-  // if the MFE has already rendered something on the page before we could set up listeners, just populate vital minimums immediately
-  const existingRoots = _runtime.globalScope.document?.querySelectorAll("[data-nr-mfe-id=\"".concat(escapeSelectorValue(target.id), "\"]"));
-  if (Array.from(existingRoots || []).some(x => isMatch(x.dataset, target))) populateVitalMinimums();
-
   // Track FCP - first contentful paint
   const fcpObs = observeMutations(target, (_, obs) => {
     // An observed "FCP" means _something_ rendered, so at minimum we can populate all the baseline values for the vitals
@@ -193,12 +208,13 @@ function trackMFEVitals(target, timings) {
   const observedElements = new Set();
   try {
     resizeObs = new _runtime.globalScope.ResizeObserver(entries => {
+      if (disconnected) return;
       entries.forEach(entry => {
         try {
           const size = entry.contentRect.width * entry.contentRect.height;
           if (size > largestSize) {
             largestSize = size;
-            lcpObservedAt = (0, _now.now)();
+            vitals.lcp.value = (0, _now.now)();
           }
           resizeObs.unobserve(entry.target);
         } catch (e) {
@@ -259,7 +275,7 @@ function trackMFEVitals(target, timings) {
     type: 'layout-shift',
     buffered: true
   }, entry => {
-    if (entry.hadRecentInput) return;
+    if (disconnected || entry.hadRecentInput) return;
     (entry.sources || []).some(source => {
       if (isInMFE(source.node, target)) {
         // an observed "CLS" means _something_ rendered for the MFE, so at minimum we can make sure all the baseline values are populated for the vitals
@@ -277,7 +293,7 @@ function trackMFEVitals(target, timings) {
     buffered: true,
     durationThreshold: 40
   }, entry => {
-    if (!entry.interactionId || !isInMFE(entry.target, target)) return;
+    if (disconnected || !entry.interactionId || !isInMFE(entry.target, target)) return;
     if (vitals.inp.value === undefined || entry.duration > vitals.inp.value) {
       // an observed "INP" means _something_ rendered for the MFE, so at minimum we can make sure all the baseline values are populated for the vitals
       populateVitalMinimums();
@@ -295,6 +311,7 @@ function trackMFEVitals(target, timings) {
 
   // Disconnect all observers
   vitals.disconnect = () => {
+    disconnected = true;
     // Disconnect all observers
     observers.forEach(obs => {
       try {
@@ -341,5 +358,11 @@ function trackMFEVitals(target, timings) {
       passive: true
     });
   });
+
+  // If the MFE has already rendered something on the page before we could set up listeners, just populate vital
+  // minimums immediately. Done last, once `observers` is fully populated and `vitals.disconnect` has its real
+  // implementation, so a stale-clock detection here can actually tear everything down instead of no-op'ing.
+  const existingRoots = _runtime.globalScope.document?.querySelectorAll("[data-nr-mfe-id=\"".concat(escapeSelectorValue(target.id), "\"]"));
+  if (Array.from(existingRoots || []).some(x => isMatch(x.dataset, target))) populateVitalMinimums();
   return vitals;
 }

package/dist/cjs/common/window/page-visibility.js

@@ -7,7 +7,7 @@ exports.subscribeToPageUnload = subscribeToPageUnload;
 exports.subscribeToVisibilityChange = subscribeToVisibilityChange;
 var _eventListenerOpts = require("../event-listener/event-listener-opts");
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */