@newrelic/browser-agent 1.320.1 → 1.321.0

package/dist/cjs/loaders/api/register.js

@@ -7,12 +7,12 @@ exports.setupRegisterAPI = setupRegisterAPI;
 exports.warnings = void 0;
 var _handle = require("../../common/event-emitter/handle");
 var _console = require("../../common/util/console");
-var _utils = require("../../common/v2/utils");
+var _constants = require("../../common/v2/constants");
 var _features = require("../features/features");
 var _now = require("../../common/timing/now");
-var _constants = require("../../features/metrics/constants");
+var _constants2 = require("../../features/metrics/constants");
 var _sharedHandlers = require("./sharedHandlers");
-var _constants2 = require("./constants");
+var _constants3 = require("./constants");
 var _log = require("./log");
 var _addPageAction = require("./addPageAction");
 var _noticeError = require("./noticeError");
@@ -23,6 +23,7 @@ var _pageVisibility = require("../../common/window/page-visibility");
 var _scriptTracker = require("../../common/v2/script-tracker");
 var _mfeVitals = require("../../common/v2/mfe-vitals");
 var _uniqueId = require("../../common/ids/unique-id");
+var _cleanUrl = require("../../common/url/clean-url");
 /**
  * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -57,7 +58,7 @@ const warnings = exports.warnings = {
  * It is not recommended for use in production environments and will not receive support for issues.
  */
 function setupRegisterAPI(agent) {
-  (0, _sharedHandlers.setupAPI)(_constants2.REGISTER, function (target) {
+  (0, _sharedHandlers.setupAPI)(_constants3.REGISTER, function (target) {
     return register(agent, target);
   }, agent);
 }
@@ -73,7 +74,7 @@ function register(agentRef, target) {
   warnings.experimental();
   target ||= {};
   target.instance = (0, _uniqueId.generateRandomHexString)(8);
-  target.type = _utils.V2_TYPES.MFE;
+  target.type = _constants.V2_TYPES.MFE;
   target.licenseKey ||= agentRef.info.licenseKey; // will inherit the license key from the container agent if not provided for brevity. A future state may dictate that we need different license keys to do different things.
   target.blocked = false;
   if (typeof target.tags !== 'object' || target.tags === null || Array.isArray(target.tags)) target.tags = {};
@@ -82,12 +83,17 @@ function register(agentRef, target) {
       return agentRef.runtime.appMetadata.agents?.[0].entityGuid;
     },
     // getter because this is asynchronously set
-    type: _utils.V2_TYPES.BA
+    type: _constants.V2_TYPES.BA
   };
+
+  // The script timings for this entity, which will be used to populate part of the MicroFrontEndTiming custom event.
   const timings = (0, _scriptTracker.findScriptTimings)(target);
 
-  // Track MFE vitals for this entity
+  // Track MFE vitals for this entity, which will be used to populate part of the MicroFrontEndTiming custom event.
   const vitals = (0, _mfeVitals.trackMFEVitals)(target, timings);
+
+  // the URL of the page at the time this entity was registered, which will be used to populate part of the MicroFrontEndTiming custom event.
+  const registerUrl = (0, _cleanUrl.cleanURL)('' + location);
   const attrs = {};
 
   // Only define attributes getter if it doesn't already exist
@@ -99,7 +105,7 @@ function register(agentRef, target) {
           'source.id': target.id,
           'source.name': target.name,
           'source.type': target.type,
-          'parent.type': target.parent?.type || _utils.V2_TYPES.BA,
+          'parent.type': target.parent?.type || _constants.V2_TYPES.BA,
           'parent.id': target.parent?.id
         };
       }
@@ -223,6 +229,13 @@ function register(agentRef, target) {
       // the url of the script that was registered, or undefined if it could not be determined (inline or no match)
       assetType: timings.type,
       // the type of asset that was associated with the timings, one of 'script', 'link' (if preloaded and found in the resource timing buffer), 'preload' (if preloaded but not found in the resource timing buffer), or "unknown" if it could not be determined
+      registerUrl,
+      // the url of the page at the time this entity was registered
+      deregisterUrl: (0, _cleanUrl.cleanURL)('' + location),
+      // the url of the page at the time this entity was deregistered (or unloaded)
+      // generic_events' addEvent() injects pageUrl/currentUrl on every custom event by default; override them away here in favor of registerUrl/deregisterUrl above
+      pageUrl: undefined,
+      currentUrl: undefined,
       timeAlive: timings.reportedAt - timings.registeredAt,
       // registeredAt to reportedAt
       timeToBeRequested: timings.fetchStart,
@@ -237,19 +250,19 @@ function register(agentRef, target) {
       // timestamp when register() was called
       // leave room to extend these with more data keys as needed
       ...(vitals.fcp.value >= 0 && {
-        'nr.vitals.fcp.value': vitals.fcp.value
+        'vitals.fcp.value': vitals.fcp.value
       }),
       // FCP vital object with value and metadata
       ...(vitals.lcp.value >= 0 && {
-        'nr.vitals.lcp.value': vitals.lcp.value
+        'vitals.lcp.value': vitals.lcp.value
       }),
       // LCP vital object with value and metadata
       ...(vitals.cls.value >= 0 && {
-        'nr.vitals.cls.value': vitals.cls.value
+        'vitals.cls.value': vitals.cls.value
       }),
       // CLS vital object with value and metadata
       ...(vitals.inp.value >= 0 && {
-        'nr.vitals.inp.value': vitals.inp.value
+        'vitals.inp.value': vitals.inp.value
       }) // INP vital object with value and metadata
     };
     api.recordCustomEvent('MicroFrontEndTiming', eventData);
@@ -281,7 +294,7 @@ function register(agentRef, target) {
     const timestamp = api.metadata.events.latestTimestamp ?? (0, _now.now)();
     api.metadata.events.latestTimestamp = undefined;
     const methodName = METHOD_NAMES.get(methodToCall) || 'unknown';
-    (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ["API/register/".concat(methodName, "/called")], undefined, _features.FEATURE_NAMES.metrics, agentRef.ee);
+    (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ["API/register/".concat(methodName, "/called")], undefined, _features.FEATURE_NAMES.metrics, agentRef.ee);
     try {
       return methodToCall(...args, target, timestamp); // always report to target
     } catch (err) {

package/dist/cjs/loaders/configure/configure.js

@@ -9,6 +9,7 @@ var _nreum = require("../../common/window/nreum");
 var _info = require("../../common/config/info");
 var _init = require("../../common/config/init");
 var _runtime = require("../../common/config/runtime");
+var _constants = require("../../common/v2/constants");
 var _runtime2 = require("../../common/constants/runtime");
 var _publicPath = require("./public-path");
 var _contextualEe = require("../../common/event-emitter/contextual-ee");
@@ -52,6 +53,19 @@ function configure(agent, opts = {}, loaderType, forceDrain) {
   agent.info = (0, _info.mergeInfo)(info);
   const updatedInit = agent.init;
   agent.runtime ??= (0, _runtime.mergeRuntime)(runtime);
+  agent.runtime.v2Target ??= {
+    type: _constants.V2_TYPES.BA,
+    instance: agent.agentIdentifier,
+    get id() {
+      return agent.runtime.appMetadata?.agents?.[0]?.entityGuid;
+    },
+    get attributes() {
+      return {
+        'entity.guid': this.id,
+        appId: agent.info.applicationID
+      };
+    }
+  };
 
   // Apply proxy settings whenever configure is called (supports late {init} setting)
   if (updatedInit.proxy.assets) {

package/dist/cjs/loaders/features/features.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.featurePriority = exports.RUM = exports.LOGS = exports.JSERRORS = exports.FEATURE_TO_ENDPOINT = exports.FEATURE_NAMES = exports.EVENTS = exports.BLOBS = void 0;
+exports.featurePriority = exports.RUM = exports.LOGS = exports.JSERRORS = exports.FEATURE_TO_ENDPOINT = exports.FEATURE_NAMES = exports.EVENTS = exports.CONNECT = exports.BLOBS = void 0;
 /**
  * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -14,6 +14,7 @@ const EVENTS = exports.EVENTS = 'events';
 const JSERRORS = exports.JSERRORS = 'jserrors';
 const BLOBS = exports.BLOBS = 'browser/blobs';
 const RUM = exports.RUM = 'rum';
+const CONNECT = exports.CONNECT = 'connect';
 const LOGS = exports.LOGS = 'browser/logs';
 const FEATURE_NAMES = exports.FEATURE_NAMES = {
   ajax: 'ajax',

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

@@ -38,7 +38,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/esm/common/constants/env.cdn.js

@@ -11,7 +11,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.320.1";
+export const VERSION = "1.321.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -11,7 +11,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.320.1";
+export const VERSION = "1.321.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -22,7 +22,7 @@ export 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/esm/common/event-listener/event-listener-opts.js

@@ -1,5 +1,5 @@
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 export function eventListenerOpts(useCapture, abortSignal) {

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

@@ -0,0 +1,195 @@
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { isBrowserScope } from '../constants/runtime';
+import { send } from './send';
+import { TimeKeeper } from '../timing/time-keeper';
+import { activateFeatures } from '../util/feature-flags';
+import { now } from '../timing/now';
+import { warn } from '../util/console';
+import { VERSION } from "../constants/env.npm";
+import { CONNECT, FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../loaders/features/features';
+import { handle } from '../event-emitter/handle';
+import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants';
+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)
+
+export 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(agentRef.runtime.session);
+    if (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 = now();
+    return send(this.#agentRef, {
+      endpoint: "browser/connect/2/".concat(this.#agentRef.info.licenseKey),
+      payload: {
+        body: {},
+        qs: {
+          a: this.#agentRef.info.applicationID,
+          v: VERSION,
+          s: this.#agentRef.runtime.session?.state.value || '0'
+        }
+      },
+      localOpts: {
+        sendEmptyBody: true,
+        headers: retryHeaders
+      },
+      raw: true,
+      featureName: CONNECT,
+      cbFinished: this.#processConnectResponse.bind(this)
+    });
+  }
+  #applyConnectResponse({
+    app,
+    config
+  }) {
+    if (!Object.keys(this.#agentRef.runtime.appMetadata).length) this.#agentRef.runtime.appMetadata = app;
+    activateFeatures(config, this.#agentRef);
+  }
+  #processConnectResponse({
+    sent,
+    status,
+    retry,
+    xhr,
+    responseText
+  }) {
+    const connectEndTime = 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
+        handle(SUPPORTABILITY_METRIC_CHANNEL, ['Session/RaceCondition/Seen'], undefined, 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) {
+      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
+        }
+      }];
+      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: FEATURE_TO_ENDPOINT[FEATURE_NAMES.metrics],
+        payload: {
+          body: {
+            sm
+          }
+        },
+        featureName: FEATURE_NAMES.metrics
+      });
+      this.#agentRef.ee.abort();
+      return;
+    }
+    let resp;
+    try {
+      resp = JSON.parse(responseText);
+    } catch (error) {
+      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) {
+        handle(SUPPORTABILITY_METRIC_CHANNEL, ['Generic/TimeKeeper/InvalidTimestamp/Seen', timeDiff], undefined, FEATURE_NAMES.metrics, this.#agentRef.ee);
+      }
+    } catch (error) {
+      warn(17, error);
+      this.#agentRef.ee.abort();
+      return;
+    }
+    this.#applyConnectResponse(resp);
+  }
+}

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

@@ -19,11 +19,13 @@ export 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 Obfuscator(agentRef);
+  }
+  startTimer(harvestInterval = this.agentRef.init.harvest.interval) {
+    if (this.#started) return;
+    this.#started = true;
     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();
@@ -31,12 +33,7 @@ export 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/esm/common/harvest/send.js

@@ -2,7 +2,7 @@
  * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { JSERRORS, RUM, EVENTS, FEATURE_NAMES, BLOBS, LOGS } from '../../loaders/features/features';
+import { JSERRORS, RUM, EVENTS, FEATURE_NAMES, BLOBS, LOGS, CONNECT } from '../../loaders/features/features';
 import { VERSION } from "../constants/env.npm";
 import { globalScope, isWorkerScope } from '../constants/runtime';
 import { handle } from '../event-emitter/handle';
@@ -12,7 +12,7 @@ import { cleanURL } from '../url/clean-url';
 import { obj, param } from '../url/encode';
 import { warn } from '../util/console';
 import { stringify } from '../util/stringify';
-import { xhr as xhrMethod, xhrFetch as fetchMethod } from '../util/submit-data';
+import { xhr as xhrMethod, xhrFetch as fetchMethod, getSubmitMethod } from '../util/submit-data';
 import { dispatchGlobalEvent } from '../dispatch/global-event';
 
 /**
@@ -31,7 +31,7 @@ export function send(agentRef, {
   endpoint,
   payload,
   localOpts = {},
-  submitMethod,
+  submitMethod = getSubmitMethod(),
   cbFinished,
   raw,
   featureName,
@@ -52,13 +52,15 @@ export 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 !== RUM ? '/' + endpoint : '', "/").concat(endpointVersion, "/").concat(agentRef.info.licenseKey);
+  const includeEndpointName = endpoint !== 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 = 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
@@ -73,7 +75,7 @@ export 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),
@@ -122,6 +124,7 @@ export function send(agentRef, {
     }
     function trackHarvestMetadata() {
       try {
+        if (featureName === CONNECT) return;
         if (featureName === FEATURE_NAMES.jserrors && !body?.err) return;
         const hasReplay = baseParams.includes('hr=1');
         const hasTrace = baseParams.includes('ht=1');
@@ -207,9 +210,7 @@ function baseQueryString(agentRef, qs, endpoint, harvesterObfuscator) {
   const session = agentRef.runtime.session;
   const hr = !!session?.state.sessionReplaySentFirstChunk && session?.state.sessionReplayMode === 1 && endpoint !== JSERRORS;
   const ht = !!session?.state.traceHarvestStarted && session?.state.sessionTraceMode === 1 && ![LOGS, BLOBS].includes(endpoint);
-  const qps = ['a=' + agentRef.info.applicationID, param('sa', agentRef.info.sa ? '' + agentRef.info.sa : ''), param('v', VERSION), transactionNameParam(), param('ct', agentRef.runtime.customTransaction), '&rst=' + now(), '&ck=0',
-  // ck param DEPRECATED - still expected by backend
-  '&s=' + (session?.state.value || '0'),
+  const qps = ['a=' + agentRef.info.applicationID, param('sa', agentRef.info.sa ? '' + agentRef.info.sa : ''), param('v', VERSION), transactionNameParam(), param('ct', agentRef.runtime.customTransaction), '&rst=' + now(), '&s=' + (session?.state.value || '0'),
   // the 0 id encaps all untrackable and default traffic
   param('ref', ref), param('ptid', agentRef.runtime.ptid ? '' + agentRef.runtime.ptid : '')];
   if (hr) qps.push(param('hr', '1', qs));

package/dist/esm/common/session/session-entity.js

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

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

@@ -1,5 +1,5 @@
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Timer } from './timer';
@@ -52,7 +52,7 @@ export class InteractionTimer extends 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/esm/common/unload/eol.js

@@ -1,5 +1,5 @@
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 import { globalScope, isWorkerScope, isBrowserScope } from '../constants/runtime';
@@ -22,9 +22,9 @@ if (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
  */
-export function subscribeToEOL(cb, capturePhase) {
+export function subscribeToEOL(cb) {
   if (isBrowserScope) {
-    subscribeToVisibilityChange(cb, true, capturePhase); // when user switches tab or hides window, esp. mobile scenario
+    subscribeToVisibilityChange(cb, true); // when user switches tab or hides window, esp. mobile scenario
   } else if (isWorkerScope) {
     globalScope.cleanupTasks.push(cb); // close() should run these tasks before quitting thread
   }

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

@@ -68,7 +68,7 @@ import { dispatchGlobalEvent } from '../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. |
@@ -94,6 +94,7 @@ import { dispatchGlobalEvent } from '../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/esm/common/util/feature-flags.js

@@ -19,7 +19,8 @@ export function activateFeatures(flags, agentRef) {
   // let any window level subscribers know that the agent is running, per install docs
   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/esm/common/v2/constants.js

@@ -0,0 +1,15 @@
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @enum {string}
+ * @readonly
+ */
+export const V2_TYPES = {
+  /** Micro Frontend */
+  MFE: 'MFE',
+  /** Browser Application */
+  BA: 'BA'
+};