@newrelic/browser-agent 1.257.0 → 1.258.1

package/dist/esm/features/jserrors/instrument/index.js

@@ -9,13 +9,11 @@ import { FEATURE_NAME } from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { globalScope } from '../../../common/constants/runtime';
 import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts';
-import { stringify } from '../../../common/util/stringify';
-import { UncaughtError } from './uncaught-error';
 import { now } from '../../../common/timing/now';
 import { SR_EVENT_EMITTER_TYPES } from '../../session_replay/constants';
+import { castError, castErrorEvent, castPromiseRejectionEvent } from '../shared/cast-error';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
-  #seenErrors = new Set();
   #replayRunning = false;
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
@@ -24,38 +22,22 @@ export class Instrument extends InstrumentBase {
       // this try-catch can be removed when IE11 is completely unsupported & gone
       this.removeOnAbort = new AbortController();
     } catch (e) {}
-
-    // Capture function errors early in case the spa feature is loaded
-    this.ee.on('fn-err', (args, obj, error) => {
-      if (!this.abortHandler || this.#seenErrors.has(error)) return;
-      this.#seenErrors.add(error);
-      handle('err', [this.#castError(error), now()], undefined, FEATURE_NAMES.jserrors, this.ee);
-    });
     this.ee.on('internal-error', error => {
       if (!this.abortHandler) return;
-      handle('ierr', [this.#castError(error), now(), true, {}, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee);
+      handle('ierr', [castError(error), now(), true, {}, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee);
     });
     this.ee.on(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, isRunning => {
       this.#replayRunning = isRunning;
     });
     globalScope.addEventListener('unhandledrejection', promiseRejectionEvent => {
       if (!this.abortHandler) return;
-      handle('err', [this.#castPromiseRejectionEvent(promiseRejectionEvent), now(), false, {
+      handle('err', [castPromiseRejectionEvent(promiseRejectionEvent), now(), false, {
         unhandledPromiseRejection: 1
       }, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee);
     }, eventListenerOpts(false, this.removeOnAbort?.signal));
     globalScope.addEventListener('error', errorEvent => {
       if (!this.abortHandler) return;
-
-      /**
-       * If the spa feature is loaded, errors may already have been captured in the `fn-err` listener above.
-       * This ensures those errors are not captured twice.
-       */
-      if (this.#seenErrors.has(errorEvent.error)) {
-        this.#seenErrors.delete(errorEvent.error);
-        return;
-      }
-      handle('err', [this.#castErrorEvent(errorEvent), now(), false, {}, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee);
+      handle('err', [castErrorEvent(errorEvent), now(), false, {}, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee);
     }, eventListenerOpts(false, this.removeOnAbort?.signal));
     this.abortHandler = this.#abort; // we also use this as a flag to denote that the feature is active or on and handling errors
     this.importAggregator();
@@ -64,71 +46,6 @@ export class Instrument extends InstrumentBase {
   /** Restoration and resource release tasks to be done if JS error loader is being aborted. Unwind changes to globals. */
   #abort() {
     this.removeOnAbort?.abort();
-    this.#seenErrors.clear();
     this.abortHandler = undefined; // weakly allow this abort op to run only once
   }
-
-  /**
-   * Any value can be used with the `throw` keyword. This function ensures that the value is
-   * either a proper Error instance or attempts to convert it to an UncaughtError instance.
-   * @param {any} error The value thrown
-   * @returns {Error|UncaughtError} The converted error instance
-   */
-  #castError(error) {
-    if (error instanceof Error) {
-      return error;
-    }
-
-    /**
-     * The thrown value may contain a message property. If it does, try to treat the thrown
-     * value as an Error-like object.
-     */
-    if (typeof error?.message !== 'undefined') {
-      return new UncaughtError(error.message, error.filename || error.sourceURL, error.lineno || error.line, error.colno || error.col);
-    }
-    return new UncaughtError(typeof error === 'string' ? error : stringify(error));
-  }
-
-  /**
-   * Attempts to convert a PromiseRejectionEvent object to an Error object
-   * @param {PromiseRejectionEvent} unhandledRejectionEvent The unhandled promise rejection event
-   * @returns {Error} An Error object with the message as the casted reason
-   */
-  #castPromiseRejectionEvent(promiseRejectionEvent) {
-    let prefix = 'Unhandled Promise Rejection: ';
-    if (promiseRejectionEvent?.reason instanceof Error) {
-      try {
-        promiseRejectionEvent.reason.message = prefix + promiseRejectionEvent.reason.message;
-        return promiseRejectionEvent.reason;
-      } catch (e) {
-        return promiseRejectionEvent.reason;
-      }
-    }
-    if (typeof promiseRejectionEvent.reason === 'undefined') return new UncaughtError(prefix);
-    const error = this.#castError(promiseRejectionEvent.reason);
-    error.message = prefix + error.message;
-    return error;
-  }
-
-  /**
-   * Attempts to convert an ErrorEvent object to an Error object
-   * @param {ErrorEvent} errorEvent The error event
-   * @returns {Error|UncaughtError} The error event converted to an Error object
-   */
-  #castErrorEvent(errorEvent) {
-    if (errorEvent.error instanceof SyntaxError && !/:\d+$/.test(errorEvent.error.stack?.trim())) {
-      const error = new UncaughtError(errorEvent.message, errorEvent.filename, errorEvent.lineno, errorEvent.colno);
-      error.name = SyntaxError.name;
-      return error;
-    }
-    if (errorEvent.error instanceof Error) {
-      return errorEvent.error;
-    }
-
-    /**
-     * Older browsers do not contain the `error` property on the ErrorEvent instance.
-     * https://caniuse.com/mdn-api_errorevent_error
-     */
-    return new UncaughtError(errorEvent.message, errorEvent.filename, errorEvent.lineno, errorEvent.colno);
-  }
 }

package/dist/esm/features/jserrors/shared/cast-error.js

@@ -0,0 +1,59 @@
+import { UncaughtError } from './uncaught-error';
+
+/**
+   * Any value can be used with the `throw` keyword. This function ensures that the value is
+   * either a proper Error instance or attempts to convert it to an UncaughtError instance.
+   * @param {any} error The value thrown
+   * @returns {Error|UncaughtError} The converted error instance
+   */
+export function castError(error) {
+  /** Sometimes a browser can emit an error object with no stack */
+  if (canTrustError(error)) {
+    return error;
+  }
+
+  /**
+     * The thrown value may contain a message property. If it does, try to treat the thrown
+     * value as an Error-like object.
+     */
+  return new UncaughtError(error?.message !== undefined ? error.message : error, error?.filename || error?.sourceURL, error?.lineno || error?.line, error?.colno || error?.col, error?.__newrelic);
+}
+
+/**
+   * Attempts to convert a PromiseRejectionEvent object to an Error object
+   * @param {PromiseRejectionEvent} unhandledRejectionEvent The unhandled promise rejection event
+   * @returns {Error} An Error object with the message as the casted reason
+   */
+export function castPromiseRejectionEvent(promiseRejectionEvent) {
+  let prefix = 'Unhandled Promise Rejection';
+  if (canTrustError(promiseRejectionEvent?.reason)) {
+    try {
+      promiseRejectionEvent.reason.message = prefix + ': ' + promiseRejectionEvent.reason.message;
+      return castError(promiseRejectionEvent.reason);
+    } catch (e) {
+      return castError(promiseRejectionEvent.reason);
+    }
+  }
+  if (typeof promiseRejectionEvent.reason === 'undefined') return castError(prefix);
+  const error = castError(promiseRejectionEvent.reason);
+  error.message = prefix + ': ' + error?.message;
+  return error;
+}
+
+/**
+   * Attempts to convert an ErrorEvent object to an Error object
+   * @param {ErrorEvent} errorEvent The error event
+   * @returns {Error|UncaughtError} The error event converted to an Error object
+   */
+export function castErrorEvent(errorEvent) {
+  if (errorEvent.error instanceof SyntaxError && !/:\d+$/.test(errorEvent.error.stack?.trim())) {
+    const error = new UncaughtError(errorEvent.message, errorEvent.filename, errorEvent.lineno, errorEvent.colno, errorEvent.error.__newrelic);
+    error.name = SyntaxError.name;
+    return error;
+  }
+  if (canTrustError(errorEvent.error)) return errorEvent.error;
+  return castError(errorEvent);
+}
+function canTrustError(error) {
+  return error instanceof Error && !!error.stack;
+}

package/dist/esm/features/jserrors/{instrument → shared}/uncaught-error.js

@@ -1,3 +1,5 @@
+import { stringify } from '../../../common/util/stringify';
+
 /**
  * Represents an uncaught non Error type error. This class does
  * not extend the Error class to prevent an invalid stack trace
@@ -5,11 +7,12 @@
  * do not use the Error class (strings, etc) to an object.
  */
 export class UncaughtError {
-  constructor(message, filename, lineno, colno) {
+  constructor(message, filename, lineno, colno, newrelic) {
     this.name = 'UncaughtError';
-    this.message = message;
+    this.message = typeof message === 'string' ? message : stringify(message);
     this.sourceURL = filename;
     this.line = lineno;
     this.column = colno;
+    this.__newrelic = newrelic;
   }
 }

package/dist/esm/features/page_view_event/aggregate/index.js

@@ -1,4 +1,4 @@
-import { globalScope, isBrowserScope } from '../../../common/constants/runtime';
+import { globalScope, isBrowserScope, originTime } from '../../../common/constants/runtime';
 import { addPT, addPN } from '../../../common/timing/nav-timing';
 import { stringify } from '../../../common/util/stringify';
 import { getInfo, getRuntime } from '../../../common/config/config';
@@ -95,14 +95,14 @@ export class Aggregate extends AggregateBase {
         // Navigation Timing level 2 API that replaced PerformanceTiming & PerformanceNavigation
         const navTimingEntry = globalScope?.performance?.getEntriesByType('navigation')?.[0];
         const perf = {
-          timing: addPT(agentRuntime.offset, navTimingEntry, {}),
+          timing: addPT(originTime, navTimingEntry, {}),
           navigation: addPN(navTimingEntry, {})
         };
         queryParameters.perf = stringify(perf);
       } else if (typeof PerformanceTiming !== 'undefined') {
         // Safari pre-15 did not support level 2 timing
         const perf = {
-          timing: addPT(agentRuntime.offset, globalScope.performance.timing, {}, true),
+          timing: addPT(originTime, globalScope.performance.timing, {}, true),
           navigation: addPN(globalScope.performance.navigation, {})
         };
         queryParameters.perf = stringify(perf);
@@ -134,7 +134,7 @@ export class Aggregate extends AggregateBase {
           return;
         }
         try {
-          const timeKeeper = new TimeKeeper();
+          const timeKeeper = new TimeKeeper(this.agentIdentifier);
           timeKeeper.processRumRequest(xhr, rumStartTime, rumEndTime);
           if (!timeKeeper.ready) throw new Error('TimeKeeper not ready');
           agentRuntime.timeKeeper = timeKeeper;

package/dist/esm/features/session_replay/aggregate/index.js

@@ -368,6 +368,7 @@ export class Aggregate extends AggregateBase {
           ...(agentMetadata.entityGuid && {
             entityGuid: agentMetadata.entityGuid
           }),
+          harvestId: [agentRuntime.session?.state.value, agentRuntime.ptid, agentRuntime.harvestCount].filter(x => x).join('_'),
           'replay.firstTimestamp': firstTimestamp,
           'replay.lastTimestamp': lastTimestamp,
           'replay.nodes': events.length,

package/dist/esm/features/session_replay/shared/utils.js

@@ -1,5 +1,5 @@
 import { getConfigurationValue, originals } from '../../../common/config/config';
-import { isBrowserScope } from '../../../common/constants/runtime';
+import { isBrowserScope, originTime } from '../../../common/constants/runtime';
 export function enableSessionTracking(agentId) {
   return isBrowserScope && getConfigurationValue(agentId, 'privacy.cookies_enabled') === true;
 }
@@ -23,8 +23,8 @@ export function buildNRMetaNode(timestamp, timeKeeper) {
     originalTimestamp: timestamp,
     correctedTimestamp,
     timestampDiff: timestamp - correctedTimestamp,
-    timeKeeperOriginTime: timeKeeper.originTime,
-    timeKeeperCorrectedOriginTime: timeKeeper.correctedOriginTime,
-    timeKeeperDiff: Math.floor(timeKeeper.originTime - timeKeeper.correctedOriginTime)
+    originTime,
+    correctedOriginTime: timeKeeper.correctedOriginTime,
+    originTimeDiff: Math.floor(originTime - timeKeeper.correctedOriginTime)
   };
 }

package/dist/esm/features/session_trace/aggregate/index.js

@@ -12,6 +12,7 @@ import { getSessionReplayMode } from '../../session_replay/shared/replay-mode';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { MODE, SESSION_EVENTS } from '../../../common/session/constants';
 import { now } from '../../../common/timing/now';
+import { originTime } from '../../../common/constants/runtime';
 const ignoredEvents = {
   // we find that certain events make the data too noisy to be useful
   global: {
@@ -46,14 +47,12 @@ export class Aggregate extends AggregateBase {
     super(agentIdentifier, aggregator, FEATURE_NAME);
     _this = this;
     this.agentRuntime = getRuntime(agentIdentifier);
-
-    // Very unlikely, but in case the existing XMLHttpRequest.prototype object on the page couldn't be wrapped.
-    if (!this.agentRuntime.xhrWrappable) return;
     this.resourceObserver = argsObj?.resourceObserver; // undefined if observer couldn't be created
     this.ptid = '';
     this.trace = {};
     this.nodeCount = 0;
     this.sentTrace = null;
+    this.prevStoredEvents = new Set();
     this.harvestTimeSeconds = getConfigurationValue(agentIdentifier, 'session_trace.harvestTimeSeconds') || 10;
     this.maxNodesPerHarvest = getConfigurationValue(agentIdentifier, 'session_trace.maxNodesPerHarvest') || 1000;
     /**
@@ -121,7 +120,7 @@ export class Aggregate extends AggregateBase {
         return controlTraceOp(on);
       }, this.featureName, this.ee);
     } else {
-      registerHandler('errorAgg', () => {
+      registerHandler('trace-jserror', () => {
         seenAnError = true;
         switchToFull();
       }, this.featureName, this.ee);
@@ -216,7 +215,7 @@ export class Aggregate extends AggregateBase {
       }
       return operationalGate.settle(() => _this.storeSTN(...args));
     }, this.featureName, this.ee);
-    registerHandler('errorAgg', function () {
+    registerHandler('trace-jserror', function () {
       for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
         args[_key6] = arguments[_key6];
       }
@@ -265,6 +264,7 @@ export class Aggregate extends AggregateBase {
     }
   }
   #prepareHarvest(options) {
+    this.prevStoredEvents.clear(); // release references to past events for GC
     if (this.isStandalone) {
       if (this.ptid && now() >= MAX_TRACE_DURATION) {
         // Perform a final harvest once we hit or exceed the max session trace time
@@ -331,6 +331,8 @@ export class Aggregate extends AggregateBase {
   // Tracks the events and their listener's duration on objects wrapped by wrap-events.
   storeEvent(currentEvent, target, start, end) {
     if (this.shouldIgnoreEvent(currentEvent, target)) return;
+    if (this.prevStoredEvents.has(currentEvent)) return; // prevent multiple listeners of an event from creating duplicate trace nodes per occurrence. Cleared every harvest. near-zero chance for re-duplication after clearing per harvest since the timestamps of the event are considered for uniqueness.
+    this.prevStoredEvents.add(currentEvent);
     const evt = {
       n: this.evtName(currentEvent.type),
       s: start,
@@ -531,13 +533,13 @@ export class Aggregate extends AggregateBase {
     }
     return {
       qs: {
-        st: this.agentRuntime.offset,
+        st: originTime,
         /** hr === "hasReplay" in NR1, standalone is always checked and processed before harvesting
          * so a race condition between ST and SR states should not be a concern if implemented here */
         hr: Number(!this.isStandalone),
         /** fts === "firstTimestamp" in NR1, indicates what the earliest NODE timestamp was
          * so that blob parsing doesn't need to happen to support UI/API functions  */
-        fts: this.agentRuntime.offset + earliestTimeStamp,
+        fts: originTime + earliestTimeStamp,
         /** n === "nodeCount" in NR1, a count of nodes in the ST payload, so that blob parsing doesn't need to happen to support UI/API functions */
         n: stns.length,
         // node count

package/dist/esm/features/spa/aggregate/index.js

@@ -642,7 +642,7 @@ export class Aggregate extends AggregateBase {
         state.interactionsSent = [];
       }
     }
-    baseEE.on('errorAgg', function (type, name, params, metrics) {
+    baseEE.on('spa-jserror', function (type, name, params, metrics) {
       if (!state.currentNode) return;
       params._interactionId = state.currentNode.interaction.id;
       // do not capture parentNodeId when in root node
@@ -650,6 +650,16 @@ export class Aggregate extends AggregateBase {
         params._interactionNodeId = state.currentNode.id;
       }
     });
+    register('function-err', function (args, obj, error) {
+      if (!state.currentNode) return;
+      error.__newrelic ??= {};
+      error.__newrelic[agentIdentifier] = {
+        interactionId: state.currentNode.interaction.id
+      };
+      if (state.currentNode.type && state.currentNode.type !== 'interaction') {
+        error.__newrelic[agentIdentifier].interactionNodeId = state.currentNode.id;
+      }
+    }, this.featureName, baseEE);
     baseEE.on('interaction', saveInteraction);
     function getActionText(node) {
       var nodeType = node.tagName.toLowerCase();

package/dist/esm/features/spa/instrument/index.js

@@ -5,10 +5,10 @@
 import { wrapMutation, wrapPromise, wrapHistory, wrapTimer, wrapFetch, wrapXhr, wrapJsonP } from '../../../common/wrap';
 import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts';
 import { InstrumentBase } from '../../utils/instrument-base';
-import { getRuntime } from '../../../common/config/config';
 import * as CONSTANTS from '../constants';
 import { isBrowserScope } from '../../../common/constants/runtime';
 import { now } from '../../../common/timing/now';
+import { handle } from '../../../common/event-emitter/handle';
 const {
   FEATURE_NAME,
   START,
@@ -24,11 +24,12 @@ const {
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
+    var _this;
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+    _this = this;
     if (!isBrowserScope) return; // SPA not supported outside web env
 
-    if (!getRuntime(agentIdentifier).xhrWrappable) return;
     try {
       this.removeOnAbort = new AbortController();
     } catch (e) {}
@@ -49,6 +50,12 @@ export class Instrument extends InstrumentBase {
     this.ee.on(FN_END, endTimestamp);
     promiseEE.on(CB_END, endTimestamp);
     jsonpEE.on(CB_END, endTimestamp);
+    this.ee.on('fn-err', function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      if (!args[2]?.__newrelic?.[agentIdentifier]) handle('function-err', [...args], undefined, _this.featureName, _this.ee);
+    });
     this.ee.buffer([FN_START, FN_END, 'xhr-resolved'], this.featureName);
     eventsEE.buffer([FN_START], this.featureName);
     timerEE.buffer(['setTimeout' + END, 'clearTimeout' + START, FN_START], this.featureName);

package/dist/esm/features/utils/agent-session.js

@@ -4,20 +4,16 @@ import { ee } from '../../common/event-emitter/contextual-ee';
 import { registerHandler } from '../../common/event-emitter/register-handler';
 import { SessionEntity } from '../../common/session/session-entity';
 import { LocalStorage } from '../../common/storage/local-storage.js';
-import { FirstPartyCookies } from '../../common/storage/first-party-cookies';
 import { DEFAULT_KEY } from '../../common/session/constants';
 let ranOnce = 0;
 export function setupAgentSession(agentIdentifier) {
   const agentRuntime = getRuntime(agentIdentifier);
   if (ranOnce++) return agentRuntime.session;
   const sessionInit = getConfiguration(agentIdentifier).session;
-  /* Domain is a string that can be specified by customer. The only way to keep the session object across subdomains is using first party cookies.
-    This determines which storage wrapper the session manager will use to keep state. */
-  const storageTypeInst = sessionInit?.domain ? new FirstPartyCookies(sessionInit.domain) : new LocalStorage();
   agentRuntime.session = new SessionEntity({
     agentIdentifier,
     key: DEFAULT_KEY,
-    storage: storageTypeInst,
+    storage: new LocalStorage(),
     expiresMs: sessionInit?.expiresMs,
     inactiveMs: sessionInit?.inactiveMs
   });

package/dist/esm/features/utils/instrument-base.js

@@ -52,7 +52,7 @@ export class InstrumentBase extends FeatureBase {
     if (getConfigurationValue(this.agentIdentifier, "".concat(this.featureName, ".autoStart")) === false) this.auto = false;
     /** if the feature requires opt-in (!auto-start), it will get registered once the api has been called */
     if (this.auto) registerDrain(agentIdentifier, featureName);else {
-      this.ee.on("".concat(this.featureName, "-opt-in"), single(() => {
+      this.ee.on('manual-start-all', single(() => {
         // register the feature to drain only once the API has been called, it will drain when importAggregator finishes for all the features
         // called by the api in that cycle
         registerDrain(this.agentIdentifier, this.featureName);

package/dist/esm/loaders/api/api.js

@@ -125,19 +125,10 @@ export function setAPI(agentIdentifier, forceDrain) {
     }
     return appendJsAttribute('application.version', value, 'setApplicationVersion', false);
   };
-  apiInterface.start = features => {
+  apiInterface.start = () => {
     try {
-      const smTag = !features ? 'undefined' : 'defined';
-      handle(SUPPORTABILITY_METRIC_CHANNEL, ["API/start/".concat(smTag, "/called")], undefined, FEATURE_NAMES.metrics, instanceEE);
-      const featNames = Object.values(FEATURE_NAMES);
-      if (features === undefined) features = featNames;else {
-        features = Array.isArray(features) && features.length ? features : [features];
-        if (features.some(f => !featNames.includes(f))) return warn("Invalid feature name supplied. Acceptable feature names are: ".concat(featNames));
-        if (!features.includes(FEATURE_NAMES.pageViewEvent)) features.push(FEATURE_NAMES.pageViewEvent);
-      }
-      features.forEach(feature => {
-        instanceEE.emit("".concat(feature, "-opt-in"));
-      });
+      handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/start/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
+      instanceEE.emit('manual-start-all');
     } catch (err) {
       warn('An unexpected issue occurred', err);
     }
@@ -168,9 +159,10 @@ export function setAPI(agentIdentifier, forceDrain) {
           try {
             return cb.apply(this, arguments);
           } catch (err) {
-            tracerEE.emit('fn-err', [arguments, this, err], contextStore);
+            const error = typeof err === 'string' ? new Error(err) : err;
+            tracerEE.emit('fn-err', [arguments, this, error], contextStore);
             // the error came from outside the agent, so don't swallow
-            throw err;
+            throw error;
           } finally {
             tracerEE.emit('fn-end', [now()], contextStore);
           }

package/dist/esm/loaders/api/apiAsync.js

@@ -5,6 +5,7 @@ import { handle } from '../../common/event-emitter/handle';
 import { registerHandler } from '../../common/event-emitter/register-handler';
 import { single } from '../../common/util/invoke';
 import { CUSTOM_METRIC_CHANNEL } from '../../features/metrics/constants';
+import { originTime } from '../../common/constants/runtime';
 export function setAPI(agentIdentifier) {
   var instanceEE = ee.get(agentIdentifier);
   var api = {
@@ -24,13 +25,13 @@ export function setAPI(agentIdentifier) {
   // first parameter. These functions can be called asynchronously.
 
   function finished(t, providedTime) {
-    var time = providedTime ? providedTime - getRuntime(agentIdentifier).offset : t;
+    var time = providedTime ? providedTime - originTime : t;
     handle(CUSTOM_METRIC_CHANNEL, ['finished', {
       time
     }], undefined, FEATURE_NAMES.metrics, instanceEE);
     addToTrace(t, {
       name: 'finished',
-      start: time + getRuntime(agentIdentifier).offset,
+      start: time + originTime,
       origin: 'nr'
     });
     handle('api-addPageAction', [time, 'finished'], undefined, FEATURE_NAMES.pageAction, instanceEE);
@@ -39,8 +40,8 @@ export function setAPI(agentIdentifier) {
     if (!(evt && typeof evt === 'object' && evt.name && evt.start)) return;
     var report = {
       n: evt.name,
-      s: evt.start - getRuntime(agentIdentifier).offset,
-      e: (evt.end || evt.start) - getRuntime(agentIdentifier).offset,
+      s: evt.start - originTime,
+      e: (evt.end || evt.start) - originTime,
       o: evt.origin || '',
       t: 'api'
     };

package/dist/types/common/config/state/configurable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configurable.d.ts","sourceRoot":"","sources":["../../../../../src/common/config/state/configurable.js"],"names":[],"mappings":"AAEA,4DAyBC"}
+{"version":3,"file":"configurable.d.ts","sourceRoot":"","sources":["../../../../../src/common/config/state/configurable.js"],"names":[],"mappings":"AAEA,4DA0BC"}

package/dist/types/common/config/state/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../src/common/config/state/init.js"],"names":[],"mappings":"AA+GA,+CAIC;AAED,0DAKC;AAED,+DAYC"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../src/common/config/state/init.js"],"names":[],"mappings":"AA8GA,+CAIC;AAED,0DAKC;AAED,+DAYC"}

package/dist/types/common/config/state/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../../src/common/config/state/runtime.js"],"names":[],"mappings":"AAgCA,yCAIC;AAED,oDAKC"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../../src/common/config/state/runtime.js"],"names":[],"mappings":"AAgCA,yCAIC;AAED,oDAQC"}

package/dist/types/common/constants/runtime.d.ts

@@ -28,5 +28,10 @@ export const iOSBelow16: boolean;
 export const ffVersion: number;
 export const isIE: boolean;
 export const supportsSendBeacon: boolean;
-export const offset: number;
+/**
+ * Represents the absolute timestamp in milliseconds that the page was loaded
+ * according to the browser's local clock.
+ * @type {number}
+ */
+export const originTime: number;
 //# sourceMappingURL=runtime.d.ts.map

package/dist/types/common/constants/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../src/common/constants/runtime.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,qCAEqB;AAErB;;GAEG;AACH,oCAeK;AAEL,oDAUI;AAEJ,oDAA6F;AAE7F,sCAA2F;AAE3F,qCAAyD;AAEzD,4BAA8E;AAE9E;;;;;;GAMG;AACH,iCAAwE;AAExE,+BAOI;AAEJ,2BAA2E;AAE3E,yCAAqE;AAErE,4BAAgE"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../src/common/constants/runtime.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,qCAEqB;AAErB;;GAEG;AACH,oCAeK;AAEL,oDAUI;AAEJ,oDAA6F;AAE7F,sCAA2F;AAE3F,qCAAyD;AAEzD,4BAA8E;AAE9E;;;;;;GAMG;AACH,iCAAwE;AAExE,+BAOI;AAEJ,2BAA2E;AAE3E,yCAAqE;AAErE;;;;GAIG;AACH,yBAFU,MAAM,CAEoD"}

package/dist/types/common/deny-list/deny-list.d.ts

@@ -4,6 +4,7 @@
  * @returns {boolean} `true` if request does not match any entries of {@link denyList|deny list}; else `false`
  */
 export function shouldCollectEvent(params: Object): boolean;
+export function hasUndefinedHostname(params: any): boolean;
 /**
  * Initializes the {@link denyList|XHR deny list} by extracting hostname and pathname from an array of filter strings.
  * @param {string[]} denyListConfig - array of URL filters to identify XHR requests to be excluded from collection

package/dist/types/common/deny-list/deny-list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deny-list.d.ts","sourceRoot":"","sources":["../../../../src/common/deny-list/deny-list.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,2CAHW,MAAM,GACJ,OAAO,CA0BnB;AAED;;;GAGG;AACH,4CAFW,MAAM,EAAE,QAgClB"}
+{"version":3,"file":"deny-list.d.ts","sourceRoot":"","sources":["../../../../src/common/deny-list/deny-list.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,2CAHW,MAAM,GACJ,OAAO,CAqBnB;AAED,2DAEC;AAED;;;GAGG;AACH,4CAFW,MAAM,EAAE,QAgClB"}

package/dist/types/common/session/constants.d.ts

@@ -3,6 +3,7 @@ export const DEFAULT_KEY: "SESSION";
 export const DEFAULT_EXPIRES_MS: 14400000;
 export const DEFAULT_INACTIVE_MS: 1800000;
 export namespace SESSION_EVENTS {
+    let STARTED: string;
     let PAUSE: string;
     let RESET: string;
     let RESUME: string;

package/dist/types/common/session/session-entity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-entity.d.ts","sourceRoot":"","sources":["../../../../src/common/session/session-entity.js"],"names":[],"mappings":"AA6BA;IACE;;;;;OAKG;IACH,uBA0BC;IApBC,qBAAsC;IACtC,aAAsB;IACtB,UAAe;IAGf,SAAc;IAEd,QAAiC;IAenC;;;;aAyEC;IAlEC,8BAA0B;IAC1B,+BAA4B;IAc1B,gCAOqC;IAUrC,4CAkBsC;IAexC,iCAAuB;IAIzB,wBAEC;IAED,sBAEC;IAED;;;OAGG;IACH,QAFa,MAAM,CA6BlB;IAED;;;;;;OAMG;IACH,YAHW,MAAM,GACJ,MAAM,CAkBlB;IAED,gBAuBC;IAED;;OAEG;IACH,gBAIC;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,OAAO,CAKnB;IAED,yDAUC;IAED,6DAIC;IAED;;;OAGG;IACH,6BAHW,MAAM,GACJ,MAAM,CAIlB;IAED,gDAaC;IAHG,YAAuD;CAI5D;sBArSqB,gBAAgB;iCAGL,4BAA4B"}
+{"version":3,"file":"session-entity.d.ts","sourceRoot":"","sources":["../../../../src/common/session/session-entity.js"],"names":[],"mappings":"AA8BA;IACE;;;;;OAKG;IACH,uBA0BC;IApBC,qBAAsC;IACtC,aAAsB;IACtB,UAAe;IAGf,SAAc;IAEd,QAAiC;IAenC;;;;aA0EC;IAnEC,8BAA0B;IAC1B,+BAA4B;IAc1B,gCAOqC;IAUrC,4CAkBsC;IAexC,iCAAuB;IAKzB,wBAEC;IAED,sBAEC;IAED;;;OAGG;IACH,QAFa,MAAM,CA6BlB;IAED;;;;;;OAMG;IACH,YAHW,MAAM,GACJ,MAAM,CAkBlB;IAED,gBAuBC;IAED;;OAEG;IACH,gBAIC;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,OAAO,CAKnB;IAED,yDAUC;IAED,6DAIC;IAED;;;OAGG;IACH,6BAHW,MAAM,GACJ,MAAM,CAIlB;IAED,gDAaC;IAHG,YAAuD;CAI5D;sBAvSqB,gBAAgB;iCAGL,4BAA4B"}

package/dist/types/common/timing/time-keeper.d.ts

@@ -4,8 +4,8 @@
  * to the harvested data event offset time.
  */
 export class TimeKeeper {
+    constructor(agentIdentifier: any);
     get ready(): number;
-    get originTime(): number;
     get correctedOriginTime(): number;
     /**
      * Process a rum request to calculate NR server time.

package/dist/types/common/timing/time-keeper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time-keeper.d.ts","sourceRoot":"","sources":["../../../../src/common/timing/time-keeper.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH;IA+BE,oBAEC;IAED,yBAEC;IAED,kCAEC;IAED;;;;;OAKG;IACH,8BAJsB,cAAc,aACf,MAAM,WACR,MAAM,QAoBxB;IAED;;;;;OAKG;IACH,uCAHwB,MAAM,GACjB,MAAM,CAIlB;IAED;;;;OAIG;IACH,oCAHqB,MAAM,GACf,MAAM,CAIjB;;CACF"}
+{"version":3,"file":"time-keeper.d.ts","sourceRoot":"","sources":["../../../../src/common/timing/time-keeper.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH;IA2BE,kCAaC;IAED,oBAEC;IAED,kCAEC;IAED;;;;;OAKG;IACH,8BAJsB,cAAc,aACf,MAAM,WACR,MAAM,QAuBxB;IAED;;;;;OAKG;IACH,uCAHwB,MAAM,GACjB,MAAM,CAIlB;IAED;;;;OAIG;IACH,oCAHqB,MAAM,GACf,MAAM,CAIjB;;CAoBF"}

package/dist/types/features/ajax/aggregate/chunk.d.ts

@@ -0,0 +1,8 @@
+export default class Chunk {
+    constructor(events: any, aggregateInstance: any);
+    addString: (str: any) => string;
+    events: any;
+    payload: string;
+    tooBig: boolean;
+}
+//# sourceMappingURL=chunk.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../../../../src/features/ajax/aggregate/chunk.js"],"names":[],"mappings":"AAGA;IACE,iDA6CC;IA5CC,gCAAuE;IACvE,YAAoB;IACpB,gBAAuB;IAyCvB,gBAA0E;CAE7E"}

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

@@ -1,16 +1,18 @@
 export class Aggregate extends AggregateBase {
     static featureName: string;
     constructor(agentIdentifier: any, aggregator: any);
-    storeXhr: (params: any, metrics: any, startTime: any, endTime: any, type: any) => void;
-    prepareHarvest: (options: any) => {
+    MAX_PAYLOAD_SIZE: any;
+    ajaxEvents: any[];
+    spaAjaxEvents: {};
+    sentAjaxEvents: any[];
+    storeXhr(params: any, metrics: any, startTime: any, endTime: any, type: any, ctx: any): void;
+    prepareHarvest(options: any): {
         body: {
             e: any;
         };
     }[] | null;
-    getStoredEvents: () => {
-        ajaxEvents: any[];
-        spaAjaxEvents: {};
-    };
+    onEventsHarvestFinished(result: any): void;
+    #private;
 }
 import { AggregateBase } from '../../utils/aggregate-base';
 //# sourceMappingURL=index.d.ts.map