@atlaskit/editor-plugin-interactivity 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @atlaskit/editor-plugin-interactivity
 
+## 1.3.0
+
+### Minor Changes
+
+- [`49ec73019afa7`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/49ec73019afa7) -
+  Add an `editor` group to the `editor interactivity` event: the three editor groups as one, in the
+  same shape, so the session p98 of the editor as a whole can be read from `editor.percentilesMs`.
+
+### Patch Changes
+
+- [`58e0ed4f4c98f`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/58e0ed4f4c98f) -
+  Rank `percentilesMs` in the `editor interactivity` event over `totalCount` rather than
+  `observedCount`, so the interactions below the Event Timing reporting threshold count towards the
+  percentile as they do for INP. A percentile that falls among them is reported as the
+  threshold, 16.
+
+## 1.2.1
+
+### Patch Changes
+
+- [`f1f320e43a22e`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/f1f320e43a22e) -
+  Ignore untrusted events in the `editor interactivity` collector, so events a script dispatched are
+  no longer counted as interactions with the editor.
+- Updated dependencies
+
 ## 1.2.0
 
 ### Minor Changes

package/README.md

@@ -10,22 +10,24 @@ be able to use this component but will not be able to submit issues.
 The Interactivity plugin reports the `editor interactivity` operational event: session-to-date
 interaction latency distributions for full page editor sessions, per
 [RFC 095](https://hello.atlassian.net/wiki/spaces/EDITOR/pages/7527607488/Editor+RFC+095+Confluence+editor+responsiveness+bucketed+INP+telemetry).
-The existing `editor inp` event reports a single value per session and cannot answer how many
-interactions were slow, so this plugin keeps bucketed counts instead.
+Signals that report one value per session cannot answer how many interactions were slow, so this
+plugin keeps bucketed counts instead.
 
 ## What it reports
 
 - `page` — every interaction on the page, as `totalCount`, `observedCount`, `sumMs`, `maxMs`,
   `buckets` and `percentilesMs`. `totalCount` comes from `performance.interactionCount` and includes
   interactions below the 16 ms Event Timing reporting threshold, so `totalCount - observedCount` is
-  the sub-threshold count.
+  the sub-threshold count. `percentilesMs` ranks over `totalCount`, as INP does, so a percentile that
+  falls among the sub-threshold interactions reads as 16.
 - `editorTyping`, `editorPointer` and `editorOther` — the interactions with the editor, in the same
   shape as `page`. Event Timing observes the whole document, so `page` alone cannot say whether a
   regression is in the editor or elsewhere on the page; these can. Every interaction with the editor
   is in exactly one of them, and in `page` as well.
-- `percentilesMs` is temporary. It holds percentiles of the same interactions, keyed by percentile
-  and exact to the 8 ms Event Timing reports durations at, to confirm that a percentile read off
-  `buckets` lands where the latencies actually are.
+- `editor` — the three editor groups as one, in the same shape: the per-session p98 of the editor as
+  a whole, which theirs cannot give.
+- `percentilesMs` — percentiles of the same interactions, keyed by percentile and exact to the 8 ms
+  Event Timing reports durations at; a per-session metric reads these rather than `buckets`.
 - Bucket keys are the upper boundary of the bucket in milliseconds and count only interactions above
   the previous boundary. Buckets are not cumulative and empty buckets are omitted, so a missing
   bucket means zero. The boundaries are versioned by `schema`.

package/dist/cjs/collector/interaction-events.js

@@ -18,6 +18,10 @@ exports.interactionEventKind = interactionEventKind;
  * every repeat of a held key, and nothing cancels a key press. Pointing is counted on `pointerup`,
  * since a press cannot repeat but can be taken over by a scroll — which the browser does not count
  * either, and in that case `pointerup` never arrives.
+ *
+ * Counting events is also why an editor group's `totalCount` is not comparable with `page`'s, which
+ * is told `performance.interactionCount`: when an event is counted the collector cannot know whether
+ * the browser will open an interaction for it.
  */
 var INTERACTION_EVENTS = {
   keydown: {

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

@@ -102,28 +102,73 @@ var InteractionGroup = exports.InteractionGroup = /*#__PURE__*/function () {
     value: function snapshot() {
       var _latencies;
       var totalCount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.totalCount;
+      var observedCount = this.observedCount();
+      // `performance.interactionCount` can lag the entries the observer has delivered.
+      var reportedTotalCount = Math.max(totalCount, observedCount);
+      if (reportedTotalCount === 0) {
+        return {
+          totalCount: 0,
+          observedCount: 0,
+          sumMs: 0,
+          maxMs: 0,
+          buckets: {},
+          percentilesMs: {}
+        };
+      }
+
       // Ascending, so the reported buckets come out in order and the last latency is the
       // maximum. Sorted once for everything below.
       var latencies = Array.from(this.countByLatency.keys()).sort(function (a, b) {
         return a - b;
       });
-      var observedCount = this.observedCount();
+
+      // A percentile is the interaction at position `ceil(quantile * total)` of all interactions
+      // sorted by latency. Event Timing never reports the ones under 16 ms, but they are the fastest,
+      // so they fill the front of the line, and the rank is the position among the measured ones:
+      //
+      //   250 interactions, 150 of them unmeasured
+      //
+      //   position   1 ........... 150   | 151 ........... 245 .... 250
+      //   latency    unmeasured, < 16 ms | 16 ms ............. measured
+      //                                                    ^ p98
+      //
+      //   p98 is position ceil(0.98 * 250) = 245 of all, rank 245 - 150 = 95 among the measured.
+      var unmeasuredCount = reportedTotalCount - observedCount;
       var percentileRanks = REPORTED_QUANTILES.map(function (quantile) {
         return {
           key: String(Math.round(quantile * 100)),
-          rank: Math.max(1, Math.ceil(quantile * observedCount))
+          rank: Math.ceil(quantile * reportedTotalCount) - unmeasuredCount
         };
       });
       var buckets = {};
       var percentilesMs = {};
       var sumMs = 0;
       var counted = 0;
-      var _iterator = _createForOfIteratorHelper(latencies),
+
+      // A rank of 0 or below is a latency Event Timing never reports, so the percentile gets the
+      // lowest one it does.
+      var _iterator = _createForOfIteratorHelper(percentileRanks),
         _step;
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _step.value,
+            key = _step$value.key,
+            rank = _step$value.rank;
+          if (rank <= 0) {
+            percentilesMs[key] = _bucketBoundaries.REPORTING_THRESHOLD_MS;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      var _iterator2 = _createForOfIteratorHelper(latencies),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
           var _this$countByLatency$, _buckets$bucket;
-          var latencyMs = _step.value;
+          var latencyMs = _step2.value;
           var count = (_this$countByLatency$ = this.countByLatency.get(latencyMs)) !== null && _this$countByLatency$ !== void 0 ? _this$countByLatency$ : 0;
           sumMs += latencyMs * count;
           var bucket = String((0, _bucketBoundaries.bucketKeyForMs)(latencyMs));
@@ -132,31 +177,30 @@ var InteractionGroup = exports.InteractionGroup = /*#__PURE__*/function () {
           // 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;
-          var _iterator2 = _createForOfIteratorHelper(percentileRanks),
-            _step2;
+          var _iterator3 = _createForOfIteratorHelper(percentileRanks),
+            _step3;
           try {
-            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-              var _step2$value = _step2.value,
-                key = _step2$value.key,
-                rank = _step2$value.rank;
-              if (percentilesMs[key] === undefined && counted >= rank) {
-                percentilesMs[key] = latencyMs;
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var _step3$value = _step3.value,
+                _key = _step3$value.key,
+                _rank = _step3$value.rank;
+              if (percentilesMs[_key] === undefined && counted >= _rank) {
+                percentilesMs[_key] = latencyMs;
               }
             }
           } catch (err) {
-            _iterator2.e(err);
+            _iterator3.e(err);
           } finally {
-            _iterator2.f();
+            _iterator3.f();
           }
         }
       } catch (err) {
-        _iterator.e(err);
+        _iterator2.e(err);
       } finally {
-        _iterator.f();
+        _iterator2.f();
       }
       return {
-        // `performance.interactionCount` can lag the entries the observer has delivered.
-        totalCount: Math.max(totalCount, observedCount),
+        totalCount: reportedTotalCount,
         observedCount: observedCount,
         sumMs: sumMs,
         maxMs: (_latencies = latencies[latencies.length - 1]) !== null && _latencies !== void 0 ? _latencies : 0,
@@ -168,17 +212,17 @@ var InteractionGroup = exports.InteractionGroup = /*#__PURE__*/function () {
     key: "observedCount",
     value: function observedCount() {
       var total = 0;
-      var _iterator3 = _createForOfIteratorHelper(this.countByLatency.values()),
-        _step3;
+      var _iterator4 = _createForOfIteratorHelper(this.countByLatency.values()),
+        _step4;
       try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var count = _step3.value;
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var count = _step4.value;
           total += count;
         }
       } catch (err) {
-        _iterator3.e(err);
+        _iterator4.e(err);
       } finally {
-        _iterator3.f();
+        _iterator4.f();
       }
       return total;
     }

package/dist/cjs/collector/interactivity-collector.js

@@ -25,8 +25,8 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
 /**
  * Collects interaction latencies for one editor mount and emits session-to-date snapshots.
  *
- * Every interaction is counted in `page`, and the ones with the editor again in one of the editor
- * groups, which is what tells a slow editor apart from a slow page around it.
+ * Every interaction is counted in `page`, and the ones with the editor again in `editor` and in one
+ * of the editor groups, which is what tells a slow editor apart from a slow page around it.
  *
  * `start` and `stop` bound the collecting, which happens once. Within it there can be several
  * sessions, because a session covers one document in one mode: a Confluence live page
@@ -256,11 +256,16 @@ var InteractivityCollector = exports.InteractivityCollector = /*#__PURE__*/funct
       if (this.stopped) {
         return;
       }
+
+      // An event a script dispatched is no interaction: the browser counts none of them either.
+      if (!event.isTrusted) {
+        return;
+      }
       var group = this.session.tracker.recordEditorEvent(event);
       if (!group) {
         return;
       }
-
+      this.session.editor.countTotal();
       // The session names its editor groups after the fields they are reported in.
       this.session[group].countTotal();
       this.session.revision += 1;
@@ -294,6 +299,7 @@ var InteractivityCollector = exports.InteractivityCollector = /*#__PURE__*/funct
               var update = _step2.value;
               var groupsChanged = this.session.page.trackInteractionUpdate(update);
               if (update.group) {
+                groupsChanged = this.session.editor.trackInteractionUpdate(update) || groupsChanged;
                 groupsChanged = this.session[update.group].trackInteractionUpdate(update) || groupsChanged;
               }
               var slowestChanged = (_this$session$slowest2 = this.session.slowest) === null || _this$session$slowest2 === void 0 ? void 0 : _this$session$slowest2.trackInteractionUpdate(entry, update);
@@ -360,6 +366,7 @@ var InteractivityCollector = exports.InteractivityCollector = /*#__PURE__*/funct
         editorDomSize: this.getEditorDomSize(),
         // Only `page` is told its total; each editor group has counted its own.
         page: session.page.snapshot(pageTotalCount),
+        editor: session.editor.snapshot(),
         editorTyping: session.editorTyping.snapshot(),
         editorPointer: session.editorPointer.snapshot(),
         editorOther: session.editorOther.snapshot()

package/dist/cjs/collector/interactivity-session.js

@@ -36,6 +36,7 @@ var InteractivitySession = exports.InteractivitySession = /*#__PURE__*/(0, _crea
   /** Page interaction count when the session opened, subtracted to get its own total. */
   (0, _defineProperty2.default)(this, "interactionCountAtStart", _interactionObserver.InteractionObserver.readPageInteractionCount());
   (0, _defineProperty2.default)(this, "page", new _interactionGroup.InteractionGroup());
+  (0, _defineProperty2.default)(this, "editor", new _interactionGroup.InteractionGroup());
   (0, _defineProperty2.default)(this, "editorTyping", new _interactionGroup.InteractionGroup());
   (0, _defineProperty2.default)(this, "editorPointer", new _interactionGroup.InteractionGroup());
   (0, _defineProperty2.default)(this, "editorOther", new _interactionGroup.InteractionGroup());

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

@@ -11,6 +11,10 @@
  * every repeat of a held key, and nothing cancels a key press. Pointing is counted on `pointerup`,
  * since a press cannot repeat but can be taken over by a scroll — which the browser does not count
  * either, and in that case `pointerup` never arrives.
+ *
+ * Counting events is also why an editor group's `totalCount` is not comparable with `page`'s, which
+ * is told `performance.interactionCount`: when an event is counted the collector cannot know whether
+ * the browser will open an interaction for it.
  */
 const INTERACTION_EVENTS = {
   keydown: {

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

@@ -1,5 +1,5 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import { bucketKeyForMs } from './bucket-boundaries';
+import { bucketKeyForMs, REPORTING_THRESHOLD_MS } 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
@@ -77,18 +77,55 @@ export class InteractionGroup {
    */
   snapshot(totalCount = this.totalCount) {
     var _latencies;
+    const observedCount = this.observedCount();
+    // `performance.interactionCount` can lag the entries the observer has delivered.
+    const reportedTotalCount = Math.max(totalCount, observedCount);
+    if (reportedTotalCount === 0) {
+      return {
+        totalCount: 0,
+        observedCount: 0,
+        sumMs: 0,
+        maxMs: 0,
+        buckets: {},
+        percentilesMs: {}
+      };
+    }
+
     // 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();
+
+    // A percentile is the interaction at position `ceil(quantile * total)` of all interactions
+    // sorted by latency. Event Timing never reports the ones under 16 ms, but they are the fastest,
+    // so they fill the front of the line, and the rank is the position among the measured ones:
+    //
+    //   250 interactions, 150 of them unmeasured
+    //
+    //   position   1 ........... 150   | 151 ........... 245 .... 250
+    //   latency    unmeasured, < 16 ms | 16 ms ............. measured
+    //                                                    ^ p98
+    //
+    //   p98 is position ceil(0.98 * 250) = 245 of all, rank 245 - 150 = 95 among the measured.
+    const unmeasuredCount = reportedTotalCount - observedCount;
     const percentileRanks = REPORTED_QUANTILES.map(quantile => ({
       key: String(Math.round(quantile * 100)),
-      rank: Math.max(1, Math.ceil(quantile * observedCount))
+      rank: Math.ceil(quantile * reportedTotalCount) - unmeasuredCount
     }));
     const buckets = {};
     const percentilesMs = {};
     let sumMs = 0;
     let counted = 0;
+
+    // A rank of 0 or below is a latency Event Timing never reports, so the percentile gets the
+    // lowest one it does.
+    for (const {
+      key,
+      rank
+    } of percentileRanks) {
+      if (rank <= 0) {
+        percentilesMs[key] = REPORTING_THRESHOLD_MS;
+      }
+    }
     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;
@@ -109,8 +146,7 @@ export class InteractionGroup {
       }
     }
     return {
-      // `performance.interactionCount` can lag the entries the observer has delivered.
-      totalCount: Math.max(totalCount, observedCount),
+      totalCount: reportedTotalCount,
       observedCount,
       sumMs,
       maxMs: (_latencies = latencies[latencies.length - 1]) !== null && _latencies !== void 0 ? _latencies : 0,

package/dist/es2019/collector/interactivity-collector.js

@@ -11,8 +11,8 @@ import { SnapshotScheduler } from './snapshot-scheduler';
 /**
  * Collects interaction latencies for one editor mount and emits session-to-date snapshots.
  *
- * Every interaction is counted in `page`, and the ones with the editor again in one of the editor
- * groups, which is what tells a slow editor apart from a slow page around it.
+ * Every interaction is counted in `page`, and the ones with the editor again in `editor` and in one
+ * of the editor groups, which is what tells a slow editor apart from a slow page around it.
  *
  * `start` and `stop` bound the collecting, which happens once. Within it there can be several
  * sessions, because a session covers one document in one mode: a Confluence live page
@@ -198,11 +198,16 @@ export class InteractivityCollector {
     if (this.stopped) {
       return;
     }
+
+    // An event a script dispatched is no interaction: the browser counts none of them either.
+    if (!event.isTrusted) {
+      return;
+    }
     const group = this.session.tracker.recordEditorEvent(event);
     if (!group) {
       return;
     }
-
+    this.session.editor.countTotal();
     // The session names its editor groups after the fields they are reported in.
     this.session[group].countTotal();
     this.session.revision += 1;
@@ -224,6 +229,7 @@ export class InteractivityCollector {
         var _this$session$slowest2;
         let groupsChanged = this.session.page.trackInteractionUpdate(update);
         if (update.group) {
+          groupsChanged = this.session.editor.trackInteractionUpdate(update) || groupsChanged;
           groupsChanged = this.session[update.group].trackInteractionUpdate(update) || groupsChanged;
         }
         const slowestChanged = (_this$session$slowest2 = this.session.slowest) === null || _this$session$slowest2 === void 0 ? void 0 : _this$session$slowest2.trackInteractionUpdate(entry, update);
@@ -278,6 +284,7 @@ export class InteractivityCollector {
       editorDomSize: this.getEditorDomSize(),
       // Only `page` is told its total; each editor group has counted its own.
       page: session.page.snapshot(pageTotalCount),
+      editor: session.editor.snapshot(),
       editorTyping: session.editorTyping.snapshot(),
       editorPointer: session.editorPointer.snapshot(),
       editorOther: session.editorOther.snapshot(),

package/dist/es2019/collector/interactivity-session.js

@@ -25,6 +25,7 @@ export class InteractivitySession {
     /** Page interaction count when the session opened, subtracted to get its own total. */
     _defineProperty(this, "interactionCountAtStart", InteractionObserver.readPageInteractionCount());
     _defineProperty(this, "page", new InteractionGroup());
+    _defineProperty(this, "editor", new InteractionGroup());
     _defineProperty(this, "editorTyping", new InteractionGroup());
     _defineProperty(this, "editorPointer", new InteractionGroup());
     _defineProperty(this, "editorOther", new InteractionGroup());

package/dist/esm/collector/interaction-events.js

@@ -11,6 +11,10 @@
  * every repeat of a held key, and nothing cancels a key press. Pointing is counted on `pointerup`,
  * since a press cannot repeat but can be taken over by a scroll — which the browser does not count
  * either, and in that case `pointerup` never arrives.
+ *
+ * Counting events is also why an editor group's `totalCount` is not comparable with `page`'s, which
+ * is told `performance.interactionCount`: when an event is counted the collector cannot know whether
+ * the browser will open an interaction for it.
  */
 var INTERACTION_EVENTS = {
   keydown: {

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

@@ -4,7 +4,7 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-import { bucketKeyForMs } from './bucket-boundaries';
+import { bucketKeyForMs, REPORTING_THRESHOLD_MS } 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
@@ -95,28 +95,73 @@ export var InteractionGroup = /*#__PURE__*/function () {
     value: function snapshot() {
       var _latencies;
       var totalCount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.totalCount;
+      var observedCount = this.observedCount();
+      // `performance.interactionCount` can lag the entries the observer has delivered.
+      var reportedTotalCount = Math.max(totalCount, observedCount);
+      if (reportedTotalCount === 0) {
+        return {
+          totalCount: 0,
+          observedCount: 0,
+          sumMs: 0,
+          maxMs: 0,
+          buckets: {},
+          percentilesMs: {}
+        };
+      }
+
       // Ascending, so the reported buckets come out in order and the last latency is the
       // maximum. Sorted once for everything below.
       var latencies = Array.from(this.countByLatency.keys()).sort(function (a, b) {
         return a - b;
       });
-      var observedCount = this.observedCount();
+
+      // A percentile is the interaction at position `ceil(quantile * total)` of all interactions
+      // sorted by latency. Event Timing never reports the ones under 16 ms, but they are the fastest,
+      // so they fill the front of the line, and the rank is the position among the measured ones:
+      //
+      //   250 interactions, 150 of them unmeasured
+      //
+      //   position   1 ........... 150   | 151 ........... 245 .... 250
+      //   latency    unmeasured, < 16 ms | 16 ms ............. measured
+      //                                                    ^ p98
+      //
+      //   p98 is position ceil(0.98 * 250) = 245 of all, rank 245 - 150 = 95 among the measured.
+      var unmeasuredCount = reportedTotalCount - observedCount;
       var percentileRanks = REPORTED_QUANTILES.map(function (quantile) {
         return {
           key: String(Math.round(quantile * 100)),
-          rank: Math.max(1, Math.ceil(quantile * observedCount))
+          rank: Math.ceil(quantile * reportedTotalCount) - unmeasuredCount
         };
       });
       var buckets = {};
       var percentilesMs = {};
       var sumMs = 0;
       var counted = 0;
-      var _iterator = _createForOfIteratorHelper(latencies),
+
+      // A rank of 0 or below is a latency Event Timing never reports, so the percentile gets the
+      // lowest one it does.
+      var _iterator = _createForOfIteratorHelper(percentileRanks),
         _step;
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _step.value,
+            key = _step$value.key,
+            rank = _step$value.rank;
+          if (rank <= 0) {
+            percentilesMs[key] = REPORTING_THRESHOLD_MS;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      var _iterator2 = _createForOfIteratorHelper(latencies),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
           var _this$countByLatency$, _buckets$bucket;
-          var latencyMs = _step.value;
+          var latencyMs = _step2.value;
           var count = (_this$countByLatency$ = this.countByLatency.get(latencyMs)) !== null && _this$countByLatency$ !== void 0 ? _this$countByLatency$ : 0;
           sumMs += latencyMs * count;
           var bucket = String(bucketKeyForMs(latencyMs));
@@ -125,31 +170,30 @@ export var InteractionGroup = /*#__PURE__*/function () {
           // 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;
-          var _iterator2 = _createForOfIteratorHelper(percentileRanks),
-            _step2;
+          var _iterator3 = _createForOfIteratorHelper(percentileRanks),
+            _step3;
           try {
-            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-              var _step2$value = _step2.value,
-                key = _step2$value.key,
-                rank = _step2$value.rank;
-              if (percentilesMs[key] === undefined && counted >= rank) {
-                percentilesMs[key] = latencyMs;
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var _step3$value = _step3.value,
+                _key = _step3$value.key,
+                _rank = _step3$value.rank;
+              if (percentilesMs[_key] === undefined && counted >= _rank) {
+                percentilesMs[_key] = latencyMs;
               }
             }
           } catch (err) {
-            _iterator2.e(err);
+            _iterator3.e(err);
           } finally {
-            _iterator2.f();
+            _iterator3.f();
           }
         }
       } catch (err) {
-        _iterator.e(err);
+        _iterator2.e(err);
       } finally {
-        _iterator.f();
+        _iterator2.f();
       }
       return {
-        // `performance.interactionCount` can lag the entries the observer has delivered.
-        totalCount: Math.max(totalCount, observedCount),
+        totalCount: reportedTotalCount,
         observedCount: observedCount,
         sumMs: sumMs,
         maxMs: (_latencies = latencies[latencies.length - 1]) !== null && _latencies !== void 0 ? _latencies : 0,
@@ -161,17 +205,17 @@ export var InteractionGroup = /*#__PURE__*/function () {
     key: "observedCount",
     value: function observedCount() {
       var total = 0;
-      var _iterator3 = _createForOfIteratorHelper(this.countByLatency.values()),
-        _step3;
+      var _iterator4 = _createForOfIteratorHelper(this.countByLatency.values()),
+        _step4;
       try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var count = _step3.value;
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var count = _step4.value;
           total += count;
         }
       } catch (err) {
-        _iterator3.e(err);
+        _iterator4.e(err);
       } finally {
-        _iterator3.f();
+        _iterator4.f();
       }
       return total;
     }

package/dist/esm/collector/interactivity-collector.js

@@ -18,8 +18,8 @@ import { SnapshotScheduler } from './snapshot-scheduler';
 /**
  * Collects interaction latencies for one editor mount and emits session-to-date snapshots.
  *
- * Every interaction is counted in `page`, and the ones with the editor again in one of the editor
- * groups, which is what tells a slow editor apart from a slow page around it.
+ * Every interaction is counted in `page`, and the ones with the editor again in `editor` and in one
+ * of the editor groups, which is what tells a slow editor apart from a slow page around it.
  *
  * `start` and `stop` bound the collecting, which happens once. Within it there can be several
  * sessions, because a session covers one document in one mode: a Confluence live page
@@ -249,11 +249,16 @@ export var InteractivityCollector = /*#__PURE__*/function () {
       if (this.stopped) {
         return;
       }
+
+      // An event a script dispatched is no interaction: the browser counts none of them either.
+      if (!event.isTrusted) {
+        return;
+      }
       var group = this.session.tracker.recordEditorEvent(event);
       if (!group) {
         return;
       }
-
+      this.session.editor.countTotal();
       // The session names its editor groups after the fields they are reported in.
       this.session[group].countTotal();
       this.session.revision += 1;
@@ -287,6 +292,7 @@ export var InteractivityCollector = /*#__PURE__*/function () {
               var update = _step2.value;
               var groupsChanged = this.session.page.trackInteractionUpdate(update);
               if (update.group) {
+                groupsChanged = this.session.editor.trackInteractionUpdate(update) || groupsChanged;
                 groupsChanged = this.session[update.group].trackInteractionUpdate(update) || groupsChanged;
               }
               var slowestChanged = (_this$session$slowest2 = this.session.slowest) === null || _this$session$slowest2 === void 0 ? void 0 : _this$session$slowest2.trackInteractionUpdate(entry, update);
@@ -353,6 +359,7 @@ export var InteractivityCollector = /*#__PURE__*/function () {
         editorDomSize: this.getEditorDomSize(),
         // Only `page` is told its total; each editor group has counted its own.
         page: session.page.snapshot(pageTotalCount),
+        editor: session.editor.snapshot(),
         editorTyping: session.editorTyping.snapshot(),
         editorPointer: session.editorPointer.snapshot(),
         editorOther: session.editorOther.snapshot()

package/dist/esm/collector/interactivity-session.js

@@ -29,6 +29,7 @@ export var InteractivitySession = /*#__PURE__*/_createClass(function Interactivi
   /** Page interaction count when the session opened, subtracted to get its own total. */
   _defineProperty(this, "interactionCountAtStart", InteractionObserver.readPageInteractionCount());
   _defineProperty(this, "page", new InteractionGroup());
+  _defineProperty(this, "editor", new InteractionGroup());
   _defineProperty(this, "editorTyping", new InteractionGroup());
   _defineProperty(this, "editorPointer", new InteractionGroup());
   _defineProperty(this, "editorOther", new InteractionGroup());

package/dist/types/analytics/interactivity-snapshot.d.ts

@@ -87,19 +87,16 @@ export type SlowInteraction = {
  * Session-to-date latency distribution for one group of interactions.
  *
  * `totalCount` counts every interaction, including those below the Event Timing reporting
- * threshold, so `totalCount - observedCount` is the sub-threshold count. `buckets` is keyed by
- * each bucket's upper boundary in milliseconds and is not cumulative; empty buckets are
+ * threshold, so `totalCount - observedCount` is the sub-threshold count. `percentilesMs` ranks over
+ * `totalCount`, so a percentile among the sub-threshold interactions reads as the threshold. `buckets`
+ * is keyed by each bucket's upper boundary in milliseconds and is not cumulative; empty buckets are
  * omitted, so a missing bucket means zero.
  */
 export type InteractionGroupSnapshot = {
     buckets: Record<string, number>;
     maxMs: number;
     observedCount: number;
-    /**
-     * Temporary. Percentiles of the same interactions, keyed by percentile and exact to the 8 ms
-     * Event Timing reports durations at, to confirm that a percentile read off `buckets` lands
-     * where the latencies actually are. Goes once that is established.
-     */
+    /** Percentiles of the same interactions, keyed by percentile and exact to the 8 ms of Event Timing. */
     percentilesMs: Record<string, number>;
     sumMs: number;
     totalCount: number;
@@ -110,6 +107,8 @@ export type InteractionGroupSnapshot = {
  */
 export type InteractivitySnapshot = {
     activeMs: number;
+    /** The three editor groups as one; a percentile of the union cannot be derived from theirs. */
+    editor: InteractionGroupSnapshot;
     editorDomSize?: number;
     /** Interactions inside the editor that are neither typing nor pointing. */
     editorOther: InteractionGroupSnapshot;

package/dist/types/collector/interactivity-collector.d.ts

@@ -11,8 +11,8 @@ export type InteractivityCollectorOptions = {
 /**
  * Collects interaction latencies for one editor mount and emits session-to-date snapshots.
  *
- * Every interaction is counted in `page`, and the ones with the editor again in one of the editor
- * groups, which is what tells a slow editor apart from a slow page around it.
+ * Every interaction is counted in `page`, and the ones with the editor again in `editor` and in one
+ * of the editor groups, which is what tells a slow editor apart from a slow page around it.
  *
  * `start` and `stop` bound the collecting, which happens once. Within it there can be several
  * sessions, because a session covers one document in one mode: a Confluence live page

package/dist/types/collector/interactivity-session.d.ts

@@ -21,6 +21,7 @@ export declare class InteractivitySession {
     readonly interactionCountAtStart: number;
     readonly tracker: InteractionTracker;
     readonly page: InteractionGroup;
+    readonly editor: InteractionGroup;
     readonly editorTyping: InteractionGroup;
     readonly editorPointer: InteractionGroup;
     readonly editorOther: InteractionGroup;

package/docs/0-intro.tsx

@@ -24,8 +24,9 @@ ${createEditorUseOnlyNotice('Editor Plugin Interactivity', [
   This package includes the interactivity plugin used by \`@atlaskit/editor-core\`.
 
   It reports the \`editor interactivity\` operational event: session-to-date interaction latency
-  histograms for full page editor sessions — for the page as a whole, and for the editor's typing,
-  pointer and other interactions — along with the slowest interactions of the session, per
+  histograms for full page editor sessions — for the page as a whole, for the editor as a whole, and
+  for the editor's typing, pointer and other interactions — along with the slowest interactions of
+  the session, per
   [RFC 095](https://hello.atlassian.net/wiki/spaces/EDITOR/pages/7527607488/Editor+RFC+095+Confluence+editor+responsiveness+bucketed+INP+telemetry).
   See the package README for the event shape, the snapshot cadence and what ends a session.
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-interactivity",
-	"version": "1.2.0",
+	"version": "1.3.0",
 	"description": "Interactivity plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -28,47 +28,11 @@
 		"bind-event-listener": "^3.0.0"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^120.10.0",
+		"@atlaskit/editor-common": "^120.16.0",
 		"react": "^18.2.0 || ^19.2.0"
 	},
 	"devDependencies": {
 		"react": "^19.2.0",
 		"typescript": "npm:@typescript/typescript6@^6.0.2"
-	},
-	"techstack": {
-		"@atlassian/frontend": {
-			"code-structure": [
-				"editor-plugin"
-			],
-			"import-structure": [
-				"atlassian-conventions"
-			],
-			"circular-dependencies": [
-				"file-and-folder-level"
-			]
-		},
-		"@repo/internal": {
-			"dom-events": "use-bind-event-listener",
-			"analytics": [
-				"analytics-next"
-			],
-			"design-tokens": [
-				"color"
-			],
-			"theming": [
-				"react-context"
-			],
-			"ui-components": [
-				"lite-mode"
-			],
-			"deprecation": "no-deprecated-imports",
-			"styling": [
-				"emotion",
-				"emotion"
-			],
-			"imports": [
-				"import-no-extraneous-disable-for-examples-and-docs"
-			]
-		}
 	}
 }