@atlaskit/editor-plugin-limited-mode 13.0.18 → 14.1.0

package/dist/cjs/pm-plugins/utils/latch-policy.js

@@ -0,0 +1,314 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LatchPolicy = exports.DEFAULT_LATCH_POLICY_CONFIG = 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 _median = require("@atlaskit/editor-common/median");
+var _shouldEnableLimitedMode = require("@atlaskit/editor-common/should-enable-limited-mode");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * The shipped policy.
+ *
+ * These values add up to: nothing counts for the first 10s; then a window qualifies on either 6 of
+ * 12 keystrokes slower than 100ms with that window's median also over 100ms, or 3 long tasks over
+ * 600ms within 30s corroborated by a slow keystroke in that same 30s. Two qualifying windows at
+ * least 30s apart latch limited mode.
+ *
+ * `freezeTaskMs` matches `DEFAULT_FREEZE_THRESHOLD` in
+ * `editor-plugin-base/src/pm-plugins/frozen-editor.ts`, which backs the existing
+ * `ACTION.BROWSER_FREEZE` telemetry, so production dashboards can be used to calibrate it.
+ * `slowInputMs` is deliberately tighter than that file's `DEFAULT_SLOW_THRESHOLD` of 300 — this
+ * needs to notice a degraded experience, not just an unusable one.
+ *
+ * `requiredConfirmations` and `confirmationGapMs` are the values that matter most — see the comment
+ * on the former.
+ */
+var DEFAULT_LATCH_POLICY_CONFIG = exports.DEFAULT_LATCH_POLICY_CONFIG = {
+  warmUpMs: 10000,
+  slowInputMs: 100,
+  latencyWindowSize: 12,
+  latencySlowSamplesRequired: 6,
+  freezeTaskMs: 600,
+  freezeTasksRequired: 3,
+  freezeWindowMs: 30000,
+  requiredConfirmations: 2,
+  confirmationGapMs: 30000,
+  bulkChangeNodeSize: 100,
+  bulkChangeSuppressionMs: 2000,
+  docSizeThreshold: 750000,
+  nodeCountThreshold: 5000
+};
+
+/**
+ * Decides whether limited mode should be on.
+ *
+ * The single authority for that question, covering both reasons:
+ *
+ * - **The document** — too large, too many nodes, or containing a legacy content macro. Evaluated on
+ *   load and on document replacement, so it can turn back off (a `replaceDocument` onto a smaller
+ *   page) without costing a full-document walk per transaction.
+ * - **The device** — sustained slow keystrokes or repeated long tasks. **One-way**: once the runtime
+ *   bar is met the policy stops evaluating, so the editor can never oscillate between modes.
+ *
+ * `isBreached()` is the combined verdict. Everything tunable is in `config`, so the whole high bar is
+ * unit-testable without needing to make a real browser slow, and a caller can substitute a
+ * differently configured policy. `latch-detector.ts` owns the browser plumbing that feeds the runtime
+ * criteria, and takes a policy instance rather than constructing one.
+ */
+var LatchPolicy = exports.LatchPolicy = /*#__PURE__*/function () {
+  function LatchPolicy(_ref) {
+    var now = _ref.now,
+      config = _ref.config;
+    (0, _classCallCheck2.default)(this, LatchPolicy);
+    /** Public so the detector can read the tunables it needs rather than duplicating them. */
+    /** Public so the detector shares one clock with the policy. */
+    (0, _defineProperty2.default)(this, "latencySamples", []);
+    (0, _defineProperty2.default)(this, "freezeTimes", []);
+    (0, _defineProperty2.default)(this, "qualifiedWindows", 0);
+    (0, _defineProperty2.default)(this, "suppressedUntil", 0);
+    (0, _defineProperty2.default)(this, "latched", false);
+    (0, _defineProperty2.default)(this, "documentBreached", false);
+    /** Cumulative for the session and never cleared, unlike the evidence buffers. */
+    (0, _defineProperty2.default)(this, "totalInputSamples", 0);
+    (0, _defineProperty2.default)(this, "totalSlowInputs", 0);
+    (0, _defineProperty2.default)(this, "totalFreezes", 0);
+    this.now = now;
+    this.config = _objectSpread(_objectSpread({}, DEFAULT_LATCH_POLICY_CONFIG), config);
+    this.startedAt = now();
+  }
+
+  /**
+   * Whether limited mode should be on, for either reason. This is the verdict consumers act on.
+   */
+  return (0, _createClass2.default)(LatchPolicy, [{
+    key: "isBreached",
+    value: function isBreached() {
+      return this.documentBreached || this.latched;
+    }
+
+    /**
+     * What the latch was based on, or `undefined` while un-latched. Intended for telemetry — nothing in
+     * the decision reads it back.
+     */
+  }, {
+    key: "getLatchDetails",
+    value: function getLatchDetails() {
+      return this.latchDetails;
+    }
+
+    /** Whether the runtime (device) criteria have latched. One-way, and never cleared. */
+  }, {
+    key: "isLatched",
+    value: function isLatched() {
+      return this.latched;
+    }
+
+    /**
+     * Latch the runtime reason directly, without accumulating evidence for it.
+     *
+     * The policy latches itself when its own criteria are met, so this exists for callers that have
+     * already decided: the plugin replaying the detector's latch transaction, and dev tooling forcing
+     * the state by hand. Idempotent, and one-way like every other route to `latched`.
+     */
+  }, {
+    key: "latch",
+    value: function latch() {
+      if (this.latched) {
+        return;
+      }
+      this.latched = true;
+      this.latchDetails = this.buildDetails('forced', undefined);
+    }
+
+    /** Whether the document currently breaches the thresholds. Can go back to false. */
+  }, {
+    key: "isDocumentBreached",
+    value: function isDocumentBreached() {
+      return this.documentBreached;
+    }
+
+    /**
+     * Evaluate the document reason against the size / node-count / legacy-content-macro thresholds.
+     *
+     * Walks the whole document, so the caller decides when it is worth paying for: `pm-plugins/main.ts`
+     * calls this on load and on `replaceDocument` (e.g. live-to-live page navigation) only, never per
+     * transaction. Editing therefore cannot turn the document reason on — a page that grows past the
+     * thresholds mid-session is only re-judged the next time it loads — but replacement can still turn
+     * it back off.
+     */
+  }, {
+    key: "evaluateDocument",
+    value: function evaluateDocument(doc) {
+      this.documentBreached = (0, _shouldEnableLimitedMode.shouldEnableLimitedModeForDocument)(doc, {
+        docSizeThreshold: this.config.docSizeThreshold,
+        nodeCountThreshold: this.config.nodeCountThreshold
+      });
+    }
+
+    /**
+     * Whether a `doc.nodeSize` delta is large enough to be bulk work rather than typing. A keystroke
+     * moves this by 1; a paste, a bulk replace or a document load moves it far more.
+     */
+  }, {
+    key: "isBulkChange",
+    value: function isBulkChange(nodeSizeDelta) {
+      return Math.abs(nodeSizeDelta) >= this.config.bulkChangeNodeSize;
+    }
+
+    /**
+     * Discard signals for a window. Called for bulk work, which is expensive but transient and
+     * self-limiting, so its cost must not be attributed to the device struggling.
+     */
+  }, {
+    key: "suppress",
+    value: function suppress() {
+      if (this.latched) {
+        return;
+      }
+      this.suppressedUntil = this.now() + this.config.bulkChangeSuppressionMs;
+    }
+
+    /**
+     * Feed one keystroke's input latency (dispatch through to the next animation frame).
+     */
+  }, {
+    key: "recordInputLatency",
+    value: function recordInputLatency(durationMs) {
+      if (!this.canRecord()) {
+        return 'ignored';
+      }
+      var _this$config = this.config,
+        slowInputMs = _this$config.slowInputMs,
+        latencyWindowSize = _this$config.latencyWindowSize,
+        latencySlowSamplesRequired = _this$config.latencySlowSamplesRequired;
+      this.totalInputSamples += 1;
+      if (durationMs > slowInputMs) {
+        this.totalSlowInputs += 1;
+        // Remembered even once the window rolls over, so the freeze criterion below can check that
+        // the jank actually coincided with editing.
+        this.lastSlowInputAt = this.now();
+      }
+      this.latencySamples.push(durationMs);
+      if (this.latencySamples.length > latencyWindowSize) {
+        this.latencySamples.shift();
+      }
+      if (this.latencySamples.length < latencyWindowSize) {
+        return 'recorded';
+      }
+      var slowSamples = this.latencySamples.filter(function (sample) {
+        return sample > slowInputMs;
+      }).length;
+      if (slowSamples < latencySlowSamplesRequired) {
+        return 'recorded';
+      }
+
+      // Median rather than mean: a mean is dragged over the threshold by one or two outliers, which
+      // is exactly the transient jank this policy is meant to ignore.
+      var windowMedian = (0, _median.median)(this.latencySamples);
+      if (windowMedian <= slowInputMs) {
+        return 'recorded';
+      }
+      return this.qualify('inputLatency', windowMedian);
+    }
+
+    /**
+     * Feed one `longtask` PerformanceObserver entry.
+     */
+  }, {
+    key: "recordLongTask",
+    value: function recordLongTask(durationMs) {
+      if (!this.canRecord()) {
+        return 'ignored';
+      }
+      var _this$config2 = this.config,
+        freezeTaskMs = _this$config2.freezeTaskMs,
+        freezeWindowMs = _this$config2.freezeWindowMs,
+        freezeTasksRequired = _this$config2.freezeTasksRequired;
+      if (durationMs <= freezeTaskMs) {
+        return 'recorded';
+      }
+      var now = this.now();
+      this.totalFreezes += 1;
+      this.freezeTimes.push(now);
+      this.freezeTimes = this.freezeTimes.filter(function (time) {
+        return now - time <= freezeWindowMs;
+      });
+      if (this.freezeTimes.length < freezeTasksRequired) {
+        return 'recorded';
+      }
+
+      // Corroboration. `longtask` is process-wide, so without this a busy background tab or an
+      // unrelated app could latch an editor the user is typing in perfectly happily.
+      if (this.lastSlowInputAt === undefined || now - this.lastSlowInputAt > freezeWindowMs) {
+        return 'recorded';
+      }
+      return this.qualify('freeze');
+    }
+  }, {
+    key: "canRecord",
+    value: function canRecord() {
+      if (this.latched) {
+        return false;
+      }
+      var now = this.now();
+      if (now - this.startedAt < this.config.warmUpMs) {
+        return false;
+      }
+      return now >= this.suppressedUntil;
+    }
+
+    /** Snapshot of what the latch was based on. Called before the evidence buffers are cleared. */
+  }, {
+    key: "buildDetails",
+    value: function buildDetails(reason, latencyMedianMs) {
+      var _this$firstWindowReas;
+      var now = this.now();
+      return {
+        reason: reason,
+        firstWindowReason: (_this$firstWindowReas = this.firstWindowReason) !== null && _this$firstWindowReas !== void 0 ? _this$firstWindowReas : reason,
+        requiredConfirmations: this.config.requiredConfirmations,
+        documentAlreadyBreached: this.documentBreached,
+        msFromFirstWindow: this.firstQualifiedAt === undefined ? undefined : Math.round(now - this.firstQualifiedAt),
+        latencyMedianMs: latencyMedianMs === undefined ? undefined : Math.round(latencyMedianMs),
+        timeToLatchMs: Math.round(now - this.startedAt),
+        totalInputSamples: this.totalInputSamples,
+        totalSlowInputs: this.totalSlowInputs,
+        totalFreezes: this.totalFreezes
+      };
+    }
+  }, {
+    key: "qualify",
+    value: function qualify(reason, latencyMedianMs) {
+      var now = this.now();
+
+      // Each qualifying window must be independent evidence, so the buffers are cleared rather than
+      // left to re-trigger off the same samples on the very next keystroke.
+      this.latencySamples = [];
+      this.freezeTimes = [];
+
+      // Too soon after the last counted window to be independent of it, so it earns no credit. The
+      // buffers above are still cleared, which is what makes the run rebuild from scratch.
+      if (this.lastQualifiedAt !== undefined && now - this.lastQualifiedAt < this.config.confirmationGapMs) {
+        return 'qualified';
+      }
+      this.qualifiedWindows += 1;
+      this.lastQualifiedAt = now;
+      if (this.firstQualifiedAt === undefined) {
+        this.firstQualifiedAt = now;
+        this.firstWindowReason = reason;
+      }
+      if (this.qualifiedWindows < this.config.requiredConfirmations) {
+        return 'qualified';
+      }
+      this.latched = true;
+      this.latchDetails = this.buildDetails(reason, latencyMedianMs);
+      return 'latched';
+    }
+  }]);
+}();

package/dist/es2019/limitedModePlugin.js

@@ -1,7 +1,8 @@
 import { getNodeIdProvider } from '@atlaskit/editor-common/node-anchor';
 import { usePluginStateEffect } from '@atlaskit/editor-common/use-plugin-state-effect';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
-import { createPlugin, limitedModePluginKey } from './pm-plugins/main';
+import { limitedModePluginKey } from './pm-plugins/plugin-key';
+import { createPlugin } from './pm-plugins/main';
 export const limitedModePlugin = ({
   api
 }) => {
@@ -10,7 +11,7 @@ export const limitedModePlugin = ({
     pmPlugins() {
       return [{
         name: 'limitedModePlugin',
-        plugin: createPlugin
+        plugin: () => createPlugin(api)
       }];
     },
     getSharedState(editorState) {
@@ -18,7 +19,7 @@ export const limitedModePlugin = ({
         return {
           get enabled() {
             var _limitedModePluginKey, _limitedModePluginKey2;
-            return (_limitedModePluginKey = (_limitedModePluginKey2 = limitedModePluginKey.getState(editorState)) === null || _limitedModePluginKey2 === void 0 ? void 0 : _limitedModePluginKey2.documentSizeBreachesThreshold) !== null && _limitedModePluginKey !== void 0 ? _limitedModePluginKey : false;
+            return (_limitedModePluginKey = (_limitedModePluginKey2 = limitedModePluginKey.getState(editorState)) === null || _limitedModePluginKey2 === void 0 ? void 0 : _limitedModePluginKey2.enabled) !== null && _limitedModePluginKey !== void 0 ? _limitedModePluginKey : false;
           },
           limitedModePluginKey
         };

package/dist/es2019/pm-plugins/main.js

@@ -1,29 +1,208 @@
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
 import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 import { shouldEnableLimitedModeForDocument } from '@atlaskit/editor-common/should-enable-limited-mode';
-import { PluginKey } from '@atlaskit/editor-prosemirror/state';
-export const limitedModePluginKey = new PluginKey('limitedModePlugin');
-export const createPlugin = () => {
+import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
+import { expVal } from '@atlaskit/platform-feature-experiments/exp-val';
+import { limitedModePluginKey } from './plugin-key';
+import { createLatchDetector } from './utils/latch-detector';
+import { LatchPolicy } from './utils/latch-policy';
+
+/**
+ * Meta shape used to latch limited mode at runtime. Dispatching this is the entire delivery
+ * mechanism: the transaction flows through `SharedStateAPI.notifyListeners`, which diffs the plugin's
+ * shared state and notifies every consumer. No plugin re-registration and no schema rebuild.
+ */
+
+/**
+ * Hardware hints, reported with a latch so it can be correlated with device class.
+ *
+ * Telemetry only — the policy no longer takes the hardware into account when deciding, so this
+ * exists to answer "which devices are latching" from the data rather than by assumption. Both hints
+ * are optional (`deviceMemory` is Chromium-only) and are simply absent where unsupported.
+ */
+const getDeviceHints = () => {
+  if (typeof navigator === 'undefined') {
+    return {};
+  }
+  const {
+    hardwareConcurrency,
+    deviceMemory
+  } = navigator;
+  return {
+    hardwareConcurrency,
+    deviceMemoryGb: deviceMemory
+  };
+};
+
+/** Control-arm state: the document decision alone, exactly as before the experiment. */
+const documentOnlyState = doc => {
+  const documentSizeBreachesThreshold = shouldEnableLimitedModeForDocument(doc);
+  return {
+    documentSizeBreachesThreshold,
+    latchPolicyBreached: false,
+    enabled: documentSizeBreachesThreshold
+  };
+};
+
+/** Treatment-arm state: whatever the policy says, for both of its reasons. */
+const policyState = policy => ({
+  documentSizeBreachesThreshold: policy.isDocumentBreached(),
+  latchPolicyBreached: policy.isBreached(),
+  enabled: policy.isBreached()
+});
+export const createPlugin = (api, injectedPolicy) => {
+  let detector;
+  let policy;
+  if (injectedPolicy) {
+    policy = injectedPolicy;
+  } else if (isExperimentEnabled('platform_editor_dynamic_limited_mode')) {
+    const config = expVal('platform_editor_dynamic_limited_mode', 'policyConfig', {
+      warmUpMs: 10_000,
+      slowInputMs: 100,
+      latencyWindowSize: 12,
+      latencySlowSamplesRequired: 6,
+      freezeTaskMs: 600,
+      freezeTasksRequired: 3,
+      freezeWindowMs: 30_000,
+      requiredConfirmations: 2,
+      confirmationGapMs: 30_000,
+      bulkChangeNodeSize: 100,
+      bulkChangeSuppressionMs: 2_000,
+      docSizeThreshold: 750_000,
+      nodeCountThreshold: 5_000
+    });
+
+    // Resolved once per editor rather than per transaction. When off, no policy is built and the
+    // document decision runs inline exactly as it did before this experiment.
+    policy = new LatchPolicy({
+      now: () => performance.now(),
+      config
+    });
+  }
   return new SafePlugin({
     key: limitedModePluginKey,
-    view: _view => {
-      return {};
+    props: {
+      handleTextInput() {
+        var _detector;
+        (_detector = detector) === null || _detector === void 0 ? void 0 : _detector.measureInput();
+
+        // Never handle the input — this is measurement only.
+        return false;
+      }
+    },
+    view: editorView => {
+      // No policy means the experiment is off: no observers, no per-keystroke measurement.
+      if (!policy) {
+        return {};
+      }
+      const startedAt = performance.now();
+      detector = createLatchDetector({
+        policy,
+        onLatchCriteriaMet: details => {
+          var _api$analytics;
+          // Treatment arm only — the detector does not exist in control. See LimitedModeLatchedAEP.
+          //
+          // `details` is the policy's own snapshot of what it latched on, taken before it cleared
+          // its evidence buffers, so it reports the closing window rather than an empty one.
+          api === null || api === void 0 ? void 0 : (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions.fireAnalyticsEvent({
+            action: ACTION.LIMITED_MODE_LATCHED,
+            actionSubject: ACTION_SUBJECT.EDITOR,
+            eventType: EVENT_TYPE.OPERATIONAL,
+            attributes: {
+              latched: true,
+              reason: details.reason,
+              firstWindowReason: details.firstWindowReason,
+              requiredConfirmations: details.requiredConfirmations,
+              documentAlreadyBreached: details.documentAlreadyBreached,
+              msFromFirstWindow: details.msFromFirstWindow,
+              latencyMedianMs: details.latencyMedianMs,
+              totalInputSamples: details.totalInputSamples,
+              totalSlowInputs: details.totalSlowInputs,
+              totalFreezes: details.totalFreezes,
+              nodeSize: editorView.state.doc.nodeSize,
+              // Read at latch time rather than at construction: the hints are static, and this
+              // keeps every device fact in one place next to the decision it is compared against.
+              ...getDeviceHints(),
+              // Measured from the plugin view starting, which is a little later than the policy's
+              // own `timeToLatchMs` (it starts at plugin construction).
+              timeToLatch: performance.now() - startedAt
+            }
+          });
+
+          // The policy already holds the latch; this transaction only prompts the plugin to
+          // re-read it, which is what notifies every consumer through shared state.
+          editorView.dispatch(editorView.state.tr.setMeta(limitedModePluginKey, {
+            latchPolicyBreached: true
+          }));
+        }
+      });
+      return {
+        destroy: () => {
+          var _detector2;
+          (_detector2 = detector) === null || _detector2 === void 0 ? void 0 : _detector2.destroy();
+          detector = undefined;
+        }
+      };
     },
     state: {
       init(_config, editorState) {
-        return {
-          documentSizeBreachesThreshold: shouldEnableLimitedModeForDocument(editorState.doc)
-        };
+        if (!policy) {
+          return documentOnlyState(editorState.doc);
+        }
+        policy.evaluateDocument(editorState.doc);
+        return policyState(policy);
       },
-      apply: (tr, currentPluginState, _oldState, _newState) => {
-        // Don't check the document size if we're already in limited mode.
-        // We ALWAYS want to re-check the document size if we're replacing the document (e.g. live-to-live page navigation).
+      apply: (tr, currentPluginState, oldState, _newState) => {
+        var _tr$getMeta;
+        const documentReplaced = Boolean(tr.getMeta('replaceDocument'));
+        if (!policy) {
+          // Control arm, unchanged: skip the traversal once already breached, but always re-check
+          // when the document is replaced (e.g. live-to-live page navigation).
+          if (currentPluginState.documentSizeBreachesThreshold && !documentReplaced) {
+            return currentPluginState;
+          }
+          return documentOnlyState(tr.doc);
+        }
 
-        if (currentPluginState.documentSizeBreachesThreshold && !tr.getMeta('replaceDocument')) {
-          return currentPluginState;
+        // The detector's latch arrives as a transaction so that plugin state stays a function of
+        // the transaction stream rather than of when `apply` happens to read the policy. Dev
+        // tooling dispatches the same meta to force limited mode by hand.
+        if ((_tr$getMeta = tr.getMeta(limitedModePluginKey)) !== null && _tr$getMeta !== void 0 && _tr$getMeta.latchPolicyBreached) {
+          policy.latch();
         }
-        return {
-          documentSizeBreachesThreshold: shouldEnableLimitedModeForDocument(tr.doc)
-        };
+
+        // Only on replacement, never on an ordinary edit: the check walks the whole document, so
+        // running it per transaction is a full-document scan on every keystroke. The trade-off is
+        // that a document editing its way past the thresholds is not noticed until it next loads.
+        //
+        // Deliberately not skipped when limited mode is already on. Replacement is the one moment
+        // the document verdict can go *down* — live-to-live navigation onto a smaller page — so
+        // skipping it there is what would strand limited mode on forever. It costs one walk per
+        // page navigation, which is nothing next to the navigation itself.
+        if (documentReplaced) {
+          policy.evaluateDocument(tr.doc);
+        }
+
+        // Report bulk work so the policy can discount it. The policy decides what counts as bulk;
+        // this only supplies the facts.
+        //
+        // Known gap: operations that are expensive but barely change document size — table
+        // resize, drag-and-drop moves (delete + insert nets to ~0), type-ahead — are not
+        // suppressed. `@atlaskit/insm` already tracks exactly these via `startHeavyTask`, but its
+        // public facade does not expose `runningHeavyTasks`, so there is no way to read them from
+        // here today. Closing that gap needs an accessor on the insm package.
+        if (tr.docChanged) {
+          var _detector3;
+          (_detector3 = detector) === null || _detector3 === void 0 ? void 0 : _detector3.noteDocumentChange({
+            nodeSizeDelta: tr.doc.nodeSize - oldState.doc.nodeSize,
+            isDocumentReplaced: documentReplaced
+          });
+        }
+        const next = policyState(policy);
+
+        // Keep the previous object when nothing changed, so shared-state diffing stays cheap and
+        // consumers are not notified for no reason.
+        return next.enabled === currentPluginState.enabled && next.documentSizeBreachesThreshold === currentPluginState.documentSizeBreachesThreshold ? currentPluginState : next;
       }
     }
   });

package/dist/es2019/pm-plugins/plugin-key.js

@@ -0,0 +1,2 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export const limitedModePluginKey = new PluginKey('limitedModePlugin');

package/dist/es2019/pm-plugins/utils/latch-detector-types.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/pm-plugins/utils/latch-detector.js

@@ -0,0 +1,92 @@
+import { isPerformanceAPIAvailable, isPerformanceObserverLongTaskAvailable } from '@atlaskit/editor-common/is-performance-api-available';
+/**
+ * Wires browser performance signals into the supplied {@link LatchPolicy}.
+ *
+ * Holds no configuration and makes no decisions: it measures, and forwards. Everything tunable lives
+ * on the policy, including the clock it reads.
+ *
+ * The measurement mirrors `editor-plugin-base/src/pm-plugins/frozen-editor.ts`, which already runs an
+ * identical `longtask` observer and per-keystroke rAF measurement for every session to feed
+ * `ACTION.SLOW_INPUT` / `ACTION.BROWSER_FREEZE`. It is duplicated rather than shared so that this
+ * experiment stays self-contained inside the limited-mode plugin — no new cross-plugin dependency,
+ * and deleting it is a single-directory revert if the experiment does not ship. The marginal cost is
+ * one `performance.now()` and one `requestAnimationFrame` per keystroke.
+ */
+export const createLatchDetector = ({
+  onLatchCriteriaMet,
+  policy
+}) => {
+  // One clock for the whole subsystem, so measured durations and the policy's windows agree.
+  const now = policy.now;
+  let observer;
+  let destroyed = false;
+  const handleEvaluation = evaluation => {
+    if (evaluation !== 'latched') {
+      return;
+    }
+
+    // One-way latch: the policy will never evaluate again, so stop paying for the observers.
+    teardownObservers();
+    const details = policy.getLatchDetails();
+    if (details) {
+      onLatchCriteriaMet(details);
+    }
+  };
+  function teardownObservers() {
+    var _observer;
+    (_observer = observer) === null || _observer === void 0 ? void 0 : _observer.disconnect();
+    observer = undefined;
+  }
+  if (isPerformanceObserverLongTaskAvailable()) {
+    try {
+      observer = new PerformanceObserver(list => {
+        for (const entry of list.getEntries()) {
+          if (policy.isLatched()) {
+            return;
+          }
+          handleEvaluation(policy.recordLongTask(entry.duration));
+        }
+      });
+      observer.observe({
+        entryTypes: ['longtask']
+      });
+    } catch {
+      // `longtask` is unsupported in some browsers even when PerformanceObserver exists. The
+      // latency criterion alone is still a valid trigger, so carry on without freeze detection.
+      observer = undefined;
+    }
+  }
+  return {
+    noteDocumentChange: ({
+      nodeSizeDelta,
+      isDocumentReplaced
+    }) => {
+      if (destroyed || policy.isLatched()) {
+        return;
+      }
+      if (isDocumentReplaced || policy.isBulkChange(nodeSizeDelta)) {
+        policy.suppress();
+      }
+    },
+    measureInput: () => {
+      if (destroyed || policy.isLatched() || !isPerformanceAPIAvailable()) {
+        return;
+      }
+      const start = now();
+
+      // Runs after every handleTextInput and all resulting plugin work, but before paint — the
+      // same measurement point frozen-editor uses, so the numbers are comparable to existing
+      // SLOW_INPUT telemetry.
+      requestAnimationFrame(() => {
+        if (destroyed || policy.isLatched()) {
+          return;
+        }
+        handleEvaluation(policy.recordInputLatency(now() - start));
+      });
+    },
+    destroy: () => {
+      destroyed = true;
+      teardownObservers();
+    }
+  };
+};