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

package/dist/types/common/harvest/send.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../../../src/common/harvest/send.js"],"names":[],"mappings":"AAuBA;;;;;GAKG;AACH,+BAJW,MAAM,sHACN,eAAe,GACb,OAAO,CAsHnB;8BA/HY,OAAO,YAAY,EAAE,eAAe"}
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../../../src/common/harvest/send.js"],"names":[],"mappings":"AAuBA;;;;;GAKG;AACH,+BAJW,MAAM,sHACN,eAAe,GACb,OAAO,CAyHnB;8BAlIY,OAAO,YAAY,EAAE,eAAe"}

package/dist/types/common/payloads/payloads.d.ts

@@ -40,14 +40,15 @@ export function isLikelyHumanReadable(headers: Object, data: any): boolean;
  */
 export function truncateAsString(data: any): string;
 /**
- * Creates string adder functions for BEL serialization with obfuscation and optional truncation.
+ * Creates string adder functions for BEL serialization with obfuscation and optional truncation, as well as raw string.
  * This ensures a single string table is used while providing separate handling for regular vs payload attributes.
  * @param {Function} getAddStringContext - Function that creates a new string table context
  * @param {Object} obfuscator - Optional obfuscator instance for string obfuscation
- * @returns {{addString: Function, addStringWithTruncation: Function}} Object containing both string adder functions
+ * @returns {{addString: Function, addStringRaw: Function, addStringWithTruncation: Function}} Object containing various string adder functions
  */
 export function createStringAdders(getAddStringContext: Function, obfuscator: Object): {
     addString: Function;
+    addStringRaw: Function;
     addStringWithTruncation: Function;
 };
 //# sourceMappingURL=payloads.d.ts.map

package/dist/types/common/payloads/payloads.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"payloads.d.ts","sourceRoot":"","sources":["../../../../src/common/payloads/payloads.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;GAYG;AACH,+CAVW,MAAM,+EAEd;IAAsB,UAAU,EAAxB,MAAM;IACS,YAAY,EAA3B,OAAO;IACO,WAAW,EAAzB,MAAM;IACQ,eAAe,EAA7B,MAAM;IACS,eAAe;CACtC,YAAQ,MAAM,EAAE,GACN,OAAO,CAqBnB;AAED;;;;GAIG;AACH,yCAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAgB5B;AAED;;;;;GAKG;AACH,+CAJW,MAAM,QACN,GAAC,GACC,OAAO,CA2BnB;AAED;;;;;;GAMG;AACH,uCAHW,GAAC,GACC,MAAM,CA2BlB;AAED;;;;;;GAMG;AACH,8EAHW,MAAM,GACJ;IAAC,SAAS,WAAW;IAAC,uBAAuB,WAAU;CAAC,CAiBpE"}
+{"version":3,"file":"payloads.d.ts","sourceRoot":"","sources":["../../../../src/common/payloads/payloads.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;GAYG;AACH,+CAVW,MAAM,+EAEd;IAAsB,UAAU,EAAxB,MAAM;IACS,YAAY,EAA3B,OAAO;IACO,WAAW,EAAzB,MAAM;IACQ,eAAe,EAA7B,MAAM;IACS,eAAe;CACtC,YAAQ,MAAM,EAAE,GACN,OAAO,CAqBnB;AAED;;;;GAIG;AACH,yCAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAgB5B;AAED;;;;;GAKG;AACH,+CAJW,MAAM,QACN,GAAC,GACC,OAAO,CA2BnB;AAED;;;;;;GAMG;AACH,uCAHW,GAAC,GACC,MAAM,CA2BlB;AAED;;;;;;GAMG;AACH,8EAHW,MAAM,GACJ;IAAC,SAAS,WAAW;IAAC,YAAY,WAAW;IAAC,uBAAuB,WAAU;CAAC,CAkB5F"}

package/dist/types/common/serialize/bel-serializer.d.ts

@@ -1,5 +1,13 @@
 export function nullable(val: any, fn: any, comma: any): string;
 export function numeric(n: any, noDefault: any): string;
 export function getAddStringContext(obfuscator: any, truncator: any): (str: any, obfuscate?: boolean) => string;
-export function addCustomAttributes(attrs: any, addString: any): any[];
+/**
+ * Attributes are serialized according to their types, using the provided serializers.  Only the first 64 attributes will be added to the payload.
+ * @param attrs
+ * @param serializers
+ * @param {function} serializers.addKey -function for serializing attribute keys
+ * @param {function} serializers.addVal - function for serializing attribute values
+ * @returns {*[]}
+ */
+export function addCustomAttributes(attrs: any, serializers: any): any[];
 //# sourceMappingURL=bel-serializer.d.ts.map

package/dist/types/common/serialize/bel-serializer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bel-serializer.d.ts","sourceRoot":"","sources":["../../../../src/common/serialize/bel-serializer.js"],"names":[],"mappings":"AAUA,gEAIC;AAED,wDAKC;AAED,gHAiBC;AAED,uEAwCC"}
+{"version":3,"file":"bel-serializer.d.ts","sourceRoot":"","sources":["../../../../src/common/serialize/bel-serializer.js"],"names":[],"mappings":"AAUA,gEAIC;AAED,wDAKC;AAED,gHAiBC;AAED;;;;;;;GAOG;AACH,mEAFa,GAAC,EAAE,CA2Cf"}

package/dist/types/common/unload/eol.d.ts

@@ -3,5 +3,5 @@
  * 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: Function, capturePhase: any): void;
+export function subscribeToEOL(cb: Function): void;
 //# sourceMappingURL=eol.d.ts.map

package/dist/types/common/unload/eol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eol.d.ts","sourceRoot":"","sources":["../../../../src/common/unload/eol.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH,sEAOC"}
+{"version":3,"file":"eol.d.ts","sourceRoot":"","sources":["../../../../src/common/unload/eol.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH,mDAOC"}

package/dist/types/common/util/console.d.ts

@@ -58,7 +58,7 @@
  * | 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. |
@@ -84,6 +84,7 @@
  * | 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/types/common/util/console.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../../../src/common/util/console.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0FG;AAEH,2BALW,MAAM,cACN,GAAC,QAiBX"}
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../../../src/common/util/console.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AAEH,2BALW,MAAM,cACN,GAAC,QAiBX"}

package/dist/types/common/v2/mfe-vitals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mfe-vitals.d.ts","sourceRoot":"","sources":["../../../../src/common/v2/mfe-vitals.js"],"names":[],"mappings":"AAqHA;;;;;GAKG;AACH,uCAJW,iBAAiB,WACjB,kBAAkB,GAChB,iBAAiB,CAuM7B;iCAtTY,OAAO,sCAAsC,EAAE,kBAAkB;gCACjE,OAAO,sCAAsC,EAAE,iBAAiB;gCAChE,OAAO,sCAAsC,EAAE,iBAAiB"}
+{"version":3,"file":"mfe-vitals.d.ts","sourceRoot":"","sources":["../../../../src/common/v2/mfe-vitals.js"],"names":[],"mappings":"AAqHA;;;;;GAKG;AACH,uCAJW,iBAAiB,WACjB,kBAAkB,GAChB,iBAAiB,CAkO7B;iCAjVY,OAAO,sCAAsC,EAAE,kBAAkB;gCACjE,OAAO,sCAAsC,EAAE,iBAAiB;gCAChE,OAAO,sCAAsC,EAAE,iBAAiB"}

package/dist/types/features/ajax/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/ajax/aggregate/index.js"],"names":[],"mappings":"AAoBA;IACE,2BAAiC;IAEjC,2BA6BC;IAvBC,uBAA4D;IAyB9D,0GA2FC;IAED,+CAOC;IAED,iDAoEC;CACF;8BAvN6B,4BAA4B;2BAK/B,gCAAgC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/ajax/aggregate/index.js"],"names":[],"mappings":"AAoBA;IACE,2BAAiC;IAEjC,2BA6BC;IAvBC,uBAA4D;IAyB9D,0GA2FC;IAED,+CAOC;IAED,iDAuEC;CACF;8BA1N6B,4BAA4B;2BAK/B,gCAAgC"}

package/dist/types/features/page_view_event/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_event/aggregate/index.js"],"names":[],"mappings":"AAyBA;IACE,2BAA2C;IAE3C,2BAuCC;IApCC,kCAAqG;IACrG,iBAAoB;IAEpB,wBAAwB;IACxB,8BAA8B;IAC9B,8BAA8B;IAC9B,gBAAgB;IAGhB,uBAA2D;IA6B7D;;;;OAIG;IACH,2BAFW,GAAC,QAiEX;IAbC;;;;;;;;;;;;;;mBAOC;IANC,iCAAyB;IAc7B,kCAEC;IAED;;;;;;aA6GC;CACF;8BAlP6B,4BAA4B;2BAQ/B,gCAAgC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_event/aggregate/index.js"],"names":[],"mappings":"AAyBA;IACE,2BAA2C;IAE3C,2BAuCC;IApCC,kCAAqG;IACrG,iBAAoB;IAEpB,wBAAwB;IACxB,8BAA8B;IAC9B,8BAA8B;IAC9B,gBAAgB;IAGhB,uBAA2D;IA6B7D;;;;OAIG;IACH,2BAFW,GAAC,QA+DX;IAXC;;;;;;;;;;;;;;mBAOC;IANC,iCAAyB;IAY7B,kCAEC;IAED;;;;;;aA2GC;CACF;8BA9O6B,4BAA4B;2BAQ/B,gCAAgC"}

package/dist/types/features/page_view_event/aggregate_v2/index.d.ts

@@ -0,0 +1,20 @@
+export class Aggregate extends AggregateBase {
+    static featureName: string;
+    constructor(agentRef: any);
+    queryStringsBuilder(): {
+        fp: any;
+        fcp: any;
+        qt: any;
+        ap: any;
+        be: number;
+        fe: number;
+        dc: number;
+        at: any;
+        af: string;
+        igp: any;
+    };
+    serializer(eventBuffer: any): any;
+    #private;
+}
+import { AggregateBase } from '../../utils/aggregate-base';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/features/page_view_event/aggregate_v2/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_event/aggregate_v2/index.js"],"names":[],"mappings":"AAiBA;IACE,2BAA2C;IAO3C,2BAkBC;IAED;;;;;;;;;;;MA0CC;IAMD,kCAEC;;CACF;8BAvF6B,4BAA4B"}

package/dist/types/features/page_view_event/instrument/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_event/instrument/index.js"],"names":[],"mappings":"AAWA;IACE,2BAA2C;IAC3C,2BAUC;IAED,8BA+BC;CACF;AAED,8CAAuC;+BAtDR,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_event/instrument/index.js"],"names":[],"mappings":"AAWA;IACE,2BAA2C;IAC3C,2BAeC;IAED,8BA+BC;CACF;AAED,8CAAuC;+BA3DR,6BAA6B"}

package/dist/types/features/page_view_timing/aggregate/index.d.ts

@@ -19,7 +19,6 @@ export class Aggregate extends AggregateBase {
      * @returns {void}
      */
     checkForFirstInteraction(): void;
-    appendGlobalCustomAttributes(timing: any): void;
     preHarvestChecks(): boolean;
     serializer(eventBuffer: any): string;
     #private;

package/dist/types/features/page_view_timing/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_timing/aggregate/index.js"],"names":[],"mappings":"AA0BA;IACE,2BAAiC;IAMjC,2BA+BC;IA7BC,4BAA+B;IAC/B,0BAA6B;IAK7B,uBAA2D;IAyB7D;;;OAGG;IACH,6BAFW,MAAM,QAOhB;IAED;;;;MA+BC;IAED;;;OAGG;IACH,4BAFa,IAAI,CAahB;IAED,gDAWC;IAED,4BAGC;IAGD,qCAwBC;;CACF;8BAjK6B,4BAA4B;2BAC/B,gCAAgC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_timing/aggregate/index.js"],"names":[],"mappings":"AA2BA;IACE,2BAAiC;IAMjC,2BAmCC;IAjCC,4BAA+B;IAC/B,0BAA6B;IAK7B,uBAA2D;IA6B7D;;;OAGG;IACH,6BAFW,MAAM,QAOhB;IAED;;;;MAiCC;IAED;;;OAGG;IACH,4BAFa,IAAI,CAahB;IAWD,4BAGC;IAGD,qCA8BC;;CACF;8BA1K6B,4BAA4B;2BAC/B,gCAAgC"}

package/dist/types/features/session_replay/instrument/index.d.ts

@@ -3,6 +3,7 @@ export class Instrument extends InstrumentBase {
     constructor(agentRef: any);
     /** The RRWEB recorder instance, if imported */
     recorder: any;
+    abortHandler: () => void;
     errorNoticed: boolean;
     /**
      * Returns a promise that imports the recorder module. Only lets the recorder module be imported and instantiated once. Rejects if failed to import/instantiate.

package/dist/types/features/session_replay/instrument/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/instrument/index.js"],"names":[],"mappings":"AAkBA;IACE,2BAAiC;IAMjC,2BAiCC;IApCD,+CAA+C;IAC/C,cAAQ;IA+BF,sBAAwB;IAmB9B;;;OAGG;IACH,+BAkBC;;CAgBF;AAED,8CAAuC;+BAtGR,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/instrument/index.js"],"names":[],"mappings":"AAkBA;IACE,2BAAiC;IAMjC,2BAqCC;IAxCD,+CAA+C;IAC/C,cAAQ;IA2BN,yBAA+B;IAQ3B,sBAAwB;IAmB9B;;;OAGG;IACH,+BAkBC;;CAqBF;AAED,8CAAuC;+BA/GR,6BAA6B"}

package/dist/types/features/session_replay/shared/recorder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder.js"],"names":[],"mappings":"AAqBA;IAUE,+BAoCC;IAtCD,sBAAmB;IAGjB,iDAAiD;IACjD,kBAAgC;IAEhC,QAAyB;IACzB,mBAA6C;IAC7C,cAAqC;IAErC,qBAAwB;IACxB,0FAA0F;IAC1F,eAAkE;IAElE,iHAAiH;IACjH,uBAAgD;IAChD,mFAAmF;IACnF,iCAA0D;IAC1D,+DAA+D;IAC/D,kBAA6B;IAC7B,uIAAuI;IACvI,yBAA4B;IAC5B,qBAAwB;IACxB,kIAAkI;IAClI,kBAAqB;IACrB,uIAAuI;IACvI,0BAAwE;IAc1E,mBAEC;IAED;;;;;;;;;MAWC;IAED,kFAAkF;IAClF,oBAGC;IAED,qDAAqD;IACrD,8CA0CC;IAED;;;;;OAKG;IACH,aAHW,GAAC,cACD,GAAC,QAiCX;IAED,yHAAyH;IACzH,yCAiCC;IAED,0HAA0H;IAC1H,yBAOC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED;;;SAGK;IACL,oCAGC;;CACF;+BAzO8B,mBAAmB"}
+{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder.js"],"names":[],"mappings":"AAqBA;IAUE,+BAoCC;IAtCD,sBAAmB;IAGjB,iDAAiD;IACjD,kBAAgC;IAEhC,QAAyB;IACzB,mBAA6C;IAC7C,cAAqC;IAErC,qBAAwB;IACxB,0FAA0F;IAC1F,eAAkE;IAElE,iHAAiH;IACjH,uBAAgD;IAChD,mFAAmF;IACnF,iCAA0D;IAC1D,+DAA+D;IAC/D,kBAA6B;IAC7B,uIAAuI;IACvI,yBAA4B;IAC5B,qBAAwB;IACxB,kIAAkI;IAClI,kBAAqB;IACrB,uIAAuI;IACvI,0BAAwE;IAc1E,mBAEC;IAED;;;;;;;;;MAWC;IAED,kFAAkF;IAClF,oBAGC;IAED,qDAAqD;IACrD,8CA0CC;IAED;;;;;OAKG;IACH,aAHW,GAAC,cACD,GAAC,QAiCX;IAED,yHAAyH;IACzH,yCAkCC;IAED,0HAA0H;IAC1H,yBAOC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED;;;SAGK;IACL,oCAGC;;CACF;+BA1O8B,mBAAmB"}

package/dist/types/features/soft_navigations/aggregate/ajax-node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ajax-node.d.ts","sourceRoot":"","sources":["../../../../../src/features/soft_navigations/aggregate/ajax-node.js"],"names":[],"mappings":"AAUA;IACE,8CA8BC;IA5BC,gBAA6B;IAC7B,YAA8B;IAC9B,YAA8B;IAC9B,YAA8B;IAC9B,UAA0B;IAC1B,YAAmC;IACnC,YAAoC;IACpC,+BAAwD;IACxD,YAA8B;IAC9B,aAAgC;IAChC,mBAA4C;IAC5C,SAAwB;IACxB,sBAAkD;IAIlD,iBAAwC;IACxC,oBAA8C;IAC9C,kBAA0C;IAC1C,kBAA0C;IAC1C,qBAAgD;IAK9C,iBAAoE;IAKxE,iFA+CC;IAhEC,sBAAkC;CAiErC;wBAnFuB,YAAY"}
+{"version":3,"file":"ajax-node.d.ts","sourceRoot":"","sources":["../../../../../src/features/soft_navigations/aggregate/ajax-node.js"],"names":[],"mappings":"AAUA;IACE,8CA8BC;IA5BC,gBAA6B;IAC7B,YAA8B;IAC9B,YAA8B;IAC9B,YAA8B;IAC9B,UAA0B;IAC1B,YAAmC;IACnC,YAAoC;IACpC,+BAAwD;IACxD,YAA8B;IAC9B,aAAgC;IAChC,mBAA4C;IAC5C,SAAwB;IACxB,sBAAkD;IAIlD,iBAAwC;IACxC,oBAA8C;IAC9C,kBAA0C;IAC1C,kBAA0C;IAC1C,qBAAgD;IAK9C,iBAAoE;IAKxE,iFAkDC;IAnEC,sBAAkC;CAoErC;wBAtFuB,YAAY"}

package/dist/types/features/soft_navigations/aggregate/interaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../../../../src/features/soft_navigations/aggregate/interaction.js"],"names":[],"mappings":"AAYA;;IAEI;AACJ;IAoBE,0FAaC;IAhCD,WAAmB;IACnB,uBAAgC;IAChC,gBAAU;IACV,qBAAqB;IACrB,oBAAoB;IACpB,eAAS;IACT,aAAO;IACP,cAAQ;IACR,+EAA+E;IAC/E,eAA8B;IAC9B,qBAAgB;IAChB,yBAAoB;IACpB,sBAAoB;IACpB,6BAA2B;IAC3B,cAAW;IACX,kBAAa;IACb,uBAAiB;IACjB,wBAAkB;IAIhB,gBAAoC;IACpC,aAAsB;IAEtB,cAAiC;IACjC,wCAGE;IACF,mBAAyC;IAAxB,qBAAwB;IAEzC,YAAsE;IAAxD,YAAwD;IAGxE,iDAKC;IAED,gCAGC;IAED,oCAUC;IAED,8BAIC;IAED,6DAeC;IAmBD;;;;;;OAMG;IACH,0BAHW,mBAAmB,WAM7B;IAGD,uBAAoB;IACpB,iCAA8B;IAC9B,sBAAmB;IAEnB;;;;;;;OAOG;IACH,qDALW,KAAK,yBACL,UAAU,kBACV,UAAU,UAgDpB;;CACF;wBA/KuB,YAAY"}
+{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../../../../src/features/soft_navigations/aggregate/interaction.js"],"names":[],"mappings":"AAaA;;IAEI;AACJ;IAoBE,0FAaC;IAhCD,WAAmB;IACnB,uBAAgC;IAChC,gBAAU;IACV,qBAAqB;IACrB,oBAAoB;IACpB,eAAS;IACT,aAAO;IACP,cAAQ;IACR,+EAA+E;IAC/E,eAA8B;IAC9B,qBAAgB;IAChB,yBAAoB;IACpB,sBAAoB;IACpB,6BAA2B;IAC3B,cAAW;IACX,kBAAa;IACb,uBAAiB;IACjB,wBAAkB;IAIhB,gBAAoC;IACpC,aAAsB;IAEtB,cAAiC;IACjC,wCAGE;IACF,mBAAyC;IAAxB,qBAAwB;IAEzC,YAAsE;IAAxD,YAAwD;IAGxE,iDAKC;IAED,gCAGC;IAED,oCAUC;IAED,8BAIC;IAED,6DAeC;IAmBD;;;;;;OAMG;IACH,0BAHW,mBAAmB,WAM7B;IAGD,uBAAoB;IACpB,iCAA8B;IAC9B,sBAAmB;IAEnB;;;;;;;OAOG;IACH,qDALW,KAAK,yBACL,UAAU,kBACV,UAAU,UAgDpB;;CACF;wBAhLuB,YAAY"}

package/dist/types/features/utils/aggregate-base.d.ts

@@ -58,11 +58,6 @@ export class AggregateBase extends FeatureBase {
         sent?: boolean | undefined;
         retry?: boolean | undefined;
     }): void;
-    /**
-     * 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: any): void;
     /**
      * Report a supportability metric
      * @param {*} metricName The tag of the name matching the Angler aggregation tag

package/dist/types/features/utils/aggregate-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aggregate-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/aggregate-base.js"],"names":[],"mappings":"AAeA;IACE;;;;OAIG;IACH,sBAHW,MAAM,eACN,MAAM,EAkBhB;IAZC,uOAAuO;IACvO,qCAAwC;IACxC,gLAAgL;IAChL,yBAA2B;IAC3B,sFAAsF;IACtF,oBAAuB;IAEvB,gBAAqB;IAqBjB,YAAsE;IAW5E,iNAAiN;IACjN,0CAEC;IAED;;;;OAIG;IACH,8BAHU,MAAM,CAKf;IAED,qBAOC;IAFG,6BAAmB;IAIvB;;;;OAIG;IACH,2BAOC;IAED;;;;OAIG;IACH,yBAHW,MAAM,EAAE,gBAyBlB;IAED;;OAEG;IACH,cAEC;IAED,qCAEC;IAED;;;;;;OAMG;IACH,uDAJW,MAAM,GAAC,SAAS,SAsB1B;IAED;;;;;OAKG;IACH,4BAHG;QAAyB,IAAI,GAArB,OAAO,YAAC;QACS,KAAK,GAAtB,OAAO,YAAC;KAClB,QAKA;IAED;;;OAGG;IACH,2CAIC;IAED;;;;OAIG;IACH,uCAHW,GAAC,UACD,GAAC,QAIX;;CACF;4BAlM2B,gBAAgB"}
+{"version":3,"file":"aggregate-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/aggregate-base.js"],"names":[],"mappings":"AAcA;IACE;;;;OAIG;IACH,sBAHW,MAAM,eACN,MAAM,EAiBhB;IAZC,uOAAuO;IACvO,qCAAwC;IACxC,gLAAgL;IAChL,yBAA2B;IAC3B,sFAAsF;IACtF,oBAAuB;IAEvB,gBAAqB;IAqBjB,YAAsE;IAW5E,iNAAiN;IACjN,0CAEC;IAED;;;;OAIG;IACH,8BAHU,MAAM,CAKf;IAED,qBAOC;IAFG,6BAAmB;IAIvB;;;;OAIG;IACH,2BAOC;IAED;;;;OAIG;IACH,yBAHW,MAAM,EAAE,gBAyBlB;IAED;;OAEG;IACH,cAEC;IAED,qCAEC;IAED;;;;;;OAMG;IACH,uDAJW,MAAM,GAAC,SAAS,SAsB1B;IAED;;;;;OAKG;IACH,4BAHG;QAAyB,IAAI,GAArB,OAAO,YAAC;QACS,KAAK,GAAtB,OAAO,YAAC;KAClB,QAKA;IAED;;;;OAIG;IACH,uCAHW,GAAC,UACD,GAAC,QAIX;;CACF;4BAtL2B,gBAAgB"}

package/dist/types/features/utils/instrument-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrument-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/instrument-base.js"],"names":[],"mappings":"AA4BA;;;GAGG;AACH;IACE;;;;OAIG;IACH,sBAHW,MAAM,eACN,MAAM,EA0ChB;IArCC,8IAA8I;IAC9I,cADW,WAAW,SAAS,CACF;IAE7B;;;MAGE;IACF,eAHU,OAAO,kBAAkB,EAAE,aAAa,CAGpB;IAE9B;;;MAGE;IACF,iCAAmC;IACnC,kCAEE;IAEF;;;MAGE;IACF,uBAAiC;IAiBnC;;;;;;;OAOG;IACH,2BALW,MAAM,qDAEN,MAAM,QAyEhB;;CAiDF;4BAnM2B,gBAAgB"}
+{"version":3,"file":"instrument-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/instrument-base.js"],"names":[],"mappings":"AA6BA;;;GAGG;AACH;IACE;;;;OAIG;IACH,sBAHW,MAAM,eACN,MAAM,EA0ChB;IArCC,8IAA8I;IAC9I,cADW,WAAW,SAAS,CACF;IAE7B;;;MAGE;IACF,eAHU,OAAO,kBAAkB,EAAE,aAAa,CAGpB;IAE9B;;;MAGE;IACF,iCAAmC;IACnC,kCAEE;IAEF;;;MAGE;IACF,uBAAiC;IAiBnC;;;;;;;OAOG;IACH,2BALW,MAAM,qDAEN,MAAM,QA2DhB;;CAiDF;4BAtL2B,gBAAgB"}

package/dist/types/loaders/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../src/loaders/agent.js"],"names":[],"mappings":"AA2BA;;;;;;;;;GASG;AAEH;;;GAGG;AACH;IACE;;OAEG;IACH,qBAFW,YAAY,EA+BtB;IAnBC,yBAAkB;IAGlB,yCAAsD;IAkBxD;;;;;MAOC;IAED,gBAEC;IAED,yBAmCC;CACF;;;;;UAjGa,OAAO,uBAAuB,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;0BApBxB,cAAc"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../src/loaders/agent.js"],"names":[],"mappings":"AA2BA;;;;;;;;;GASG;AAEH;;;GAGG;AACH;IACE;;OAEG;IACH,qBAFW,YAAY,EA+BtB;IAnBC,yBAAkB;IAGlB,yCAAsD;IAkBxD;;;;;MAOC;IAED,gBAEC;IAED,yBAoCC;CACF;;;;;UAlGa,OAAO,uBAAuB,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;0BApBxB,cAAc"}

package/dist/types/loaders/features/features.d.ts

@@ -6,6 +6,7 @@ export const EVENTS: "events";
 export const JSERRORS: "jserrors";
 export const BLOBS: "browser/blobs";
 export const RUM: "rum";
+export const CONNECT: "connect";
 export const LOGS: "browser/logs";
 export namespace FEATURE_NAMES {
     export let ajax: string;

package/dist/types/loaders/features/features.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../../../src/loaders/features/features.js"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,qBAAsB,QAAQ,CAAA;AAC9B,uBAAwB,UAAU,CAAA;AAClC,oBAAqB,eAAe,CAAA;AACpC,kBAAmB,KAAK,CAAA;AACxB,mBAAoB,cAAc,CAAA;;;;;;;;;;;;;;AAmBlC;;;GAGG;AACH;IACE,CAAC,aAAa,CAAC,aAAa,CAAC,SAAG;IAChC,CAAC,aAAa,CAAC,cAAc,CAAC,SAAG;IACjC,CAAC,aAAa,CAAC,OAAO,CAAC,SAAG;IAC1B,CAAC,aAAa,CAAC,QAAQ,CAAC,SAAG;IAC3B,CAAC,aAAa,CAAC,OAAO,CAAC,SAAG;IAC1B,CAAC,aAAa,CAAC,IAAI,CAAC,SAAG;IACvB,CAAC,aAAa,CAAC,YAAY,CAAC,SAAG;IAC/B,CAAC,aAAa,CAAC,aAAa,CAAC,SAAG;IAChC,CAAC,aAAa,CAAC,OAAO,CAAC,SAAG;IAC1B,CAAC,aAAa,CAAC,aAAa,CAAC,SAAI;EAClC;AAED;IACE,CAAC,aAAa,CAAC,aAAa,CAAC,SAAK;IAClC,CAAC,aAAa,CAAC,cAAc,CAAC,SAAQ;IACtC,CAAC,aAAa,CAAC,IAAI,CAAC,SAAQ;IAC5B,CAAC,aAAa,CAAC,OAAO,CAAC,SAAQ;IAC/B,CAAC,aAAa,CAAC,OAAO,CAAC,SAAU;IACjC,CAAC,aAAa,CAAC,QAAQ,CAAC,SAAU;IAClC,CAAC,aAAa,CAAC,YAAY,CAAC,SAAO;IACnC,CAAC,aAAa,CAAC,aAAa,CAAC,SAAO;IACpC,CAAC,aAAa,CAAC,OAAO,CAAC,SAAM;IAC7B,CAAC,aAAa,CAAC,aAAa,CAAC,SAAO;EACrC"}
+{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../../../src/loaders/features/features.js"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,qBAAsB,QAAQ,CAAA;AAC9B,uBAAwB,UAAU,CAAA;AAClC,oBAAqB,eAAe,CAAA;AACpC,kBAAmB,KAAK,CAAA;AACxB,sBAAuB,SAAS,CAAA;AAChC,mBAAoB,cAAc,CAAA;;;;;;;;;;;;;;AAmBlC;;;GAGG;AACH;IACE,CAAC,aAAa,CAAC,aAAa,CAAC,SAAG;IAChC,CAAC,aAAa,CAAC,cAAc,CAAC,SAAG;IACjC,CAAC,aAAa,CAAC,OAAO,CAAC,SAAG;IAC1B,CAAC,aAAa,CAAC,QAAQ,CAAC,SAAG;IAC3B,CAAC,aAAa,CAAC,OAAO,CAAC,SAAG;IAC1B,CAAC,aAAa,CAAC,IAAI,CAAC,SAAG;IACvB,CAAC,aAAa,CAAC,YAAY,CAAC,SAAG;IAC/B,CAAC,aAAa,CAAC,aAAa,CAAC,SAAG;IAChC,CAAC,aAAa,CAAC,OAAO,CAAC,SAAG;IAC1B,CAAC,aAAa,CAAC,aAAa,CAAC,SAAI;EAClC;AAED;IACE,CAAC,aAAa,CAAC,aAAa,CAAC,SAAK;IAClC,CAAC,aAAa,CAAC,cAAc,CAAC,SAAQ;IACtC,CAAC,aAAa,CAAC,IAAI,CAAC,SAAQ;IAC5B,CAAC,aAAa,CAAC,OAAO,CAAC,SAAQ;IAC/B,CAAC,aAAa,CAAC,OAAO,CAAC,SAAU;IACjC,CAAC,aAAa,CAAC,QAAQ,CAAC,SAAU;IAClC,CAAC,aAAa,CAAC,YAAY,CAAC,SAAO;IACnC,CAAC,aAAa,CAAC,aAAa,CAAC,SAAO;IACpC,CAAC,aAAa,CAAC,OAAO,CAAC,SAAM;IAC7B,CAAC,aAAa,CAAC,aAAa,CAAC,SAAO;EACrC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.320.0",
+  "version": "1.320.1-rc.1",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",
@@ -294,4 +294,4 @@
     "README.md",
     "CHANGELOG.md"
   ]
-}
+}

package/src/common/config/runtime.js

@@ -41,6 +41,7 @@ const RuntimeModel = {
   disabled: false,
   /** @type {Map<string, {staged: boolean, priority: number}>} */
   drainRegistry: new Map(),
+  connector: undefined,
   harvester: undefined,
   isolatedBacklog: false,
   isRecording: false, // true when actively recording, false when paused or stopped

package/src/common/event-listener/event-listener-opts.js

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

package/src/common/harvest/connector.js

@@ -0,0 +1,168 @@
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { isBrowserScope } from '../constants/runtime'
+import { send } from './send'
+import { TimeKeeper } from '../timing/time-keeper'
+import { activateFeatures } from '../util/feature-flags'
+import { now } from '../timing/now'
+import { warn } from '../util/console'
+import { VERSION } from '../constants/env'
+import { CONNECT, FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../loaders/features/features'
+import { handle } from '../event-emitter/handle'
+import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants'
+
+const MAX_CONNECT_ATTEMPTS = 3
+const CONNECT_RETRY_BASE_MS = 3000 // affects each retry window proportionally (attempt 2: 0-3s, 3: 0-6s, 4: 0-12s, etc)
+
+export class Connector {
+  #agentRef
+  #connectStartTime
+  #numOfAttempts = 0
+
+  constructor (agentRef) {
+    if (!agentRef.init.feature_flags.includes('rum_v2')) return // the Connector does not run in v1; legacy PVE has its own BCS handling
+    this.#agentRef = agentRef
+    agentRef.runtime.timeKeeper = new TimeKeeper(agentRef.runtime.session)
+
+    if (isBrowserScope) {
+      const cached = agentRef.runtime.session && agentRef.runtime.session.state.cachedRumResponse
+      if (cached) {
+        // `cachedRumResponse` is stored flat (`{ app, ...flags }`, matching the old v1 RUM response), so re-nest it before applying.
+        const { app, ...config } = cached
+        this.#applyConnectResponse({ app, config })
+        return
+      }
+    }
+    this.makeConnectRequest()
+  }
+
+  makeConnectRequest (retryHeaders) {
+    this.#connectStartTime = now()
+    return send(this.#agentRef, {
+      endpoint: `browser/connect/2/${this.#agentRef.info.licenseKey}`,
+      payload: {
+        body: {},
+        qs: {
+          a: this.#agentRef.info.applicationID,
+          v: VERSION,
+          s: this.#agentRef.runtime.session?.state.value || '0'
+        }
+      },
+      localOpts: { sendEmptyBody: true, headers: retryHeaders },
+      raw: true,
+      featureName: CONNECT,
+      cbFinished: this.#processConnectResponse.bind(this)
+    })
+  }
+
+  #applyConnectResponse ({ app, config }) {
+    if (!Object.keys(this.#agentRef.runtime.appMetadata).length) this.#agentRef.runtime.appMetadata = app
+    activateFeatures(config, this.#agentRef)
+  }
+
+  #processConnectResponse ({ sent, status, retry, xhr, responseText }) {
+    const connectEndTime = now()
+    const session = this.#agentRef.runtime.session
+
+    if (session) {
+      // Double check that there isn't a response saved (e.g. from another agent/browser tab) btwn the async time of the request and now in a race-condition.
+      const cachedResp = session.state.cachedRumResponse
+      if (cachedResp) {
+        // `cachedRumResponse` is stored flat (`{ app, ...flags }`, matching the old v1 RUM response), so re-nest it before applying.
+        const { app, ...config } = cachedResp
+        this.#applyConnectResponse({ app, config })
+        return
+      }
+    }
+
+    const shouldRetry = sent && retry // important to note: no retry if HTTP status is 0
+    if (shouldRetry && ++this.#numOfAttempts < MAX_CONNECT_ATTEMPTS) {
+      // We use an exponential backoff calculation for the retry to avoid thundering herd, skipping any further processing.
+      const delay = Math.floor(Math.random() * CONNECT_RETRY_BASE_MS * (2 ** (this.#numOfAttempts - 1)))
+      const retryHeaders = [
+        { key: 'X-Retry-Count', value: this.#numOfAttempts },
+        { key: 'X-Previous-Status', value: status }
+      ]
+      setTimeout(() => this.makeConnectRequest(retryHeaders), delay)
+      return
+    }
+
+    if (status >= 400 || status === 0) {
+      warn(18, status)
+
+      // Get estimated payload size of our backlog.
+      const textEncoder = new TextEncoder()
+      const payloadSize = Object.values(newrelic.ee.backlog).reduce((acc, value) => {
+        if (!value) return acc
+        const encoded = textEncoder.encode(value)
+        return acc + encoded.byteLength
+      }, 0)
+
+      // Send SMs about the (last) failed connect request, then abort agent.
+      const BCSError = 'BCS/Error/'
+      const sm = [{
+        params: {
+          name: BCSError + status
+        },
+        stats: {
+          c: 1
+        }
+      }, {
+        params: {
+          name: BCSError + 'Duration/Ms'
+        },
+        stats: {
+          c: 1,
+          t: connectEndTime - this.#connectStartTime
+        }
+      }, {
+        params: {
+          name: BCSError + 'Dropped/Bytes'
+        },
+        stats: {
+          c: 1,
+          t: payloadSize
+        }
+      }]
+      send(this.#agentRef, { // note we have to send it this way because the Metrics feature will never be harvested under this branch of code (BCS failure)
+        endpoint: FEATURE_TO_ENDPOINT[FEATURE_NAMES.metrics],
+        payload: { body: { sm } },
+        featureName: FEATURE_NAMES.metrics
+      })
+
+      this.#agentRef.ee.abort()
+      return
+    }
+
+    let resp
+    try {
+      resp = JSON.parse(responseText)
+    } catch (error) {
+      warn(53, error)
+      this.#agentRef.ee.abort()
+      return
+    }
+    // store the response for other pages later in same session or in parallel tabs; flatten `.config` into the old v1 RUM response shape
+    if (session) session.write({ cachedRumResponse: { app: resp.app, ...resp.config } })
+    try {
+      const wasReady = this.#agentRef.runtime.timeKeeper.ready
+      this.#agentRef.runtime.timeKeeper.processRumRequest(xhr, this.#connectStartTime, connectEndTime, resp.app.nrServerTime)
+      if (!this.#agentRef.runtime.timeKeeper.ready) throw new Error('TimeKeeper not ready')
+
+      // If timeKeeper's origin time is ahead of nrServerTime, then the timestamp is invalid. Report a supportability metric.
+      const timeDiff = this.#agentRef.runtime.timeKeeper.correctedOriginTime - resp.app.nrServerTime
+      if (wasReady && timeDiff > 0) {
+        handle(SUPPORTABILITY_METRIC_CHANNEL, ['Generic/TimeKeeper/InvalidTimestamp/Seen', timeDiff], undefined, FEATURE_NAMES.metrics, this.#agentRef.ee)
+      }
+    } catch (error) {
+      warn(17, error)
+      this.#agentRef.ee.abort()
+      return
+    }
+
+    this.#applyConnectResponse(resp)
+  }
+}

package/src/common/harvest/harvester.js

@@ -22,23 +22,21 @@ export class Harvester {
   constructor (agentRef) {
     this.agentRef = agentRef
 
-    // Create obfuscator for harvest metadata (referrer URL, etc.)
     // No event type specified - applies to all harvests regardless of feature
     this.obfuscator = new Obfuscator(agentRef)
-
-    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()
-      })
-      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
 
+    subscribeToEOL(() => {
+      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()
+      })
+      this.initializedAggregates.forEach(aggregateInst => this.triggerHarvestFor(aggregateInst, { isFinalHarvest: true }))
+    })
+
     const onHarvestInterval = () => {
       this.initializedAggregates.forEach(aggregateInst => this.triggerHarvestFor(aggregateInst))
       setTimeout(onHarvestInterval, harvestInterval * 1000) // repeat in X seconds

package/src/common/harvest/send.js

@@ -2,7 +2,7 @@
  * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { JSERRORS, RUM, EVENTS, FEATURE_NAMES, BLOBS, LOGS } from '../../loaders/features/features'
+import { JSERRORS, RUM, EVENTS, FEATURE_NAMES, BLOBS, LOGS, CONNECT } from '../../loaders/features/features'
 import { VERSION } from '../constants/env'
 import { globalScope, isWorkerScope } from '../constants/runtime'
 import { handle } from '../event-emitter/handle'
@@ -12,7 +12,7 @@ import { cleanURL } from '../url/clean-url'
 import { obj, param } from '../url/encode'
 import { warn } from '../util/console'
 import { stringify } from '../util/stringify'
-import { xhr as xhrMethod, xhrFetch as fetchMethod } from '../util/submit-data'
+import { xhr as xhrMethod, xhrFetch as fetchMethod, getSubmitMethod } from '../util/submit-data'
 import { dispatchGlobalEvent } from '../dispatch/global-event'
 
 /**
@@ -27,7 +27,7 @@ const warnings = {}
  * @param {NetworkSendSpec} spec Specification for sending data
  * @returns {boolean} True if a network call was made. Note that this does not mean or guarantee that it was successful.
  */
-export function send (agentRef, { endpoint, payload, localOpts = {}, submitMethod, cbFinished, raw, featureName, endpointVersion = 1, harvesterObfuscator }) {
+export function send (agentRef, { endpoint, payload, localOpts = {}, submitMethod = getSubmitMethod(), cbFinished, raw, featureName, endpointVersion = 1, harvesterObfuscator }) {
   if (!agentRef.info.errorBeacon) return false
 
   let { body, qs } = cleanPayload(payload)
@@ -39,16 +39,18 @@ export function send (agentRef, { endpoint, payload, localOpts = {}, submitMetho
 
   const protocol = agentRef.init.ssl === false ? 'http' : 'https'
   const perceivedBeacon = agentRef.init.proxy.beacon || agentRef.info.errorBeacon
+  const includeEndpointName = endpoint !== RUM || endpointVersion !== 1
   const url = raw
     ? `${protocol}://${perceivedBeacon}/${endpoint}`
-    : `${protocol}://${perceivedBeacon}${endpoint !== RUM ? '/' + endpoint : ''}/${endpointVersion}/${agentRef.info.licenseKey}`
+    : `${protocol}://${perceivedBeacon}${includeEndpointName ? '/' + endpoint : ''}/${endpointVersion}/${agentRef.info.licenseKey}`
   const baseParams = !raw ? baseQueryString(agentRef, qs, endpoint, harvesterObfuscator) : ''
   let payloadParams = obj(qs, agentRef.runtime.maxBytes)
   if (baseParams === '' && payloadParams.startsWith('&')) {
     payloadParams = payloadParams.substring(1)
   }
 
-  const fullUrl = `${url}?${baseParams}${payloadParams}`
+  const queryString = `${baseParams}${payloadParams}`
+  const fullUrl = queryString ? `${url}?${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
@@ -61,7 +63,7 @@ export function send (agentRef, { endpoint, payload, localOpts = {}, submitMetho
   // Warn--once per endpoint--if the agent tries to send large payloads
   if (endpoint !== BLOBS && stringBody.length > 750000 && (warnings[endpoint] = (warnings[endpoint] || 0) + 1) === 1) warn(28, endpoint)
 
-  const headers = [{ key: 'content-type', value: 'text/plain' }]
+  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),
@@ -92,6 +94,7 @@ export function send (agentRef, { endpoint, payload, localOpts = {}, submitMetho
 
     function trackHarvestMetadata () {
       try {
+        if (featureName === CONNECT) return
         if (featureName === FEATURE_NAMES.jserrors && !body?.err) return
 
         const hasReplay = baseParams.includes('hr=1')
@@ -189,7 +192,6 @@ function baseQueryString (agentRef, qs, endpoint, harvesterObfuscator) {
     transactionNameParam(),
     param('ct', agentRef.runtime.customTransaction),
     '&rst=' + now(),
-    '&ck=0', // ck param DEPRECATED - still expected by backend
     '&s=' + (session?.state.value || '0'), // the 0 id encaps all untrackable and default traffic
     param('ref', ref),
     param('ptid', (agentRef.runtime.ptid ? '' + agentRef.runtime.ptid : ''))

package/src/common/payloads/payloads.js

@@ -129,11 +129,11 @@ export function truncateAsString (data) {
 }
 
 /**
- * Creates string adder functions for BEL serialization with obfuscation and optional truncation.
+ * Creates string adder functions for BEL serialization with obfuscation and optional truncation, as well as raw string.
  * This ensures a single string table is used while providing separate handling for regular vs payload attributes.
  * @param {Function} getAddStringContext - Function that creates a new string table context
  * @param {Object} obfuscator - Optional obfuscator instance for string obfuscation
- * @returns {{addString: Function, addStringWithTruncation: Function}} Object containing both string adder functions
+ * @returns {{addString: Function, addStringRaw: Function, addStringWithTruncation: Function}} Object containing various string adder functions
  */
 export function createStringAdders (getAddStringContext, obfuscator) {
   const addStringRaw = getAddStringContext()
@@ -148,6 +148,7 @@ export function createStringAdders (getAddStringContext, obfuscator) {
 
   return {
     addString: (str) => processString(str, false),
+    addStringRaw: (str) => addStringRaw(str),
     addStringWithTruncation: (str) => processString(str, true)
   }
 }

package/src/common/serialize/bel-serializer.js

@@ -40,7 +40,16 @@ export function getAddStringContext (obfuscator, truncator) {
   }
 }
 
-export function addCustomAttributes (attrs, addString) {
+/**
+ * Attributes are serialized according to their types, using the provided serializers.  Only the first 64 attributes will be added to the payload.
+ * @param attrs
+ * @param serializers
+ * @param {function} serializers.addKey -function for serializing attribute keys
+ * @param {function} serializers.addVal - function for serializing attribute values
+ * @returns {*[]}
+ */
+export function addCustomAttributes (attrs, serializers) {
+  const { addKey, addVal } = serializers
   var attrParts = []
 
   Object.entries(attrs || {}).forEach(([key, val]) => {
@@ -48,13 +57,13 @@ export function addCustomAttributes (attrs, addString) {
     var type = 5
     var serializedValue
     // add key to string table first
-    key = addString(key, false)
+    key = addKey(key)
 
     switch (typeof val) {
       case 'object':
         if (val) {
           // serialize objects to strings
-          serializedValue = addString(stringify(val))
+          serializedValue = addVal(stringify(val))
         } else {
           // null attribute type
           type = 9
@@ -73,7 +82,7 @@ export function addCustomAttributes (attrs, addString) {
         type = 9
         break
       default:
-        serializedValue = addString(val)
+        serializedValue = addVal(val)
     }
 
     attrParts.push([type, key + (serializedValue ? ',' + serializedValue : '')])

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)
     }
   }