@newrelic/browser-agent 1.312.1 → 1.313.0-rc.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.313.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.312.1...v1.313.0) (2026-04-14)
+
+
+### Features
+
+* Apply legal and compliance requirements to register API ([#1742](https://github.com/newrelic/newrelic-browser-agent/issues/1742)) ([24199ee](https://github.com/newrelic/newrelic-browser-agent/commit/24199ee75c0e8d1e74d7d882526fd868b87a93ae))
+* Automatically Detect MFE Errors ([#1720](https://github.com/newrelic/newrelic-browser-agent/issues/1720)) ([281617a](https://github.com/newrelic/newrelic-browser-agent/commit/281617a351459afe82c52e0ce657d3f7b1b5f19c))
+* Improve MicroFrontEndTiming heuristics ([#1735](https://github.com/newrelic/newrelic-browser-agent/issues/1735)) ([e59c60a](https://github.com/newrelic/newrelic-browser-agent/commit/e59c60af34e8f2408ffa4835dc6db4fdcbf756ba))
+* remove "withCredentials" ([#1747](https://github.com/newrelic/newrelic-browser-agent/issues/1747)) ([e84c292](https://github.com/newrelic/newrelic-browser-agent/commit/e84c292b9d17918de0e8e1542fe363e28fa67d33))
+* Report CSP violations as new events ([#1736](https://github.com/newrelic/newrelic-browser-agent/issues/1736)) ([65b5b98](https://github.com/newrelic/newrelic-browser-agent/commit/65b5b988c6cb8d852ad952a3eee94a54864afcd2))
+
+
+### Bug Fixes
+
+* Bad `trace.lastTimestamp` in Safari + back nav edge case ([#1754](https://github.com/newrelic/newrelic-browser-agent/issues/1754)) ([a607ee1](https://github.com/newrelic/newrelic-browser-agent/commit/a607ee1b34bb57fb800f0220074cd27d1f86a32d))
+
 ## [1.312.1](https://github.com/newrelic/newrelic-browser-agent/compare/v1.312.0...v1.312.1) (2026-04-02)
 
 

package/dist/cjs/common/config/init-types.js

@@ -17,8 +17,9 @@ exports.default = void 0;
  * @property {boolean} [ajax.enabled] - Turn on/off the ajax feature (on by default).
  * @property {boolean} [ajax.autoStart] - If true, the agent will automatically start the ajax feature. Otherwise, it will be in a deferred state until the `start` API method is called.
  * @property {Object} [api]
- * @property {boolean} [api.allow_registered_children] - If true, the agent will allow registered children to be sent to the server.
- * @property {boolean} [api.duplicate_registered_data] - If true, the agent will capture registered child data to the main agent as well as the registered child.
+ * @property {Object} [api.register]
+ * @property {boolean} [api.register.enabled] - If true, the agent will allow registered children to be sent to the server.
+ * @property {boolean} [api.register.duplicate_data_to_container] - If true, the agent will capture registered child data to the main agent as well as the registered child.
  * @property {Object} [distributed_tracing]
  * @property {boolean} [distributed_tracing.enabled] - If true, distributed tracing headers will be added to outgoing requests. Requires ajax feature to be running.
  * @property {boolean} [distributed_tracing.exclude_newrelic_header]

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

@@ -27,7 +27,7 @@ const InitModelFn = () => {
   const hiddenState = {
     feature_flags: [],
     experimental: {
-      allow_registered_children: false,
+      register: false,
       resources: false
     },
     mask_selector: '*',
@@ -60,13 +60,15 @@ const InitModelFn = () => {
       autoStart: true
     },
     api: {
-      get allow_registered_children() {
-        return hiddenState.feature_flags.includes(_constants.FEATURE_FLAGS.REGISTER) || hiddenState.experimental.allow_registered_children;
-      },
-      set allow_registered_children(val) {
-        hiddenState.experimental.allow_registered_children = val;
-      },
-      duplicate_registered_data: false
+      register: {
+        get enabled() {
+          return hiddenState.feature_flags.includes(_constants.FEATURE_FLAGS.REGISTER) || hiddenState.experimental.register;
+        },
+        set enabled(val) {
+          hiddenState.experimental.register = val;
+        },
+        duplicate_data_to_container: false
+      }
     },
     browser_consent_mode: {
       enabled: 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.312.1";
+const VERSION = exports.VERSION = "1.313.0-rc.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.312.1";
+const VERSION = exports.VERSION = "1.313.0-rc.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/timing/time-keeper.js

@@ -4,10 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.TimeKeeper = void 0;
+var _constants = require("../../features/metrics/constants");
 var _runtime = require("../constants/runtime");
 var _monkeyPatched = require("../util/monkey-patched");
+var _handle = require("../event-emitter/handle");
+var _features = require("../../loaders/features/features");
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -42,11 +45,31 @@ class TimeKeeper {
    * @type {boolean}
    */
   #ready = false;
+  #reportedDrift = false;
   constructor(sessionObj) {
     this.#session = sessionObj;
     this.processStoredDiff();
     (0, _monkeyPatched.isNative)(performance.now, Date.now); // will warn the user if these are not native functions.  We need these to be native for time in the agent to be accurate in general.
   }
+  #detectDrift() {
+    if (this.#reportedDrift) return;
+    try {
+      // Drift detection: measures if performance.now() and Date.now() have become desynchronized
+      // This can happen when a machine sleeps and the performance timer freezes while Date continues
+      // this can also happen when a user sets their clock forward during the page lifecycle,
+      // but we have no way of distinguishing that from actual clock drift so we will just treat it as drift.
+      // In either case, the performance timestamps would be inaccurate at that point so we want to detect and report a count of it.
+      // We only detect positive drift (performance clock falling behind Date clock)
+      // Note: localTimeDiff (server time offset) is NOT part of drift - that's a legitimate offset
+      const drift = Date.now() - _runtime.originTime - performance.now();
+      if (drift > 1000) {
+        this.#reportedDrift = true;
+        (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['Generic/TimeKeeper/ClockDrift/Detected', drift], undefined, _features.FEATURE_NAMES.metrics, this.#session.agentRef.ee);
+      }
+    } catch (err) {
+      // Silently ignore drift detection errors to avoid breaking normal operation
+    }
+  }
   get ready() {
     return this.#ready;
   }
@@ -91,6 +114,7 @@ class TimeKeeper {
    * @returns {number} Corrected unix/epoch timestamp
    */
   convertRelativeTimestamp(relativeTime) {
+    this.#detectDrift();
     return _runtime.originTime + relativeTime;
   }
 
@@ -101,6 +125,7 @@ class TimeKeeper {
    * @returns {number}
    */
   convertAbsoluteTimestamp(timestamp) {
+    this.#detectDrift();
     return timestamp - _runtime.originTime;
   }
 
@@ -110,6 +135,7 @@ class TimeKeeper {
    * @return {number} Corrected unix/epoch timestamp
    */
   correctAbsoluteTimestamp(timestamp) {
+    this.#detectDrift();
     return timestamp - this.#localTimeDiff;
   }
 
@@ -119,6 +145,7 @@ class TimeKeeper {
    * @returns {number}
    */
   correctRelativeTimestamp(relativeTime) {
+    this.#detectDrift();
     return this.correctAbsoluteTimestamp(this.convertRelativeTimestamp(relativeTime));
   }
 

package/dist/cjs/common/util/short-circuit.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ShortCircuit = void 0;
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** A special error used to short-circuit the error processing pipeline */
+class ShortCircuit extends Error {}
+exports.ShortCircuit = ShortCircuit;

package/dist/cjs/common/util/submit-data.js

@@ -9,7 +9,7 @@ exports.xhr = xhr;
 exports.xhrFetch = xhrFetch;
 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
  */
 
@@ -70,8 +70,7 @@ function xhrFetch({
   return fetch(url, {
     headers: objHeaders,
     method,
-    body,
-    credentials: 'include'
+    body
   });
 }
 
@@ -97,12 +96,6 @@ function xhr({
 }) {
   const request = new XMLHttpRequest();
   request.open(method, url, !sync);
-  try {
-    // Set cookie
-    if ('withCredentials' in request) request.withCredentials = true;
-  } catch (e) {
-    // do nothing
-  }
   headers.forEach(header => {
     request.setRequestHeader(header.key, header.value);
   });

package/dist/cjs/common/v2/script-correlation.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ScriptCorrelation = void 0;
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Represents script correlation data combining DOM and Performance API information
+ */
+class ScriptCorrelation {
+  /** @type {CorrelationTiming} [dom] - DOM-related information */
+  dom = new CorrelationTiming();
+  /** @type {CorrelationTiming} [performance] - Performance-related information */
+  performance = new CorrelationTiming();
+
+  /**
+   * Creates a new ScriptCorrelation instance
+   * @param {string} url - The cleaned URL of the script
+   */
+  constructor(url) {
+    /** @type {string} The cleaned URL of the script */
+    this.url = url;
+  }
+
+  /**
+   * Gets the script timing, using DOM timings if available, otherwise falling back to performance timings or registeredAt as appropriate. This is used to provide the most accurate script timing possible for registered entities.
+   * @returns {{start: number, end: number}
+   */
+  get script() {
+    const start = Math.max(this.dom.start, this.performance.end);
+    const end = Math.max(this.dom.end, this.performance.end, start);
+    return {
+      start,
+      end
+    };
+  }
+}
+exports.ScriptCorrelation = ScriptCorrelation;
+class CorrelationTiming {
+  /** @type {number} [start] - The startTime from the performance entry */
+  start = 0;
+  /** @type {number} [end] - The responseEnd from the performance entry */
+  end = 0;
+  /** @type {*} [value] - The entry value */
+  value = undefined;
+}

package/dist/cjs/common/v2/script-tracker.js

@@ -0,0 +1,278 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractUrlsFromStack = extractUrlsFromStack;
+exports.findScriptTimings = findScriptTimings;
+exports.getDeepStackTrace = getDeepStackTrace;
+exports.thisFile = exports.scriptCorrelations = void 0;
+var _runtime = require("../constants/runtime");
+var _now = require("../timing/now");
+var _cleanUrl = require("../url/clean-url");
+var _browserStackMatchers = require("../util/browser-stack-matchers");
+var _scriptCorrelation = require("./script-correlation");
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @typedef {import('./register-api-types').RegisterAPITimings} RegisterAPITimings
+ */
+
+/** export for testing purposes */
+let thisFile = exports.thisFile = void 0;
+try {
+  exports.thisFile = thisFile = extractUrlsFromStack(getDeepStackTrace())[0];
+} catch (err) {
+  exports.thisFile = thisFile = extractUrlsFromStack(err)[0];
+}
+
+/** @type {(entry: PerformanceEntry) => boolean} - A shared function to determine if a performance entry is a valid script or link resource for evaluation */
+const validEntryCriteria = entry => entry.initiatorType === 'script' || ['link', 'fetch'].includes(entry.initiatorType) && entry.name.endsWith('.js');
+
+/** @type {Map<string, ScriptCorrelation>} - Central registry for script correlations containing both DOM and Performance data */
+const scriptCorrelations = exports.scriptCorrelations = new Map();
+/** @type {Array<{ test: (entry: PerformanceEntry) => boolean, addedAt: number }>} an array of PerformanceObserver subscribers to check for late emissions */
+let poSubscribers = [];
+
+/**
+ * Retrieves a script correlation by URL using exact matching
+ * @param {string} targetUrl - The URL to find
+ * @returns {ScriptCorrelation | undefined} - The correlation object if found
+ */
+function findCorrelation(targetUrl) {
+  return scriptCorrelations.get(targetUrl);
+}
+
+/**
+ * Gets or creates a script correlation entry
+ * @param {string} url - The cleaned URL
+ * @returns {ScriptCorrelation} - The correlation object
+ */
+function getOrCreateCorrelation(url) {
+  const existing = findCorrelation(url);
+  if (existing) return existing;
+  const correlation = new _scriptCorrelation.ScriptCorrelation(url);
+  scriptCorrelations.set(url, correlation);
+
+  // Keep size under control
+  if (scriptCorrelations.size > 1000) {
+    const firstKey = scriptCorrelations.keys().next().value;
+    scriptCorrelations.delete(firstKey);
+  }
+  return correlation;
+}
+
+/** Set up a MutationObserver to detect script elements being added to the DOM */
+if (_runtime.globalScope.MutationObserver && _runtime.globalScope.document) {
+  const scriptMutationObserver = new MutationObserver(mutations => {
+    mutations.forEach(mutation => {
+      mutation.addedNodes.forEach(node => {
+        if (node.nodeName === 'SCRIPT' && node.src) {
+          const cleanedSrc = (0, _cleanUrl.cleanURL)(node.src);
+          const correlation = getOrCreateCorrelation(cleanedSrc);
+          correlation.dom.start = (0, _now.now)();
+          correlation.dom.value = node;
+          const setEnd = () => {
+            correlation.dom.end = (0, _now.now)();
+          };
+          ['load', 'error'].forEach(event => node.addEventListener(event, setEnd, {
+            once: true
+          }));
+        }
+      });
+    });
+  });
+  scriptMutationObserver.observe(_runtime.globalScope.document, {
+    childList: true,
+    subtree: true
+  });
+}
+if (_runtime.globalScope.PerformanceObserver?.supportedEntryTypes.includes('resource')) {
+  /** We must track the script assets this way, because the performance buffer can fill up and when it does that
+   * it stops accepting new entries (instead of dropping old entries), which means if the register API is called
+   * after the buffer fills up we won't be able to get the script timing information from the resource timing API
+  */
+  const scriptObserver = new PerformanceObserver(list => {
+    list.getEntries().filter(validEntryCriteria).forEach(entry => {
+      // Update correlation with performance data (creates entry if needed)
+      const entryUrl = (0, _cleanUrl.cleanURL)(entry.name);
+      const correlation = getOrCreateCorrelation(entryUrl);
+      correlation.performance.start = Math.floor(entry.startTime);
+      correlation.performance.end = Math.floor(entry.responseEnd);
+      correlation.performance.value = entry;
+
+      // Clear resolved or expired subscribers
+      const canClear = [];
+      poSubscribers.forEach(({
+        test,
+        addedAt
+      }, idx) => {
+        if (test(entry) || (0, _now.now)() - addedAt > 10000) canClear.push(idx);
+      });
+      poSubscribers = poSubscribers.filter((_, idx) => !canClear.includes(idx));
+    });
+  });
+  scriptObserver.observe({
+    type: 'resource',
+    buffered: true
+  });
+}
+
+/**
+ * Extracts URLs from stack traces using the same logic as compute-stack-trace.js
+ * @param {string} stack The error stack trace
+ * @returns {string[]} Array of cleaned URLs found in the stack trace
+ */
+function extractUrlsFromStack(stack) {
+  if (!stack || typeof stack !== 'string') return [];
+  const urls = new Set();
+  const lines = stack.split('\n');
+  for (const line of lines) {
+    // Try gecko format first, then chrome
+    const parts = line.match(_browserStackMatchers.gecko) || line.match(_browserStackMatchers.chrome) || line.match(_browserStackMatchers.chromeEval);
+    if (parts && parts[2]) {
+      urls.add((0, _cleanUrl.cleanURL)(parts[2]));
+    } else {
+      // Fallback: match URLs using a generic .js pattern (non-greedy to handle ports and query params)
+      const fallbackMatch = line.match(/\(([^)]+\.js):\d+:\d+\)/) || line.match(/^\s+at\s+([^\s(]+\.js):\d+:\d+/);
+      if (fallbackMatch && fallbackMatch[1]) {
+        urls.add((0, _cleanUrl.cleanURL)(fallbackMatch[1]));
+      }
+    }
+  }
+  return [...urls];
+}
+
+/**
+ * Returns a deep stack trace by temporarily increasing the stack trace limit.
+ * @returns {Error.stack | undefined}
+ */
+function getDeepStackTrace() {
+  let stack;
+  try {
+    const originalStackLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 50;
+    stack = new Error().stack;
+    Error.stackTraceLimit = originalStackLimit;
+  } catch (e) {
+    stack = new Error().stack;
+  }
+  return stack;
+}
+
+/**
+ * Indicates whether the provided URL matches any script preload link tags in the document.
+ * @param {string} targetUrl The URL to match against preload tags
+ * @returns {boolean} True if a matching preload link is found, false otherwise
+ */
+function wasPreloaded(targetUrl) {
+  if (!targetUrl || !_runtime.globalScope.document) return false;
+  try {
+    const linkTags = _runtime.globalScope.document.querySelectorAll('link[rel="preload"][as="script"]');
+    for (const link of linkTags) {
+      // link.href is resolved to an absolute URL by the browser (even if supplied as relative), so we can match exactly against the cleaned target URL
+      if ((0, _cleanUrl.cleanURL)(link.href) === targetUrl) return true;
+    }
+  } catch (error) {
+    // Don't let DOM parsing errors break anything
+  }
+  return false;
+}
+
+/**
+ * Checks if a performance entry matches the target MFE script URL using exact matching
+ * @param {PerformanceResourceTiming} entry - The resource timing entry
+ * @param {string} targetUrl - The MFE script URL to match
+ * @returns {boolean} True if the entry matches
+ */
+function entryMatchesUrl(entry, targetUrl) {
+  const entryUrl = (0, _cleanUrl.cleanURL)(entry.name);
+  return entryUrl === targetUrl;
+}
+
+/**
+ * Applies performance entry timing data to a timings object
+ * @param {RegisterAPITimings} timings - The timings object to update
+ * @param {PerformanceResourceTiming} entry - The performance entry
+ */
+function applyPerformanceEntry(timings, entry) {
+  timings.fetchStart = Math.floor(entry.startTime);
+  timings.fetchEnd = Math.floor(entry.responseEnd);
+  timings.asset = entry.name;
+  timings.type = entry.initiatorType;
+}
+
+/**
+ * Uses the stack of the initiator function, returns script timing information if a script can be found with the resource timing API matching the URL found in the stack.
+ * @returns {RegisterAPITimings} Object containing script fetch start and end times, and the asset URL if found
+ */
+function findScriptTimings() {
+  const timings = {
+    registeredAt: (0, _now.now)(),
+    reportedAt: undefined,
+    fetchStart: 0,
+    fetchEnd: 0,
+    scriptStart: 0,
+    scriptEnd: 0,
+    asset: undefined,
+    type: 'unknown'
+  };
+  const stack = getDeepStackTrace();
+  if (!stack) return timings;
+  const navUrl = _runtime.globalScope.performance?.getEntriesByType('navigation')?.[0]?.name || '';
+  try {
+    const urls = extractUrlsFromStack(stack);
+    // Filter out agent file from URLs (unless it's the only one)
+    const mfeScriptUrl = (urls.length > 1 ? urls.filter(line => thisFile !== line) : urls)[0];
+    if (!mfeScriptUrl) return timings;
+
+    // Check for inline script
+    if (navUrl.includes(mfeScriptUrl)) {
+      timings.asset = (0, _cleanUrl.cleanURL)(navUrl);
+      timings.type = 'inline';
+      return timings;
+    }
+
+    // Get correlation data
+    timings.correlation = findCorrelation(mfeScriptUrl);
+
+    // Use correlation's performance entry if available, otherwise check live performance API
+    const performanceEntry = timings.correlation?.performance.value || performance.getEntriesByType('resource').find(e => entryMatchesUrl(e, mfeScriptUrl));
+    if (performanceEntry) {
+      applyPerformanceEntry(timings, performanceEntry);
+    } else if (wasPreloaded(mfeScriptUrl)) {
+      // Handle preloaded scripts that may report late
+      timings.asset = mfeScriptUrl;
+      timings.type = 'preload';
+
+      // Subscribe to late performance observer callbacks
+      poSubscribers.push({
+        addedAt: (0, _now.now)(),
+        test: entry => {
+          if (entryMatchesUrl(entry, mfeScriptUrl)) {
+            applyPerformanceEntry(timings, entry);
+            return true;
+          }
+          return false;
+        }
+      });
+    }
+
+    /*
+     * Use getters here because the correlation data may arrive after this function returns the timing object, and we want to provide the most up-to-date timing information possible when the getters are accessed at harvest time.
+     * The getters will fall back to fetchEnd if correlation data isn't available yet, which is our best approximation for script execution start when actual script timings can not be determined.
+    */
+    Object.defineProperty(timings, 'scriptStart', {
+      get: () => timings.correlation?.script.start || timings.fetchEnd
+    });
+    Object.defineProperty(timings, 'scriptEnd', {
+      get: () => timings.correlation?.script.end || timings.registeredAt
+    });
+  } catch (error) {
+    // Don't let stack parsing errors break anything
+  }
+  return timings;
+}

package/dist/cjs/common/{util/v2.js → v2/utils.js}

@@ -34,7 +34,7 @@ const V2_TYPES = exports.V2_TYPES = {
  * @returns {import("../../interfaces/registered-entity").RegisterAPIMetadataTarget[]}
  */
 function getRegisteredTargetsFromId(id, agentRef) {
-  if (!id || !agentRef?.init.api.allow_registered_children) return [];
+  if (!id || !agentRef?.init.api.register.enabled) return [];
   const registeredEntities = agentRef.runtime.registeredEntities;
   return registeredEntities?.filter(entity => String(entity.metadata.target.id) === String(id)).map(entity => entity.metadata.target) || [];
 }
@@ -46,7 +46,7 @@ function getRegisteredTargetsFromId(id, agentRef) {
  * @returns {import("../../interfaces/registered-entity").RegisterAPIMetadataTarget[]}
  */
 function getRegisteredTargetsFromFilename(filename, agentRef) {
-  if (!filename || !agentRef?.init.api.allow_registered_children) return [];
+  if (!filename || !agentRef?.init.api.register.enabled) return [];
   const registeredEntities = agentRef.runtime.registeredEntities;
   return registeredEntities?.filter(entity => entity.metadata.timings?.asset?.endsWith(filename)).map(entity => entity.metadata.target) || [];
 }
@@ -98,7 +98,7 @@ 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.duplicate_registered_data;
+  return !!target && !!supportsV2(aggregateInstance) && aggregateInstance.agentRef.init.api.register.duplicate_data_to_container;
 }
 
 /**
@@ -107,7 +107,7 @@ function shouldDuplicate(target, aggregateInstance) {
  * @returns {Array} An array of targets found from the stack trace. If no targets are found or allowed, returns an array with undefined.
  */
 function findTargetsFromStackTrace(agentRef) {
-  if (!agentRef?.init.api.allow_registered_children) return [undefined];
+  if (!agentRef?.init.api.register.enabled) return [undefined];
   const targets = [];
   try {
     var urls = (0, _scriptTracker.extractUrlsFromStack)((0, _scriptTracker.getDeepStackTrace)());

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

@@ -7,7 +7,7 @@ exports.scopedEE = scopedEE;
 exports.wrapFetch = wrapFetch;
 var _contextualEe = require("../event-emitter/contextual-ee");
 var _runtime = require("../constants/runtime");
-var _v = require("../util/v2");
+var _utils = require("../v2/utils");
 /**
  * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -79,7 +79,7 @@ function wrapFetch(sharedEE, agentRef) {
       target[name] = function () {
         var args = [...arguments];
         const ctx = {};
-        const targets = (0, _v.findTargetsFromStackTrace)(agentRef);
+        const targets = (0, _utils.findTargetsFromStackTrace)(agentRef);
 
         // we are wrapping args in an array so we can preserve the reference
         ee.emit(prefix + 'before-start', [args], ctx);

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

@@ -8,7 +8,7 @@ exports.createWrapperWithEmitter = createWrapperWithEmitter;
 exports.flag = exports.default = void 0;
 var _contextualEe = require("../event-emitter/contextual-ee");
 var _bundleId = require("../ids/bundle-id");
-var _v = require("../util/v2");
+var _utils = require("../v2/utils");
 /**
  * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -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, _v.findTargetsFromStackTrace)(agentRef) : [undefined]; // undefined target always maps to the container agent
+        targets = evaluateStack ? (0, _utils.findTargetsFromStackTrace)(agentRef) : [undefined]; // undefined target always maps to the container agent
 
         if (typeof getContext === 'function') {
           ctx = getContext(args, originalThis);

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

@@ -11,7 +11,7 @@ var _eventListenerOpts = require("../event-listener/event-listener-opts");
 var _wrapFunction = require("./wrap-function");
 var _runtime = require("../constants/runtime");
 var _console = require("../util/console");
-var _v = require("../util/v2");
+var _utils = require("../v2/utils");
 /**
  * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -55,7 +55,7 @@ function wrapXhr(sharedEE, agentRef) {
   function newXHR(opts) {
     const xhr = new OrigXHR(opts);
     const context = ee.context(xhr);
-    context.targets = (0, _v.findTargetsFromStackTrace)(agentRef);
+    context.targets = (0, _utils.findTargetsFromStackTrace)(agentRef);
     try {
       ee.emit('new-xhr', [xhr], context);
       xhr.addEventListener(READY_STATE_CHANGE, wrapXHR(context), (0, _eventListenerOpts.eventListenerOpts)(false));

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

@@ -14,7 +14,7 @@ var _aggregateBase = require("../../utils/aggregate-base");
 var _gql = require("./gql");
 var _belSerializer = require("../../../common/serialize/bel-serializer");
 var _nreum = require("../../../common/window/nreum");
-var _v = require("../../../common/util/v2");
+var _utils = require("../../../common/v2/utils");
 /**
  * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -106,11 +106,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
     if (target) {
       this.events.add({
         ...event,
-        targetAttributes: (0, _v.getVersion2Attributes)(target, this)
+        targetAttributes: (0, _utils.getVersion2Attributes)(target, this)
       });
-      if ((0, _v.shouldDuplicate)(target, this)) this.reportContainerEvent({
+      if ((0, _utils.shouldDuplicate)(target, this)) this.reportContainerEvent({
         ...event,
-        targetAttributes: (0, _v.getVersion2DuplicationAttributes)(target, this)
+        targetAttributes: (0, _utils.getVersion2DuplicationAttributes)(target, this)
       }, ctx);
     } else {
       this.reportContainerEvent(event, ctx);