@atlaskit/insm 1.2.11 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @atlaskit/insm
 
+## 1.3.0
+
+### Minor Changes
+
+- [`60bbe3aea8c6e`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/60bbe3aea8c6e) -
+  Add editorDomSize (the page editor's DOM element count) to the insm measured event, and new
+  registerEditorDom / unregisterEditorDom apis for the editor to provide the element to measure.
+  Behind the platform_editor_insm_dom_node_count experiment.
+
+  The insm api is now also available from the `@atlaskit/insm/api` entry point, so consumers do not
+  have to import it from the package barrel. The barrel export is unchanged.
+
+## 1.2.12
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 1.2.11
 
 ### Patch Changes

package/api/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@atlaskit/insm/api",
+  "main": "../dist/cjs/api.js",
+  "module": "../dist/esm/api.js",
+  "module:es2019": "../dist/es2019/api.js",
+  "types": "../dist/types/api.d.ts"
+}

package/dist/cjs/api.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init = init;
+exports.insm = void 0;
+var _insm = require("./insm");
+var initialisedInsm;
+
+/**
+ * Initializes the INSM (Interactivity Session Measurement) tooling
+ */
+function init(options) {
+  initialisedInsm = new _insm.INSM(options);
+}
+function insmInitialised() {
+  if (!initialisedInsm) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * **In**teractivity **s**ession **m**onitoring
+ */
+var insm = exports.insm = {
+  startHeavyTask: function startHeavyTask(heavyTaskName) {
+    if (insmInitialised()) {
+      initialisedInsm.startHeavyTask(heavyTaskName);
+    }
+  },
+  endHeavyTask: function endHeavyTask(heavyTaskName) {
+    if (insmInitialised()) {
+      initialisedInsm.endHeavyTask(heavyTaskName);
+    }
+  },
+  registerEditorDom: function registerEditorDom(editorDom) {
+    if (insmInitialised()) {
+      initialisedInsm.registerEditorDom(editorDom);
+    }
+  },
+  unregisterEditorDom: function unregisterEditorDom(editorDom) {
+    if (insmInitialised()) {
+      initialisedInsm.unregisterEditorDom(editorDom);
+    }
+  },
+  start: function start(experienceKey, experienceProperties) {
+    if (insmInitialised()) {
+      initialisedInsm.start(experienceKey, experienceProperties);
+    }
+  },
+  overrideExperienceKey: function overrideExperienceKey(experienceKey) {
+    if (insmInitialised()) {
+      initialisedInsm.overrideExperienceKey(experienceKey);
+    }
+  },
+  stopEarly: function stopEarly(reasonKey, description) {
+    if (insmInitialised()) {
+      initialisedInsm.stopEarly(reasonKey, description);
+    }
+  },
+  // We only expose details and feature start/stop to consumers
+  // as the other properties are internals for the insm and InsmPeriod
+  // to interact with the running session.
+  get session() {
+    if (insmInitialised()) {
+      return initialisedInsm.runningSession;
+    }
+  },
+  // @ts-expect-error Private method for testing purposes
+  __setAnalyticsWebClient: function __setAnalyticsWebClient(analyticsWebClient) {
+    if (initialisedInsm) {
+      initialisedInsm.analyticsWebClient = analyticsWebClient;
+    }
+  }
+};

package/dist/cjs/dom-element-count.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.countDomElements = countDomElements;
+/**
+ * Returns the total number of DOM elements inside the given element.
+ *
+ * Uses the native `getElementsByTagName('*')`, which counts descendants iteratively in the
+ * browser engine -- intentionally not a recursive JS walk, so it can't overflow the stack on
+ * very large documents.
+ */
+function countDomElements(element) {
+  return element.getElementsByTagName('*').length;
+}

package/dist/cjs/editor-dom-registry.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EditorDomRegistry = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+/**
+ * Holds the page editor's content DOM.
+ *
+ * insm holds no reference to the editor, so the element is registered from the outside — it is
+ * the same `editorView.dom` element the editor measures for the `editorDomSize` attribute on
+ * its INP event.
+ *
+ * Only the page editor registers itself: an insm session measures a page, and secondary
+ * editors on the page (inline comments, nested legacy content extensions) would make the
+ * registration ambiguous.
+ *
+ * The element is held via a `WeakRef` so a destroyed editor's DOM can be collected even if
+ * `unregister` is never reached.
+ */
+var EditorDomRegistry = exports.EditorDomRegistry = /*#__PURE__*/function () {
+  function EditorDomRegistry() {
+    (0, _classCallCheck2.default)(this, EditorDomRegistry);
+  }
+  return (0, _createClass2.default)(EditorDomRegistry, [{
+    key: "register",
+    value:
+    /**
+     * Registers the page editor's content DOM element (`editorView.dom`).
+     */
+    function register(editorDom) {
+      this.registered = new WeakRef(editorDom);
+    }
+
+    /**
+     * Unregisters an editor's content DOM element. Expected to be called when the editor is
+     * destroyed. Ignored when a different editor is currently registered, so an editor being
+     * torn down after its replacement registered does not clear the newer one.
+     */
+  }, {
+    key: "unregister",
+    value: function unregister(editorDom) {
+      var _this$registered;
+      if (((_this$registered = this.registered) === null || _this$registered === void 0 ? void 0 : _this$registered.deref()) === editorDom) {
+        this.registered = undefined;
+      }
+    }
+
+    /**
+     * The registered editor's content DOM, or undefined when no editor is registered or the
+     * registered one is no longer in the document -- ie. an experience without a page editor,
+     * or a session which outlived the editor.
+     */
+  }, {
+    key: "editorDom",
+    get: function get() {
+      var _this$registered2;
+      var editorDom = (_this$registered2 = this.registered) === null || _this$registered2 === void 0 ? void 0 : _this$registered2.deref();
+      return editorDom !== null && editorDom !== void 0 && editorDom.isConnected ? editorDom : undefined;
+    }
+  }]);
+}();

package/dist/cjs/index.js

@@ -3,65 +3,16 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.init = init;
-exports.insm = void 0;
-var _insm = require("./insm");
-var initialisedInsm;
-
-/**
- * Initializes the INSM (Interactivity Session Measurement) tooling
- */
-function init(options) {
-  initialisedInsm = new _insm.INSM(options);
-}
-function insmInitialised() {
-  if (!initialisedInsm) {
-    return false;
+Object.defineProperty(exports, "init", {
+  enumerable: true,
+  get: function get() {
+    return _api.init;
   }
-  return true;
-}
-
-/**
- * **In**teractivity **s**ession **m**onitoring
- */
-var insm = exports.insm = {
-  startHeavyTask: function startHeavyTask(heavyTaskName) {
-    if (insmInitialised()) {
-      initialisedInsm.startHeavyTask(heavyTaskName);
-    }
-  },
-  endHeavyTask: function endHeavyTask(heavyTaskName) {
-    if (insmInitialised()) {
-      initialisedInsm.endHeavyTask(heavyTaskName);
-    }
-  },
-  start: function start(experienceKey, experienceProperties) {
-    if (insmInitialised()) {
-      initialisedInsm.start(experienceKey, experienceProperties);
-    }
-  },
-  overrideExperienceKey: function overrideExperienceKey(experienceKey) {
-    if (insmInitialised()) {
-      initialisedInsm.overrideExperienceKey(experienceKey);
-    }
-  },
-  stopEarly: function stopEarly(reasonKey, description) {
-    if (insmInitialised()) {
-      initialisedInsm.stopEarly(reasonKey, description);
-    }
-  },
-  // We only expose details and feature start/stop to consumers
-  // as the other properties are internals for the insm and InsmPeriod
-  // to interact with the running session.
-  get session() {
-    if (insmInitialised()) {
-      return initialisedInsm.runningSession;
-    }
-  },
-  // @ts-expect-error Private method for testing purposes
-  __setAnalyticsWebClient: function __setAnalyticsWebClient(analyticsWebClient) {
-    if (initialisedInsm) {
-      initialisedInsm.analyticsWebClient = analyticsWebClient;
-    }
+});
+Object.defineProperty(exports, "insm", {
+  enumerable: true,
+  get: function get() {
+    return _api.insm;
   }
-};
+});
+var _api = require("./api");

package/dist/cjs/insm-session.js

@@ -9,6 +9,7 @@ var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/cl
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _bowserUltralight = _interopRequireDefault(require("bowser-ultralight"));
+var _isExperimentEnabled = require("@atlaskit/platform-feature-experiments/is-experiment-enabled");
 var _expValEquals = require("@atlaskit/tmp-editor-statsig/exp-val-equals");
 var _insmPeriod = require("./insm-period");
 var _LongAnimationFrameMeasurer = require("./session-measurers/LongAnimationFrameMeasurer");
@@ -204,11 +205,14 @@ var INSMSession = exports.INSMSession = /*#__PURE__*/function () {
       var operationalEvent = {
         actionSubject: 'insm',
         action: 'measured',
-        attributes: _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, this.staticProperties), evaluatedAddedProperties), {}, {
+        attributes: _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, this.staticProperties), evaluatedAddedProperties), {}, {
           'event:population': this.insm.options.population,
           experienceKey: this.experienceKey,
           initial: this.experienceProperties.initial,
-          contentId: this.experienceProperties.contentId,
+          contentId: this.experienceProperties.contentId
+        }, (0, _isExperimentEnabled.isExperimentEnabled)('platform_editor_insm_dom_node_count') ? {
+          editorDomSize: this.insm.getEditorDomSize()
+        } : {}), {}, {
           timing: {
             startedAt: this.startedAt,
             // Note: this will not match up with the periods sum of durations, as it includes

package/dist/cjs/insm.js

@@ -8,6 +8,8 @@ exports.INSM = void 0;
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _domElementCount = require("./dom-element-count");
+var _editorDomRegistry = require("./editor-dom-registry");
 var _insmSession = require("./insm-session");
 var _afps = require("./period-measurers/afps");
 var _inp = require("./inp-measurers/inp");
@@ -22,6 +24,11 @@ var INSM = exports.INSM = /*#__PURE__*/function () {
      * page session.
      */
     (0, _defineProperty2.default)(this, "runningHeavyTasks", new Set());
+    /**
+     * The editor is tracked at the insm layer (rather than per session) as it can
+     * outlive, or be mounted after, the session it is measured by.
+     */
+    (0, _defineProperty2.default)(this, "editorDomRegistry", new _editorDomRegistry.EditorDomRegistry());
     this.periodMeasurers = [(0, _expValEquals.expValEquals)('platform_editor_disable_afps', 'isEnabled', true) ? undefined : new _afps.AnimationFPSIM(), new _inp.INPTracker()];
     this.options = options;
 
@@ -89,6 +96,50 @@ var INSM = exports.INSM = /*#__PURE__*/function () {
       }
     }
 
+    /**
+     * Registers the page editor's content DOM element (`editorView.dom`) with insm.
+     *
+     * insm does not locate the editor itself - the element is provided by the editor so
+     * that session events can report its DOM element count (`editorDomSize`).
+     *
+     * A session measures a page, so only the page's own editor should register. Secondary
+     * editors (inline comments, nested legacy content extensions) must not, as the
+     * reported size would then depend on which editor registered last.
+     *
+     * ```ts
+     * insm.registerEditorDom(editorView.dom);
+     * ```
+     */
+  }, {
+    key: "registerEditorDom",
+    value: function registerEditorDom(editorDom) {
+      this.editorDomRegistry.register(editorDom);
+    }
+
+    /**
+     * Unregisters the editor's content DOM element. This is expected to be called when
+     * the editor is destroyed.
+     */
+  }, {
+    key: "unregisterEditorDom",
+    value: function unregisterEditorDom(editorDom) {
+      this.editorDomRegistry.unregister(editorDom);
+    }
+
+    /**
+     * The number of DOM elements inside the registered editor, used as a proxy for
+     * document complexity in performance events.
+     *
+     * Undefined when no editor is registered, or the registered one is no longer in
+     * the document.
+     */
+  }, {
+    key: "getEditorDomSize",
+    value: function getEditorDomSize() {
+      var editorDom = this.editorDomRegistry.editorDom;
+      return editorDom ? (0, _domElementCount.countDomElements)(editorDom) : undefined;
+    }
+
     /**
      * Call this when starting a new experience.  This is expected to be wired to the product
      * routing solution.

package/dist/es2019/api.js

@@ -0,0 +1,70 @@
+import { INSM } from './insm';
+let initialisedInsm;
+
+/**
+ * Initializes the INSM (Interactivity Session Measurement) tooling
+ */
+export function init(options) {
+  initialisedInsm = new INSM(options);
+}
+function insmInitialised() {
+  if (!initialisedInsm) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * **In**teractivity **s**ession **m**onitoring
+ */
+export const insm = {
+  startHeavyTask(heavyTaskName) {
+    if (insmInitialised()) {
+      initialisedInsm.startHeavyTask(heavyTaskName);
+    }
+  },
+  endHeavyTask(heavyTaskName) {
+    if (insmInitialised()) {
+      initialisedInsm.endHeavyTask(heavyTaskName);
+    }
+  },
+  registerEditorDom(editorDom) {
+    if (insmInitialised()) {
+      initialisedInsm.registerEditorDom(editorDom);
+    }
+  },
+  unregisterEditorDom(editorDom) {
+    if (insmInitialised()) {
+      initialisedInsm.unregisterEditorDom(editorDom);
+    }
+  },
+  start(experienceKey, experienceProperties) {
+    if (insmInitialised()) {
+      initialisedInsm.start(experienceKey, experienceProperties);
+    }
+  },
+  overrideExperienceKey(experienceKey) {
+    if (insmInitialised()) {
+      initialisedInsm.overrideExperienceKey(experienceKey);
+    }
+  },
+  stopEarly(reasonKey, description) {
+    if (insmInitialised()) {
+      initialisedInsm.stopEarly(reasonKey, description);
+    }
+  },
+  // We only expose details and feature start/stop to consumers
+  // as the other properties are internals for the insm and InsmPeriod
+  // to interact with the running session.
+  get session() {
+    if (insmInitialised()) {
+      return initialisedInsm.runningSession;
+    }
+  },
+  // @ts-expect-error Private method for testing purposes
+  __setAnalyticsWebClient(analyticsWebClient) {
+    if (initialisedInsm) {
+      initialisedInsm.analyticsWebClient = analyticsWebClient;
+    }
+  }
+};

package/dist/es2019/dom-element-count.js

@@ -0,0 +1,10 @@
+/**
+ * Returns the total number of DOM elements inside the given element.
+ *
+ * Uses the native `getElementsByTagName('*')`, which counts descendants iteratively in the
+ * browser engine -- intentionally not a recursive JS walk, so it can't overflow the stack on
+ * very large documents.
+ */
+export function countDomElements(element) {
+  return element.getElementsByTagName('*').length;
+}

package/dist/es2019/editor-dom-registry.js

@@ -0,0 +1,45 @@
+/**
+ * Holds the page editor's content DOM.
+ *
+ * insm holds no reference to the editor, so the element is registered from the outside — it is
+ * the same `editorView.dom` element the editor measures for the `editorDomSize` attribute on
+ * its INP event.
+ *
+ * Only the page editor registers itself: an insm session measures a page, and secondary
+ * editors on the page (inline comments, nested legacy content extensions) would make the
+ * registration ambiguous.
+ *
+ * The element is held via a `WeakRef` so a destroyed editor's DOM can be collected even if
+ * `unregister` is never reached.
+ */
+export class EditorDomRegistry {
+  /**
+   * Registers the page editor's content DOM element (`editorView.dom`).
+   */
+  register(editorDom) {
+    this.registered = new WeakRef(editorDom);
+  }
+
+  /**
+   * Unregisters an editor's content DOM element. Expected to be called when the editor is
+   * destroyed. Ignored when a different editor is currently registered, so an editor being
+   * torn down after its replacement registered does not clear the newer one.
+   */
+  unregister(editorDom) {
+    var _this$registered;
+    if (((_this$registered = this.registered) === null || _this$registered === void 0 ? void 0 : _this$registered.deref()) === editorDom) {
+      this.registered = undefined;
+    }
+  }
+
+  /**
+   * The registered editor's content DOM, or undefined when no editor is registered or the
+   * registered one is no longer in the document -- ie. an experience without a page editor,
+   * or a session which outlived the editor.
+   */
+  get editorDom() {
+    var _this$registered2;
+    const editorDom = (_this$registered2 = this.registered) === null || _this$registered2 === void 0 ? void 0 : _this$registered2.deref();
+    return editorDom !== null && editorDom !== void 0 && editorDom.isConnected ? editorDom : undefined;
+  }
+}

package/dist/es2019/index.js

@@ -1,60 +1,5 @@
-import { INSM } from './insm';
-let initialisedInsm;
-
-/**
- * Initializes the INSM (Interactivity Session Measurement) tooling
- */
-export function init(options) {
-  initialisedInsm = new INSM(options);
-}
-function insmInitialised() {
-  if (!initialisedInsm) {
-    return false;
-  }
-  return true;
-}
-
-/**
- * **In**teractivity **s**ession **m**onitoring
- */
-export const insm = {
-  startHeavyTask(heavyTaskName) {
-    if (insmInitialised()) {
-      initialisedInsm.startHeavyTask(heavyTaskName);
-    }
-  },
-  endHeavyTask(heavyTaskName) {
-    if (insmInitialised()) {
-      initialisedInsm.endHeavyTask(heavyTaskName);
-    }
-  },
-  start(experienceKey, experienceProperties) {
-    if (insmInitialised()) {
-      initialisedInsm.start(experienceKey, experienceProperties);
-    }
-  },
-  overrideExperienceKey(experienceKey) {
-    if (insmInitialised()) {
-      initialisedInsm.overrideExperienceKey(experienceKey);
-    }
-  },
-  stopEarly(reasonKey, description) {
-    if (insmInitialised()) {
-      initialisedInsm.stopEarly(reasonKey, description);
-    }
-  },
-  // We only expose details and feature start/stop to consumers
-  // as the other properties are internals for the insm and InsmPeriod
-  // to interact with the running session.
-  get session() {
-    if (insmInitialised()) {
-      return initialisedInsm.runningSession;
-    }
-  },
-  // @ts-expect-error Private method for testing purposes
-  __setAnalyticsWebClient(analyticsWebClient) {
-    if (initialisedInsm) {
-      initialisedInsm.analyticsWebClient = analyticsWebClient;
-    }
-  }
-};
+/* eslint-disable @atlaskit/editor/no-re-export */
+// Entry file in package.json
+// Barrel kept for existing consumers -- new call sites should import from the
+// `@atlaskit/insm/api` entry point instead.
+export { init, insm } from './api';

package/dist/es2019/insm-session.js

@@ -1,5 +1,6 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import Bowser from 'bowser-ultralight';
+import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { PeriodTracking } from './insm-period';
 import { LongAnimationFrameMeasurer } from './session-measurers/LongAnimationFrameMeasurer';
@@ -171,6 +172,11 @@ export class INSMSession {
         experienceKey: this.experienceKey,
         initial: this.experienceProperties.initial,
         contentId: this.experienceProperties.contentId,
+        // The same measurement as the `editorDomSize` attribute on the editor's INP
+        // event, sampled from the registered editor when the session ends.
+        ...(isExperimentEnabled('platform_editor_insm_dom_node_count') ? {
+          editorDomSize: this.insm.getEditorDomSize()
+        } : {}),
         timing: {
           startedAt: this.startedAt,
           // Note: this will not match up with the periods sum of durations, as it includes

package/dist/es2019/insm.js

@@ -1,4 +1,6 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { countDomElements } from './dom-element-count';
+import { EditorDomRegistry } from './editor-dom-registry';
 import { INSMSession } from './insm-session';
 import { AnimationFPSIM } from './period-measurers/afps';
 import { INPTracker } from './inp-measurers/inp';
@@ -11,6 +13,11 @@ export class INSM {
      * page session.
      */
     _defineProperty(this, "runningHeavyTasks", new Set());
+    /**
+     * The editor is tracked at the insm layer (rather than per session) as it can
+     * outlive, or be mounted after, the session it is measured by.
+     */
+    _defineProperty(this, "editorDomRegistry", new EditorDomRegistry());
     this.periodMeasurers = [expValEquals('platform_editor_disable_afps', 'isEnabled', true) ? undefined : new AnimationFPSIM(), new INPTracker()];
     this.options = options;
 
@@ -72,6 +79,44 @@ export class INSM {
     }
   }
 
+  /**
+   * Registers the page editor's content DOM element (`editorView.dom`) with insm.
+   *
+   * insm does not locate the editor itself - the element is provided by the editor so
+   * that session events can report its DOM element count (`editorDomSize`).
+   *
+   * A session measures a page, so only the page's own editor should register. Secondary
+   * editors (inline comments, nested legacy content extensions) must not, as the
+   * reported size would then depend on which editor registered last.
+   *
+   * ```ts
+   * insm.registerEditorDom(editorView.dom);
+   * ```
+   */
+  registerEditorDom(editorDom) {
+    this.editorDomRegistry.register(editorDom);
+  }
+
+  /**
+   * Unregisters the editor's content DOM element. This is expected to be called when
+   * the editor is destroyed.
+   */
+  unregisterEditorDom(editorDom) {
+    this.editorDomRegistry.unregister(editorDom);
+  }
+
+  /**
+   * The number of DOM elements inside the registered editor, used as a proxy for
+   * document complexity in performance events.
+   *
+   * Undefined when no editor is registered, or the registered one is no longer in
+   * the document.
+   */
+  getEditorDomSize() {
+    const editorDom = this.editorDomRegistry.editorDom;
+    return editorDom ? countDomElements(editorDom) : undefined;
+  }
+
   /**
    * Call this when starting a new experience.  This is expected to be wired to the product
    * routing solution.

package/dist/esm/api.js

@@ -0,0 +1,70 @@
+import { INSM } from './insm';
+var initialisedInsm;
+
+/**
+ * Initializes the INSM (Interactivity Session Measurement) tooling
+ */
+export function init(options) {
+  initialisedInsm = new INSM(options);
+}
+function insmInitialised() {
+  if (!initialisedInsm) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * **In**teractivity **s**ession **m**onitoring
+ */
+export var insm = {
+  startHeavyTask: function startHeavyTask(heavyTaskName) {
+    if (insmInitialised()) {
+      initialisedInsm.startHeavyTask(heavyTaskName);
+    }
+  },
+  endHeavyTask: function endHeavyTask(heavyTaskName) {
+    if (insmInitialised()) {
+      initialisedInsm.endHeavyTask(heavyTaskName);
+    }
+  },
+  registerEditorDom: function registerEditorDom(editorDom) {
+    if (insmInitialised()) {
+      initialisedInsm.registerEditorDom(editorDom);
+    }
+  },
+  unregisterEditorDom: function unregisterEditorDom(editorDom) {
+    if (insmInitialised()) {
+      initialisedInsm.unregisterEditorDom(editorDom);
+    }
+  },
+  start: function start(experienceKey, experienceProperties) {
+    if (insmInitialised()) {
+      initialisedInsm.start(experienceKey, experienceProperties);
+    }
+  },
+  overrideExperienceKey: function overrideExperienceKey(experienceKey) {
+    if (insmInitialised()) {
+      initialisedInsm.overrideExperienceKey(experienceKey);
+    }
+  },
+  stopEarly: function stopEarly(reasonKey, description) {
+    if (insmInitialised()) {
+      initialisedInsm.stopEarly(reasonKey, description);
+    }
+  },
+  // We only expose details and feature start/stop to consumers
+  // as the other properties are internals for the insm and InsmPeriod
+  // to interact with the running session.
+  get session() {
+    if (insmInitialised()) {
+      return initialisedInsm.runningSession;
+    }
+  },
+  // @ts-expect-error Private method for testing purposes
+  __setAnalyticsWebClient: function __setAnalyticsWebClient(analyticsWebClient) {
+    if (initialisedInsm) {
+      initialisedInsm.analyticsWebClient = analyticsWebClient;
+    }
+  }
+};

package/dist/esm/dom-element-count.js

@@ -0,0 +1,10 @@
+/**
+ * Returns the total number of DOM elements inside the given element.
+ *
+ * Uses the native `getElementsByTagName('*')`, which counts descendants iteratively in the
+ * browser engine -- intentionally not a recursive JS walk, so it can't overflow the stack on
+ * very large documents.
+ */
+export function countDomElements(element) {
+  return element.getElementsByTagName('*').length;
+}

package/dist/esm/editor-dom-registry.js

@@ -0,0 +1,58 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+/**
+ * Holds the page editor's content DOM.
+ *
+ * insm holds no reference to the editor, so the element is registered from the outside — it is
+ * the same `editorView.dom` element the editor measures for the `editorDomSize` attribute on
+ * its INP event.
+ *
+ * Only the page editor registers itself: an insm session measures a page, and secondary
+ * editors on the page (inline comments, nested legacy content extensions) would make the
+ * registration ambiguous.
+ *
+ * The element is held via a `WeakRef` so a destroyed editor's DOM can be collected even if
+ * `unregister` is never reached.
+ */
+export var EditorDomRegistry = /*#__PURE__*/function () {
+  function EditorDomRegistry() {
+    _classCallCheck(this, EditorDomRegistry);
+  }
+  return _createClass(EditorDomRegistry, [{
+    key: "register",
+    value:
+    /**
+     * Registers the page editor's content DOM element (`editorView.dom`).
+     */
+    function register(editorDom) {
+      this.registered = new WeakRef(editorDom);
+    }
+
+    /**
+     * Unregisters an editor's content DOM element. Expected to be called when the editor is
+     * destroyed. Ignored when a different editor is currently registered, so an editor being
+     * torn down after its replacement registered does not clear the newer one.
+     */
+  }, {
+    key: "unregister",
+    value: function unregister(editorDom) {
+      var _this$registered;
+      if (((_this$registered = this.registered) === null || _this$registered === void 0 ? void 0 : _this$registered.deref()) === editorDom) {
+        this.registered = undefined;
+      }
+    }
+
+    /**
+     * The registered editor's content DOM, or undefined when no editor is registered or the
+     * registered one is no longer in the document -- ie. an experience without a page editor,
+     * or a session which outlived the editor.
+     */
+  }, {
+    key: "editorDom",
+    get: function get() {
+      var _this$registered2;
+      var editorDom = (_this$registered2 = this.registered) === null || _this$registered2 === void 0 ? void 0 : _this$registered2.deref();
+      return editorDom !== null && editorDom !== void 0 && editorDom.isConnected ? editorDom : undefined;
+    }
+  }]);
+}();

package/dist/esm/index.js

@@ -1,60 +1,5 @@
-import { INSM } from './insm';
-var initialisedInsm;
-
-/**
- * Initializes the INSM (Interactivity Session Measurement) tooling
- */
-export function init(options) {
-  initialisedInsm = new INSM(options);
-}
-function insmInitialised() {
-  if (!initialisedInsm) {
-    return false;
-  }
-  return true;
-}
-
-/**
- * **In**teractivity **s**ession **m**onitoring
- */
-export var insm = {
-  startHeavyTask: function startHeavyTask(heavyTaskName) {
-    if (insmInitialised()) {
-      initialisedInsm.startHeavyTask(heavyTaskName);
-    }
-  },
-  endHeavyTask: function endHeavyTask(heavyTaskName) {
-    if (insmInitialised()) {
-      initialisedInsm.endHeavyTask(heavyTaskName);
-    }
-  },
-  start: function start(experienceKey, experienceProperties) {
-    if (insmInitialised()) {
-      initialisedInsm.start(experienceKey, experienceProperties);
-    }
-  },
-  overrideExperienceKey: function overrideExperienceKey(experienceKey) {
-    if (insmInitialised()) {
-      initialisedInsm.overrideExperienceKey(experienceKey);
-    }
-  },
-  stopEarly: function stopEarly(reasonKey, description) {
-    if (insmInitialised()) {
-      initialisedInsm.stopEarly(reasonKey, description);
-    }
-  },
-  // We only expose details and feature start/stop to consumers
-  // as the other properties are internals for the insm and InsmPeriod
-  // to interact with the running session.
-  get session() {
-    if (insmInitialised()) {
-      return initialisedInsm.runningSession;
-    }
-  },
-  // @ts-expect-error Private method for testing purposes
-  __setAnalyticsWebClient: function __setAnalyticsWebClient(analyticsWebClient) {
-    if (initialisedInsm) {
-      initialisedInsm.analyticsWebClient = analyticsWebClient;
-    }
-  }
-};
+/* eslint-disable @atlaskit/editor/no-re-export */
+// Entry file in package.json
+// Barrel kept for existing consumers -- new call sites should import from the
+// `@atlaskit/insm/api` entry point instead.
+export { init, insm } from './api';

package/dist/esm/insm-session.js

@@ -7,6 +7,7 @@ function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol
 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 Bowser from 'bowser-ultralight';
+import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { PeriodTracking } from './insm-period';
 import { LongAnimationFrameMeasurer } from './session-measurers/LongAnimationFrameMeasurer';
@@ -198,11 +199,14 @@ export var INSMSession = /*#__PURE__*/function () {
       var operationalEvent = {
         actionSubject: 'insm',
         action: 'measured',
-        attributes: _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, this.staticProperties), evaluatedAddedProperties), {}, {
+        attributes: _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, this.staticProperties), evaluatedAddedProperties), {}, {
           'event:population': this.insm.options.population,
           experienceKey: this.experienceKey,
           initial: this.experienceProperties.initial,
-          contentId: this.experienceProperties.contentId,
+          contentId: this.experienceProperties.contentId
+        }, isExperimentEnabled('platform_editor_insm_dom_node_count') ? {
+          editorDomSize: this.insm.getEditorDomSize()
+        } : {}), {}, {
           timing: {
             startedAt: this.startedAt,
             // Note: this will not match up with the periods sum of durations, as it includes

package/dist/esm/insm.js

@@ -1,6 +1,8 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { countDomElements } from './dom-element-count';
+import { EditorDomRegistry } from './editor-dom-registry';
 import { INSMSession } from './insm-session';
 import { AnimationFPSIM } from './period-measurers/afps';
 import { INPTracker } from './inp-measurers/inp';
@@ -15,6 +17,11 @@ export var INSM = /*#__PURE__*/function () {
      * page session.
      */
     _defineProperty(this, "runningHeavyTasks", new Set());
+    /**
+     * The editor is tracked at the insm layer (rather than per session) as it can
+     * outlive, or be mounted after, the session it is measured by.
+     */
+    _defineProperty(this, "editorDomRegistry", new EditorDomRegistry());
     this.periodMeasurers = [expValEquals('platform_editor_disable_afps', 'isEnabled', true) ? undefined : new AnimationFPSIM(), new INPTracker()];
     this.options = options;
 
@@ -82,6 +89,50 @@ export var INSM = /*#__PURE__*/function () {
       }
     }
 
+    /**
+     * Registers the page editor's content DOM element (`editorView.dom`) with insm.
+     *
+     * insm does not locate the editor itself - the element is provided by the editor so
+     * that session events can report its DOM element count (`editorDomSize`).
+     *
+     * A session measures a page, so only the page's own editor should register. Secondary
+     * editors (inline comments, nested legacy content extensions) must not, as the
+     * reported size would then depend on which editor registered last.
+     *
+     * ```ts
+     * insm.registerEditorDom(editorView.dom);
+     * ```
+     */
+  }, {
+    key: "registerEditorDom",
+    value: function registerEditorDom(editorDom) {
+      this.editorDomRegistry.register(editorDom);
+    }
+
+    /**
+     * Unregisters the editor's content DOM element. This is expected to be called when
+     * the editor is destroyed.
+     */
+  }, {
+    key: "unregisterEditorDom",
+    value: function unregisterEditorDom(editorDom) {
+      this.editorDomRegistry.unregister(editorDom);
+    }
+
+    /**
+     * The number of DOM elements inside the registered editor, used as a proxy for
+     * document complexity in performance events.
+     *
+     * Undefined when no editor is registered, or the registered one is no longer in
+     * the document.
+     */
+  }, {
+    key: "getEditorDomSize",
+    value: function getEditorDomSize() {
+      var editorDom = this.editorDomRegistry.editorDom;
+      return editorDom ? countDomElements(editorDom) : undefined;
+    }
+
     /**
      * Call this when starting a new experience.  This is expected to be wired to the product
      * routing solution.

package/dist/types/api.d.ts

@@ -0,0 +1,13 @@
+import type { INSMOptions } from './types';
+import type { INSMSession } from './insm-session';
+import { INSM } from './insm';
+/**
+ * Initializes the INSM (Interactivity Session Measurement) tooling
+ */
+export declare function init(options: INSMOptions): void;
+/**
+ * **In**teractivity **s**ession **m**onitoring
+ */
+export declare const insm: Pick<INSM, 'start' | 'stopEarly' | 'startHeavyTask' | 'endHeavyTask' | 'overrideExperienceKey' | 'registerEditorDom' | 'unregisterEditorDom'> & {
+    session: Pick<INSMSession, 'details' | 'startFeature' | 'endFeature' | 'addProperties' | 'setProperty'> | undefined;
+};

package/dist/types/dom-element-count.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns the total number of DOM elements inside the given element.
+ *
+ * Uses the native `getElementsByTagName('*')`, which counts descendants iteratively in the
+ * browser engine -- intentionally not a recursive JS walk, so it can't overflow the stack on
+ * very large documents.
+ */
+export declare function countDomElements(element: Element): number;

package/dist/types/editor-dom-registry.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Holds the page editor's content DOM.
+ *
+ * insm holds no reference to the editor, so the element is registered from the outside — it is
+ * the same `editorView.dom` element the editor measures for the `editorDomSize` attribute on
+ * its INP event.
+ *
+ * Only the page editor registers itself: an insm session measures a page, and secondary
+ * editors on the page (inline comments, nested legacy content extensions) would make the
+ * registration ambiguous.
+ *
+ * The element is held via a `WeakRef` so a destroyed editor's DOM can be collected even if
+ * `unregister` is never reached.
+ */
+export declare class EditorDomRegistry {
+    private registered;
+    /**
+     * Registers the page editor's content DOM element (`editorView.dom`).
+     */
+    register(editorDom: HTMLElement): void;
+    /**
+     * Unregisters an editor's content DOM element. Expected to be called when the editor is
+     * destroyed. Ignored when a different editor is currently registered, so an editor being
+     * torn down after its replacement registered does not clear the newer one.
+     */
+    unregister(editorDom: HTMLElement): void;
+    /**
+     * The registered editor's content DOM, or undefined when no editor is registered or the
+     * registered one is no longer in the document -- ie. an experience without a page editor,
+     * or a session which outlived the editor.
+     */
+    get editorDom(): HTMLElement | undefined;
+}

package/dist/types/index.d.ts

@@ -1,13 +1 @@
-import type { INSMOptions } from './types';
-import type { INSMSession } from './insm-session';
-import { INSM } from './insm';
-/**
- * Initializes the INSM (Interactivity Session Measurement) tooling
- */
-export declare function init(options: INSMOptions): void;
-/**
- * **In**teractivity **s**ession **m**onitoring
- */
-export declare const insm: Pick<INSM, 'start' | 'stopEarly' | 'startHeavyTask' | 'endHeavyTask' | 'overrideExperienceKey'> & {
-    session: Pick<INSMSession, 'details' | 'startFeature' | 'endFeature' | 'addProperties' | 'setProperty'> | undefined;
-};
+export { init, insm } from './api';

package/dist/types/insm.d.ts

@@ -14,6 +14,11 @@ export declare class INSM {
      * page session.
      */
     runningHeavyTasks: Set<string>;
+    /**
+     * The editor is tracked at the insm layer (rather than per session) as it can
+     * outlive, or be mounted after, the session it is measured by.
+     */
+    private editorDomRegistry;
     constructor(options: INSMOptions);
     /**
      * Starts a heavy task in the currently running session.
@@ -28,6 +33,34 @@ export declare class INSM {
      * Ends a heavy task in the currently running session
      */
     endHeavyTask(heavyTaskName: string): void;
+    /**
+     * Registers the page editor's content DOM element (`editorView.dom`) with insm.
+     *
+     * insm does not locate the editor itself - the element is provided by the editor so
+     * that session events can report its DOM element count (`editorDomSize`).
+     *
+     * A session measures a page, so only the page's own editor should register. Secondary
+     * editors (inline comments, nested legacy content extensions) must not, as the
+     * reported size would then depend on which editor registered last.
+     *
+     * ```ts
+     * insm.registerEditorDom(editorView.dom);
+     * ```
+     */
+    registerEditorDom(editorDom: HTMLElement): void;
+    /**
+     * Unregisters the editor's content DOM element. This is expected to be called when
+     * the editor is destroyed.
+     */
+    unregisterEditorDom(editorDom: HTMLElement): void;
+    /**
+     * The number of DOM elements inside the registered editor, used as a proxy for
+     * document complexity in performance events.
+     *
+     * Undefined when no editor is registered, or the registered one is no longer in
+     * the document.
+     */
+    getEditorDomSize(): number | undefined;
     /**
      * Call this when starting a new experience.  This is expected to be wired to the product
      * routing solution.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/insm",
-	"version": "1.2.11",
+	"version": "1.3.0",
 	"description": "INSM tooling measures user-perceived interactivity of a page",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -18,7 +18,8 @@
 	"atlaskit:src": "src/index.ts",
 	"dependencies": {
 		"@atlaskit/analytics-listeners": "^11.1.0",
-		"@atlaskit/tmp-editor-statsig": "^146.0.0",
+		"@atlaskit/platform-feature-experiments": "^0.3.0",
+		"@atlaskit/tmp-editor-statsig": "^147.0.0",
 		"@babel/runtime": "^7.0.0",
 		"bowser-ultralight": "^1.0.6"
 	},
@@ -26,6 +27,7 @@
 		"react": "^18.2.0 || ^19.2.0"
 	},
 	"devDependencies": {
+		"@atlassian/experiment-test-utils": "^0.2.0",
 		"@atlassian/structured-docs-types": "workspace:^",
 		"react": "^19.2.0"
 	}