@newrelic/browser-agent 1.320.1 → 1.321.0

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.321.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.320.1...v1.321.0) (2026-08-31)
+
+
+### Features
+
+* Add instrumentation to track races between tabs ([#1838](https://github.com/newrelic/newrelic-browser-agent/issues/1838)) ([f678c3a](https://github.com/newrelic/newrelic-browser-agent/commit/f678c3a60f53455eb5d43eab90ab28e081b18a83))
+* improve v2 target standardization ([#1826](https://github.com/newrelic/newrelic-browser-agent/issues/1826)) ([1a18e10](https://github.com/newrelic/newrelic-browser-agent/commit/1a18e10f4754f6516fdac82020fe5cc5eed489a4))
+* Introduce v2 PageView & decouple connect service call ([#1824](https://github.com/newrelic/newrelic-browser-agent/issues/1824)) ([a07609a](https://github.com/newrelic/newrelic-browser-agent/commit/a07609a36f9891d85001711ba2d723fef096421b))
+* MicroFrontEndTiming attributes changes ([#1837](https://github.com/newrelic/newrelic-browser-agent/issues/1837)) ([a282ba0](https://github.com/newrelic/newrelic-browser-agent/commit/a282ba0afbc9291aaaef165050da813bfc79f8b6))
+
+
+### Bug Fixes
+
+* Ensure Session Replay's custom masker applies to non-inputs ([#1840](https://github.com/newrelic/newrelic-browser-agent/issues/1840)) ([db9faa5](https://github.com/newrelic/newrelic-browser-agent/commit/db9faa52730585c8ecbd1100e00a3b6fe94c2ab9))
+
 ## [1.320.1](https://github.com/newrelic/newrelic-browser-agent/compare/v1.320.0...v1.320.1) (2026-08-12)
 
 

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

@@ -44,7 +44,10 @@ const RuntimeModel = {
   disabled: false,
   /** @type {Map<string, {staged: boolean, priority: number}>} */
   drainRegistry: new Map(),
+  connector: undefined,
   harvester: undefined,
+  /** eagerly-created in configure() -- the v2 target representing the container (main) agent, see common/v2/utils#V2Target */
+  v2Target: undefined,
   isolatedBacklog: false,
   isRecording: false,
   // true when actively recording, false when paused or stopped

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.1";
+const VERSION = exports.VERSION = "1.321.0";
 
 /**
  * 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.1";
+const VERSION = exports.VERSION = "1.321.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/dom/selector-path.js

@@ -27,7 +27,7 @@ const analyzeElemPath = (elem, targetFields = [], agentRef) => {
     path: undefined,
     nearestFields: {},
     get targets() {
-      return targets.length ? targets : [undefined];
+      return targets.length ? targets : [agentRef.runtime.v2Target];
     },
     hasButton: false,
     hasLink: false

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,202 @@
+"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) {
+        // Report that we've seen a race condition on updating session state
+        (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['Session/RaceCondition/Seen'], undefined, _features.FEATURE_NAMES.metrics, this.#agentRef.ee);
+        // `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/session/session-entity.js

@@ -66,7 +66,7 @@ class SessionEntity {
     // key is intended to act as the k=v pair
     this.key = key;
     this.ee = agentRef.ee;
-    (0, _wrapEvents.wrapEvents)(this.ee);
+    (0, _wrapEvents.wrapEvents)(this.ee, agentRef);
     this.setup(opts);
 
     /**

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/constants.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.V2_TYPES = void 0;
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @enum {string}
+ * @readonly
+ */
+const V2_TYPES = exports.V2_TYPES = {
+  /** Micro Frontend */
+  MFE: 'MFE',
+  /** Browser Application */
+  BA: 'BA'
+};

package/dist/cjs/common/v2/utils.js

@@ -3,7 +3,6 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.V2_TYPES = void 0;
 exports.dedupeRegisteredEntitiesByAsset = dedupeRegisteredEntitiesByAsset;
 exports.dedupeTargetsByInstance = dedupeTargetsByInstance;
 exports.findTargetsFromStackTrace = findTargetsFromStackTrace;
@@ -12,23 +11,31 @@ exports.getRegisteredTargetsFromFilename = getRegisteredTargetsFromFilename;
 exports.getRegisteredTargetsFromId = getRegisteredTargetsFromId;
 exports.getVersion2Attributes = getVersion2Attributes;
 exports.getVersion2DuplicationAttributes = getVersion2DuplicationAttributes;
+exports.isMfeTarget = isMfeTarget;
 exports.shouldDuplicate = shouldDuplicate;
 var _scriptTracker = require("./script-tracker");
+var _constants = require("./constants");
 /**
  * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
 /**
- * @enum {string}
- * @readonly
+ * @typedef {Object} V2Target
+ * @property {'BA'} type always V2_TYPES.BA -- identifies this as the container (main) agent, not a registered MFE
+ * @property {string} instance the container agent's agentIdentifier
+ * @property {string} [id] the container agent's entity guid, once known (getter, resolved asynchronously)
+ * @property {{[key:string]: any}} attributes the V2 payload attributes for the container agent (getter)
  */
-const V2_TYPES = exports.V2_TYPES = {
-  /** Micro Frontend */
-  MFE: 'MFE',
-  /** Browser Application */
-  BA: 'BA'
-};
+
+/**
+ * Determines if a given target represents a registered MFE (as opposed to the container agent).
+ * @param {*} target the target to check
+ * @returns {boolean} true if the target is a registered MFE target
+ */
+function isMfeTarget(target) {
+  return target?.type === _constants.V2_TYPES.MFE;
+}
 
 /**
  * Returns a single registered entity associated with a given iframe interface ID. Returns undefined if no entity is found.
@@ -124,14 +131,8 @@ function dedupeRegisteredEntitiesByAsset(entities) {
  */
 function getVersion2Attributes(target, aggregateInstance) {
   if (!supportsV2(aggregateInstance)) return {};
-  const containerAgentEntityGuid = aggregateInstance.agentRef.runtime.appMetadata.agents[0].entityGuid;
-  /** if there's no target, but we are in v2 mode, this means the data belongs to the container agent */
-  if (!target) {
-    return {
-      'entity.guid': containerAgentEntityGuid,
-      appId: aggregateInstance.agentRef.info.applicationID
-    };
-  }
+  /** if the target isn't a registered MFE, but we are in v2 mode, this means the data belongs to the container agent */
+  if (!isMfeTarget(target)) return aggregateInstance.agentRef.runtime.v2Target.attributes;
   /** otherwise, the data belongs to the target (MFE) and should be attributed as such */
   return target.attributes;
 }
@@ -161,16 +162,17 @@ function getVersion2DuplicationAttributes(target, aggregateInstance) {
  * @returns {boolean} returns true if the event should be duplicated for the target, false otherwise
  */
 function shouldDuplicate(target, aggregateInstance) {
-  return !!target && !!supportsV2(aggregateInstance) && aggregateInstance.agentRef.init.api.register.duplicate_data_to_container;
+  return isMfeTarget(target) && !!supportsV2(aggregateInstance) && aggregateInstance.agentRef.init.api.register.duplicate_data_to_container;
 }
 
 /**
  * Finds the registered targets from the stack trace for a given agent reference.
  * @param {*} agentRef The agent reference to use for finding targets.
- * @returns {Array} An array of targets found from the stack trace. If no targets are found or allowed, returns an array with undefined.
+ * @returns {Array} An array of targets found from the stack trace. If no targets are found or allowed, returns an array containing the container target.
  */
 function findTargetsFromStackTrace(agentRef) {
-  if (!isValid(true, agentRef) || !agentRef?.runtime?.registeredEntities?.length) return [undefined];
+  if (!agentRef?.runtime) return [];
+  if (!isValid(true, agentRef) || !agentRef.runtime.registeredEntities?.length) return [agentRef.runtime.v2Target];
   const targets = [];
   try {
     var urls = (0, _scriptTracker.extractUrlsFromStack)((0, _scriptTracker.getDeepStackTrace)());
@@ -182,15 +184,15 @@ function findTargetsFromStackTrace(agentRef) {
     // Silent catch to prevent errors from propagating
   }
   const deduped = dedupeTargetsByInstance(targets);
-  if (!deduped.length) deduped.push(undefined); // if we can't find any targets from the stack trace, return an array with undefined to signify the container agent is the target
+  if (!deduped.length) deduped.push(agentRef.runtime.v2Target); // if we can't find any targets from the stack trace, the container agent is the target
   return deduped;
 }
 
 /**
  * Removes duplicate targets from an array, keyed by `target.instance`. This guards against the same canonical
  * target re-entering the array via multiple matched stack-frame URLs (e.g. a recursive call whose stack contains the
- * same file at multiple depths). Entries with no `instance` (i.e. `undefined`, meaning "the container agent")
- * naturally collapse to a single entry too, which is the desired behavior.
+ * same file at multiple depths). Multiple container-target entries (whose `instance` is the container agent's stable
+ * `agentIdentifier`) naturally collapse to a single entry too, which is the desired behavior.
  * @param {Array} targets
  * @returns {Array} deduped list of targets, preserving relative order of first occurrence
  */

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
  */
 

package/dist/cjs/common/wrap/wrap-events.js

@@ -10,7 +10,7 @@ var _wrapFunction = require("./wrap-function");
 var _getOrSet = require("../util/get-or-set");
 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
  */
 
@@ -31,16 +31,17 @@ const flag = "nr@wrapped:".concat(_contextualEe.contextId);
  * `document` (if in a browser scope). Adds custom events in context of a new emitter scoped only to these methods.
  * @param {Object} sharedEE - The shared event emitter on which a new scoped
  *     event emitter will be based.
+ * @param {*} [agentRef] - The agent reference, used to attribute wrapped calls to the correct v2 target.
  * @returns {Object} Scoped event emitter with a debug ID of `events`.
  */
-function wrapEvents(sharedEE) {
+function wrapEvents(sharedEE, agentRef) {
   var ee = scopedEE(sharedEE);
 
   // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
   // then we increment the count to track # of feats using this at runtime.
   if (wrapped[ee.debugId]++) return ee;
   wrapped[ee.debugId] = 1; // otherwise, first feature to wrap events
-  var wrapFn = (0, _wrapFunction.createWrapperWithEmitter)(ee, true);
+  var wrapFn = (0, _wrapFunction.createWrapperWithEmitter)(ee, true, agentRef);
 
   // Guard against instrumenting environments w/o necessary features
   if ('getPrototypeOf' in Object) {

package/dist/cjs/common/wrap/wrap-fetch.js

@@ -52,8 +52,8 @@ function wrapFetch(sharedEE, agentRef) {
   wrapPromiseMethod(_runtime.globalScope, 'fetch', prefix);
   ee.on(prefix + 'end', function (err, res, targets) {
     var ctx = this;
-    // undefined target reports to container
-    ctx.targets = targets || [undefined];
+    // default target reports to container
+    ctx.targets = targets || [agentRef.runtime.v2Target];
     if (res) {
       var size = res.headers.get('content-length');
       if (size !== null) {

package/dist/cjs/common/wrap/wrap-function.js

@@ -89,7 +89,7 @@ function createWrapperWithEmitter(emitter, always, agentRef) {
 
         // certain wrappers can inform the function wrapper to evaluate the stack of the executed wrapped function to find targets of the execution
         // (e.g. wrap-logger can inform this method to find try to find the MFE source of a console.log)
-        targets = evaluateStack ? (0, _utils.findTargetsFromStackTrace)(agentRef) : [undefined]; // undefined target always maps to the container agent
+        targets = evaluateStack ? (0, _utils.findTargetsFromStackTrace)(agentRef) : [agentRef?.runtime?.v2Target]; // default target always maps to the container agent
 
         if (typeof getContext === 'function') {
           ctx = getContext(args, originalThis);

package/dist/cjs/common/wrap/wrap-history.js

@@ -25,9 +25,10 @@ const HISTORY_FNS = ['pushState', 'replaceState'];
  * Wraps the `pushState` and `replaceState` methods of `window.history` and returns a corresponding event emitter
  * scoped to the history object.
  * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.
+ * @param {*} [agentRef] - The agent reference, used to attribute wrapped calls to the correct v2 target.
  * @returns {Object} Scoped event emitter with a debug ID of `history`.
  */
-function wrapHistory(sharedEE) {
+function wrapHistory(sharedEE, agentRef) {
   const ee = scopedEE(sharedEE);
 
   // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
@@ -36,7 +37,7 @@ function wrapHistory(sharedEE) {
   if (!_runtime.isBrowserScope || wrapped[ee.debugId]++) return ee;
   wrapped[ee.debugId] = 1; // otherwise, first feature to wrap history
 
-  var wrapFn = (0, _wrapFunction.createWrapperWithEmitter)(ee);
+  var wrapFn = (0, _wrapFunction.createWrapperWithEmitter)(ee, undefined, agentRef);
   /*
    * For objects that will be instantiated more than once, we wrap the object's prototype methods. The history object
    * is instantiated only once, so we can wrap its methods directly--and we must wrap the history methods directly as