@newrelic/browser-agent 1.255.0 → 1.256.0

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

@@ -1,6 +1,6 @@
 import { record as recorder } from 'rrweb';
 import { stringify } from '../../../common/util/stringify';
-import { AVG_COMPRESSION, CHECKOUT_MS, IDEAL_PAYLOAD_SIZE, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES } from '../constants';
+import { AVG_COMPRESSION, CHECKOUT_MS, IDEAL_PAYLOAD_SIZE, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES, SR_EVENT_EMITTER_TYPES } from '../constants';
 import { getConfigurationValue } from '../../../common/config/config';
 import { RecorderEvents } from './recorder-events';
 import { MODE } from '../../../common/session/constants';
@@ -8,6 +8,7 @@ import { stylesheetEvaluator } from './stylesheet-evaluator';
 import { handle } from '../../../common/event-emitter/handle';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
+import { buildNRMetaNode } from './utils';
 export class Recorder {
   /** Each page mutation or event will be stored (raw) in this array. This array will be cleared on each harvest */
   #events;
@@ -18,15 +19,9 @@ export class Recorder {
   /** flag that if true, blocks events from being "stored".  Only set to true when a full snapshot has incomplete nodes (only stylesheets ATM) */
   #fixing = false;
   constructor(parent) {
-    this.#events = new RecorderEvents({
-      canCorrectTimestamps: !!parent.timeKeeper?.ready
-    });
-    this.#backloggedEvents = new RecorderEvents({
-      canCorrectTimestamps: !!parent.timeKeeper?.ready
-    });
-    this.#preloaded = [new RecorderEvents({
-      canCorrectTimestamps: !!parent.timeKeeper?.ready
-    })];
+    this.#events = new RecorderEvents();
+    this.#backloggedEvents = new RecorderEvents();
+    this.#preloaded = [new RecorderEvents()];
     /** True when actively recording, false when paused or stopped */
     this.recording = false;
     /** The pointer to the current bucket holding rrweb events */
@@ -43,18 +38,12 @@ export class Recorder {
     this.stopRecording = () => {/* no-op until set by rrweb initializer */};
   }
   getEvents() {
-    if (this.#preloaded[0]?.events.length) {
-      const preloadedEvents = this.returnCorrectTimestamps(this.#preloaded[0]);
-      return {
-        ...this.#preloaded[0],
-        events: preloadedEvents,
-        type: 'preloaded'
-      };
-    }
-    const backloggedEvents = this.returnCorrectTimestamps(this.#backloggedEvents);
-    const events = this.returnCorrectTimestamps(this.#events);
+    if (this.#preloaded[0]?.events.length) return {
+      ...this.#preloaded[0],
+      type: 'preloaded'
+    };
     return {
-      events: [...backloggedEvents, ...events].filter(x => x),
+      events: [...this.#backloggedEvents.events, ...this.#events.events].filter(x => x),
       type: 'standard',
       cycleTimestamp: Math.min(this.#backloggedEvents.cycleTimestamp, this.#events.cycleTimestamp),
       payloadBytesEstimation: this.#backloggedEvents.payloadBytesEstimation + this.#events.payloadBytesEstimation,
@@ -65,34 +54,10 @@ export class Recorder {
     };
   }
 
-  /**
-   * Returns time-corrected events. If the events were correctable from the beginning, this correction will have already been applied.
-   * @param {SessionReplayEvent[]} events The array of buffered SR nodes
-   * @returns {CorrectedSessionReplayEvent[]}
-   */
-  returnCorrectTimestamps(events) {
-    if (!this.parent.timeKeeper?.ready) return events.events;
-    return events.canCorrectTimestamps ? events.events : events.events.map(_ref => {
-      let {
-        __serialized,
-        timestamp,
-        ...e
-      } = _ref;
-      return {
-        timestamp: this.parent.timeKeeper.correctAbsoluteTimestamp(timestamp),
-        ...e
-      };
-    });
-  }
-
   /** Clears the buffer (this.#events), and resets all payload metadata properties */
   clearBuffer() {
-    if (this.#preloaded[0]?.events.length) this.#preloaded.shift();else if (this.parent.mode === MODE.ERROR) this.#backloggedEvents = this.#events;else this.#backloggedEvents = new RecorderEvents({
-      canCorrectTimestamps: !!this.parent.timeKeeper?.ready
-    });
-    this.#events = new RecorderEvents({
-      canCorrectTimestamps: !!this.parent.timeKeeper?.ready
-    });
+    if (this.#preloaded[0]?.events.length) this.#preloaded.shift();else if (this.parent.mode === MODE.ERROR) this.#backloggedEvents = this.#events;else this.#backloggedEvents = new RecorderEvents();
+    this.#events = new RecorderEvents();
   }
 
   /** Begin recording using configured recording lib */
@@ -110,6 +75,10 @@ export class Recorder {
       inline_images,
       collect_fonts
     } = getConfigurationValue(this.parent.agentIdentifier, 'session_replay');
+    const customMasker = (text, element) => {
+      if (element?.type?.toLowerCase() !== 'password' && (element?.dataset.nrUnmask !== undefined || element?.classList.contains('nr-unmask'))) return text;
+      return '*'.repeat(text.length);
+    };
     // set up rrweb configurations for maximum privacy --
     // https://newrelic.atlassian.net/wiki/spaces/O11Y/pages/2792293280/2023+02+28+Browser+-+Session+Replay#Configuration-options
     const stop = recorder({
@@ -120,14 +89,18 @@ export class Recorder {
       blockSelector: block_selector,
       maskInputOptions: mask_input_options,
       maskTextSelector: mask_text_selector,
+      maskTextFn: customMasker,
       maskAllInputs: mask_all_inputs,
+      maskInputFn: customMasker,
       inlineStylesheet: inline_stylesheet,
       inlineImages: inline_images,
       collectFonts: collect_fonts,
       checkoutEveryNms: CHECKOUT_MS[this.parent.mode]
     });
+    this.parent.ee.emit(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [true, this.parent.mode]);
     this.stopRecording = () => {
       this.recording = false;
+      this.parent.ee.emit(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [false, this.parent.mode]);
       stop();
     };
   }
@@ -171,7 +144,8 @@ export class Recorder {
     if (!event) return;
     if (!this.parent.scheduler && this.#preloaded.length) this.currentBufferTarget = this.#preloaded[this.#preloaded.length - 1];else this.currentBufferTarget = this.#events;
     if (this.parent.blocked) return;
-    if (this.currentBufferTarget.canCorrectTimestamps) {
+    if (this.parent.timeKeeper?.ready && !event.__newrelic) {
+      event.__newrelic = buildNRMetaNode(event.timestamp, this.parent.timeKeeper);
       event.timestamp = this.parent.timeKeeper.correctAbsoluteTimestamp(event.timestamp);
     }
     event.__serialized = stringify(event);
@@ -206,9 +180,7 @@ export class Recorder {
         this.parent.scheduler.runHarvest();
       } else {
         // we are still in "preload" and it triggered a "stop point".  Make a new set, which will get pointed at on next cycle
-        this.#preloaded.push(new RecorderEvents({
-          canCorrectTimestamps: !!this.parent.timeKeeper?.ready
-        }));
+        this.#preloaded.push(new RecorderEvents());
       }
     }
   }

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

@@ -14,4 +14,15 @@ export function isPreloadAllowed(agentId) {
 export function canImportReplayAgg(agentId, sessionMgr) {
   if (!hasReplayPrerequisite(agentId)) return false;
   return !!sessionMgr?.isNew || !!sessionMgr?.state.sessionReplayMode; // Session Replay should only try to run if already running from a previous page, or at the beginning of a session
+}
+export function buildNRMetaNode(timestamp, timeKeeper) {
+  const correctedTimestamp = timeKeeper.correctAbsoluteTimestamp(timestamp);
+  return {
+    originalTimestamp: timestamp,
+    correctedTimestamp,
+    timestampDiff: timestamp - correctedTimestamp,
+    timeKeeperOriginTime: timeKeeper.originTime,
+    timeKeeperCorrectedOriginTime: timeKeeper.correctedOriginTime,
+    timeKeeperDiff: Math.floor(timeKeeper.originTime - timeKeeper.correctedOriginTime)
+  };
 }

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

@@ -50,10 +50,11 @@ export class Aggregate extends AggregateBase {
     // 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.ptid = this.agentRuntime.ptid;
     this.trace = {};
     this.nodeCount = 0;
     this.sentTrace = null;
+    this.everSent = false;
     this.harvestTimeSeconds = getConfigurationValue(agentIdentifier, 'session_trace.harvestTimeSeconds') || 10;
     this.maxNodesPerHarvest = getConfigurationValue(agentIdentifier, 'session_trace.maxNodesPerHarvest') || 1000;
     /**
@@ -105,9 +106,7 @@ export class Aggregate extends AggregateBase {
         this.isStandalone = false;
         if (prevMode === MODE.ERROR && this.#scheduler) {
           this.trimSTNs(ERROR_MODE_SECONDS_WINDOW); // up until now, Trace would've been just buffering nodes up to max, which needs to be trimmed to last X seconds
-          this.#scheduler.runHarvest({
-            needResponse: true
-          });
+          this.#scheduler.runHarvest({});
         } else {
           controlTraceOp(MODE.FULL);
         }
@@ -130,7 +129,7 @@ export class Aggregate extends AggregateBase {
           sessionTraceMode: MODE.OFF
         });
         operationalGate.permanentlyDecide(false);
-        if (mostRecentModeKnown === MODE.FULL) this.#scheduler?.runHarvest(); // allow queued nodes (past opGate) to final harvest, unless they were buffered in other modes
+        if (mostRecentModeKnown === MODE.FULL) this.#scheduler?.runHarvest({}); // allow queued nodes (past opGate) to final harvest, unless they were buffered in other modes
         this.#scheduler?.stopTimer(true); // the 'true' arg here will forcibly block any future call to runHarvest, so the last runHarvest above must be prior
         this.#scheduler = null;
       };
@@ -149,9 +148,7 @@ export class Aggregate extends AggregateBase {
            - if trace switches to Full mode, harvest should start (prev: Error) if not already running (prev: Full). */
           this.ee.on(SESSION_EVENTS.RESUME, () => {
             const updatedTraceMode = sessionEntity.state.sessionTraceMode;
-            if (updatedTraceMode === MODE.OFF) stopTracePerm();else if (updatedTraceMode === MODE.FULL && this.#scheduler && !this.#scheduler.started) this.#scheduler.runHarvest({
-              needResponse: true
-            });
+            if (updatedTraceMode === MODE.OFF) stopTracePerm();else if (updatedTraceMode === MODE.FULL && this.#scheduler && !this.#scheduler.started) this.#scheduler.runHarvest({});
             mostRecentModeKnown = updatedTraceMode;
           });
           this.ee.on(SESSION_EVENTS.PAUSE, () => {
@@ -242,15 +239,12 @@ export class Aggregate extends AggregateBase {
       retryDelay: this.harvestTimeSeconds
     }, this);
     this.#scheduler.harvest.on('resources', this.#prepareHarvest.bind(this));
-    if (dontStartHarvestYet === false) this.#scheduler.runHarvest({
-      needResponse: true
-    }); // sends first stn harvest immediately
+    if (dontStartHarvestYet === false) this.#scheduler.runHarvest({}); // sends first stn harvest immediately
     startupBuffer.decide(true); // signal to ALLOW & process data in EE's buffer into internal nodes queued for next harvest
   }
   #onHarvestFinished(result) {
-    if (result.sent && result.responseText && !this.ptid) {
-      // continue interval harvest only if ptid was returned by server on the first
-      this.agentRuntime.ptid = this.ptid = result.responseText;
+    if (result.sent && !result.failed && !this.#scheduler.started) {
+      // continue interval harvest only after first call
       this.#scheduler.startTimer(this.harvestTimeSeconds);
     }
     if (result.sent && result.retry && this.sentTrace) {
@@ -266,15 +260,18 @@ export class Aggregate extends AggregateBase {
   }
   #prepareHarvest(options) {
     if (this.isStandalone) {
-      if (this.ptid && now() >= MAX_TRACE_DURATION) {
-        // Perform a final harvest once we hit or exceed the max session trace time
-        options.isFinalHarvest = true;
-        this.operationalGate.permanentlyDecide(false);
-        this.#scheduler.stopTimer(true);
-      } else if (this.ptid && this.nodeCount <= REQ_THRESHOLD_TO_SEND && !options.isFinalHarvest) {
-        // Only harvest when more than some threshold of nodes are pending, after the very first harvest, with the exception of the last outgoing harvest.
-        return;
+      if (this.#scheduler.started) {
+        if (now() >= MAX_TRACE_DURATION) {
+          // Perform a final harvest once we hit or exceed the max session trace time
+          options.isFinalHarvest = true;
+          this.operationalGate.permanentlyDecide(false);
+          this.#scheduler.stopTimer(true);
+        } else if (this.nodeCount <= REQ_THRESHOLD_TO_SEND && !options.isFinalHarvest) {
+          // Only harvest when more than some threshold of nodes are pending, after the very first harvest, with the exception of the last outgoing harvest.
+          return;
+        }
       }
+      // else, we must be on the very first harvest (standalone mode), so go to next square
     } else {
       //   -- *cli May '26 - Update: Not rate limiting backgrounded pages either for now.
       //   if (this.ptid && document.visibilityState === 'hidden' && this.nodeCount <= REQ_THRESHOLD_TO_SEND) return

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

@@ -15,6 +15,7 @@ import { gosCDN } from '../../common/window/nreum';
 import { apiMethods, asyncApiMethods } from './api-methods';
 import { SR_EVENT_EMITTER_TYPES } from '../../features/session_replay/constants';
 import { now } from '../../common/timing/now';
+import { MODE } from '../../common/session/constants';
 export function setTopLevelCallers() {
   const nr = gosCDN();
   apiMethods.forEach(f => {
@@ -38,12 +39,17 @@ export function setTopLevelCallers() {
     return returnVals.length > 1 ? returnVals : returnVals[0];
   }
 }
+const replayRunning = {};
 export function setAPI(agentIdentifier, forceDrain) {
   let runSoftNavOverSpa = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   if (!forceDrain) registerDrain(agentIdentifier, 'api');
   const apiInterface = {};
   var instanceEE = ee.get(agentIdentifier);
   var tracerEE = instanceEE.get('tracer');
+  replayRunning[agentIdentifier] = MODE.OFF;
+  instanceEE.on(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, isRunning => {
+    replayRunning[agentIdentifier] = isRunning;
+  });
   var prefix = 'api-';
   var spaPrefix = prefix + 'ixn-';
 
@@ -186,7 +192,7 @@ export function setAPI(agentIdentifier, forceDrain) {
   apiInterface.noticeError = function (err, customAttributes) {
     if (typeof err === 'string') err = new Error(err);
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/noticeError/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
-    handle('err', [err, now(), false, customAttributes], undefined, FEATURE_NAMES.jserrors, instanceEE);
+    handle('err', [err, now(), false, customAttributes, !!replayRunning[agentIdentifier]], undefined, FEATURE_NAMES.jserrors, instanceEE);
   };
 
   // theres no window.load event on non-browser scopes, lazy load immediately

package/dist/esm/loaders/configure/configure.js

@@ -54,6 +54,7 @@ export function configure(agent) {
     agent.runSoftNavOverSpa &&= updatedInit.soft_navigations.enabled === true && updatedInit.feature_flags.includes('soft_nav');
   }
   runtime.denyList = [...(updatedInit.ajax.deny_list || []), ...(updatedInit.ajax.block_internal ? internalTrafficList : [])];
+  runtime.ptid = agent.agentIdentifier;
   setRuntime(agent.agentIdentifier, runtime);
   if (agent.api === undefined) agent.api = setAPI(agent.agentIdentifier, forceDrain, agent.runSoftNavOverSpa);
   if (agent.exposed === undefined) agent.exposed = exposed;

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,4BAAyI"}
+{"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"}

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;;;;aAwEC;IAjEC,8BAA0B;IAC1B,+BAA4B;IAc1B,gCAOqC;IAUrC,4CAiBsC;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;sBApSqB,gBAAgB;iCAGL,4BAA4B"}
+{"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"}

package/dist/types/common/timer/interaction-timer.d.ts

@@ -2,6 +2,8 @@ export class InteractionTimer extends Timer {
     onPause: any;
     onRefresh: any;
     onResume: any;
+    /** used to double-check LS state at resume time */
+    readStorage: any;
     remainingMs: number | undefined;
     abortController: AbortController | undefined;
     ee: any;

package/dist/types/common/timer/interaction-timer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interaction-timer.d.ts","sourceRoot":"","sources":["../../../../src/common/timer/interaction-timer.js"],"names":[],"mappings":"AAKA;IAGI,aAAuF;IACvF,eAA6F;IAC7F,cAA0F;IAG1F,gCAA4B;IAM1B,6CAA4C;IAO1C,QAAiB;IAEjB,kDAIC;IAoBP,cAQC;IAED,cAIC;IAED,eAGC;IAED,gCAMC;CACF;sBAhFqB,SAAS"}
+{"version":3,"file":"interaction-timer.d.ts","sourceRoot":"","sources":["../../../../src/common/timer/interaction-timer.js"],"names":[],"mappings":"AAKA;IAGI,aAAuF;IACvF,eAA6F;IAC7F,cAA0F;IAE1F,mDAAmD;IACnD,iBAAmC;IAGnC,gCAA4B;IAM1B,6CAA4C;IAO1C,QAAiB;IAEjB,kDAIC;IAoBP,cAQC;IAED,cAIC;IAED,eAeC;IAED,gCAMC;CACF;sBA/FqB,SAAS"}

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":"AAEA;;;;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":"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"}

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

@@ -10,6 +10,7 @@ export class Aggregate extends AggregateBase {
     bufferedErrorsUnderSpa: {};
     currentBody: {} | null | undefined;
     errorOnPage: boolean;
+    replayAborted: boolean;
     onHarvestStarted(options: any): {
         body: {} | null;
         qs: {};
@@ -25,7 +26,7 @@ export class Aggregate extends AggregateBase {
      * @returns {string} A canonical stack string built from the URLs and function names in the given `stackInfo` object.
      */
     buildCanonicalStackString(stackInfo: StackInfo): string;
-    storeError(err: any, time: any, internal: any, customAttributes: any): void;
+    storeError(err: any, time: any, internal: any, customAttributes: any, hasReplay: any): void;
     onInteractionDone(interaction: any, wasSaved: any): void;
     onSoftNavNotification(interactionId: any, wasFinished: any, softNavAttrs: any): void;
     #private;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AAyBA;;GAEG;AAEH;IACE,2BAAiC;IACjC,mDAgCC;IA7BC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,2BAAgC;IAChC,mCAA4B;IAC5B,qBAAwB;IA0B1B;;;MAoBC;IAED,qCAWC;IAED,8BAEC;IAED,oEAMC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED,4EAuFC;IA4BD,yDA6BC;IAED,qFAOC;;CACF;wBAvQY,OAAO,0BAA0B,EAAE,SAAS;8BAN3B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AAyBA;;GAEG;AAEH;IACE,2BAAiC;IACjC,mDAmCC;IAhCC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,2BAAgC;IAChC,mCAA4B;IAC5B,qBAAwB;IACxB,uBAA0B;IA4B5B;;;MA2BC;IAED,qCAWC;IAED,8BAEC;IAED,oEAMC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED,4FAsFC;IA4BD,yDA6BC;IAED,qFAOC;;CACF;wBAhRY,OAAO,0BAA0B,EAAE,SAAS;8BAN3B,4BAA4B"}

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/instrument/index.js"],"names":[],"mappings":"AAeA;IACE,2BAAiC;IAIjC,mEA4CC;IAvCG,2CAA0C;IAqC5C,yBAA+B;;CAoFlC;+BA5I8B,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/instrument/index.js"],"names":[],"mappings":"AAgBA;IACE,2BAAiC;IAKjC,mEA+CC;IA1CG,2CAA0C;IAwC5C,yBAA+B;;CAoFlC;+BAjJ8B,6BAA6B"}

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

@@ -1,6 +1,7 @@
 export class Aggregate extends AggregateBase {
     static featureName: string;
     constructor(agentIdentifier: any, aggregator: any, args: any);
+    mode: number;
     /** The interval to harvest at.  This gets overridden if the size of the payload exceeds certain thresholds */
     harvestTimeSeconds: any;
     /** Set once the recorder has fully initialized after flag checks and sampling */
@@ -9,14 +10,15 @@ export class Aggregate extends AggregateBase {
     gzipper: typeof import("fflate").gzipSync | undefined;
     /** populated with the u8 string lib async */
     u8: typeof import("fflate").strToU8 | undefined;
-    mode: any;
     /** set by BCS response */
     entitled: boolean;
     /** set at BCS response, stored in runtime */
     timeKeeper: any;
     recorder: any;
+    preloaded: boolean;
+    errorNoticed: any;
     scheduler: HarvestScheduler;
-    errorNoticed: boolean;
+    handleError(e: any): void;
     switchToFull(): void;
     /**
      * Evaluate entitlements and sampling before starting feature mechanics, importing and configuring recording library, and setting storage state
@@ -41,6 +43,7 @@ export class Aggregate extends AggregateBase {
         };
         body: any;
     }[] | undefined;
+    getCorrectedTimestamp(node: any): any;
     getHarvestContents(recorderEvents: any): {
         qs: {
             browser_monitoring_key: any;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/aggregate/index.js"],"names":[],"mappings":"AA+BA;IACE,2BAAiC;IAEjC,8DAoHC;IAlHC,8GAA8G;IAC9G,wBAAgH;IAChH,iFAAiF;IACjF,qBAAwB;IAGxB,2CAA2C;IAC3C,sDAAwB;IACxB,6CAA6C;IAC7C,gDAAmB;IAGnB,UAAuD;IAEvD,0BAA0B;IAC1B,kBAAqB;IACrB,6CAA6C;IAC7C,gBAA2B;IAE3B,cAA8B;IA8B9B,4BAKQ;IAmBN,sBAAwB;IA2C5B,qBAWC;IAED;;;;;;;OAOG;IACH,iCALW,OAAO,cACP,OAAO,iBACP,OAAO,GACL,IAAI,CA6DhB;IAED,2BASC;IAED;;;;;;;;;;;;oBAoCC;IAED;;;;;;;;;;MAmEC;IAED,qCAOC;IAED;;;;OAIG;IACH,mCAKC;IAED,yDAAyD;IACzD,yBAUC;IAED,yCAGC;CACF;8BAtX6B,4BAA4B;iCAHzB,2CAA2C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/aggregate/index.js"],"names":[],"mappings":"AAgCA;IACE,2BAAiC;IAIjC,8DAsGC;IAzGD,aAAe;IAKb,8GAA8G;IAC9G,wBAAgH;IAChH,iFAAiF;IACjF,qBAAwB;IAGxB,2CAA2C;IAC3C,sDAAwB;IACxB,6CAA6C;IAC7C,gDAAmB;IAEnB,0BAA0B;IAC1B,kBAAqB;IACrB,6CAA6C;IAC7C,gBAA2B;IAE3B,cAA8B;IAC9B,mBAAgC;IAChC,kBAA+C;IA4B/C,4BAKQ;IAmDV,0BAMC;IAED,qBAWC;IAED;;;;;;;OAOG;IACH,iCALW,OAAO,cACP,OAAO,iBACP,OAAO,GACL,IAAI,CA8DhB;IAED,2BASC;IAED;;;;;;;;;;;;oBAiDC;IAED,sCAIC;IAED;;;;;;;;;;MAoEC;IAED,qCAOC;IAED;;;;OAIG;IACH,mCAKC;IAED,yDAAyD;IACzD,yBAUC;IAED,yCAGC;CACF;8BAxY6B,4BAA4B;iCAHzB,2CAA2C"}

package/dist/types/features/session_replay/constants.d.ts

@@ -2,6 +2,7 @@ export const FEATURE_NAME: string;
 export namespace SR_EVENT_EMITTER_TYPES {
     let RECORD: string;
     let PAUSE: string;
+    let REPLAY_RUNNING: string;
 }
 export const AVG_COMPRESSION: 0.12;
 export namespace RRWEB_EVENT_TYPES {

package/dist/types/features/session_replay/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/session_replay/constants.js"],"names":[],"mappings":"AAGA,kCAAuD;;;;;AAOvD,mCAAmC;;;;;;;;;AASnC,uCAAuC;AACvC,uCAAuC;AACvC,iCAAiC;AACjC,uCAAuC;AACvC,2GAA2G;AAC3G;;EAAsF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BtF,0CAA0C;AAC1C,uCAAuC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/session_replay/constants.js"],"names":[],"mappings":"AAGA,kCAAuD;;;;;;AAQvD,mCAAmC;;;;;;;;;AASnC,uCAAuC;AACvC,uCAAuC;AACvC,iCAAiC;AACjC,uCAAuC;AACvC,2GAA2G;AAC3G;;EAAsF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BtF,0CAA0C;AAC1C,uCAAuC"}

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

@@ -1,6 +1,7 @@
 export class Instrument extends InstrumentBase {
     static featureName: string;
     constructor(agentIdentifier: any, aggregator: any, auto?: boolean);
+    errorNoticed: boolean;
     recorder: import("../shared/recorder").Recorder | undefined;
     #private;
 }

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":"AAgBA;IACE,2BAAiC;IACjC,mEAYC;IAiBC,4DAA6E;;CAKhF;+BAxC8B,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/instrument/index.js"],"names":[],"mappings":"AAgBA;IACE,2BAAiC;IACjC,mEAiBC;IAPK,sBAAwB;IAwB5B,4DAA0F;;CAK7F;+BA7C8B,6BAA6B"}

package/dist/types/features/session_replay/shared/recorder-events.d.ts

@@ -1,18 +1,10 @@
 export class RecorderEvents {
-    constructor({ canCorrectTimestamps }: {
-        canCorrectTimestamps: any;
-    });
     /** The buffer to hold recorder event nodes */
     events: any[];
     /** Payload metadata -- Should indicate when a replay blob started recording.  Resets each time a harvest occurs.
      * cycle timestamps are used as fallbacks if event timestamps cannot be used
      */
     cycleTimestamp: number;
-    /** Payload metadata -- Whether timestamps can be corrected, defaults as false, can be set to true if timekeeper is present at init time.  Used to determine
-     * if harvest needs to re-loop through nodes and correct them before sending.  Ideal behavior is to correct them as they flow into the recorder
-     * to prevent re-looping, but is not always possible since the timekeeper is not set until after page load and the recorder can be preloaded.
-    */
-    canCorrectTimestamps: boolean;
     /** A value which increments with every new mutation node reported. Resets after a harvest is sent */
     payloadBytesEstimation: number;
     /** Payload metadata -- Should indicate that the payload being sent has a full DOM snapshot. This can happen

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

@@ -1 +1 @@
-{"version":3,"file":"recorder-events.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder-events.js"],"names":[],"mappings":"AAAA;IACE;;OAyBC;IAxBC,8CAA8C;IAC9C,cAAgB;IAChB;;OAEG;IACH,uBAAgC;IAChC;;;MAGE;IACF,8BAAkD;IAClD,qGAAqG;IACrG,+BAA+B;IAC/B;;;MAGE;IACF,qBAAwB;IACxB,4IAA4I;IAC5I,iBAAoB;IACpB,+HAA+H;IAC/H,kBAAqB;IACrB,0FAA0F;IAC1F,+BAAiC;IAGnC,sBAEC;CACF"}
+{"version":3,"file":"recorder-events.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder-events.js"],"names":[],"mappings":"AAAA;IAEI,8CAA8C;IAC9C,cAAgB;IAChB;;OAEG;IACH,uBAAgC;IAChC,qGAAqG;IACrG,+BAA+B;IAC/B;;;MAGE;IACF,qBAAwB;IACxB,4IAA4I;IAC5I,iBAAoB;IACpB,+HAA+H;IAC/H,kBAAqB;IACrB,0FAA0F;IAC1F,+BAAiC;IAGnC,sBAEC;CACF"}

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

@@ -15,31 +15,15 @@ export class Recorder {
     /** The method to stop recording. This defaults to a noop, but is overwritten once the recording library is imported and initialized */
     stopRecording: () => void;
     getEvents(): {
-        events: CorrectedSessionReplayEvent[];
         type: string;
+        events: any[];
         cycleTimestamp: number;
-        canCorrectTimestamps: boolean;
         payloadBytesEstimation: number;
         hasSnapshot: boolean;
         hasMeta: boolean;
         hasError: boolean;
         inlinedAllStylesheets: boolean;
-    } | {
-        events: any[];
-        type: string;
-        cycleTimestamp: number;
-        payloadBytesEstimation: number;
-        hasError: boolean;
-        hasMeta: boolean;
-        hasSnapshot: boolean;
-        inlinedAllStylesheets: boolean;
     };
-    /**
-     * Returns time-corrected events. If the events were correctable from the beginning, this correction will have already been applied.
-     * @param {SessionReplayEvent[]} events The array of buffered SR nodes
-     * @returns {CorrectedSessionReplayEvent[]}
-     */
-    returnCorrectTimestamps(events: SessionReplayEvent[]): CorrectedSessionReplayEvent[];
     /** Clears the buffer (this.#events), and resets all payload metadata properties */
     clearBuffer(): void;
     /** Begin recording using configured recording lib */

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":"AAWA;IAUE,yBAkBC;IAdC,iEAAiE;IACjE,mBAAsB;IACtB,6DAA6D;IAC7D,oCAAuC;IACvC,kIAAkI;IAClI,kBAAqB;IACrB,sDAAsD;IACtD,YAAoB;IACpB,oEAAoE;IACpE,6BAAqH;IACrH,0FAA0F;IAC1F,eAA6C;IAC7C,uIAAuI;IACvI,0BAAyE;IAG3E;;;;;;;;;;;;;;;;;;;MAiBC;IAED;;;;OAIG;IACH,gCAHW,oBAAoB,GAClB,6BAA6B,CAOzC;IAED,mFAAmF;IACnF,oBAKC;IAED,qDAAqD;IACrD,uBAwBC;IAED;;;;;OAKG;IACH,yCA0BC;IAED,0HAA0H;IAC1H,yCA+CC;IAED,0HAA0H;IAC1H,yBAOC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED;;;SAGK;IACL,oCAGC;;CACF;+BAvN8B,mBAAmB"}
+{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder.js"],"names":[],"mappings":"AAYA;IAUE,yBAkBC;IAdC,iEAAiE;IACjE,mBAAsB;IACtB,6DAA6D;IAC7D,oCAAuC;IACvC,kIAAkI;IAClI,kBAAqB;IACrB,sDAAsD;IACtD,YAAoB;IACpB,oEAAoE;IACpE,6BAAqH;IACrH,0FAA0F;IAC1F,eAA6C;IAC7C,uIAAuI;IACvI,0BAAyE;IAG3E;;;;;;;;;MAYC;IAED,mFAAmF;IACnF,oBAKC;IAED,qDAAqD;IACrD,uBAiCC;IAED;;;;;OAKG;IACH,yCA0BC;IAED,0HAA0H;IAC1H,yCAgDC;IAED,0HAA0H;IAC1H,yBAOC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED;;;SAGK;IACL,oCAGC;;CACF;+BAjN8B,mBAAmB"}

package/dist/types/features/session_replay/shared/utils.d.ts

@@ -1,4 +1,12 @@
 export function isPreloadAllowed(agentId: any): any;
 export function canImportReplayAgg(agentId: any, sessionMgr: any): boolean;
+export function buildNRMetaNode(timestamp: any, timeKeeper: any): {
+    originalTimestamp: any;
+    correctedTimestamp: any;
+    timestampDiff: number;
+    timeKeeperOriginTime: any;
+    timeKeeperCorrectedOriginTime: any;
+    timeKeeperDiff: number;
+};
 export function enableSessionTracking(agentId: any): boolean;
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/utils.js"],"names":[],"mappings":"AAWA,oDAEC;AAED,2EAGC;AAfM,6DAA+H"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/utils.js"],"names":[],"mappings":"AAWA,oDAEC;AAED,2EAGC;AAED;;;;;;;EAUC;AA3BM,6DAA+H"}

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

@@ -3,10 +3,11 @@ export class Aggregate extends AggregateBase {
     constructor(agentIdentifier: any, aggregator: any, argsObj: any);
     agentRuntime: any;
     resourceObserver: any;
-    ptid: string | undefined;
+    ptid: any;
     trace: {} | undefined;
     nodeCount: number | undefined;
     sentTrace: {} | null | undefined;
+    everSent: boolean | undefined;
     harvestTimeSeconds: any;
     maxNodesPerHarvest: any;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_trace/aggregate/index.js"],"names":[],"mappings":"AAiCA;IACE,2BAAiC;IAGjC,iEA4IC;IA1IC,kBAA+C;IAK/C,sBAAiD;IACjD,yBAAc;IACd,sBAAe;IACf,8BAAkB;IAClB,iCAAqB;IACrB,wBAA0G;IAC1G,wBAA4G;IAC5G;;4EAEwE;IACxE,kCAAyB;IAGzB,0CAAsC;IA0HxC,sEAcC;IA6CD,oDAOC;IAGD,oCAwBC;IAGD,uEAkBC;IAED,oDAKC;IAED,wBAwBC;IAED,uCAuBC;IAGD,gDASC;IAID,qCAkBC;IAGD,qEAUC;IAGD,mEAUC;IAGD,yBAeC;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAsBlB;IAGD;;;;;;;YAkCM;0GAC8F;;YAE9F;0FAC8E;;YAE9E,4IAA4I;;;;;;MAMjJ;IAED,mEA6BC;;CACF;8BA9gB6B,4BAA4B;6BAF7B,2BAA2B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_trace/aggregate/index.js"],"names":[],"mappings":"AAiCA;IACE,2BAAiC;IAGjC,iEA6IC;IA3IC,kBAA+C;IAK/C,sBAAiD;IACjD,UAAkC;IAClC,sBAAe;IACf,8BAAkB;IAClB,iCAAqB;IACrB,8BAAqB;IACrB,wBAA0G;IAC1G,wBAA4G;IAC5G;;4EAEwE;IACxE,kCAAyB;IAGzB,0CAAsC;IA0HxC,sEAcC;IA8CD,oDAOC;IAGD,oCAwBC;IAGD,uEAkBC;IAED,oDAKC;IAED,wBAwBC;IAED,uCAuBC;IAGD,gDASC;IAID,qCAkBC;IAGD,qEAUC;IAGD,mEAUC;IAGD,yBAeC;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAsBlB;IAGD;;;;;;;YAkCM;0GAC8F;;YAE9F;0FAC8E;;YAE9E,4IAA4I;;;;;;MAMjJ;IAED,mEA6BC;;CACF;8BAhhB6B,4BAA4B;6BAF7B,2BAA2B"}

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

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/api.js"],"names":[],"mappings":"AAkBA,2CAeC;AAED;;;;IAiDE;;;;OAIG;qBAFQ,MAAM;IAWjB;;;;OAIG;iCAFQ,MAAM,GAAC,IAAI;;;;;EA0GvB"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/api.js"],"names":[],"mappings":"AAmBA,2CAeC;AAID;;;;IAuDE;;;;OAIG;qBAFQ,MAAM;IAWjB;;;;OAIG;iCAFQ,MAAM,GAAC,IAAI;;;;;EA0GvB"}

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

@@ -1 +1 @@
-{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../../../../src/loaders/configure/configure.js"],"names":[],"mappings":"AASA;;GAEG;AACH,oGA+CC"}
+{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../../../../src/loaders/configure/configure.js"],"names":[],"mappings":"AASA;;GAEG;AACH,oGAgDC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.255.0",
+  "version": "1.256.0",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",
@@ -168,7 +168,7 @@
   "dependencies": {
     "core-js": "^3.26.0",
     "fflate": "^0.7.4",
-    "rrweb": "2.0.0-alpha.11",
+    "rrweb": "2.0.0-alpha.12",
     "web-vitals": "^3.1.0"
   },
   "devDependencies": {

package/src/common/constants/runtime.js

@@ -74,4 +74,4 @@ export const isIE = Boolean(isBrowserScope && window.document.documentMode) // d
 
 export const supportsSendBeacon = !!globalScope.navigator?.sendBeacon
 
-export const offset = Math.floor(globalScope?.performance?.timeOrigin || globalScope?.performance?.timing?.navigationStart || Date.now())
+export const offset = Math.floor(Date.now() - performance.now())

package/src/common/harvest/harvest.js

@@ -145,7 +145,7 @@ export class Harvest extends SharedContext {
       result.addEventListener('loadend', function () {
         // `this` refers to the XHR object in this scope, do not change this to a fat arrow
         // status 0 refers to a local error, such as CORS or network failure, or a blocked request by the browser (e.g. adblocker)
-        const cbResult = { sent: this.status !== 0, status: this.status, xhr: this, fullUrl }
+        const cbResult = { sent: this.status !== 0, status: this.status, failed: this.status === 0 || this.status >= 400, xhr: this, fullUrl }
         if (this.status === 429) {
           cbResult.retry = true
           cbResult.delay = harvestScope.tooManyRequestsDelay

package/src/common/session/session-entity.js

@@ -117,7 +117,8 @@ export class SessionEntity {
           this.write(getModeledObject(this.state, model))
         },
         ee: this.ee,
-        refreshEvents: ['click', 'keydown', 'scroll']
+        refreshEvents: ['click', 'keydown', 'scroll'],
+        readStorage: () => this.storage.get(this.lookupKey)
       }, this.state.inactiveAt - Date.now())
     } else {
       this.state.inactiveAt = Infinity

package/src/common/timer/interaction-timer.js

@@ -10,6 +10,9 @@ export class InteractionTimer extends Timer {
     this.onRefresh = typeof opts.onRefresh === 'function' ? opts.onRefresh : () => { /* noop */ }
     this.onResume = typeof opts.onResume === 'function' ? opts.onResume : () => { /* noop */ }
 
+    /** used to double-check LS state at resume time */
+    this.readStorage = opts.readStorage
+
     // used by pause/resume
     this.remainingMs = undefined
 
@@ -67,8 +70,20 @@ export class InteractionTimer extends Timer {
   }
 
   resume () {
-    this.refresh()
-    this.onResume() // emit resume event after state updated
+    try {
+      const lsData = this.readStorage()
+      const obj = typeof lsData === 'string' ? JSON.parse(lsData) : lsData
+      if (isExpired(obj.expiresAt) || isExpired(obj.inactiveAt)) this.end()
+      else {
+        this.refresh()
+        this.onResume() // emit resume event after state updated
+      }
+    } catch (err) {
+      this.end()
+    }
+    function isExpired (timestamp) {
+      return Date.now() > timestamp
+    }
   }
 
   refresh (cb, ms) {