@newrelic/browser-agent 1.312.1-rc.9 → 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/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-rc.9";
+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-rc.9";
+const VERSION = exports.VERSION = "1.313.0-rc.0";
 
 /**
  * Exposes the build type of the agent

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/features/jserrors/aggregate/index.js

@@ -20,6 +20,7 @@ var _traverse = require("../../../common/util/traverse");
 var _internalErrors = require("./internal-errors");
 var _utils = require("../../../common/v2/utils");
 var _causeString = require("./cause-string");
+var _shortCircuit = require("../../../common/util/short-circuit");
 /**
  * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -40,8 +41,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.observedAt = {};
     this.pageviewReported = {};
     this.errorOnPage = false;
-    (0, _registerHandler.registerHandler)('err', (...args) => this.storeError(...args), this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('ierr', (...args) => this.storeError(...args), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('err', this.processError.bind(this), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('ierr', this.processError.bind(this), this.featureName, this.ee);
     (0, _registerHandler.registerHandler)('returnJserror', (jsErrorEvent, softNavAttrs) => this.#storeJserrorForHarvest(jsErrorEvent, softNavAttrs), this.featureName, this.ee);
 
     // 0 == off, 1 == on
@@ -73,60 +74,162 @@ class Aggregate extends _aggregateBase.AggregateBase {
   }
 
   /**
-   * Builds a standardized stack trace string from the frames in the given `stackInfo` object, with each frame separated
-   * by a newline character. Lines take the form `<functionName>@<url>:<lineNumber>`.
+   * Main entry point for processing JavaScript errors. This method orchestrates the complete error processing pipeline.
    *
-   * @param {StackInfo} stackInfo - An object specifying a stack string and individual frames.
-   * @returns {string} A canonical stack string built from the URLs and function names in the given `stackInfo` object.
+   * Processing Flow:
+   * 1. Filter the error through the customer's onerror handler (if configured and not internal)
+   * 2. Compute the stack trace from the error object
+   * 3. Evaluate if the error should be swallowed (internal errors, known issues, etc.)
+   * 4. Derive target(s) for the error (MFE detection for v2 endpoints, or default target) - Note: "undefined" indicates the default target will be used
+   * 5. Store the error for each derived target. During storage (#storeJserrorForHarvest), duplication for MFE <-> container will be handled
+   *
+   * Important: "ShortCircuit" Pattern:
+   * Several steps in the pipeline can throw a ShortCircuit error to halt processing without
+   * treating it as a reportable error. This pattern is used when:
+   * - The customer's onerror handler returns a truthy value (excluding fingerprinting objects)
+   * - The error is identified as an internal error that shouldn't be reported
+   *
+   * When a ShortCircuit is thrown, processing stops immediately and the error is not stored.
+   * Any other thrown error is re-thrown as it represents an actual problem in the agent code.
+   *
+   * @param {Error|UncaughtError} err - The error instance to be processed
+   * @param {number} [time] - The relative ms (to origin) timestamp of occurrence. Defaults to now()
+   * @param {boolean} [internal=false] - If the error was "caught" and deemed "internal" before reporting to the jserrors feature
+   * @param {object} [customAttributes] - Any custom attributes to be included in the error payload
+   * @param {boolean} [hasReplay=false] - A flag indicating if the error occurred during a replay session
+   * @param {string} [swallowReason] - A string indicating pre-defined reason if swallowing the error. Mainly used by internal error supportability metrics
+   * @param {object} [target] - The target to buffer and harvest to. If undefined, the default configuration target is used
+   * @returns {void}
    */
-  buildCanonicalStackString(stackInfo) {
-    var canonicalStackString = '';
-    for (var i = 0; i < stackInfo.frames.length; i++) {
-      var frame = stackInfo.frames[i];
-      var func = (0, _canonicalFunctionName.canonicalFunctionName)(frame.func);
-      if (canonicalStackString) canonicalStackString += '\n';
-      if (func) canonicalStackString += func + '@';
-      if (typeof frame.url === 'string') canonicalStackString += frame.url;
-      if (frame.line) canonicalStackString += ':' + frame.line;
+  processError(err, time, internal, customAttributes, hasReplay, swallowReason, target) {
+    if (!err) return;
+    time = time || (0, _now.now)();
+    try {
+      const filterOutput = this.#filterError(err, internal);
+      const stackInfo = (0, _computeStackTrace.computeStackTrace)(err);
+      this.#swallowError(stackInfo, internal, swallowReason);
+      this.#deriveTargets(stackInfo, target).forEach(target => {
+        this.#storeError(err, time, stackInfo, filterOutput, customAttributes, hasReplay, target);
+      });
+    } catch (e) {
+      if (!(e instanceof _shortCircuit.ShortCircuit)) {
+        throw e;
+      }
     }
-    return canonicalStackString;
   }
 
   /**
+   * Filters an error through the customer's configured onerror handler.
    *
-   * @param {Error|UncaughtError} err The error instance to be processed
-   * @param {number} time the relative ms (to origin) timestamp of occurrence
-   * @param {boolean=} internal if the error was "caught" and deemed "internal" before reporting to the jserrors feature
-   * @param {object=} customAttributes  any custom attributes to be included in the error payload
-   * @param {boolean=} hasReplay a flag indicating if the error occurred during a replay session
-   * @param {string=} swallowReason a string indicating pre-defined reason if swallowing the error.  Mainly used by the internal error SMs.
-   * @param {object=} target the target to buffer and harvest to, if undefined the default configuration target is used
-   * @returns
+   * If the customer has configured a custom onerror handler and the error is not internal,
+   * this method invokes that handler. The handler's return value determines whether the error
+   * should be reported:
+   * - Falsey values (false, null, undefined, etc.) → Report the error normally
+   * - Truthy non-object values → Don't report (throws ShortCircuit)
+   * - Object with 'group' property (non-empty string) → Report with fingerprinting label
+   * - Any other truthy value → Don't report (throws ShortCircuit)
+   *
+   * @param {Error|UncaughtError} err - The error to filter
+   * @param {boolean} internal - Whether this is an internal error (internal errors skip filtering)
+   * @returns {undefined|object} The filter output. If an object with 'group' property, contains fingerprinting data
+   * @throws {ShortCircuit} When the error should not be reported based on the filter output
    */
-  storeError(err, time, internal, customAttributes, hasReplay, swallowReason, target) {
-    if (!err) return;
-    // are we in an interaction
-    time = time || (0, _now.now)();
+  #filterError(err, internal) {
     let filterOutput;
     if (!internal && this.agentRef.runtime.onerror) {
       filterOutput = this.agentRef.runtime.onerror(err);
       if (filterOutput && !(typeof filterOutput.group === 'string' && filterOutput.group.length)) {
         // All truthy values mean don't report (store) the error, per backwards-compatible usage,
         // - EXCEPT if a fingerprinting label is returned, via an object with key of 'group' and value of non-empty string
-        return;
+        throw new _shortCircuit.ShortCircuit();
       }
       // Again as with previous usage, all falsey values would include the error.
     }
-    var stackInfo = (0, _computeStackTrace.computeStackTrace)(err);
+    return filterOutput;
+  }
+
+  /**
+   * Evaluates whether an error should be swallowed (not reported) based on internal error criteria.
+   *
+   * This method uses the evaluateInternalError function to determine if the error matches known
+   * internal error patterns (e.g., errors from the agent itself, known browser issues, etc.).
+   * If the error should be swallowed, a supportability metric is recorded and processing is halted.
+   *
+   * @param {StackInfo} stackInfo - The computed stack trace information
+   * @param {boolean} internal - Whether the error was marked as internal
+   * @param {string} [swallowReason] - Optional pre-determined reason for swallowing
+   * @returns {void}
+   * @throws {ShortCircuit} When the error should be swallowed and not reported
+   */
+  #swallowError(stackInfo, internal, swallowReason) {
     const {
       shouldSwallow,
       reason
     } = (0, _internalErrors.evaluateInternalError)(stackInfo, internal, swallowReason);
     if (shouldSwallow) {
       this.reportSupportabilityMetric('Internal/Error/' + reason);
-      return;
+      throw new _shortCircuit.ShortCircuit();
     }
-    var canonicalStackString = this.buildCanonicalStackString(stackInfo);
+  }
+
+  /**
+   * Derives the appropriate targets for reporting the given stack information.
+   *
+   * Targets represent the entities that should receive the error data. This is particularly
+   * important for Micro Frontend (MFE) scenarios where errors may need to be reported to
+   * different applications.
+   *
+   * Logic:
+   * - If a target is explicitly provided (e.g., from the register API), use it
+   * - For v2 endpoints without an explicit target, scan stack frames to detect MFE sources
+   * - If no MFE is detected or v2 is not enabled, use undefined (default target)
+   *
+   * @param {StackInfo} stackInfo - The computed stack trace information containing frames
+   * @param {object} [target] - Explicitly provided target, typically from the register API
+   * @returns {Array<object|undefined>} Array of targets to report the error to. Always contains at least one element.
+   */
+  #deriveTargets(stackInfo, target) {
+    const targets = [];
+    if (target) {
+      // reported by the register API directly
+      targets.push(target);
+    } else {
+      // we dont know if this is MFE yet, we need to figure it out.
+      if (this.harvestEndpointVersion === 2) {
+        for (const frame of stackInfo.frames) {
+          targets.push(...(0, _utils.getRegisteredTargetsFromFilename)(frame.url, this.agentRef));
+          if (targets.length) break;
+        }
+      }
+      if (!targets.length) targets.push(undefined);
+    }
+    return targets;
+  }
+
+  /**
+   * Stores error data for eventual harvesting and transmission to the backend.
+   *
+   * This method processes the error through several stages:
+   * 1. Build canonical stack string for cross-browser error grouping
+   * 2. Build cause chain string if the error has a cause property
+   * 3. Create params object with error metadata (stack hash, class, message, etc.)
+   * 4. Create bucket hash for internal deduplication
+   * 5. Store stack trace on first occurrence of this error
+   * 6. Add custom attributes and send to other features (trace, replay)
+   * 7. Route through soft nav if enabled, or directly to harvest storage
+   * 8. Handle MFE duplication for v2 endpoints if needed
+   *
+   * @param {Error|UncaughtError} err - The error instance to be processed
+   * @param {number} time - The relative ms (to origin) timestamp of occurrence
+   * @param {StackInfo} stackInfo - The computed stack trace information
+   * @param {object} [filterOutput] - Output from the customer's onerror handler, may contain fingerprinting group
+   * @param {object} [customAttributes] - Any custom attributes to be included in the error payload
+   * @param {boolean} [hasReplay=false] - A flag indicating if the error occurred during a replay session
+   * @param {object} [target] - The target to buffer and harvest to. If undefined, the default configuration target is used
+   * @returns {void}
+   */
+  #storeError(err, time, stackInfo, filterOutput, customAttributes, hasReplay, target) {
+    var canonicalStackString = this.#buildCanonicalStackString(stackInfo);
     const causeStackString = (0, _causeString.buildCauseString)(err);
     const params = {
       stackHash: (0, _stringHashCode.stringHashCode)(canonicalStackString),
@@ -149,7 +252,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
      * the canonical stack trace excludes items like the column number increasing the hit-rate of different errors potentially
      * bucketing and ultimately resulting in the loss of data in NR1.
      */
-    var bucketHash = (0, _stringHashCode.stringHashCode)("".concat(stackInfo.name, "_").concat(stackInfo.message, "_").concat(stackInfo.stackString, "_").concat(params.hasReplay ? 1 : 0, "_").concat(target?.id || 'container'));
+    var bucketHash = (0, _stringHashCode.stringHashCode)("".concat(stackInfo.name, "_").concat(stackInfo.message, "_").concat(stackInfo.stackString, "_").concat(params.hasReplay ? 1 : 0, "_").concat(target?.id || 'container', "_").concat(target?.instance || ''));
     if (!this.stackReported[bucketHash]) {
       this.stackReported[bucketHash] = true;
       params.stack_trace = (0, _formatStackTrace.truncateSize)(stackInfo.stackString);
@@ -189,27 +292,90 @@ class Aggregate extends _aggregateBase.AggregateBase {
         // pass the error to soft nav for evaluation - it will return it via 'returnJserror' when interaction is resolved
         (0, _handle.handle)('jserror', [jsErrorEvent], undefined, _features.FEATURE_NAMES.softNav, this.ee);
       } else {
-        this.#storeJserrorForHarvest(jsErrorEvent, false);
+        this.#storeJserrorForHarvest(jsErrorEvent);
       }
     }
 
     // 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], false, params._softNavAttributes);
+    if (target) this.#storeJserrorForHarvest(jsErrorEvent, {}, target);
+  }
+
+  /**
+   * Builds a standardized (canonical) stack trace string from the frames in the given `stackInfo` object.
+   *
+   * The canonical format is used for cross-browser error grouping in NR1, as different browsers
+   * format stack traces differently. Each frame is separated by a newline character and takes
+   * the form: `<functionName>@<url>:<lineNumber>`
+   *
+   * Note: Column numbers are intentionally excluded from the canonical format to improve
+   * grouping accuracy, as the same error across different minified builds might have different
+   * column numbers but should still be grouped together.
+   *
+   * Example output:
+   * ```
+   * handleClick@https://example.com/app.js:42
+   * EventEmitter.emit@https://example.com/vendor.js:1337
+   * ```
+   *
+   * @param {StackInfo} stackInfo - An object containing parsed stack frames from computeStackTrace
+   * @returns {string} A canonical stack string built from the URLs and function names in the given `stackInfo` object
+   */
+  #buildCanonicalStackString(stackInfo) {
+    var canonicalStackString = '';
+    for (var i = 0; i < stackInfo.frames.length; i++) {
+      var frame = stackInfo.frames[i];
+      var func = (0, _canonicalFunctionName.canonicalFunctionName)(frame.func);
+      if (canonicalStackString) canonicalStackString += '\n';
+      if (func) canonicalStackString += func + '@';
+      if (typeof frame.url === 'string') canonicalStackString += frame.url;
+      if (frame.line) canonicalStackString += ':' + frame.line;
+    }
+    return canonicalStackString;
   }
-  #storeJserrorForHarvest(errorInfoArr, softNavCustomAttrs = {}) {
-    let [type, bucketHash, params, newMetrics, localAttrs, target] = errorInfoArr;
+
+  /**
+   * Adds a processed error to the harvest buffer with all custom attributes merged.
+   *
+   * This is the final step before an error is stored to be sent to the backend. It handles:
+   * - Merging all custom attributes (global, soft nav, MFE, and local)
+   * - Creating a unique aggregate hash for deduplication
+   * - Adding the error to the events buffer for harvest
+   * - Duplicating the error for MFE scenarios when needed (v2 endpoints)
+   *
+   * Custom Attribute Precedence (lowest to highest):
+   * 1. Global jsAttributes from agent config
+   * 2. Soft navigation attributes (if from a soft nav interaction)
+   * 3. MFE v2 attributes (source/parent metadata)
+   * 4. Local custom attributes passed with the specific error
+   *
+   * @param {Array} errorInfoArr - Array containing [type, bucketHash, params, metrics, customAttributes, target]
+   * @param {object} [attrs={}] - Additional attributes to merge (e.g., from soft nav interactions)
+   * @returns {void}
+   */
+  #storeJserrorForHarvest(errorInfoArr, attrs = {}, target) {
+    let [type, bucketHash, params, newMetrics, localAttrs] = errorInfoArr;
     const allCustomAttrs = {
       /** MFE specific attributes if in "multiple" mode (ie consumer version 2) */
       ...(0, _utils.getVersion2Attributes)(target, this)
     };
     Object.entries(this.agentRef.info.jsAttributes).forEach(([k, v]) => setCustom(k, v));
-    Object.entries(softNavCustomAttrs).forEach(([k, v]) => setCustom(k, v)); // when an ixn finishes, it'll pass attrs specific to the ixn; if no associated ixn, this defaults to empty
+    Object.entries(attrs).forEach(([k, v]) => setCustom(k, v)); // when an ixn finishes, it'll pass attrs specific to the ixn; if no associated ixn, this defaults to empty
     if (params.browserInteractionId) bucketHash += params.browserInteractionId;
     if (localAttrs) Object.entries(localAttrs).forEach(([k, v]) => setCustom(k, v)); // local custom attrs are applied in either case with the highest precedence
 
     const jsAttributesHash = (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(allCustomAttrs));
     const aggregateHash = bucketHash + ':' + jsAttributesHash;
     this.events.add([type, aggregateHash, params, newMetrics, allCustomAttrs]);
+    if ((0, _utils.shouldDuplicate)(target, this)) {
+      // Clone the array with new object references to prevent deduplication in the shared aggregator
+      this.#storeJserrorForHarvest([type, bucketHash, {
+        ...params
+      }, {
+        ...newMetrics
+      }, localAttrs && {
+        ...localAttrs
+      }], (0, _utils.getVersion2DuplicationAttributes)(target, this));
+    }
     function setCustom(key, val) {
       allCustomAttrs[key] = val && typeof val === 'object' ? (0, _stringify.stringify)(val) : val;
     }

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 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");
@@ -32,6 +33,17 @@ var _uniqueId = require("../../common/ids/unique-id");
 
 const PROTECTED_KEYS = ['name', 'id', 'type'];
 
+/**
+ * Warning functions that only fire once - can be reset in tests
+ * @private
+ */
+const warnings = exports.warnings = {
+  experimental: (0, _invoke.single)(() => (0, _console.warn)(54, 'newrelic.register')),
+  disabled: (0, _invoke.single)(() => (0, _console.warn)(55)),
+  invalidTarget: (0, _invoke.single)(target => (0, _console.warn)(48, target)),
+  deregistered: (0, _invoke.single)(() => (0, _console.warn)(68))
+};
+
 /**
  * @experimental
  * IMPORTANT: This feature is being developed for use internally and is not in a public-facing production-ready state.
@@ -51,7 +63,7 @@ function setupRegisterAPI(agent) {
  * @returns {RegisterAPI} the api object to be returned from the register api method
  */
 function register(agentRef, target) {
-  (0, _console.warn)(54, 'newrelic.register');
+  warnings.experimental();
   target ||= {};
   target.instance = (0, _uniqueId.generateRandomHexString)(8);
   target.type = _utils.V2_TYPES.MFE;
@@ -109,8 +121,8 @@ function register(agentRef, target) {
   }
 
   /** primary cases that can block the register API from working at init time */
-  if (!agentRef.init.api.register.enabled) block((0, _invoke.single)(() => (0, _console.warn)(55)));
-  if (!hasValidValue(target.id) || !hasValidValue(target.name)) block((0, _invoke.single)(() => (0, _console.warn)(48, target)));
+  if (!agentRef.init.api.register.enabled) block(warnings.disabled);
+  if (!hasValidValue(target.id) || !hasValidValue(target.name)) block(() => warnings.invalidTarget(target));
 
   /** @type {RegisterAPI} */
   const api = {
@@ -121,7 +133,7 @@ function register(agentRef, target) {
     deregister: () => {
       /** note: blocking this instance will disable access for all entities sharing the instance, and will invalidate it from the v2 checks */
       reportTimings();
-      block((0, _invoke.single)(() => (0, _console.warn)(68)));
+      block(warnings.deregistered);
     },
     log: (message, options = {}) => report(_log.log, [message, {
       ...options,

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

@@ -11,7 +11,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.312.1-rc.9";
+export const VERSION = "1.313.0-rc.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.312.1-rc.9";
+export const VERSION = "1.313.0-rc.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -0,0 +1,6 @@
+/**
+ * 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 */
+export class ShortCircuit extends Error {}

package/dist/esm/common/util/submit-data.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
  */
 
@@ -62,8 +62,7 @@ export function xhrFetch({
   return fetch(url, {
     headers: objHeaders,
     method,
-    body,
-    credentials: 'include'
+    body
   });
 }
 
@@ -89,12 +88,6 @@ export 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);
   });