@newrelic/browser-agent 1.323.0 → 1.324.0-rc.1

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

@@ -16,7 +16,7 @@ import { canCapturePayload, isLikelyHumanReadable, parseQueryString, createStrin
 import { Obfuscator } from '../../../common/util/obfuscate';
 import { getVersion2Attributes, getVersion2DuplicationAttributes, shouldDuplicate, isMfeTarget } from '../../../common/v2/utils';
 import { EVENT_TYPES } from '../../../common/constants/events';
-import { generateUuid } from '../../../common/ids/unique-id';
+import { generateSpanId, generateTraceId, generateUuid } from '../../../common/ids/unique-id';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef) {
@@ -126,10 +126,23 @@ export class Aggregate extends AggregateBase {
         ...event,
         targetAttributes: getVersion2Attributes(target, this)
       });
-      if (shouldDuplicate(target, this)) this.reportContainerEvent({
-        ...event,
-        targetAttributes: getVersion2DuplicationAttributes(target, this)
-      }, ctx);
+      if (shouldDuplicate(target, this)) {
+        const duplicateEvent = {
+          ...event,
+          targetAttributes: getVersion2DuplicationAttributes(target, this)
+        };
+        /** the container-duplicate copy represents the same single real HTTP call as the MFE event above, so it
+         * needs its own independent trace/span identity -- otherwise the two would collide on the same
+         * spanId/traceId, and BELC could not create two separate Spans/Traces from them. Only the id namespace is
+         * independent; spanTimestamp is intentionally left as-is (event.spanTimestamp), since it still reflects the
+         * real call's actual timing. When `event.spanId` was never set (e.g. distributed tracing is disabled), there
+         * is no span identity to duplicate either -- both copies correctly end up with no spanId/traceId. */
+        if (event.spanId) {
+          duplicateEvent.spanId = generateSpanId();
+          duplicateEvent.traceId = generateTraceId();
+        }
+        this.reportContainerEvent(duplicateEvent, ctx);
+      }
     } else {
       this.reportContainerEvent(event, ctx);
     }

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

@@ -21,6 +21,7 @@ import { getRegisteredTargetsFromFilename, getVersion2Attributes, getVersion2Dup
 import { buildCauseString } from './cause-string';
 import { ShortCircuit } from '../../../common/util/short-circuit';
 import { EVENT_TYPES } from '../../../common/constants/events';
+import { SESSION_EVENTS, SESSION_EVENT_TYPES } from '../../../common/session/constants';
 
 /**
  * @typedef {import('./compute-stack-trace.js').StackInfo} StackInfo
@@ -45,6 +46,27 @@ export class Aggregate extends AggregateBase {
     register('ierr', this.processError.bind(this), this.featureName, this.ee);
     register('returnJserror', (jsErrorEvent, softNavAttrs) => this.#storeJserrorForHarvest(jsErrorEvent, softNavAttrs), this.featureName, this.ee);
 
+    /*
+     * The backend only remembers a stack trace for as long as the session that first reported it.
+     * The SessionEntity emits SESSION_EVENTS.RESET whenever the session expires (max duration or
+     * inactivity) or is otherwise reset, which is the same boundary the backend uses to forget
+     * previously-seen stack hashes. Forget them here too, so the next occurrence of an
+     * already-seen error resends its full stack_trace once, instead of a browser_stack_hash the
+     * backend can no longer resolve.
+     */
+    const forgetReportedStacks = () => {
+      this.stackReported = {};
+      this.observedAt = {};
+    };
+    let currentSessionId = this.agentRef.runtime.session?.state?.value;
+    this.ee.on(SESSION_EVENTS.RESET, forgetReportedStacks);
+    this.ee.on(SESSION_EVENTS.UPDATE, (type, data) => {
+      if (!data?.value) return;
+      /* A reset in another tab arrived as a cross-tab update carrying a new session id. */
+      if (type === SESSION_EVENT_TYPES.CROSS_TAB && currentSessionId && data.value !== currentSessionId) forgetReportedStacks();
+      currentSessionId = data.value; // also tracks same-tab writes, so a local reset's new id is picked up
+    });
+
     // 0 == off, 1 == on
     this.waitForFlags(['err']).then(([errFlag]) => {
       if (errFlag) {

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

@@ -9,8 +9,9 @@ import { EventBuffer } from './event-buffer';
 import { handle } from '../../common/event-emitter/handle';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../metrics/constants';
 import { EventAggregator } from '../../common/aggregate/event-aggregator';
-import { MAX_PAYLOAD_SIZE, IDEAL_PAYLOAD_SIZE, SUPPORTS_REGISTERED_ENTITIES } from '../../common/constants/agent-constants';
+import { MAX_PAYLOAD_SIZE, IDEAL_PAYLOAD_SIZE, MIN_EARLY_HARVEST_INTERVAL, EARLY_HARVEST_BYPASS_SIZE, SUPPORTS_REGISTERED_ENTITIES } from '../../common/constants/agent-constants';
 import { warn } from '../../common/util/console';
+import { now } from '../../common/timing/now';
 export class AggregateBase extends FeatureBase {
   /**
    * Create an AggregateBase instance.
@@ -26,6 +27,8 @@ export class AggregateBase extends FeatureBase {
     this.canHarvestEarly = true;
     /** @type {Boolean} indicates if the feature is actively in a retry deferral period */
     this.isRetrying = false;
+    /** @type {number|undefined} the timestamp (ms, relative to page start) of the last early harvest triggered by this feature, if any */
+    this.lastEarlyHarvestAt = undefined;
     this.harvestOpts = {}; // features aggregate classes can define custom opts for when their harvest is called
 
     this.#setupEventStore();
@@ -81,13 +84,19 @@ export class AggregateBase extends FeatureBase {
 
   /**
    * Evaluates whether a harvest should be made early by estimating the size of the current payload.  Currently, this only happens if the event storage is EventBuffer, since that triggers this method directly.
-   * If conditions are met, a new harvest will be triggered immediately.
+   * If conditions are met, a new harvest will be triggered immediately, unless this feature already harvested early within the last `MIN_EARLY_HARVEST_INTERVAL` ms.
+   * Data held back by that limit stays buffered until the next early, interval, or final harvest. Once the estimated payload reaches `EARLY_HARVEST_BYPASS_SIZE`
+   * the limit no longer applies, so a flood of data cannot fill the buffer to its maximum size, where new events would be dropped, while waiting.
    * @returns void
    */
   decideEarlyHarvest() {
     if (!this.canHarvestEarly || this.blocked || this.isRetrying) return;
     const estimatedSize = this.events.byteSize() + (this.customAttributesAreSeparate ? this.agentRef.runtime.jsAttributesMetadata.bytes : 0);
     if (estimatedSize > IDEAL_PAYLOAD_SIZE) {
+      const currentTime = now();
+      /* Bounds the request rate when a page produces data in a flood, regardless of how fast or whether requests complete. Large payloads skip the limit to avoid dropping data. */
+      if (estimatedSize < EARLY_HARVEST_BYPASS_SIZE && this.lastEarlyHarvestAt !== undefined && currentTime - this.lastEarlyHarvestAt < MIN_EARLY_HARVEST_INTERVAL) return;
+      this.lastEarlyHarvestAt = currentTime;
       this.agentRef.runtime.harvester.triggerHarvestFor(this);
       this.reportSupportabilityMetric("".concat(this.featureName, "/Harvest/Early/Seen"), estimatedSize);
     }

package/dist/esm/interfaces/registered-iframe-entity.js

@@ -115,10 +115,13 @@ export class RegisteredIframeEntity {
       return;
     }
 
+    /* Script timings are found by parsing the call stack for the script that called register(), so this has to run
+       synchronously here. By the time the registration promise resolves, that caller is no longer on the stack. */
+    const timings = findScriptTimings(opts);
+
     // Store the registration promise so other methods can wait for it
     this.#registrationPromise = this.#register(opts);
     this.#registrationPromise.then(() => {
-      const timings = findScriptTimings();
       // Send initial timing values, skipping ones still at their "not yet known" default
       // (e.g. reportedAt: undefined, fetchStart: 0) to avoid pointless postMessage calls
       for (const [key, value] of Object.entries(timings)) {

package/dist/types/common/constants/agent-constants.d.ts

@@ -1,5 +1,9 @@
 export const IDEAL_PAYLOAD_SIZE: 16000;
 export const MAX_PAYLOAD_SIZE: 1000000;
+/** The minimum time (ms) between early harvests of a single feature. Data that arrives inside this window stays buffered for the next harvest. */
+export const MIN_EARLY_HARVEST_INTERVAL: 500;
+/** The estimated payload size at which a feature may harvest early even inside the minimum interval, so that a flood of data cannot fill the buffer to MAX_PAYLOAD_SIZE (and start dropping events) while waiting. */
+export const EARLY_HARVEST_BYPASS_SIZE: number;
 export const DEFAULT_KEY: "NR_CONTAINER_AGENT";
 export const SESSION_ERROR: "SESSION_ERROR";
 export const SUPPORTS_REGISTERED_ENTITIES: {

package/dist/types/common/constants/agent-constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-constants.d.ts","sourceRoot":"","sources":["../../../../src/common/constants/agent-constants.js"],"names":[],"mappings":"AAMA,iCAAkC,KAAK,CAAA;AACvC,+BAAgC,OAAO,CAAA;AACvC,0BAA2B,oBAAoB,CAAA;AAC/C,4BAA6B,eAAe,CAAA;AAE5C;IACE,CAAC,aAAa,CAAC,OAAO,CAAC,UAAM;IAC7B,CAAC,aAAa,CAAC,aAAa,CAAC,UAAM;IACnC,CAAC,aAAa,CAAC,QAAQ,CAAC,UAAM;IAC9B,CAAC,aAAa,CAAC,IAAI,CAAC,UAAM;EAC3B;8BAZ6B,iCAAiC"}
+{"version":3,"file":"agent-constants.d.ts","sourceRoot":"","sources":["../../../../src/common/constants/agent-constants.js"],"names":[],"mappings":"AAMA,iCAAkC,KAAK,CAAA;AACvC,+BAAgC,OAAO,CAAA;AACvC,kJAAkJ;AAClJ,yCAA0C,GAAG,CAAA;AAC7C,sNAAsN;AACtN,+CAA6D;AAC7D,0BAA2B,oBAAoB,CAAA;AAC/C,4BAA6B,eAAe,CAAA;AAE5C;IACE,CAAC,aAAa,CAAC,OAAO,CAAC,UAAM;IAC7B,CAAC,aAAa,CAAC,aAAa,CAAC,UAAM;IACnC,CAAC,aAAa,CAAC,QAAQ,CAAC,UAAM;IAC9B,CAAC,aAAa,CAAC,IAAI,CAAC,UAAM;EAC3B;8BAhB6B,iCAAiC"}

package/dist/types/common/util/attribute-size.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attribute-size.d.ts","sourceRoot":"","sources":["../../../../src/common/util/attribute-size.js"],"names":[],"mappings":"AAMA;;EAiBC"}
+{"version":3,"file":"attribute-size.d.ts","sourceRoot":"","sources":["../../../../src/common/util/attribute-size.js"],"names":[],"mappings":"AAMA;;EAoBC"}

package/dist/types/common/v2/manifest.d.ts

@@ -52,7 +52,7 @@ export type ParsedManifest = {
 };
 export type AssetFile = {
     /**
-     * - the path/path-fragment string, or RegExp, used to match a resolved URL against this asset
+     * - the path/path-fragment string, or RegExp, used to match a resolved URL against this asset. A matcher may match many resources (e.g. a RegExp for hashed chunks); every matching resource contributes to the MFE's `totalWeight`/`renderBlocking` and, per `timingMethod`, its timing window
      */
     matcher: string | RegExp;
     /**

package/dist/types/common/v2/script-tracker-types.d.ts

@@ -15,6 +15,12 @@ export type TimingsInternals = {
      * script itself) is never counted twice.
      */
     weighedAssetUrls: Set<string>;
+    /**
+     * - Always present. Cleaned URLs of manifest assets whose entry has already
+     * widened `fetchStart`/`fetchEnd`/the script window, so a duplicate load of the same URL (typically cache-served,
+     * with a later `responseEnd`) can't stretch the window a second time.
+     */
+    widenedAssetUrls: Set<string>;
     /**
      * - Always present (seeded by
      * `getOrCreateInternals`, see `script-tracker.js`). `findScriptTimings` overrides the seeded default with one that

package/dist/types/common/v2/script-tracker-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"script-tracker-types.d.ts","sourceRoot":"","sources":["../../../../src/common/v2/script-tracker-types.js"],"names":[],"mappings":";;;;;;;;2CAMa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI;;;;;;;;sBAQnC,GAAG,CAAC,MAAM,CAAC;;;;;;gCAIX,4BAA4B"}
+{"version":3,"file":"script-tracker-types.d.ts","sourceRoot":"","sources":["../../../../src/common/v2/script-tracker-types.js"],"names":[],"mappings":";;;;;;;;2CAMa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI;;;;;;;;sBAQnC,GAAG,CAAC,MAAM,CAAC;;;;;;sBAIX,GAAG,CAAC,MAAM,CAAC;;;;;;gCAGX,4BAA4B"}

package/dist/types/common/v2/script-tracker.d.ts

@@ -19,7 +19,9 @@ export function extractUrlsFromStack(stack: string): string[];
 export function getDeepStackTrace(): Error.stack | undefined;
 /**
  * Applies a registered MFE's manifest to a timings object (already populated by `findScriptTimings`). No-op if no
- * manifest is present. Weight/renderBlocking always accumulate from every detected manifest asset; timing widening
+ * manifest is present. Every resource entry matching any manifest asset contributes -- an asset is not consumed by its
+ * first match, so a broad matcher (e.g. a RegExp for hashed chunks) credits all of the chunks it matches.
+ * Weight/renderBlocking always accumulate from every detected manifest asset; timing widening
  * (fetchStart/fetchEnd/scriptStart/scriptEnd/asset anchor) is opt-in via `timingMethod` -- see `applyManifestEntry`.
  * @param {RegisterAPITimings} timings - the timings object to widen in place
  * @param {RegisterAPITarget} target - the registered MFE target, which may carry a parsed `manifest`

package/dist/types/common/v2/script-tracker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"script-tracker.d.ts","sourceRoot":"","sources":["../../../../src/common/v2/script-tracker.js"],"names":[],"mappings":"AAkEA;;;;;;GAMG;AACH,2CAHW,MAAM,GACJ,iBAAiB,GAAG,SAAS,CAIzC;AA6ED;;;;GAIG;AACH,4CAHW,MAAM,GACJ,MAAM,EAAE,CAsBpB;AAED;;;GAGG;AACH,qCAFa,KAAK,CAAC,KAAK,GAAG,SAAS,CAanC;AAwKD;;;;;;GAMG;AACH,8CAHW,kBAAkB,UAClB,iBAAiB,QAmB3B;AAED;;;;;GAKG;AACH,2CAJW,iBAAiB,GAEf,kBAAkB,CAkG9B;AA7dD;;;;;GAKG;AAEH,kCAAkC;AAClC,yBAAmB;AAUnB,iIAAiI;AACjI,iCADW,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CACE;iCAlB9B,OAAO,sCAAsC,EAAE,kBAAkB;gCACjE,OAAO,sCAAsC,EAAE,iBAAiB;2CAChE,OAAO,wBAAwB,EAAE,4BAA4B;+BAC7D,OAAO,wBAAwB,EAAE,gBAAgB;kCAR5B,sBAAsB"}
+{"version":3,"file":"script-tracker.d.ts","sourceRoot":"","sources":["../../../../src/common/v2/script-tracker.js"],"names":[],"mappings":"AAmEA;;;;;;GAMG;AACH,2CAHW,MAAM,GACJ,iBAAiB,GAAG,SAAS,CAIzC;AAoFD;;;;GAIG;AACH,4CAHW,MAAM,GACJ,MAAM,EAAE,CAsBpB;AAED;;;GAGG;AACH,qCAFa,KAAK,CAAC,KAAK,GAAG,SAAS,CAanC;AA0LD;;;;;;;;GAQG;AACH,8CAHW,kBAAkB,UAClB,iBAAiB,QAkB3B;AAED;;;;;GAKG;AACH,2CAJW,iBAAiB,GAEf,kBAAkB,CAkG9B;AAxfD;;;;;GAKG;AAEH,kCAAkC;AAClC,yBAAmB;AAUnB,iIAAiI;AACjI,iCADW,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CACE;iCAlB9B,OAAO,sCAAsC,EAAE,kBAAkB;gCACjE,OAAO,sCAAsC,EAAE,iBAAiB;2CAChE,OAAO,wBAAwB,EAAE,4BAA4B;+BAC7D,OAAO,wBAAwB,EAAE,gBAAgB;kCAR5B,sBAAsB"}

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

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

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":"AA0BA;;GAEG;AAEH;IACE,2BAAiC;IACjC,2BA2BC;IAtBC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,qBAAwB;IAGxB,4BAAgE;IAChE,0BAA+D;IAiBjE;;;;MAMC;IAED;;;MAcC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,kBATW,KAAK,GAAC,aAAa,SACnB,MAAM,aACN,OAAO,qBACP,MAAM,cACN,OAAO,kBACP,MAAM,WACN,MAAM,GACJ,IAAI,CAiBhB;;CAyQF;wBA9WY,OAAO,0BAA0B,EAAE,SAAS;8BAV3B,4BAA4B;2BAE/B,gCAAgC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AA2BA;;GAEG;AAEH;IACE,2BAAiC;IACjC,2BAgDC;IA3CC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,qBAAwB;IAGxB,4BAAgE;IAChE,0BAA+D;IAsCjE;;;;MAMC;IAED;;;MAcC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,kBATW,KAAK,GAAC,aAAa,SACnB,MAAM,aACN,OAAO,qBACP,MAAM,cACN,OAAO,kBACP,MAAM,WACN,MAAM,GACJ,IAAI,CAiBhB;;CAyQF;wBAnYY,OAAO,0BAA0B,EAAE,SAAS;8BAX3B,4BAA4B;2BAE/B,gCAAgC"}

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

@@ -11,6 +11,8 @@ export class AggregateBase extends FeatureBase {
     canHarvestEarly: boolean;
     /** @type {Boolean} indicates if the feature is actively in a retry deferral period */
     isRetrying: boolean;
+    /** @type {number|undefined} the timestamp (ms, relative to page start) of the last early harvest triggered by this feature, if any */
+    lastEarlyHarvestAt: number | undefined;
     harvestOpts: {};
     events: any;
     /** @type {Boolean} indicates if the feature supports registered entities and the harvest requirements therein. Also read by getter "harvestEndpointVersion". Controlled by feature flag in pre-release phase. */
@@ -25,7 +27,9 @@ export class AggregateBase extends FeatureBase {
     drained: boolean | undefined;
     /**
      * Evaluates whether a harvest should be made early by estimating the size of the current payload.  Currently, this only happens if the event storage is EventBuffer, since that triggers this method directly.
-     * If conditions are met, a new harvest will be triggered immediately.
+     * If conditions are met, a new harvest will be triggered immediately, unless this feature already harvested early within the last `MIN_EARLY_HARVEST_INTERVAL` ms.
+     * Data held back by that limit stays buffered until the next early, interval, or final harvest. Once the estimated payload reaches `EARLY_HARVEST_BYPASS_SIZE`
+     * the limit no longer applies, so a flood of data cannot fill the buffer to its maximum size, where new events would be dropped, while waiting.
      * @returns void
      */
     decideEarlyHarvest(): void;

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

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

package/dist/types/interfaces/registered-iframe-entity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registered-iframe-entity.d.ts","sourceRoot":"","sources":["../../../src/interfaces/registered-iframe-entity.js"],"names":[],"mappings":"AAuBA;;;;GAIG;AAEH;;;;;;GAMG;AACH;IAkDE;;;OAGG;IACH,kBAFW,sBAAsB,EAsDhC;IAzGD,kCAAkC;IAClC,UADW,mBAAmB,CAW7B;IAyBD,mBANa,OAAO,EAQnB;IAbD;;;;;;OAMG;IACH,eAFa,OAAO,CAInB;IAoTD;;;;;OAKG;IACH,oBAHW,MAAM,eACN,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,cAFa,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;;;SAKK;IACL,6BAHa,MAAM,eACN,MAAM,QAIlB;IAED;;;;;;OAMG;IACH,cAJW,MAAM,YACN;QAAC,KAAK,CAAC,EAAE,MAAM,GAAC,eAAe,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,GAAC,eAAe,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC,GACvF,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAC,CAAC,CAI7F;IAED;;;;;;OAMG;IACH,yBAJW,MAAM,SACN,MAAM,GAAC,MAAM,GAAC,OAAO,GAAC,IAAI,YAC1B,OAAO,QAIjB;IAED;;;;;OAKG;IACH,mBAHW,KAAK,GAAC,MAAM,qBACZ,MAAM,QAIhB;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GAAC,IAAI,iBACX,OAAO,QAIjB;IAED;;;;;;;OAOG;IACH,6BAJW,MAAM,GAAC,IAAI,QAMrB;IAED;;;;;MAKE;IACF,aAHW,MAAM,YACN;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,GAAC,OAAO,GAAC,OAAO,GAAC,MAAM,GAAC,MAAM,CAAA;KAAC,QAIpF;;CACF;0BA9cY,OAAO,mCAAmC,EAAE,WAAW;kCACvD,OAAO,mCAAmC,EAAE,mBAAmB;qCAC/D,OAAO,mCAAmC,EAAE,sBAAsB"}
+{"version":3,"file":"registered-iframe-entity.d.ts","sourceRoot":"","sources":["../../../src/interfaces/registered-iframe-entity.js"],"names":[],"mappings":"AAuBA;;;;GAIG;AAEH;;;;;;GAMG;AACH;IAkDE;;;OAGG;IACH,kBAFW,sBAAsB,EAyDhC;IA5GD,kCAAkC;IAClC,UADW,mBAAmB,CAW7B;IAyBD,mBANa,OAAO,EAQnB;IAbD;;;;;;OAMG;IACH,eAFa,OAAO,CAInB;IAuTD;;;;;OAKG;IACH,oBAHW,MAAM,eACN,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,cAFa,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;;;SAKK;IACL,6BAHa,MAAM,eACN,MAAM,QAIlB;IAED;;;;;;OAMG;IACH,cAJW,MAAM,YACN;QAAC,KAAK,CAAC,EAAE,MAAM,GAAC,eAAe,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,GAAC,eAAe,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC,GACvF,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAC,CAAC,CAI7F;IAED;;;;;;OAMG;IACH,yBAJW,MAAM,SACN,MAAM,GAAC,MAAM,GAAC,OAAO,GAAC,IAAI,YAC1B,OAAO,QAIjB;IAED;;;;;OAKG;IACH,mBAHW,KAAK,GAAC,MAAM,qBACZ,MAAM,QAIhB;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GAAC,IAAI,iBACX,OAAO,QAIjB;IAED;;;;;;;OAOG;IACH,6BAJW,MAAM,GAAC,IAAI,QAMrB;IAED;;;;;MAKE;IACF,aAHW,MAAM,YACN;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,GAAC,OAAO,GAAC,OAAO,GAAC,MAAM,GAAC,MAAM,CAAA;KAAC,QAIpF;;CACF;0BAjdY,OAAO,mCAAmC,EAAE,WAAW;kCACvD,OAAO,mCAAmC,EAAE,mBAAmB;qCAC/D,OAAO,mCAAmC,EAAE,sBAAsB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.323.0",
+  "version": "1.324.0-rc.1",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",
@@ -170,7 +170,7 @@
     "runtime": {
       "name": "node",
       "onFail": "error",
-      "version": ">=22.11.0"
+      "version": ">=24.14.0"
     },
     "packageManager": {
       "name": "npm",
@@ -204,6 +204,7 @@
     "cdn:webpack": "npx webpack --progress --config ./tools/webpack/index.mjs",
     "cdn:watch": "jung -r ./src -F '.*\\.test\\.js' --run -- npm run cdn:build:local",
     "test-server": "node ./tools/wdio/bin/server",
+    "electron:open": "node tools/local-browsers/electron/open.mjs",
     "lt:update-browsers": "node ./tools/browsers-lists/lt-update-supported.mjs",
     "lt:upload-webview-assets": "node ./tools/lambda-test/upload-webview-assets.mjs",
     "build:frameworks": "npm run build:npm && npm --prefix ./tools/test-builds run build-frameworks",
@@ -297,4 +298,4 @@
     "README.md",
     "CHANGELOG.md"
   ]
-}
+}

package/src/common/constants/agent-constants.js

@@ -6,6 +6,10 @@ import { FEATURE_NAMES } from '../../loaders/features/features'
 
 export const IDEAL_PAYLOAD_SIZE = 16000
 export const MAX_PAYLOAD_SIZE = 1000000
+/** The minimum time (ms) between early harvests of a single feature. Data that arrives inside this window stays buffered for the next harvest. */
+export const MIN_EARLY_HARVEST_INTERVAL = 500
+/** The estimated payload size at which a feature may harvest early even inside the minimum interval, so that a flood of data cannot fill the buffer to MAX_PAYLOAD_SIZE (and start dropping events) while waiting. */
+export const EARLY_HARVEST_BYPASS_SIZE = MAX_PAYLOAD_SIZE / 2
 export const DEFAULT_KEY = 'NR_CONTAINER_AGENT'
 export const SESSION_ERROR = 'SESSION_ERROR'
 

package/src/common/util/attribute-size.js

@@ -1,5 +1,5 @@
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 import { stringify } from './stringify'
@@ -10,12 +10,15 @@ export function trackObjectAttributeSize (parent, object) {
   // proxy attribute to calculate its size when changed
   parent[object] = new Proxy(originalAttribute, {
     set (target, prop, value) {
+      /* An overwrite replaces the existing entry, so its previous size must be removed first. Otherwise repeated sets of the same key inflate the count far beyond the real size. */
+      if (Object.prototype.hasOwnProperty.call(target, prop)) output.bytes -= prop.length + stringify(target[prop]).length
       output.bytes += prop.length + stringify(value).length
       target[prop] = value
       return true
     },
     deleteProperty (target, prop) {
-      output.bytes -= prop.length + stringify(target[prop]).length
+      /* Deleting a key that was never set removes nothing, so the count must not change. */
+      if (Object.prototype.hasOwnProperty.call(target, prop)) output.bytes -= prop.length + stringify(target[prop]).length
       return delete target[prop]
     }
   })

package/src/common/v2/manifest.js

@@ -9,7 +9,7 @@ import { single } from '../util/invoke'
 
 /**
  * @typedef {Object} AssetFile
- * @property {string|RegExp} matcher - the path/path-fragment string, or RegExp, used to match a resolved URL against this asset
+ * @property {string|RegExp} matcher - the path/path-fragment string, or RegExp, used to match a resolved URL against this asset. A matcher may match many resources (e.g. a RegExp for hashed chunks); every matching resource contributes to the MFE's `totalWeight`/`renderBlocking` and, per `timingMethod`, its timing window
  * @property {'script'|'asset'} [type] - optional override for script-capability inference. When omitted, script-capability is inferred from a
  * `.js` suffix on a string `matcher` (a RegExp `matcher` is never inferred as a script). Supply `type: 'script'` to explicitly flag an entry
  * as a script regardless of its matcher shape/suffix (e.g. an extensionless URL, or a RegExp targeting a script path), or `type: 'asset'` to

package/src/common/v2/script-tracker-types.js

@@ -16,6 +16,9 @@
  * `script-tracker.js`). Cleaned URLs already folded into `timings.totalWeight`/`timings.renderBlocking` by
  * `applyResourceWeight`, so the same underlying resource (e.g. a manifest asset that's also the .register calling
  * script itself) is never counted twice.
+ * @property {Set<string>} widenedAssetUrls - Always present. Cleaned URLs of manifest assets whose entry has already
+ * widened `fetchStart`/`fetchEnd`/the script window, so a duplicate load of the same URL (typically cache-served,
+ * with a later `responseEnd`) can't stretch the window a second time.
  * @property {RecordManifestScriptWindowFn} recordManifestScriptWindow - Always present (seeded by
  * `getOrCreateInternals`, see `script-tracker.js`). `findScriptTimings` overrides the seeded default with one that
  * folds into the live `scriptStart`/`scriptEnd` getters instead.

package/src/common/v2/script-tracker.js

@@ -54,6 +54,7 @@ function getOrCreateInternals (timings) {
   if (!internals) {
     internals = {
       weighedAssetUrls: new Set(),
+      widenedAssetUrls: new Set(),
       recordManifestScriptWindow: (start, end) => {
         if (start) timings.scriptStart = timings.scriptStart > 0 ? Math.min(timings.scriptStart, start) : start
         if (end) timings.scriptEnd = timings.scriptEnd > 0 ? Math.max(timings.scriptEnd, end) : end
@@ -104,6 +105,9 @@ if (globalScope.MutationObserver && globalScope.document) {
         if (node.nodeName === 'SCRIPT' && node.src) {
           const cleanedSrc = cleanURL(node.src)
           const correlation = getOrCreateCorrelation(cleanedSrc)
+          /* The first node wins, same as the performance entry below. Skipping here also means no load/error listeners
+             are attached for duplicate references. */
+          if (correlation.dom.value) return
 
           correlation.dom.start = now()
           correlation.dom.value = node
@@ -131,9 +135,13 @@ if (globalScope.PerformanceObserver?.supportedEntryTypes.includes('resource')) {
       if (validEntryCriteria(entry)) {
         const entryUrl = cleanURL(entry.name)
         const correlation = getOrCreateCorrelation(entryUrl)
-        correlation.performance.start = Math.floor(entry.startTime)
-        correlation.performance.end = Math.floor(entry.responseEnd)
-        correlation.performance.value = entry
+        /* The first entry wins. A script referenced more than once is typically re-served from the browser cache, so a
+           later entry for the same URL would overwrite the real network timing with a near-instant one. */
+        if (!correlation.performance.value) {
+          correlation.performance.start = Math.floor(entry.startTime)
+          correlation.performance.end = Math.floor(entry.responseEnd)
+          correlation.performance.value = entry
+        }
       }
 
       // Late-resolution subscribers can be for any asset type (not just scripts), so every entry is checked here,
@@ -285,7 +293,8 @@ function subscribeToLatePerformanceEntry (timings, mfeScriptUrl) {
 
 /**
  * Applies one manifest asset's performance entry to a timings object: weight/renderBlocking always accumulate;
- * fetchStart/fetchEnd and scriptStart/scriptEnd widen (never shrink) only when `timingMethod` calls for it; asset/
+ * fetchStart/fetchEnd and scriptStart/scriptEnd widen (never shrink) only when `timingMethod` calls for it, and only for
+ * the first entry seen per URL; asset/
  * type get anchored to the first script asset seen to resolve.
  * @param {RegisterAPITimings} timings
  * @param {PerformanceResourceTiming} entry
@@ -299,6 +308,13 @@ function applyManifestEntry (timings, entry, asset, entryState, timingMethod) {
 
   if (timingMethod !== 'scripts' && timingMethod !== 'all') return // no timing-widening effect at the 'entry' default/unset
 
+  /* Only the first entry per URL widens timing. A resource referenced more than once is typically re-served from the
+     browser cache with a later responseEnd, which would otherwise stretch fetchEnd out to the duplicate's load. */
+  const { widenedAssetUrls } = getOrCreateInternals(timings)
+  const url = cleanURL(entry.name)
+  if (widenedAssetUrls.has(url)) return
+  widenedAssetUrls.add(url)
+
   const widensAllAssets = timingMethod === 'all'
   // Under 'scripts', only script assets widen the fetch window; under 'all', every matched asset does.
   if (widensAllAssets || asset.isScript) {
@@ -335,34 +351,46 @@ function applyManifestEntry (timings, entry, asset, entryState, timingMethod) {
 }
 
 /**
- * Subscribes to late resource timing emissions for manifest assets not yet resolved against the buffered entries.
- * Reuses the shared page-wide scriptObserver/poSubscribers mechanism (one PerformanceObserver for all MFEs, not
- * one per MFE) and, unlike that observer's own correlation bookkeeping, checks every resource entry -- not just
- * script-like ones -- so lazy-loaded images/fonts/stylesheets resolve too.
+ * Finds the manifest asset a resource entry should be credited to. An entry matching several assets is applied once;
+ * a script asset is preferred so an overlapping non-script matcher can't cause 'scripts' mode to skip a script entry.
+ * @param {import('./manifest').ParsedManifestAsset[]} assets
+ * @param {PerformanceResourceTiming} entry
+ * @returns {import('./manifest').ParsedManifestAsset|undefined}
+ */
+function findMatchingManifestAsset (assets, entry) {
+  const matches = assets.filter(asset => asset.test(entry.name))
+  return matches.find(asset => asset.isScript) || matches[0]
+}
+
+/**
+ * Subscribes to late resource timing emissions for manifest assets. Reuses the shared page-wide
+ * scriptObserver/poSubscribers mechanism (one PerformanceObserver for all MFEs, not one per MFE) and, unlike that
+ * observer's own correlation bookkeeping, checks every resource entry -- not just script-like ones -- so lazy-loaded
+ * images/fonts/stylesheets resolve too. A matcher can legitimately match many resources (e.g. a hashed-chunk RegExp),
+ * so this subscriber never reports itself as finished; it is cleared by the shared observer's expiry instead.
  * @param {RegisterAPITimings} timings
- * @param {Set<import('./manifest').ParsedManifestAsset>} pending - manifest assets still unresolved
+ * @param {import('./manifest').ParsedManifestAsset[]} assets - every manifest asset to match late entries against
  * @param {{ resolved: boolean }} entryState - shared "first script asset wins" guard for a single `applyManifestTimings` call
  * @param {'entry'|'scripts'|'all'} [timingMethod] - forwarded to `applyManifestEntry` for each late-resolving asset
  */
-function subscribeToLateManifestEntries (timings, pending, entryState, timingMethod) {
+function subscribeToLateManifestEntries (timings, assets, entryState, timingMethod) {
   if (!globalScope.PerformanceObserver?.supportedEntryTypes?.includes('resource')) return
 
   poSubscribers.push({
     addedAt: now(),
     test: (entry) => {
-      const matched = [...pending].find(asset => asset.test(entry.name))
-      if (matched) {
-        applyManifestEntry(timings, entry, matched, entryState, timingMethod)
-        pending.delete(matched)
-      }
-      return pending.size === 0
+      const matched = findMatchingManifestAsset(assets, entry)
+      if (matched) applyManifestEntry(timings, entry, matched, entryState, timingMethod)
+      return false
     }
   })
 }
 
 /**
  * Applies a registered MFE's manifest to a timings object (already populated by `findScriptTimings`). No-op if no
- * manifest is present. Weight/renderBlocking always accumulate from every detected manifest asset; timing widening
+ * manifest is present. Every resource entry matching any manifest asset contributes -- an asset is not consumed by its
+ * first match, so a broad matcher (e.g. a RegExp for hashed chunks) credits all of the chunks it matches.
+ * Weight/renderBlocking always accumulate from every detected manifest asset; timing widening
  * (fetchStart/fetchEnd/scriptStart/scriptEnd/asset anchor) is opt-in via `timingMethod` -- see `applyManifestEntry`.
  * @param {RegisterAPITimings} timings - the timings object to widen in place
  * @param {RegisterAPITarget} target - the registered MFE target, which may carry a parsed `manifest`
@@ -372,18 +400,17 @@ export function applyManifestTimings (timings, target) {
   if (!parsedManifest || !parsedManifest.assets.length) return
 
   const entryState = { resolved: false }
-  const pending = new Set(parsedManifest.assets)
+  const { assets } = parsedManifest
 
   const resourceEntries = globalScope.performance?.getEntriesByType('resource') || []
   resourceEntries.forEach((entry) => {
-    const matched = [...pending].find(asset => asset.test(entry.name))
-    if (matched) {
-      applyManifestEntry(timings, entry, matched, entryState, target.timingMethod)
-      pending.delete(matched)
-    }
+    const matched = findMatchingManifestAsset(assets, entry)
+    if (matched) applyManifestEntry(timings, entry, matched, entryState, target.timingMethod)
   })
 
-  if (pending.size) subscribeToLateManifestEntries(timings, pending, entryState, target.timingMethod)
+  // Always subscribe: assets may still match resources that load after this point, and (unlike an exact matcher) a
+  // wildcard can't know its last match has been seen.
+  subscribeToLateManifestEntries(timings, assets, entryState, target.timingMethod)
 }
 
 /**

package/src/features/ajax/aggregate/index.js

@@ -16,7 +16,7 @@ import { canCapturePayload, isLikelyHumanReadable, parseQueryString, createStrin
 import { Obfuscator } from '../../../common/util/obfuscate'
 import { getVersion2Attributes, getVersion2DuplicationAttributes, shouldDuplicate, isMfeTarget } from '../../../common/v2/utils'
 import { EVENT_TYPES } from '../../../common/constants/events'
-import { generateUuid } from '../../../common/ids/unique-id'
+import { generateSpanId, generateTraceId, generateUuid } from '../../../common/ids/unique-id'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
@@ -139,7 +139,20 @@ export class Aggregate extends AggregateBase {
     /** make a copy of the event for the MFE target if it exists */
     if (isMfeTarget(target)) {
       this.events.add({ ...event, targetAttributes: getVersion2Attributes(target, this) })
-      if (shouldDuplicate(target, this)) this.reportContainerEvent({ ...event, targetAttributes: getVersion2DuplicationAttributes(target, this) }, ctx)
+      if (shouldDuplicate(target, this)) {
+        const duplicateEvent = { ...event, targetAttributes: getVersion2DuplicationAttributes(target, this) }
+        /** the container-duplicate copy represents the same single real HTTP call as the MFE event above, so it
+         * needs its own independent trace/span identity -- otherwise the two would collide on the same
+         * spanId/traceId, and BELC could not create two separate Spans/Traces from them. Only the id namespace is
+         * independent; spanTimestamp is intentionally left as-is (event.spanTimestamp), since it still reflects the
+         * real call's actual timing. When `event.spanId` was never set (e.g. distributed tracing is disabled), there
+         * is no span identity to duplicate either -- both copies correctly end up with no spanId/traceId. */
+        if (event.spanId) {
+          duplicateEvent.spanId = generateSpanId()
+          duplicateEvent.traceId = generateTraceId()
+        }
+        this.reportContainerEvent(duplicateEvent, ctx)
+      }
     } else {
       this.reportContainerEvent(event, ctx)
     }

package/src/features/jserrors/aggregate/index.js

@@ -23,6 +23,7 @@ import { getRegisteredTargetsFromFilename, getVersion2Attributes, getVersion2Dup
 import { buildCauseString } from './cause-string'
 import { ShortCircuit } from '../../../common/util/short-circuit'
 import { EVENT_TYPES } from '../../../common/constants/events'
+import { SESSION_EVENTS, SESSION_EVENT_TYPES } from '../../../common/session/constants'
 
 /**
  * @typedef {import('./compute-stack-trace.js').StackInfo} StackInfo
@@ -48,6 +49,27 @@ export class Aggregate extends AggregateBase {
     register('ierr', this.processError.bind(this), this.featureName, this.ee)
     register('returnJserror', (jsErrorEvent, softNavAttrs) => this.#storeJserrorForHarvest(jsErrorEvent, softNavAttrs), this.featureName, this.ee)
 
+    /*
+     * The backend only remembers a stack trace for as long as the session that first reported it.
+     * The SessionEntity emits SESSION_EVENTS.RESET whenever the session expires (max duration or
+     * inactivity) or is otherwise reset, which is the same boundary the backend uses to forget
+     * previously-seen stack hashes. Forget them here too, so the next occurrence of an
+     * already-seen error resends its full stack_trace once, instead of a browser_stack_hash the
+     * backend can no longer resolve.
+     */
+    const forgetReportedStacks = () => {
+      this.stackReported = {}
+      this.observedAt = {}
+    }
+    let currentSessionId = this.agentRef.runtime.session?.state?.value
+    this.ee.on(SESSION_EVENTS.RESET, forgetReportedStacks)
+    this.ee.on(SESSION_EVENTS.UPDATE, (type, data) => {
+      if (!data?.value) return
+      /* A reset in another tab arrived as a cross-tab update carrying a new session id. */
+      if (type === SESSION_EVENT_TYPES.CROSS_TAB && currentSessionId && data.value !== currentSessionId) forgetReportedStacks()
+      currentSessionId = data.value // also tracks same-tab writes, so a local reset's new id is picked up
+    })
+
     // 0 == off, 1 == on
     this.waitForFlags(['err']).then(([errFlag]) => {
       if (errFlag) {

package/src/features/utils/aggregate-base.js

@@ -9,8 +9,9 @@ import { EventBuffer } from './event-buffer'
 import { handle } from '../../common/event-emitter/handle'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../metrics/constants'
 import { EventAggregator } from '../../common/aggregate/event-aggregator'
-import { MAX_PAYLOAD_SIZE, IDEAL_PAYLOAD_SIZE, SUPPORTS_REGISTERED_ENTITIES } from '../../common/constants/agent-constants'
+import { MAX_PAYLOAD_SIZE, IDEAL_PAYLOAD_SIZE, MIN_EARLY_HARVEST_INTERVAL, EARLY_HARVEST_BYPASS_SIZE, SUPPORTS_REGISTERED_ENTITIES } from '../../common/constants/agent-constants'
 import { warn } from '../../common/util/console'
+import { now } from '../../common/timing/now'
 
 export class AggregateBase extends FeatureBase {
   /**
@@ -27,6 +28,8 @@ export class AggregateBase extends FeatureBase {
     this.canHarvestEarly = true
     /** @type {Boolean} indicates if the feature is actively in a retry deferral period */
     this.isRetrying = false
+    /** @type {number|undefined} the timestamp (ms, relative to page start) of the last early harvest triggered by this feature, if any */
+    this.lastEarlyHarvestAt = undefined
 
     this.harvestOpts = {} // features aggregate classes can define custom opts for when their harvest is called
 
@@ -85,13 +88,19 @@ export class AggregateBase extends FeatureBase {
 
   /**
    * Evaluates whether a harvest should be made early by estimating the size of the current payload.  Currently, this only happens if the event storage is EventBuffer, since that triggers this method directly.
-   * If conditions are met, a new harvest will be triggered immediately.
+   * If conditions are met, a new harvest will be triggered immediately, unless this feature already harvested early within the last `MIN_EARLY_HARVEST_INTERVAL` ms.
+   * Data held back by that limit stays buffered until the next early, interval, or final harvest. Once the estimated payload reaches `EARLY_HARVEST_BYPASS_SIZE`
+   * the limit no longer applies, so a flood of data cannot fill the buffer to its maximum size, where new events would be dropped, while waiting.
    * @returns void
    */
   decideEarlyHarvest () {
     if (!this.canHarvestEarly || this.blocked || this.isRetrying) return
     const estimatedSize = this.events.byteSize() + (this.customAttributesAreSeparate ? this.agentRef.runtime.jsAttributesMetadata.bytes : 0)
     if (estimatedSize > IDEAL_PAYLOAD_SIZE) {
+      const currentTime = now()
+      /* Bounds the request rate when a page produces data in a flood, regardless of how fast or whether requests complete. Large payloads skip the limit to avoid dropping data. */
+      if (estimatedSize < EARLY_HARVEST_BYPASS_SIZE && this.lastEarlyHarvestAt !== undefined && currentTime - this.lastEarlyHarvestAt < MIN_EARLY_HARVEST_INTERVAL) return
+      this.lastEarlyHarvestAt = currentTime
       this.agentRef.runtime.harvester.triggerHarvestFor(this)
       this.reportSupportabilityMetric(`${this.featureName}/Harvest/Early/Seen`, estimatedSize)
     }

package/src/interfaces/registered-iframe-entity.js

@@ -107,11 +107,14 @@ export class RegisteredIframeEntity {
       return
     }
 
+    /* Script timings are found by parsing the call stack for the script that called register(), so this has to run
+       synchronously here. By the time the registration promise resolves, that caller is no longer on the stack. */
+    const timings = findScriptTimings(opts)
+
     // Store the registration promise so other methods can wait for it
     this.#registrationPromise = this.#register(opts)
     this.#registrationPromise
       .then(() => {
-        const timings = findScriptTimings()
         // Send initial timing values, skipping ones still at their "not yet known" default
         // (e.g. reportedAt: undefined, fetchStart: 0) to avoid pointless postMessage calls
         for (const [key, value] of Object.entries(timings)) {