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

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.1-rc.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.1-rc.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/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/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/features/page_view_event/aggregate/index.js

@@ -140,9 +140,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       return queryParameters;
     };
     this.events.add(body);
-    if (this.agentRef.runtime.harvester.triggerHarvestFor(this, {
-      sendEmptyBody: true
-    }).ranSend) this.sentRum = true;
+    if (this.agentRef.runtime.harvester.triggerHarvestFor(this).ranSend) this.sentRum = true;
   }
   serializer(eventBuffer) {
     // this is necessary because PVE sends a single item rather than an array; in the case of undefined, this prevents sending [null] as body
@@ -183,9 +181,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
 
     if (this.isRetrying && this.retries++ < 1) {
       // Only retry once
-      setTimeout(() => this.agentRef.runtime.harvester.triggerHarvestFor(this, {
-        sendEmptyBody: true
-      }), 5000); // Retry sending the RUM event after 5 seconds
+      setTimeout(() => this.agentRef.runtime.harvester.triggerHarvestFor(this), 5000); // Retry sending the RUM event after 5 seconds
       return;
     }
     if (status >= 400 || status === 0) {

package/dist/cjs/features/page_view_event/aggregate_v2/index.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Aggregate = void 0;
+var _runtime = require("../../../common/constants/runtime");
+var _navTiming = require("../../../common/timing/nav-timing");
+var _stringify = require("../../../common/util/stringify");
+var CONSTANTS = _interopRequireWildcard(require("../constants"));
+var _initializedFeatures = require("../aggregate/initialized-features");
+var _aggregateBase = require("../../utils/aggregate-base");
+var _firstContentfulPaint = require("../../../common/vitals/first-contentful-paint");
+var _firstPaint = require("../../../common/vitals/first-paint");
+var _timeToFirstByte = require("../../../common/vitals/time-to-first-byte");
+var _obfuscate = require("../../../common/util/obfuscate");
+var _webdriverDetection = require("../../../common/util/webdriver-detection");
+var _events = require("../../../common/constants/events");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+class Aggregate extends _aggregateBase.AggregateBase {
+  static featureName = CONSTANTS.FEATURE_NAME;
+  #timeToFirstByte = 0;
+  #firstByteToWindowLoad = 0; // our "frontend" duration
+  #firstByteToDomContent = 0; // our "dom processing" duration
+  #obfuscator;
+  constructor(agentRef) {
+    super(agentRef, CONSTANTS.FEATURE_NAME);
+    this.#obfuscator = new _obfuscate.Obfuscator(agentRef, _events.EVENT_TYPES.PVE);
+    if (_runtime.isBrowserScope) {
+      _timeToFirstByte.timeToFirstByte.subscribe(({
+        value,
+        attrs
+      }) => {
+        const navEntry = attrs.navigationEntry;
+        this.#timeToFirstByte = Math.max(value, this.#timeToFirstByte);
+        this.#firstByteToWindowLoad = Math.max(Math.round(navEntry.loadEventEnd - this.#timeToFirstByte), this.#firstByteToWindowLoad); // our "frontend" duration
+        this.#firstByteToDomContent = Math.max(Math.round(navEntry.domContentLoadedEventEnd - this.#timeToFirstByte), this.#firstByteToDomContent); // our "dom processing" duration
+      });
+    }
+    this.waitForFlags([]).then(() => {
+      const body = this.#obfuscator.traverseAndObfuscateEvents({
+        ja: {
+          ...agentRef.info.jsAttributes,
+          webdriverDetected: _webdriverDetection.webdriverDetected
+        }
+      });
+      this.events.add(body);
+      this.drain();
+    });
+  }
+  queryStringsBuilder() {
+    const info = this.agentRef.info;
+    const measures = {};
+    if (info.queueTime) measures.qt = info.queueTime;
+    if (info.applicationTime) measures.ap = info.applicationTime;
+
+    // These 3 values should've been recorded after load and before this func runs. They are part of the minimum required for PageView events to be created.
+    // Following PR #428, which demands that the BA must drive entity indexing, these need to be sent even outside of the main window context where PerformanceTiming
+    // or PerformanceNavigationTiming do not exists. Hence, they'll be filled in by 0s instead in, for example, worker threads that still init the PVE module.
+    measures.be = this.#timeToFirstByte;
+    measures.fe = this.#firstByteToWindowLoad;
+    measures.dc = this.#firstByteToDomContent;
+    const queryParameters = {
+      at: info.atts,
+      af: (0, _initializedFeatures.getActivatedFeaturesFlags)(this.agentRef).join(','),
+      igp: this.agentRef.runtime.appMetadata.igp,
+      ...measures,
+      fp: _firstPaint.firstPaint.current.value,
+      fcp: _firstContentfulPaint.firstContentfulPaint.current.value
+    };
+    if (_runtime.globalScope.performance) {
+      const navTimingEntry = (0, _runtime.getNavigationEntry)();
+      if (navTimingEntry) {
+        // Navigation Timing level 2 API that replaced PerformanceTiming & PerformanceNavigation
+        const perf = {
+          timing: (0, _navTiming.addPT)(_runtime.originTime, navTimingEntry, {}),
+          navigation: (0, _navTiming.addPN)(navTimingEntry, {})
+        };
+        queryParameters.perf = (0, _stringify.stringify)(perf);
+      } else if (typeof PerformanceTiming !== 'undefined') {
+        // Modern Safari iFrames and Safari pre-15 do not support level 2 timing.
+        const perf = {
+          timing: (0, _navTiming.addPT)(_runtime.originTime, _runtime.globalScope.performance.timing, {}, true),
+          navigation: (0, _navTiming.addPN)(_runtime.globalScope.performance.navigation, {})
+        };
+        queryParameters.perf = (0, _stringify.stringify)(perf);
+      }
+    }
+    const {
+      correctedOriginTime
+    } = this.agentRef.runtime.timeKeeper;
+    if (correctedOriginTime) queryParameters.timestamp = correctedOriginTime; // a "PageView" is set to represent the page's (server adjusted) origin time rather than when event is recorded/harvested
+
+    return queryParameters;
+  }
+  get harvestEndpointVersion() {
+    return 2;
+  }
+  serializer(eventBuffer) {
+    // this is necessary because PVE sends a single item rather than an array; in the case of undefined, this prevents sending [null] as body
+    return eventBuffer[0];
+  }
+}
+exports.Aggregate = Aggregate;

package/dist/cjs/features/page_view_event/instrument/index.js

@@ -24,7 +24,12 @@ class Instrument extends _instrumentBase.InstrumentBase {
 
     /** feature specific APIs */
     (0, _setPageViewName.setupSetPageViewNameAPI)(agentRef);
-    this.importAggregator(agentRef, () => Promise.resolve().then(() => _interopRequireWildcard(require(/* webpackChunkName: "page_view_event-aggregate" */'../aggregate'))));
+    this.importAggregator(agentRef, () => {
+      if (agentRef.init.feature_flags.includes('rum_v2')) {
+        return Promise.resolve().then(() => _interopRequireWildcard(require(/* webpackChunkName: "page_view_event-aggregate" */'../aggregate_v2')));
+      }
+      return Promise.resolve().then(() => _interopRequireWildcard(require(/* webpackChunkName: "page_view_event-aggregate" */'../aggregate')));
+    });
   }
   setupInspectionEvents() {
     const dispatch = (evt, name) => {

package/dist/cjs/features/page_view_timing/aggregate/index.js

@@ -72,7 +72,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
         } = _cumulativeLayoutShift.cumulativeLayoutShift.current;
         if (value === undefined) return;
         this.addTiming(name, value * 1000, attrs);
-      }, true, true); // CLS node should only reports on vis change rather than on every change
+      }, true, true); // CLS node should only report on vis change rather than on every change.
+      /* NOTE: the capture=true is required -- empirically verified against a real browser (Chrome) for CLS
+      timing node to reliably be in the same final harvest as the rest, alongside Harvester#startTimer's
+      queueMicrotask deferral of the EOL harvest itself. Dropping this flag caused CLS to be split into its own,
+      separate, later harvest instead of going out together with pageHide/INP. */
 
       this.drain();
     });

package/dist/cjs/features/session_replay/instrument/index.js

@@ -44,6 +44,10 @@ class Instrument extends _instrumentBase.InstrumentBase {
         recorder.startRecording(_constants2.TRIGGERS.PRELOAD, session?.sessionReplayMode);
       }); // could handle specific fail-state behaviors with a .catch block here
     }
+
+    // If the aggregate never successfully loads (missing session prerequisite, or the aggregate module itself
+    // fails to import/construct), any preload recording that already started needs to be stopped.
+    this.abortHandler = this.#abort;
     this.importAggregator(this.agentRef, () => Promise.resolve().then(() => _interopRequireWildcard(require(/* webpackChunkName: "session_replay-aggregate" */'../aggregate'))), this);
 
     /** If the recorder is running, we can pass error events on to the agg to help it switch to full mode later */
@@ -108,6 +112,11 @@ class Instrument extends _instrumentBase.InstrumentBase {
       }); // could handle specific fail-state behaviors with a .catch block here
     }
   }
+
+  /** Stops any preload recording that already started if the aggregate never ends up successfully loading. */
+  #abort() {
+    this.recorder?.stopRecording();
+  }
 }
 exports.Instrument = Instrument;
 const SessionReplay = exports.SessionReplay = Instrument;

package/dist/cjs/features/session_replay/shared/recorder.js

@@ -216,7 +216,8 @@ class Recorder {
 
     // We are making an effort to try to keep payloads manageable for unloading.  If they reach the unload limit before their interval,
     // it will send immediately.  This often happens on the first snapshot, which can be significantly larger than the other payloads.
-    if ((this.events.hasSnapshot && this.events.hasMeta || payloadSize > _agentConstants.IDEAL_PAYLOAD_SIZE) && !this.isErrorMode) {
+    // (the aggregate may not exist yet/at all if its own bootstrap hasn't finished or failed -- nothing to harvest for in that case.)
+    if ((this.events.hasSnapshot && this.events.hasMeta || payloadSize > _agentConstants.IDEAL_PAYLOAD_SIZE) && !this.isErrorMode && this.srInstrument.featAggregate) {
       // if we've made it to the ideal size of ~16kb before the interval timer, we should send early.
       this.agentRef.runtime.harvester.triggerHarvestFor(this.srInstrument.featAggregate);
     }

package/dist/cjs/features/utils/aggregate-base.js

@@ -7,7 +7,6 @@ exports.AggregateBase = void 0;
 var _featureBase = require("./feature-base");
 var _drain = require("../../common/drain/drain");
 var _features = require("../../loaders/features/features");
-var _harvester = require("../../common/harvest/harvester");
 var _eventBuffer = require("./event-buffer");
 var _handle = require("../../common/event-emitter/handle");
 var _constants = require("../metrics/constants");
@@ -27,7 +26,6 @@ class AggregateBase extends _featureBase.FeatureBase {
    */
   constructor(agentRef, featureName) {
     super(agentRef, featureName);
-    this.doOnceForAllAggregate(agentRef);
 
     /** @type {Boolean} indicates if custom attributes are combined in each event payload for size estimation purposes. this is set to true in derived classes that need to evaluate custom attributes separately from the event payload */
     this.customAttributesAreSeparate = false;
@@ -179,16 +177,6 @@ class AggregateBase extends _featureBase.FeatureBase {
     this.events.clearSave(this.harvestOpts);
   }
 
-  /**
-   * These are actions related to shared resources that should be initialized once by whichever feature Aggregate subclass loads first.
-   * This method should run after checkConfiguration, which may reset the agent's info/runtime object that is used here.
-   */
-  doOnceForAllAggregate(agentRef) {
-    // Note: obfuscator is now created per-feature for their specific event types
-
-    if (!agentRef.runtime.harvester) agentRef.runtime.harvester = new _harvester.Harvester(agentRef);
-  }
-
   /**
    * Report a supportability metric
    * @param {*} metricName The tag of the name matching the Angler aggregation tag