@newrelic/browser-agent 1.317.0 → 1.318.0-rc.0

package/dist/cjs/common/v2/mfe-vitals.js

@@ -0,0 +1,303 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.trackMFEVitals = trackMFEVitals;
+var _runtime = require("../constants/runtime");
+var _now = require("../timing/now");
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @typedef {import('./register-api-types').RegisterAPITimings} RegisterAPITimings
+ */
+
+const isObservable = node => {
+  try {
+    return node?.textContent?.trim() || ['img', 'video', 'canvas', 'svg'].includes(node?.nodeName?.toLowerCase());
+  } catch (e) {
+    return false;
+  }
+};
+
+/**
+ * Check if node is within a specific MFE
+ * @param {Node} node - DOM node to check
+ * @param {string} id - MFE ID to match
+ * @returns {boolean}
+ */
+const isInMFE = (node, id) => {
+  if (!node || !id) return false;
+  try {
+    let curr = node.nodeType === 1 ? node : node.parentElement;
+    while (curr?.tagName) {
+      if (curr.dataset?.nrMfeId === id) return true;
+      curr = curr.parentNode;
+    }
+  } catch (e) {}
+  return false;
+};
+
+/**
+ * Create mutation observer for MFE nodes
+ * @param {string} id - MFE ID to track
+ * @param {Function} onMatch - Callback when matching node is *added*
+ * @returns {MutationObserver}
+ */
+const observeMutations = (id, onMatch) => {
+  // Try to find existing MFE root
+  const mfeRoot = _runtime.globalScope.document?.querySelector("[data-nr-mfe-id=\"".concat(id, "\"]"));
+  let observingRoot = !!mfeRoot;
+  const obs = new _runtime.globalScope.MutationObserver(mutations => {
+    mutations.forEach(m => {
+      m.addedNodes.forEach(node => {
+        // Check if this is the MFE root being added
+        const elem = node.nodeType === 1 ? node : null;
+        if (elem?.dataset?.nrMfeId === id) {
+          // Found the root! Lets switch to observing just this subtree for performance reasons
+          obs.disconnect();
+          obs.observe(elem, {
+            childList: true,
+            subtree: true
+          });
+          observingRoot = true;
+        }
+
+        // Only check isInMFE if we're observing the whole document; skip expensive ancestor walk when observing root
+        if (isObservable(node) && (observingRoot || isInMFE(node, id))) {
+          onMatch(node, obs);
+        }
+      });
+    });
+  });
+
+  // If root exists, observe just that subtree; otherwise observe document to catch when root is added
+  obs.observe(mfeRoot || _runtime.globalScope.document, {
+    childList: true,
+    subtree: true
+  });
+  return obs;
+};
+
+/**
+ * Create performance observer for MFE entries
+ * @param {Array} observers - Array to track observers
+ * @param {Object} config - Observer configuration
+ * @param {Function} onEntry - Callback for each entry
+ * @returns {PerformanceObserver|null} Observer if successful, null if unsupported
+ */
+const observePerformance = (observers, config, onEntry) => {
+  try {
+    const obs = new _runtime.globalScope.PerformanceObserver(list => {
+      list.getEntries().forEach(onEntry);
+    });
+    obs.observe(config);
+    observers.push(obs);
+    return obs;
+  } catch (e) {
+    return null;
+  }
+};
+
+/**
+ * Tracks all Core Web Vitals for a specific MFE.
+ * @param {string} id - The MFE ID to track
+ * @returns {{fcp: object|null, lcp: object|null, cls: object|null, inp: object|null, disconnect: Function}}
+ */
+function trackMFEVitals(id, timings) {
+  let fcpObservedAt = null;
+  let lcpObservedAt = null;
+  const getTimeRelativeToScriptStart = capturedAt => {
+    if (capturedAt === null) return null;
+    return capturedAt - (timings?.scriptStart || timings?.registeredAt || 0);
+  };
+  const vitals = {
+    fcp: {
+      get value() {
+        return getTimeRelativeToScriptStart(fcpObservedAt);
+      }
+    },
+    lcp: {
+      get value() {
+        return getTimeRelativeToScriptStart(lcpObservedAt);
+      }
+    },
+    cls: {
+      value: null
+    },
+    inp: {
+      value: null
+    },
+    disconnect: () => {}
+  };
+  if (!id || !_runtime.isBrowserScope || !_runtime.globalScope.MutationObserver || !_runtime.globalScope.PerformanceObserver) return vitals;
+  const observers = [];
+  const populateVitalMinimums = () => {
+    fcpObservedAt ??= (0, _now.now)();
+    lcpObservedAt ??= (0, _now.now)();
+    vitals.cls.value ??= 0;
+  };
+
+  // if the MFE has already rendered something on the page before we could set up listeners, just populate vital minimums immediately
+  if (_runtime.globalScope.document?.querySelector("[data-nr-mfe-id=\"".concat(id, "\"]"))) populateVitalMinimums();
+
+  // Track FCP - first contentful paint
+  observeMutations(id, (_, obs) => {
+    // An observed "FCP" means _something_ rendered, so at minimum we can populate all the baseline values for the vitals
+    populateVitalMinimums();
+    obs.disconnect();
+  });
+
+  // Track LCP - largest contentful paint
+  let largestSize = 0;
+  let resizeObs = null;
+  const observedElements = new Set();
+  try {
+    resizeObs = new _runtime.globalScope.ResizeObserver(entries => {
+      entries.forEach(entry => {
+        try {
+          const size = entry.contentRect.width * entry.contentRect.height;
+          if (size > largestSize) {
+            largestSize = size;
+            lcpObservedAt = (0, _now.now)();
+          }
+          resizeObs.unobserve(entry.target);
+        } catch (e) {
+          // Element may be detached from DOM
+        }
+      });
+    });
+  } catch (e) {
+    // ResizeObserver not supported
+  }
+  const lcpObs = observeMutations(id, node => {
+    // an observed "LCP" means _something_ rendered, so at minimum we can make sure all the baseline values are populated for the vitals
+    populateVitalMinimums();
+    if (resizeObs) {
+      try {
+        const elem = node.nodeType === 1 ? node : node.parentElement;
+        if (elem && !observedElements.has(elem)) {
+          observedElements.add(elem);
+
+          // For media elements, wait for content to load before observing size
+          if (elem.tagName === 'IMG') {
+            if (elem.complete) {
+              resizeObs.observe(elem);
+            } else {
+              elem.addEventListener('load', () => {
+                resizeObs.observe(elem);
+              }, {
+                once: true
+              });
+            }
+          } else if (elem.tagName === 'VIDEO') {
+            // For video, wait for first frame (HAVE_CURRENT_DATA = 2)
+            if (elem.readyState >= 2) {
+              resizeObs.observe(elem);
+            } else {
+              elem.addEventListener('loadeddata', () => {
+                resizeObs.observe(elem);
+              }, {
+                once: true
+              });
+            }
+          } else {
+            // For other elements, observe immediately
+            resizeObs.observe(elem);
+          }
+        }
+      } catch (e) {
+        // Element may not be observable
+      }
+    }
+  });
+  if (resizeObs) observers.push(resizeObs);
+  observers.push(lcpObs);
+
+  // Track CLS - cumulative layout shift
+  // Initialize CLS to 0 if browser supports it
+  observePerformance(observers, {
+    type: 'layout-shift',
+    buffered: true
+  }, entry => {
+    if (entry.hadRecentInput) return;
+    (entry.sources || []).some(source => {
+      if (isInMFE(source.node, id)) {
+        // an observed "CLS" means _something_ rendered for the MFE, so at minimum we can make sure all the baseline values are populated for the vitals
+        populateVitalMinimums();
+        vitals.cls.value += entry.value;
+        return true;
+      }
+      return false;
+    });
+  });
+
+  // Track INP - interaction to next paint
+  observePerformance(observers, {
+    type: 'event',
+    buffered: true,
+    durationThreshold: 40
+  }, entry => {
+    if (!entry.interactionId || !isInMFE(entry.target, id)) return;
+    if (vitals.inp.value === null || entry.duration > vitals.inp.value) {
+      // an observed "INP" means _something_ rendered for the MFE, so at minimum we can make sure all the baseline values are populated for the vitals
+      populateVitalMinimums();
+      vitals.inp.value = entry.duration;
+    }
+  });
+  const interactionEvents = ['pointerdown', 'keydown'];
+  const disconnectInteractionListeners = () => {
+    interactionEvents.forEach(type => {
+      _runtime.globalScope.removeEventListener(type, handleInteraction, {
+        passive: true
+      });
+    });
+  };
+
+  // Disconnect all observers
+  vitals.disconnect = () => {
+    // Disconnect all observers
+    observers.forEach(obs => {
+      try {
+        obs?.disconnect();
+      } catch (e) {
+        // Observer may already be disconnected
+      }
+    });
+    disconnectInteractionListeners();
+  };
+
+  // Auto-disconnect LCP observer on user interaction (per Web Vitals spec)
+  // CLS and INP continue tracking until visibility change or deregister
+  const disconnectLCP = () => {
+    try {
+      lcpObs?.disconnect();
+      resizeObs?.disconnect();
+    } catch (e) {
+      // Observer may already be disconnected
+    }
+  };
+  const handleInteraction = event => {
+    if (!isInMFE(event?.target, id)) return;
+    disconnectLCP();
+    disconnectInteractionListeners();
+  };
+  interactionEvents.forEach(type => {
+    _runtime.globalScope.addEventListener(type, handleInteraction, {
+      passive: true
+    });
+  })
+
+  // Disconnect all observers on visibility change or page unload
+;
+  ['visibilitychange', 'pagehide'].forEach(type => {
+    _runtime.globalScope.addEventListener(type, vitals.disconnect, {
+      once: true,
+      passive: true
+    });
+  });
+  return vitals;
+}

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

@@ -261,7 +261,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
         };
         this.addEvent(event, target);
       }, this.featureName, this.ee);
-      if (agentRef.init.feature_flags.includes('websockets')) {
+      if (agentRef.init.feature_flags.includes('websockets') || agentRef.init.web_sockets?.enabled) {
         (0, _registerHandler.registerHandler)('ws-complete', nrData => {
           const event = {
             ...nrData,

package/dist/cjs/features/generic_events/instrument/index.js

@@ -30,7 +30,7 @@ class Instrument extends _instrumentBase.InstrumentBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, _constants.FEATURE_NAME);
-    const websocketsEnabled = agentRef.init.feature_flags.includes('websockets');
+    const websocketsEnabled = agentRef.init.feature_flags.includes('websockets') || agentRef.init.web_sockets?.enabled;
     const securityPolicyViolationEnabled = !agentRef.init.feature_flags.includes('no_spv');
 
     /** config values that gate whether the generic events aggregator should be imported at all */

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

@@ -61,7 +61,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       }; // likewise, don't want to overwrite the mode if it was set already
       const session = this.agentRef.runtime.session;
       if ((0, _featureGates.canEnableSessionTracking)(agentRef.init) && session) {
-        if (session.isNew) this.#syncWithSessionManager();else updateLocalLoggingMode(session.state.loggingMode, session.state.logApiMode);
+        if (session.state.loggingMode === null || session.state.logApiMode === null) this.#writeToStorage(this.loggingMode);else updateLocalLoggingMode(session.state.loggingMode, session.state.logApiMode);
       }
       if (this.loggingMode.auto === _constants.LOGGING_MODE.OFF && this.loggingMode.api === _constants.LOGGING_MODE.OFF) {
         this.blocked = true;
@@ -169,13 +169,13 @@ class Aggregate extends _aggregateBase.AggregateBase {
       auto: _constants.LOGGING_MODE.OFF,
       api: _constants.LOGGING_MODE.OFF
     };
-    this.#syncWithSessionManager();
+    this.#writeToStorage(this.loggingMode);
     this.deregisterDrain();
   }
-  #syncWithSessionManager() {
+  #writeToStorage(logModes) {
     this.agentRef.runtime.session?.write({
-      loggingMode: this.loggingMode.auto,
-      logApiMode: this.loggingMode.api
+      loggingMode: logModes.auto,
+      logApiMode: logModes.api
     });
   }
 }

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

@@ -17,8 +17,9 @@ var _firstPaint = require("../../../common/vitals/first-paint");
 var _timeToFirstByte = require("../../../common/vitals/time-to-first-byte");
 var _now = require("../../../common/timing/now");
 var _timeKeeper = require("../../../common/timing/time-keeper");
+var _send = require("../../../common/harvest/send");
+var _featureGates = require("../../utils/feature-gates");
 var _obfuscate = require("../../../common/util/obfuscate");
-var _harvester = require("../../../common/harvest/harvester");
 var _features = require("../../../loaders/features/features");
 var _submitData = require("../../../common/util/submit-data");
 var _webdriverDetection = require("../../../common/util/webdriver-detection");
@@ -33,6 +34,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = CONSTANTS.FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, CONSTANTS.FEATURE_NAME);
+    this.isSessionTrackingEnabled = (0, _featureGates.canEnableSessionTracking)(agentRef.init) && !!agentRef.runtime.session;
     this.sentRum = false; // flag to facilitate calling sendRum() once externally (by the consent API in agent-session.js)
 
     this.timeToFirstByte = 0;
@@ -44,6 +46,19 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.obfuscator = new _obfuscate.Obfuscator(agentRef, _events.EVENT_TYPES.PVE);
     agentRef.runtime.timeKeeper = new _timeKeeper.TimeKeeper(agentRef.runtime.session);
     if (_runtime.isBrowserScope) {
+      const cached = this.isSessionTrackingEnabled && agentRef.runtime.session?.state.cachedRumResponse;
+      if (cached) {
+        const {
+          app: cachedApp,
+          ...cachedFlags
+        } = cached;
+
+        // set the agent runtime objects that require the rum response or entity guid
+        if (!Object.keys(this.agentRef.runtime.appMetadata).length) agentRef.runtime.appMetadata = cachedApp;
+        this.drain();
+        agentRef.runtime.harvester.startTimer();
+        (0, _featureFlags.activateFeatures)(cachedFlags, agentRef);
+      }
       _timeToFirstByte.timeToFirstByte.subscribe(({
         value,
         attrs
@@ -88,8 +103,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       ua: info.userAttributes,
       at: info.atts
     };
-    if (this.agentRef.runtime.session) queryParameters.fsh = Number(this.agentRef.runtime.session.isNew); // "first session harvest" aka RUM request or PageView event of a session
-
+    if (this.agentRef.runtime.session) queryParameters.fsh = Number(!this.agentRef.runtime.session.state.cachedRumResponse);
     let body = this.obfuscator.traverseAndObfuscateEvents({
       ja: {
         ...customAttributes,
@@ -143,6 +157,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
   }) {
     const rumEndTime = (0, _now.now)();
     let app, flags;
+    const hasCachedRumResponse = !!this.agentRef.runtime.session?.state.cachedRumResponse;
     try {
       ({
         app,
@@ -152,10 +167,20 @@ class Aggregate extends _aggregateBase.AggregateBase {
       // wont set entity stuff here, if main agent will later abort, if registered agent, nothing will happen
       (0, _console.warn)(53, error);
     }
+    const shouldCacheResponse = this.isSessionTrackingEnabled && !hasCachedRumResponse && !!app;
+    if (hasCachedRumResponse) {
+      let {
+        app: cachedApp,
+        ...cachedFlags
+      } = this.agentRef.runtime.session.state.cachedRumResponse;
+      app ??= cachedApp;
+      flags = cachedFlags;
+    }
     super.postHarvestCleanup({
       sent,
-      retry
+      retry: retry && !hasCachedRumResponse
     }); // this will set isRetrying & re-buffer the body if request is to be retried
+
     if (this.isRetrying && this.retries++ < 1) {
       // Only retry once
       setTimeout(() => this.agentRef.runtime.harvester.triggerHarvestFor(this, {
@@ -165,7 +190,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
     if (status >= 400 || status === 0) {
       (0, _console.warn)(18, status);
-      this.blocked = true;
 
       // Get estimated payload size of our backlog
       const textEncoder = new TextEncoder();
@@ -176,15 +200,24 @@ class Aggregate extends _aggregateBase.AggregateBase {
       }, 0);
       const BCSError = 'BCS/Error/';
       // Send SMs about failed RUM request
-      const body = {
-        sm: [{
-          params: {
-            name: BCSError + status
-          },
-          stats: {
-            c: 1
-          }
-        }, {
+      const sm = [{
+        params: {
+          name: BCSError + status
+        },
+        stats: {
+          c: 1
+        }
+      }, {
+        params: {
+          name: BCSError + 'Duration/Ms'
+        },
+        stats: {
+          c: 1,
+          t: rumEndTime - this.rumStartTime
+        }
+      }];
+      if (!hasCachedRumResponse) {
+        sm.push({
           params: {
             name: BCSError + 'Dropped/Bytes'
           },
@@ -192,28 +225,30 @@ class Aggregate extends _aggregateBase.AggregateBase {
             c: 1,
             t: payloadSize
           }
-        }, {
-          params: {
-            name: BCSError + 'Duration/Ms'
-          },
-          stats: {
-            c: 1,
-            t: rumEndTime - this.rumStartTime
-          }
-        }]
-      };
-      (0, _harvester.send)(this.agentRef, {
+        });
+      }
+      (0, _send.send)(this.agentRef, {
         endpoint: _features.FEATURE_TO_ENDPOINT[_features.FEATURE_NAMES.metrics],
         payload: {
-          body
+          body: {
+            sm
+          }
         },
         submitMethod: (0, _submitData.getSubmitMethod)(),
         featureName: _features.FEATURE_NAMES.metrics
       });
-
-      // Adding retry logic for the rum call will be a separate change; this.blocked will need to be changed since that prevents another triggerHarvestFor()
-      this.ee.abort();
-      return;
+      if (!hasCachedRumResponse) {
+        this.blocked = true;
+        this.ee.abort();
+        return;
+      }
+    } else if (shouldCacheResponse) {
+      this.agentRef.runtime.session.write({
+        cachedRumResponse: {
+          app,
+          ...flags
+        }
+      });
     }
     try {
       const wasReady = this.agentRef.runtime.timeKeeper.ready;

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

@@ -30,7 +30,7 @@ function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r
  */
 class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
-  mode = _constants2.MODE.OFF;
+  mode = null;
 
   // pass the recorder into the aggregator
   constructor(agentRef, args) {
@@ -75,7 +75,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       if (!this.recorder) return;
       // if the mode changed on a different tab, it needs to update this instance to match
       this.mode = agentRef.runtime.session.state.sessionReplayMode;
-      if (!this.initialized || this.mode === _constants2.MODE.OFF) return;
+      if (!this.initialized || this.mode === _constants2.MODE.OFF || !this.mode) return;
       this.recorder?.startRecording(_constants.TRIGGERS.RESUME, this.mode);
     });
     this.ee.on(_constants2.SESSION_EVENTS.UPDATE, (type, data) => {
@@ -102,6 +102,10 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.waitForFlags(['srs', 'sr']).then(([srMode, entitled]) => {
       this.entitled = !!entitled;
       if (!this.entitled) {
+        this.mode = _constants2.MODE.OFF;
+        this.#writeToStorage({
+          sessionReplayMode: this.mode
+        });
         this.deregisterDrain();
         if (this.agentRef.runtime.isRecording) {
           this.abort(_constants.ABORT_REASONS.ENTITLEMENTS);
@@ -113,7 +117,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
         this.drain();
       });
     }).then(() => {
-      if (this.mode === _constants2.MODE.OFF) {
+      if (!this.mode) {
         this.recorder?.stopRecording(); // stop any conservative preload recording launched by instrument
         while (this.recorder?.getEvents().events.length) this.recorder?.clearBuffer?.();
       }
@@ -146,7 +150,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     // if the error was noticed AFTER the recorder was already imported....
     if (this.recorder && this.initialized) {
       if (!this.agentRef.runtime.isRecording) this.recorder.startRecording(_constants.TRIGGERS.SWITCH_TO_FULL, this.mode); // off --> full
-      this.syncWithSessionManager({
+      this.#writeToStorage({
         sessionReplayMode: this.mode
       });
     } else {
@@ -178,35 +182,35 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.timeKeeper = timeKeeper;
     if (this.recorder?.trigger === _constants.TRIGGERS.API && this.agentRef.runtime.isRecording) {
       this.mode = _constants2.MODE.FULL;
-    } else if (!session.isNew && !ignoreSession) {
+    } else if (session.state.sessionReplayMode !== null && !ignoreSession) {
       // inherit the mode of the existing session
       this.mode = session.state.sessionReplayMode;
     } else {
       // The session is new... determine the mode the new session should start in
       this.mode = srMode;
     }
-    // If off, then don't record (early return)
-    if (this.mode === _constants2.MODE.OFF) return;
-    try {
-      /** will return a recorder instance if already imported, otherwise, will fetch the recorder and initialize it */
-      this.recorder ??= await this.instrumentClass.importRecorder();
-    } catch (err) {
-      /** if the recorder fails to import, abort the feature */
-      return this.abort(_constants.ABORT_REASONS.IMPORT, err);
-    }
+    if (this.mode !== _constants2.MODE.OFF) {
+      try {
+        /** will return a recorder instance if already imported, otherwise, will fetch the recorder and initialize it */
+        this.recorder ??= await this.instrumentClass.importRecorder();
+      } catch (err) {
+        /** if the recorder fails to import, abort the feature */
+        return this.abort(_constants.ABORT_REASONS.IMPORT, err);
+      }
 
-    // If an error was noticed before the mode could be set (like in the early lifecycle of the page), immediately set to FULL mode
-    if (this.mode === _constants2.MODE.ERROR && this.instrumentClass.errorNoticed) {
-      this.mode = _constants2.MODE.FULL;
-    }
+      // If an error was noticed before the mode could be set (like in the early lifecycle of the page), immediately set to FULL mode
+      if (this.mode === _constants2.MODE.ERROR && this.instrumentClass.errorNoticed) {
+        this.mode = _constants2.MODE.FULL;
+      }
 
-    // FULL mode records AND reports from the beginning, while ERROR mode only records (but does not report).
-    // ERROR mode will do this until an error is thrown, and then switch into FULL mode.
-    // The makeHarvestPayload should ensure that no payload is returned if we're not in FULL mode...
+      // FULL mode records AND reports from the beginning, while ERROR mode only records (but does not report).
+      // ERROR mode will do this until an error is thrown, and then switch into FULL mode.
+      // The makeHarvestPayload should ensure that no payload is returned if we're not in FULL mode...
 
-    await this.prepUtils();
-    if (!this.agentRef.runtime.isRecording) this.recorder.startRecording(trigger, this.mode);
-    this.syncWithSessionManager({
+      await this.prepUtils();
+      if (!this.agentRef.runtime.isRecording) this.recorder.startRecording(trigger, this.mode);
+    }
+    this.#writeToStorage({
       sessionReplayMode: this.mode
     });
   }
@@ -253,7 +257,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       this.abort(_constants.ABORT_REASONS.TOO_BIG, len);
       return;
     }
-    if (!this.agentRef.runtime.session.state.sessionReplaySentFirstChunk) this.syncWithSessionManager({
+    if (!this.agentRef.runtime.session.state.sessionReplaySentFirstChunk) this.#writeToStorage({
       sessionReplaySentFirstChunk: true
     });
     this.recorder.clearBuffer();
@@ -382,7 +386,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     if (forceHarvest) this.agentRef.runtime.harvester.triggerHarvestFor(this);
     this.mode = _constants2.MODE.OFF;
     this.recorder?.stopRecording?.();
-    this.syncWithSessionManager({
+    this.#writeToStorage({
       sessionReplayMode: this.mode
     });
   }
@@ -394,13 +398,13 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.blocked = true;
     this.mode = _constants2.MODE.OFF;
     this.recorder?.stopRecording?.();
-    this.syncWithSessionManager({
+    this.#writeToStorage({
       sessionReplayMode: this.mode
     });
     this.recorder?.clearTimestamps?.();
     while (this.recorder?.getEvents().events.length) this.recorder?.clearBuffer?.();
   }
-  syncWithSessionManager(state = {}) {
+  #writeToStorage(state = {}) {
     if (this.isSessionTrackingEnabled) {
       this.agentRef.runtime.session.write(state);
     }