@atlaskit/editor-plugin-interactivity 0.1.0 → 0.2.0

package/dist/cjs/interactivityPlugin.js

@@ -4,15 +4,90 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.interactivityPlugin = void 0;
+var _react = require("react");
+var _monitoring = require("@atlaskit/editor-common/monitoring");
+var _fireInteractivityEvent = require("./analytics/fire-interactivity-event");
+var _interactivityCollector = require("./collector/interactivity-collector");
 /**
- * Reports interaction latency distributions for full page editor sessions as the
- * `editor interactivity` operational event.
+ * Reports session-to-date interaction latency distributions for full page editor sessions
+ * as the `editor interactivity` operational event.
  *
- * A stub for now: the plugin only registers itself. The collector and the event land in
- * EDITOR-8553.
+ * The session runs for as long as the plugin's hook stays mounted, which is one editor
+ * mount: `MountPluginHooks` in editor-core keys hook fibers by plugin name, so a preset
+ * reconfigure — which destroys and recreates ProseMirror plugin views — leaves this hook,
+ * and the session, in place.
  */
-var interactivityPlugin = exports.interactivityPlugin = function interactivityPlugin() {
+var interactivityPlugin = exports.interactivityPlugin = function interactivityPlugin(_ref) {
+  var api = _ref.api;
   return {
-    name: 'interactivity'
+    name: 'interactivity',
+    usePluginHook: function usePluginHook(_ref2) {
+      var editorView = _ref2.editorView;
+      (0, _react.useEffect)(function () {
+        // Nothing measured here is worth an editor. This effect runs inside the plugin slot's
+        // error boundary, which also renders every plugin's content components, so a throw
+        // from instrumentation would take that UI down with it.
+        try {
+          var _api$contextIdentifie2, _api$editorViewMode2;
+          var collector = new _interactivityCollector.InteractivityCollector({
+            emit: function emit(snapshot) {
+              var _api$analytics;
+              return (0, _fireInteractivityEvent.fireInteractivityEvent)(api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions, snapshot);
+            },
+            getObjectId: function getObjectId() {
+              var _api$contextIdentifie;
+              return api === null || api === void 0 || (_api$contextIdentifie = api.contextIdentifier) === null || _api$contextIdentifie === void 0 || (_api$contextIdentifie = _api$contextIdentifie.sharedState.currentState()) === null || _api$contextIdentifie === void 0 || (_api$contextIdentifie = _api$contextIdentifie.contextIdentifierProvider) === null || _api$contextIdentifie === void 0 ? void 0 : _api$contextIdentifie.objectId;
+            },
+            getSessionMode: function getSessionMode() {
+              var _api$editorViewMode;
+              var mode = api === null || api === void 0 || (_api$editorViewMode = api.editorViewMode) === null || _api$editorViewMode === void 0 || (_api$editorViewMode = _api$editorViewMode.sharedState.currentState()) === null || _api$editorViewMode === void 0 ? void 0 : _api$editorViewMode.mode;
+              if (mode === undefined) {
+                return undefined;
+              }
+              return mode === 'view' ? 'reading' : 'editing';
+            },
+            // A destroyed view still answers, with the document it was destroyed with, so
+            // both report nothing rather than a size the editor no longer has.
+            getNodeSize: function getNodeSize() {
+              return editorView.isDestroyed ? undefined : editorView.state.doc.nodeSize;
+            },
+            // `getElementsByTagName` counts descendants in the browser engine, so this
+            // cannot overflow the stack on very large documents.
+            getEditorDomSize: function getEditorDomSize() {
+              return editorView.isDestroyed ? undefined : editorView.dom.getElementsByTagName('*').length;
+            }
+          });
+          if (!collector.start()) {
+            return;
+          }
+
+          // Confluence live pages navigate and switch between reading and editing without
+          // remounting the editor. A session covers one document in one mode, so either
+          // change ends it and starts the next.
+          var unsubscribeFromObjectId = api === null || api === void 0 || (_api$contextIdentifie2 = api.contextIdentifier) === null || _api$contextIdentifie2 === void 0 ? void 0 : _api$contextIdentifie2.sharedState.onChange(function () {
+            return collector.onObjectIdChanged();
+          });
+          var unsubscribeFromViewMode = api === null || api === void 0 || (_api$editorViewMode2 = api.editorViewMode) === null || _api$editorViewMode2 === void 0 ? void 0 : _api$editorViewMode2.sharedState.onChange(function () {
+            return collector.onViewModeChanged();
+          });
+          return function () {
+            unsubscribeFromObjectId === null || unsubscribeFromObjectId === void 0 || unsubscribeFromObjectId();
+            unsubscribeFromViewMode === null || unsubscribeFromViewMode === void 0 || unsubscribeFromViewMode();
+            collector.stop();
+          };
+        } catch (error) {
+          // Instrumentation must not fail the editor around it, but a failure that hits every
+          // browser of one engine would be invisible without this.
+          void (0, _monitoring.logException)(error, {
+            location: 'editor-plugin-interactivity/start'
+          });
+          return;
+        }
+        // `api` is deliberately not a dependency: a preset reconfigure hands out a new
+        // proxy object, but the one captured here keeps resolving plugins from the same
+        // live registry, and restarting the session on a reconfigure would split one
+        // editor session in two.
+      }, [editorView]);
+    }
   };
 };

package/dist/es2019/analytics/fire-interactivity-event.js

@@ -0,0 +1,33 @@
+import { ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/analytics/types/enums';
+/** The reasons that mean the page may not be around long enough to deliver a queued event. */
+const REASONS_THE_PAGE_MAY_NOT_OUTLIVE = ['hidden', 'pagehide', 'unmount'];
+
+/**
+ * The `editor interactivity` operational event.
+ *
+ * `editorSessionId` arrives without being set here: `@atlaskit/analytics-listeners` merges
+ * the editor analytics context into the attributes of every event on the editor channel.
+ * `objectId` comes both from that context and from the snapshot, which carries the value
+ * the session was collected against.
+ */
+
+/**
+ * Sends a snapshot as the `editor interactivity` event.
+ *
+ * Does nothing without the analytics plugin: an editor without it has nowhere to send events,
+ * and the collector keeps measuring either way.
+ */
+export function fireInteractivityEvent(analytics, snapshot) {
+  analytics === null || analytics === void 0 ? void 0 : analytics.fireAnalyticsEvent({
+    action: 'interactivity',
+    actionSubject: ACTION_SUBJECT.EDITOR,
+    eventType: EVENT_TYPE.OPERATIONAL,
+    attributes: snapshot
+  }, undefined,
+  // Events are queued into an idle callback by default, which a page being unloaded never
+  // runs and a backgrounded tab throttles. The snapshots taken because the page is going
+  // away go immediately; the rest can wait their turn.
+  {
+    immediate: REASONS_THE_PAGE_MAY_NOT_OUTLIVE.includes(snapshot.reason)
+  });
+}

package/dist/es2019/collector/bucket-boundaries.js

@@ -0,0 +1,117 @@
+/**
+ * Bucket boundaries for the interaction latency buckets, version 1.
+ *
+ * Two ranges:
+ * - 16 ms to 200 ms — a boundary every 8 ms: 16, 24, 32, … 200. Event Timing rounds
+ *   durations to 8 ms, so nothing finer is measurable.
+ * - above 200 ms — each boundary ~15% above the previous one, five of them per doubling:
+ *   222, 256, 294, 337, 388, 445, 512, … A 40 ms difference matters at 100 ms and is
+ *   noise at 4 seconds, so buckets grow with the latency instead of staying 8 ms wide.
+ *
+ * 500 ms — the Google INP "poor" threshold — falls inside the 445…512 bucket, so that one
+ * bucket is split at 500 to count the threshold instead of interpolating it. 200 ms, the
+ * "good" threshold, is already a boundary.
+ *
+ * Bump SCHEMA_VERSION whenever any boundary moves; queries group by it.
+ */
+export const SCHEMA_VERSION = 1;
+
+/**
+ * Event Timing reporting threshold. Faster interactions are never delivered to the
+ * observer, so they reach no bucket at all — `performance.interactionCount` is what counts
+ * them, as `totalCount - observedCount`. This bucket holds the interactions reported at
+ * exactly the threshold.
+ */
+export const REPORTING_THRESHOLD_MS = 16;
+
+/**
+ * Exceptions to the grid: latencies that must be a boundary of their own so that they are
+ * counted exactly rather than read off a bucket that spans them. Each one splits the bucket it
+ * falls inside. 500 ms is the Google INP "poor" threshold; the "good" one, 200 ms, needs no
+ * exception because the evenly spaced range already ends there.
+ *
+ * Every entry has to sit above that range, and adding one changes the reported keys, so bump
+ * SCHEMA_VERSION with it.
+ */
+const EXACT_THRESHOLDS_MS = [500];
+const EVENLY_SPACED_MAX_MS = 200;
+/**
+ * Keep this a multiple of 8 (8, 16, 24, …). Event Timing reports durations in 8 ms steps, so a
+ * step that is not a multiple of 8 leaves buckets no interaction can ever land in.
+ */
+const EVENLY_SPACED_STEP_MS = 8;
+const BOUNDARIES_PER_DOUBLING = 5;
+
+/**
+ * The first boundary at or above `latencyMs`, for the range above 200 ms.
+ *
+ * Five boundaries per doubling is the same as saying the nth boundary sits at `2^(n/5)` ms —
+ * boundary 40 at 256 ms, 45 at 512 ms, 50 at 1024 ms. So this turns the latency into a
+ * boundary number, rounds that up, and turns it back into milliseconds.
+ *
+ * Boundaries are floored to whole milliseconds, which keeps each one at or below the exact
+ * value it stands for. That is what makes `bucketKeyForMs(boundary) === boundary` hold.
+ */
+function firstBoundaryAtOrAbove(latencyMs) {
+  // `Math.log2(latencyMs) * 5` is the boundary number: log2 answers how many doublings of
+  // 1 ms reach this latency, and five boundaries cover each doubling.
+  //
+  // A latency sitting on a boundary makes that a whole number, which `Math.ceil` has to
+  // keep. ECMA-262 only requires `Math.log2` to be approximate, so 9.0000000000000002 for
+  // `log2(512)` would round up to boundary 46 and report 512 ms as 588 ms. EPSILON is
+  // larger than such imprecision and far smaller than the gap between two boundaries.
+  const EPSILON = 1e-9;
+  const boundaryNumber = Math.ceil(BOUNDARIES_PER_DOUBLING * Math.log2(latencyMs) - EPSILON);
+
+  // One `Math.pow` over the whole exponent, so the result is rounded once. Multiplying the
+  // ratio between neighbouring boundaries (2^(1/5) ≈ 1.1487) by itself instead accumulates
+  // the rounding of every step, reaching 512.0000000000018 by boundary 45.
+  return Math.floor(Math.pow(2, boundaryNumber / BOUNDARIES_PER_DOUBLING));
+}
+
+/** The bucket each exact threshold splits — 500 ms splits the one ending at 512 ms. */
+const EXACT_THRESHOLD_BUCKETS = EXACT_THRESHOLDS_MS.map(thresholdMs => ({
+  thresholdMs,
+  bucketMs: firstBoundaryAtOrAbove(thresholdMs)
+}));
+
+/**
+ * The bucket a latency belongs to, identified by the bucket's upper boundary in whole
+ * milliseconds — which is also its key in the reported buckets.
+ *
+ * Every latency gets a bucket, however slow: the boundaries continue upwards, so there is no
+ * overflow bucket. Expects the whole-millisecond durations Event Timing reports; boundaries
+ * are floored, so a fractional latency can land in a bucket whose key reads up to a
+ * millisecond below it. Non-finite latencies never reach here — `InteractionTracker` drops
+ * them as it reads the entry.
+ */
+export function bucketKeyForMs(latencyMs) {
+  if (latencyMs <= REPORTING_THRESHOLD_MS) {
+    return REPORTING_THRESHOLD_MS;
+  }
+  if (latencyMs <= EVENLY_SPACED_MAX_MS) {
+    // How many 8 ms steps above the threshold the latency is, rounded up: 17 ms is 0.125
+    // steps up and lands on the boundary one step up, 24 ms. Rounding up is what keeps the
+    // set of keys fixed when a latency is not a multiple of 8 ms.
+    //
+    // No EPSILON here, unlike the branch below: subtracting whole numbers gives a whole
+    // number, and dividing by a power of two shifts a binary float's exponent without
+    // touching its digits, so a latency on a boundary cannot come out just above a whole
+    // number of steps.
+    const steps = Math.ceil((latencyMs - REPORTING_THRESHOLD_MS) / EVENLY_SPACED_STEP_MS);
+    return REPORTING_THRESHOLD_MS + steps * EVENLY_SPACED_STEP_MS;
+  }
+  const boundary = firstBoundaryAtOrAbove(latencyMs);
+
+  // A latency in the lower part of a split bucket is reported as the threshold itself, so the
+  // threshold is counted exactly.
+  for (const {
+    thresholdMs,
+    bucketMs
+  } of EXACT_THRESHOLD_BUCKETS) {
+    if (boundary === bucketMs && latencyMs <= thresholdMs) {
+      return thresholdMs;
+    }
+  }
+  return boundary;
+}

package/dist/es2019/collector/interaction-group.js

@@ -0,0 +1,110 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { bucketKeyForMs } from './bucket-boundaries';
+
+/**
+ * Latencies are counted per 8 ms, the resolution Event Timing reports durations at. Every
+ * latency is rounded up to this step on the way in, which caps the number of distinct values
+ * a group can hold whatever the latency was derived from.
+ */
+const RESOLUTION_MS = 8;
+
+/** Which percentiles are reported, as quantiles. */
+const REPORTED_QUANTILES = [0.9, 0.98];
+
+/**
+ * The latencies of one set of interactions — every interaction on the page, or only the ones
+ * inside the editor — reported as one object in the event.
+ *
+ * The whole state is a count per distinct latency, so an interaction only costs a counter
+ * whatever its latency was, and everything the event carries — the reported buckets, the
+ * count, the sum, the maximum and the percentiles — is derived from that map when a snapshot
+ * is taken. Nothing is computed while interactions arrive.
+ */
+export class InteractionGroup {
+  constructor() {
+    _defineProperty(this, "countByLatency", new Map());
+  }
+  add(latencyMs) {
+    this.increment(latencyMs);
+  }
+  remeasure(previousLatencyMs, latencyMs) {
+    // Moved rather than counted again: the count belongs to the same interaction.
+    this.decrement(previousLatencyMs);
+    this.increment(latencyMs);
+  }
+
+  /**
+   * @param totalCount every interaction of the group, including those below the Event Timing
+   * reporting threshold, which this group never sees.
+   */
+  snapshot(totalCount) {
+    var _latencies;
+    // Ascending, so the reported buckets come out in order and the last latency is the
+    // maximum. Sorted once for everything below.
+    const latencies = Array.from(this.countByLatency.keys()).sort((a, b) => a - b);
+    const observedCount = this.observedCount();
+    const percentileRanks = REPORTED_QUANTILES.map(quantile => ({
+      key: String(Math.round(quantile * 100)),
+      rank: Math.max(1, Math.ceil(quantile * observedCount))
+    }));
+    const buckets = {};
+    const percentilesMs = {};
+    let sumMs = 0;
+    let counted = 0;
+    for (const latencyMs of latencies) {
+      var _this$countByLatency$, _buckets$bucket;
+      const count = (_this$countByLatency$ = this.countByLatency.get(latencyMs)) !== null && _this$countByLatency$ !== void 0 ? _this$countByLatency$ : 0;
+      sumMs += latencyMs * count;
+      const bucket = String(bucketKeyForMs(latencyMs));
+      buckets[bucket] = ((_buckets$bucket = buckets[bucket]) !== null && _buckets$bucket !== void 0 ? _buckets$bucket : 0) + count;
+
+      // A percentile is the latency the group's interactions reach counting up from the
+      // fastest, so it is answered as soon as this many of them have been passed.
+      counted += count;
+      for (const {
+        key,
+        rank
+      } of percentileRanks) {
+        if (percentilesMs[key] === undefined && counted >= rank) {
+          percentilesMs[key] = latencyMs;
+        }
+      }
+    }
+    return {
+      // `performance.interactionCount` can lag the entries the observer has delivered.
+      totalCount: Math.max(totalCount, observedCount),
+      observedCount,
+      sumMs,
+      maxMs: (_latencies = latencies[latencies.length - 1]) !== null && _latencies !== void 0 ? _latencies : 0,
+      buckets,
+      percentilesMs
+    };
+  }
+  observedCount() {
+    let total = 0;
+    for (const count of this.countByLatency.values()) {
+      total += count;
+    }
+    return total;
+  }
+
+  /** Rounding lives here so that every count goes through the same step, in or out. */
+  roundLatencyUp(latencyMs) {
+    return Math.ceil(latencyMs / RESOLUTION_MS) * RESOLUTION_MS;
+  }
+  increment(latencyMs) {
+    var _this$countByLatency$2;
+    const step = this.roundLatencyUp(latencyMs);
+    this.countByLatency.set(step, ((_this$countByLatency$2 = this.countByLatency.get(step)) !== null && _this$countByLatency$2 !== void 0 ? _this$countByLatency$2 : 0) + 1);
+  }
+  decrement(latencyMs) {
+    var _this$countByLatency$3;
+    const step = this.roundLatencyUp(latencyMs);
+    const next = ((_this$countByLatency$3 = this.countByLatency.get(step)) !== null && _this$countByLatency$3 !== void 0 ? _this$countByLatency$3 : 0) - 1;
+    if (next > 0) {
+      this.countByLatency.set(step, next);
+    } else {
+      this.countByLatency.delete(step);
+    }
+  }
+}

package/dist/es2019/collector/interaction-observer.js

@@ -0,0 +1,90 @@
+import { REPORTING_THRESHOLD_MS } from './bucket-boundaries';
+/** `performance.interactionCount` is Chromium-only and absent from the DOM typings. */
+const interactionCount = () => performance.interactionCount;
+
+/** `durationThreshold` is absent from the DOM typings for `PerformanceObserverInit`. */
+
+/**
+ * Reports the interactions the browser observes to `onEntries`.
+ *
+ * `drain` and `stop` are safe to call before `start` and after each other, so a session
+ * that never started collecting needs no special handling.
+ */
+export class InteractionObserver {
+  /**
+   * Whether the browser reports both things a session needs: `interactionId`, which groups
+   * entries into interactions, and `performance.interactionCount`, which counts the ones
+   * below the reporting threshold. Both are Chromium-only, and without the count
+   * `totalCount` would be indistinguishable from `observedCount`.
+   */
+  static isSupported() {
+    if (typeof window === 'undefined' || typeof PerformanceObserver === 'undefined') {
+      return false;
+    }
+    if (!('PerformanceEventTiming' in window) || !('interactionId' in PerformanceEventTiming.prototype)) {
+      return false;
+    }
+    if (!PerformanceObserver.supportedEntryTypes.includes('event')) {
+      return false;
+    }
+    return typeof interactionCount() === 'number';
+  }
+
+  /**
+   * Total interactions on the page since page load, including those below the reporting
+   * threshold that no observer ever sees. A property of the page, not of an observer.
+   */
+  static readPageInteractionCount() {
+    var _interactionCount;
+    return (_interactionCount = interactionCount()) !== null && _interactionCount !== void 0 ? _interactionCount : 0;
+  }
+  constructor(onEntries) {
+    this.onEntries = onEntries;
+  }
+
+  /**
+   * Starts reporting interactions from this point on. Does nothing when already started, so
+   * a second call cannot leave an observer running with nobody to disconnect it.
+   *
+   * `buffered` is `false`: the entries the browser collected earlier are interactions with
+   * the page while the editor was still loading, and they belong to no session of ours.
+   */
+  start() {
+    if (this.observer) {
+      return;
+    }
+    this.observer = new PerformanceObserver(list => {
+      // Delay by a microtask to work around a Safari bug where the callback is
+      // invoked synchronously rather than in a separate task.
+      // See: https://github.com/GoogleChrome/web-vitals/issues/277
+      Promise.resolve().then(() => {
+        this.onEntries(list.getEntries());
+      });
+    });
+    const init = {
+      type: 'event',
+      buffered: false,
+      // 16 ms is also the smallest value the spec honours; lower values are clamped.
+      durationThreshold: REPORTING_THRESHOLD_MS
+    };
+    this.observer.observe(init);
+  }
+
+  /**
+   * Synchronously reports the entries the browser has produced but not yet dispatched to
+   * the callback. A snapshot taken because the page is going away has to include them,
+   * because there is no later chance to.
+   */
+  drain() {
+    var _this$observer;
+    const entries = (_this$observer = this.observer) === null || _this$observer === void 0 ? void 0 : _this$observer.takeRecords();
+    if (entries) {
+      this.onEntries(entries);
+    }
+  }
+  stop() {
+    var _this$observer2;
+    (_this$observer2 = this.observer) === null || _this$observer2 === void 0 ? void 0 : _this$observer2.disconnect();
+    this.observer = undefined;
+  }
+}

package/dist/es2019/collector/interaction-tracker.js

@@ -0,0 +1,116 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/**
+ * The Event Timing fields this package reads. `interactionId` is missing from the DOM
+ * typings' `PerformanceEventTiming`, so it is declared here as optional, which also makes
+ * a `PerformanceEntry` from `getEntries()` assignable without a cast.
+ */
+
+/**
+ * What an entry did to the interaction it belongs to: either it is the first entry of a new
+ * interaction, or it measured an interaction that was already counted as slower than it was
+ * known to be.
+ */
+
+/**
+ * How many interactions are remembered, so their growth can still be applied. Entries of one
+ * interaction arrive within the interaction itself, so anything older is not needed.
+ */
+const MAX_TRACKED = 256;
+/**
+ * How many are dropped per cleanup. Dropping one at a time would run a cleanup on every new
+ * interaction once the limit is reached; a batch makes it one cleanup per 64 of them.
+ */
+const PRUNE_BATCH = 64;
+
+/**
+ * Groups Event Timing entries into interactions.
+ *
+ * Entries sharing a non-zero `interactionId` are one interaction whose latency is the
+ * maximum `duration` among them. Entries arrive incrementally, so an interaction's latency
+ * can grow after it was first reported — callers apply that to what they already counted
+ * rather than counting the interaction twice.
+ *
+ * A non-zero `interactionId` is the browser's own definition of an interaction, which is
+ * also what INP filters on: it is assigned to the pointer and keyboard events that make one
+ * up, and never to scrolling or pointer movement.
+ */
+export class InteractionTracker {
+  /**
+   * @param startsAfterInteractionId interactions up to and including this one belong to the
+   * previous tracker and are ignored. `interactionId` counts up over the life of the page, so
+   * a session opening mid-page passes the highest id the one before it saw; without that, an
+   * entry still arriving for an interaction from the previous session would look new here and
+   * be counted in both.
+   */
+  constructor(startsAfterInteractionId = 0) {
+    _defineProperty(this, "latencies", new Map());
+    _defineProperty(this, "highestInteractionId", 0);
+    this.startsAfterInteractionId = startsAfterInteractionId;
+  }
+
+  /** The highest `interactionId` this tracker has seen. */
+  get lastInteractionId() {
+    return Math.max(this.highestInteractionId, this.startsAfterInteractionId);
+  }
+
+  /**
+   * Merges an entry into the interaction it belongs to.
+   *
+   * @returns what that did to the interaction's latency, or nothing when the entry is not
+   * part of an interaction, belongs to a previous tracker, or does not change one.
+   */
+  merge(entry) {
+    const {
+      interactionId
+    } = entry;
+    // `first-input` and non-interaction events report `interactionId` 0.
+    if (!interactionId) {
+      return undefined;
+    }
+    if (interactionId <= this.startsAfterInteractionId) {
+      return undefined;
+    }
+    this.highestInteractionId = Math.max(this.highestInteractionId, interactionId);
+
+    // Every latency is counted through here, so this is where one that cannot be measured
+    // is rejected: a `NaN` getting through becomes a `NaN` bucket key and a `NaN` `sumMs`
+    // for the rest of the session.
+    if (!Number.isFinite(entry.duration) || entry.duration < 0) {
+      return undefined;
+    }
+    const previousLatencyMs = this.latencies.get(interactionId);
+    if (previousLatencyMs === undefined) {
+      this.latencies.set(interactionId, entry.duration);
+      this.prune();
+      return {
+        type: 'new',
+        latencyMs: entry.duration
+      };
+    }
+    if (entry.duration <= previousLatencyMs) {
+      return undefined;
+    }
+    this.latencies.set(interactionId, entry.duration);
+    return {
+      type: 'remeasured',
+      fromMs: previousLatencyMs,
+      toMs: entry.duration
+    };
+  }
+  prune() {
+    if (this.latencies.size <= MAX_TRACKED) {
+      return;
+    }
+
+    // `Map` preserves insertion order and `interactionId` increases monotonically,
+    // so the entries inserted first are the least likely to see another entry.
+    let remaining = PRUNE_BATCH;
+    for (const interactionId of this.latencies.keys()) {
+      this.latencies.delete(interactionId);
+      remaining -= 1;
+      if (remaining === 0) {
+        return;
+      }
+    }
+  }
+}