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

package/src/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'
@@ -53,7 +53,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)
     }
   }
 

package/src/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/src/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/src/common/util/feature-flags.js

@@ -19,7 +19,7 @@ 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/src/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'
+}

package/src/common/v2/utils.js

@@ -4,16 +4,23 @@
  */
 
 import { extractUrlsFromStack, getDeepStackTrace } from './script-tracker'
+import { V2_TYPES } from './constants'
 
 /**
- * @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)
  */
-export const 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
+ */
+export function isMfeTarget (target) {
+  return target?.type === V2_TYPES.MFE
 }
 
 /**
@@ -114,14 +121,8 @@ export function dedupeRegisteredEntitiesByAsset (entities) {
  */
 export 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
 }
@@ -147,16 +148,17 @@ export function getVersion2DuplicationAttributes (target, aggregateInstance) {
  * @returns {boolean} returns true if the event should be duplicated for the target, false otherwise
  */
 export 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.
  */
 export 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 {
@@ -170,15 +172,15 @@ export function findTargetsFromStackTrace (agentRef) {
   }
 
   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/src/common/window/page-visibility.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
  */
 

package/src/common/wrap/wrap-events.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
  */
 
@@ -24,16 +24,17 @@ const flag = `nr@wrapped:${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`.
  */
-export function wrapEvents (sharedEE) {
+export 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 = wfn(ee, true)
+  var wrapFn = wfn(ee, true, agentRef)
 
   // Guard against instrumenting environments w/o necessary features
   if ('getPrototypeOf' in Object) {

package/src/common/wrap/wrap-fetch.js

@@ -47,8 +47,8 @@ export function wrapFetch (sharedEE, agentRef) {
 
   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/src/common/wrap/wrap-function.js

@@ -88,7 +88,7 @@ export 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 ? findTargetsFromStackTrace(agentRef) : [undefined] // undefined target always maps to the container agent
+        targets = evaluateStack ? findTargetsFromStackTrace(agentRef) : [agentRef?.runtime?.v2Target] // default target always maps to the container agent
 
         if (typeof getContext === 'function') {
           ctx = getContext(args, originalThis)

package/src/common/wrap/wrap-history.js

@@ -18,9 +18,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`.
  */
-export function wrapHistory (sharedEE) {
+export 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,
@@ -29,7 +30,7 @@ export function wrapHistory (sharedEE) {
   if (!isBrowserScope || wrapped[ee.debugId]++) return ee
   wrapped[ee.debugId] = 1 // otherwise, first feature to wrap history
 
-  var wrapFn = wfn(ee)
+  var wrapFn = wfn(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

package/src/common/wrap/wrap-xhr.js

@@ -37,8 +37,8 @@ export function wrapXhr (sharedEE, agentRef) {
   if (wrapped[ee.debugId]++) return ee
   wrapped[ee.debugId] = 1 // otherwise, first feature to wrap XHR
 
-  wrapEvents(baseEE) // wrap-events patches XMLHttpRequest.prototype.addEventListener for us
-  var wrapFn = wfn(ee)
+  wrapEvents(baseEE, agentRef) // wrap-events patches XMLHttpRequest.prototype.addEventListener for us
+  var wrapFn = wfn(ee, undefined, agentRef)
 
   var OrigXHR = globalScope.XMLHttpRequest
   var MutationObserver = globalScope.MutationObserver

package/src/features/ajax/aggregate/index.js

@@ -14,7 +14,7 @@ import { gosNREUMOriginals } from '../../../common/window/nreum'
 import { hasGQLErrors, parseGQL } from './gql'
 import { canCapturePayload, isLikelyHumanReadable, parseQueryString, createStringAdders } from '../../../common/payloads/payloads'
 import { Obfuscator } from '../../../common/util/obfuscate'
-import { getVersion2Attributes, getVersion2DuplicationAttributes, shouldDuplicate } from '../../../common/v2/utils'
+import { getVersion2Attributes, getVersion2DuplicationAttributes, shouldDuplicate, isMfeTarget } from '../../../common/v2/utils'
 import { EVENT_TYPES } from '../../../common/constants/events'
 import { generateUuid } from '../../../common/ids/unique-id'
 
@@ -137,7 +137,7 @@ export class Aggregate extends AggregateBase {
     if (event.gql) this.reportSupportabilityMetric('Ajax/Events/GraphQL/Bytes-Added', stringify(event.gql).length)
 
     /** make a copy of the event for the MFE target if it exists */
-    if (target) {
+    if (isMfeTarget(target)) {
       this.events.add({ ...event, targetAttributes: getVersion2Attributes(target, this) })
       if (shouldDuplicate(target, this)) this.reportContainerEvent({ ...event, targetAttributes: getVersion2DuplicationAttributes(target, this) }, ctx)
     } else {

package/src/features/generic_events/aggregate/index.js

@@ -252,7 +252,7 @@ export class Aggregate extends AggregateBase {
       }, this.featureName, this.ee)
 
       if (agentRef.init.feature_flags.includes('websockets') || agentRef.init.web_sockets?.enabled) {
-        registerHandler('ws-complete', (nrData, targets = [undefined]) => {
+        registerHandler('ws-complete', (nrData, targets = [agentRef.runtime.v2Target]) => {
           targets.forEach(target => {
             const event = {
               ...nrData,

package/src/features/generic_events/instrument/index.js

@@ -68,7 +68,7 @@ export class Instrument extends InstrumentBase {
     if (isBrowserScope) {
       wrapFetch(this.ee, agentRef)
       wrapXhr(this.ee, agentRef)
-      historyEE = wrapHistory(this.ee)
+      historyEE = wrapHistory(this.ee, agentRef)
 
       if (agentRef.init.user_actions.enabled) {
         OBSERVED_EVENTS.forEach(eventType =>

package/src/features/jserrors/aggregate/index.js

@@ -19,7 +19,7 @@ import { AggregateBase } from '../../utils/aggregate-base'
 import { now } from '../../../common/timing/now'
 import { Obfuscator } from '../../../common/util/obfuscate'
 import { evaluateInternalError } from './internal-errors'
-import { getRegisteredTargetsFromFilename, getVersion2Attributes, getVersion2DuplicationAttributes, shouldDuplicate } from '../../../common/v2/utils'
+import { getRegisteredTargetsFromFilename, getVersion2Attributes, getVersion2DuplicationAttributes, shouldDuplicate, isMfeTarget } from '../../../common/v2/utils'
 import { buildCauseString } from './cause-string'
 import { ShortCircuit } from '../../../common/util/short-circuit'
 import { EVENT_TYPES } from '../../../common/constants/events'
@@ -209,7 +209,7 @@ export class Aggregate extends AggregateBase {
           if (targets.length) break
         }
       }
-      if (!targets.length) targets.push(undefined)
+      if (!targets.length) targets.push(this.agentRef.runtime.v2Target)
     }
     return targets
   }
@@ -253,7 +253,7 @@ export class Aggregate extends AggregateBase {
     if (filterOutput?.group) params.errorGroup = filterOutput.group
 
     // Should only decorate "hasReplay" for the container agent, so check if the target matches the config
-    if (hasReplay && !target) params.hasReplay = hasReplay
+    if (hasReplay && !isMfeTarget(target)) params.hasReplay = hasReplay
     /**
      * The bucketHash is different from the params.stackHash because the params.stackHash is based on the canonicalized
      * stack trace and is used downstream in NR1 to attempt to group the same errors across different browsers. However,
@@ -289,7 +289,7 @@ export class Aggregate extends AggregateBase {
 
     // Trace sends the error in its payload, and both trace & replay simply listens for any error to occur.
     const jsErrorEvent = [type, bucketHash, params, newMetrics, customAttributes]
-    if (!target) handle('trace-jserror', jsErrorEvent, undefined, FEATURE_NAMES.sessionTrace, this.ee)
+    if (!isMfeTarget(target)) handle('trace-jserror', jsErrorEvent, undefined, FEATURE_NAMES.sessionTrace, this.ee)
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return
 
@@ -297,7 +297,7 @@ export class Aggregate extends AggregateBase {
       customAttributes.socketId = err.__newrelic.socketId
     }
 
-    if (!target) {
+    if (!isMfeTarget(target)) {
       const softNavInUse = Boolean(this.agentRef.features?.[FEATURE_NAMES.softNav])
       if (softNavInUse) { // pass the error to soft nav for evaluation - it will return it via 'returnJserror' when interaction is resolved
         handle('jserror', [jsErrorEvent], undefined, FEATURE_NAMES.softNav, this.ee)
@@ -307,7 +307,7 @@ export class Aggregate extends AggregateBase {
     }
 
     // always add directly if scoped to a sub-entity, the other pathways above will be deterministic if the main agent should procede
-    if (target) this.#storeJserrorForHarvest(jsErrorEvent, {}, target)
+    if (isMfeTarget(target)) this.#storeJserrorForHarvest(jsErrorEvent, {}, target)
   }
 
   /**

package/src/features/logging/instrument/index.js

@@ -31,7 +31,7 @@ export class Instrument extends InstrumentBase {
     })
 
     /** emitted by wrap-logger function */
-    this.ee.on('wrap-logger-end', function handleLog ([message], _, __, targets = []) {
+    this.ee.on('wrap-logger-end', function handleLog ([message], _, __, targets = [agentRef.runtime.v2Target]) {
       const { level, customAttributes, autoCaptured } = this
       targets.forEach(target => {
         bufferLog(instanceEE, message, customAttributes, level, autoCaptured, target)

package/src/features/page_view_event/aggregate/index.js

@@ -132,9 +132,7 @@ export class Aggregate extends AggregateBase {
     }
     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
@@ -162,9 +160,7 @@ export class Aggregate extends AggregateBase {
     super.postHarvestCleanup({ sent, retry: retry && !hasCachedRumResponse }) // this will set isRetrying & re-buffer the body if request is to be retried
 
     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
     }
 

package/src/features/page_view_event/aggregate_v2/index.js

@@ -0,0 +1,97 @@
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { globalScope, isBrowserScope, originTime, getNavigationEntry } from '../../../common/constants/runtime'
+import { addPT, addPN } from '../../../common/timing/nav-timing'
+import { stringify } from '../../../common/util/stringify'
+import * as CONSTANTS from '../constants'
+import { getActivatedFeaturesFlags } from '../aggregate/initialized-features'
+import { AggregateBase } from '../../utils/aggregate-base'
+import { firstContentfulPaint } from '../../../common/vitals/first-contentful-paint'
+import { firstPaint } from '../../../common/vitals/first-paint'
+import { timeToFirstByte } from '../../../common/vitals/time-to-first-byte'
+import { Obfuscator } from '../../../common/util/obfuscate'
+import { webdriverDetected } from '../../../common/util/webdriver-detection'
+import { EVENT_TYPES } from '../../../common/constants/events'
+
+export class Aggregate extends 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 Obfuscator(agentRef, EVENT_TYPES.PVE)
+
+    if (isBrowserScope) {
+      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 } })
+      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: getActivatedFeaturesFlags(this.agentRef).join(','),
+      igp: this.agentRef.runtime.appMetadata.igp,
+      ...measures,
+      fp: firstPaint.current.value,
+      fcp: firstContentfulPaint.current.value
+    }
+    if (globalScope.performance) {
+      const navTimingEntry = getNavigationEntry()
+      if (navTimingEntry) { // Navigation Timing level 2 API that replaced PerformanceTiming & PerformanceNavigation
+        const perf = ({
+          timing: addPT(originTime, navTimingEntry, {}),
+          navigation: addPN(navTimingEntry, {})
+        })
+        queryParameters.perf = stringify(perf)
+      } else if (typeof PerformanceTiming !== 'undefined') { // Modern Safari iFrames and Safari pre-15 do not support level 2 timing.
+        const perf = ({
+          timing: addPT(originTime, globalScope.performance.timing, {}, true),
+          navigation: addPN(globalScope.performance.navigation, {})
+        })
+        queryParameters.perf = 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]
+  }
+}

package/src/features/page_view_event/instrument/index.js

@@ -20,7 +20,12 @@ export class Instrument extends InstrumentBase {
     /** feature specific APIs */
     setupSetPageViewNameAPI(agentRef)
 
-    this.importAggregator(agentRef, () => import(/* webpackChunkName: "page_view_event-aggregate" */ '../aggregate'))
+    this.importAggregator(agentRef, () => {
+      if (agentRef.init.feature_flags.includes('rum_v2')) {
+        return import(/* webpackChunkName: "page_view_event-aggregate" */ '../aggregate_v2')
+      }
+      return import(/* webpackChunkName: "page_view_event-aggregate" */ '../aggregate')
+    })
   }
 
   setupInspectionEvents () {

package/src/features/page_view_timing/aggregate/index.js

@@ -59,7 +59,11 @@ export class Aggregate extends AggregateBase {
         const { name, value, attrs } = 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/src/features/session_replay/instrument/index.js

@@ -46,6 +46,10 @@ export class Instrument extends InstrumentBase {
       }) // 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, () => import(/* 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 */
@@ -109,6 +113,11 @@ export class Instrument extends 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()
+  }
 }
 
 export const SessionReplay = Instrument

package/src/features/session_replay/shared/recorder.js

@@ -204,7 +204,8 @@ export 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 > 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 > 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/src/features/session_trace/instrument/index.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 { handle } from '../../../common/event-emitter/handle'
@@ -33,8 +33,8 @@ export class Instrument extends InstrumentBase {
     }
 
     const thisInstrumentEE = this.ee
-    wrapHistory(thisInstrumentEE)
-    this.eventsEE = wrapEvents(thisInstrumentEE)
+    wrapHistory(thisInstrumentEE, agentRef)
+    this.eventsEE = wrapEvents(thisInstrumentEE, agentRef)
 
     this.eventsEE.on(FN_START, function (args, target) {
       this.bstStart = now()

package/src/features/soft_navigations/instrument/index.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 { gosNREUMOriginals } from '../../../common/window/nreum'
@@ -30,7 +30,7 @@ export class Instrument extends InstrumentBase {
 
     if (!isBrowserScope || !gosNREUMOriginals().o.MO) return // soft navigations is not supported outside web env or browsers without the mutation observer API
 
-    const historyEE = wrapHistory(this.ee)
+    const historyEE = wrapHistory(this.ee, agentRef)
     try {
       this.removeOnAbort = new AbortController()
     } catch (e) {}

package/src/features/utils/aggregate-base.js

@@ -5,7 +5,6 @@
 import { FeatureBase } from './feature-base'
 import { drain } from '../../common/drain/drain'
 import { FEATURE_NAMES } from '../../loaders/features/features'
-import { Harvester } from '../../common/harvest/harvester'
 import { EventBuffer } from './event-buffer'
 import { handle } from '../../common/event-emitter/handle'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../metrics/constants'
@@ -21,7 +20,6 @@ export class AggregateBase extends 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
@@ -178,16 +176,6 @@ export class AggregateBase extends 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(agentRef)
-  }
-
   /**
    * Report a supportability metric
    * @param {*} metricName The tag of the name matching the Angler aggregation tag