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

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

@@ -0,0 +1,277 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { median } from '@atlaskit/editor-common/median';
+import { shouldEnableLimitedModeForDocument } from '@atlaskit/editor-common/should-enable-limited-mode';
+/**
+ * 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.
+ */
+export const DEFAULT_LATCH_POLICY_CONFIG = {
+  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
+};
+
+/**
+ * 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.
+ */
+export class LatchPolicy {
+  constructor({
+    now,
+    config
+  }) {
+    /** Public so the detector can read the tunables it needs rather than duplicating them. */
+    /** Public so the detector shares one clock with the policy. */
+    _defineProperty(this, "latencySamples", []);
+    _defineProperty(this, "freezeTimes", []);
+    _defineProperty(this, "qualifiedWindows", 0);
+    _defineProperty(this, "suppressedUntil", 0);
+    _defineProperty(this, "latched", false);
+    _defineProperty(this, "documentBreached", false);
+    /** Cumulative for the session and never cleared, unlike the evidence buffers. */
+    _defineProperty(this, "totalInputSamples", 0);
+    _defineProperty(this, "totalSlowInputs", 0);
+    _defineProperty(this, "totalFreezes", 0);
+    this.now = now;
+    this.config = {
+      ...DEFAULT_LATCH_POLICY_CONFIG,
+      ...config
+    };
+    this.startedAt = now();
+  }
+
+  /**
+   * Whether limited mode should be on, for either reason. This is the verdict consumers act on.
+   */
+  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.
+   */
+  getLatchDetails() {
+    return this.latchDetails;
+  }
+
+  /** Whether the runtime (device) criteria have latched. One-way, and never cleared. */
+  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`.
+   */
+  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. */
+  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.
+   */
+  evaluateDocument(doc) {
+    this.documentBreached = 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.
+   */
+  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.
+   */
+  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).
+   */
+  recordInputLatency(durationMs) {
+    if (!this.canRecord()) {
+      return 'ignored';
+    }
+    const {
+      slowInputMs,
+      latencyWindowSize,
+      latencySlowSamplesRequired
+    } = this.config;
+    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';
+    }
+    const slowSamples = this.latencySamples.filter(sample => 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.
+    const windowMedian = median(this.latencySamples);
+    if (windowMedian <= slowInputMs) {
+      return 'recorded';
+    }
+    return this.qualify('inputLatency', windowMedian);
+  }
+
+  /**
+   * Feed one `longtask` PerformanceObserver entry.
+   */
+  recordLongTask(durationMs) {
+    if (!this.canRecord()) {
+      return 'ignored';
+    }
+    const {
+      freezeTaskMs,
+      freezeWindowMs,
+      freezeTasksRequired
+    } = this.config;
+    if (durationMs <= freezeTaskMs) {
+      return 'recorded';
+    }
+    const now = this.now();
+    this.totalFreezes += 1;
+    this.freezeTimes.push(now);
+    this.freezeTimes = this.freezeTimes.filter(time => 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');
+  }
+  canRecord() {
+    if (this.latched) {
+      return false;
+    }
+    const 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. */
+  buildDetails(reason, latencyMedianMs) {
+    var _this$firstWindowReas;
+    const now = this.now();
+    return {
+      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
+    };
+  }
+  qualify(reason, latencyMedianMs) {
+    const 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/esm/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 var limitedModePlugin = function limitedModePlugin(_ref) {
   var api = _ref.api;
   return {
@@ -9,7 +10,9 @@ export var limitedModePlugin = function limitedModePlugin(_ref) {
     pmPlugins: function pmPlugins() {
       return [{
         name: 'limitedModePlugin',
-        plugin: createPlugin
+        plugin: function plugin() {
+          return createPlugin(api);
+        }
       }];
     },
     getSharedState: function getSharedState(editorState) {
@@ -17,7 +20,7 @@ export var limitedModePlugin = function limitedModePlugin(_ref) {
         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: limitedModePluginKey
         };

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

@@ -1,29 +1,212 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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) { _defineProperty(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; }
+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 var limitedModePluginKey = new PluginKey('limitedModePlugin');
-export var createPlugin = function 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.
+ */
+var getDeviceHints = function getDeviceHints() {
+  if (typeof navigator === 'undefined') {
+    return {};
+  }
+  var _ref = navigator,
+    hardwareConcurrency = _ref.hardwareConcurrency,
+    deviceMemory = _ref.deviceMemory;
+  return {
+    hardwareConcurrency: hardwareConcurrency,
+    deviceMemoryGb: deviceMemory
+  };
+};
+
+/** Control-arm state: the document decision alone, exactly as before the experiment. */
+var documentOnlyState = function documentOnlyState(doc) {
+  var documentSizeBreachesThreshold = shouldEnableLimitedModeForDocument(doc);
+  return {
+    documentSizeBreachesThreshold: documentSizeBreachesThreshold,
+    latchPolicyBreached: false,
+    enabled: documentSizeBreachesThreshold
+  };
+};
+
+/** Treatment-arm state: whatever the policy says, for both of its reasons. */
+var policyState = function policyState(policy) {
+  return {
+    documentSizeBreachesThreshold: policy.isDocumentBreached(),
+    latchPolicyBreached: policy.isBreached(),
+    enabled: policy.isBreached()
+  };
+};
+export var createPlugin = function createPlugin(api, injectedPolicy) {
+  var detector;
+  var policy;
+  if (injectedPolicy) {
+    policy = injectedPolicy;
+  } else if (isExperimentEnabled('platform_editor_dynamic_limited_mode')) {
+    var config = expVal('platform_editor_dynamic_limited_mode', 'policyConfig', {
+      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
+    });
+
+    // 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: function now() {
+        return performance.now();
+      },
+      config: config
+    });
+  }
   return new SafePlugin({
     key: limitedModePluginKey,
-    view: function view(_view) {
-      return {};
+    props: {
+      handleTextInput: function handleTextInput() {
+        var _detector;
+        (_detector = detector) === null || _detector === void 0 || _detector.measureInput();
+
+        // Never handle the input — this is measurement only.
+        return false;
+      }
+    },
+    view: function view(editorView) {
+      // No policy means the experiment is off: no observers, no per-keystroke measurement.
+      if (!policy) {
+        return {};
+      }
+      var startedAt = performance.now();
+      detector = createLatchDetector({
+        policy: policy,
+        onLatchCriteriaMet: function 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 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 || _api$analytics.actions.fireAnalyticsEvent({
+            action: ACTION.LIMITED_MODE_LATCHED,
+            actionSubject: ACTION_SUBJECT.EDITOR,
+            eventType: EVENT_TYPE.OPERATIONAL,
+            attributes: _objectSpread(_objectSpread({
+              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
+            }, 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: function destroy() {
+          var _detector2;
+          (_detector2 = detector) === null || _detector2 === void 0 || _detector2.destroy();
+          detector = undefined;
+        }
+      };
     },
     state: {
       init: function init(_config, editorState) {
-        return {
-          documentSizeBreachesThreshold: shouldEnableLimitedModeForDocument(editorState.doc)
-        };
+        if (!policy) {
+          return documentOnlyState(editorState.doc);
+        }
+        policy.evaluateDocument(editorState.doc);
+        return policyState(policy);
       },
-      apply: function 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: function apply(tr, currentPluginState, oldState, _newState) {
+        var _tr$getMeta;
+        var 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 || _detector3.noteDocumentChange({
+            nodeSizeDelta: tr.doc.nodeSize - oldState.doc.nodeSize,
+            isDocumentReplaced: documentReplaced
+          });
+        }
+        var 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/esm/pm-plugins/plugin-key.js

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

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

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

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

@@ -0,0 +1,102 @@
+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 { 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 var createLatchDetector = function createLatchDetector(_ref) {
+  var onLatchCriteriaMet = _ref.onLatchCriteriaMet,
+    policy = _ref.policy;
+  // One clock for the whole subsystem, so measured durations and the policy's windows agree.
+  var now = policy.now;
+  var observer;
+  var destroyed = false;
+  var handleEvaluation = function handleEvaluation(evaluation) {
+    if (evaluation !== 'latched') {
+      return;
+    }
+
+    // One-way latch: the policy will never evaluate again, so stop paying for the observers.
+    teardownObservers();
+    var details = policy.getLatchDetails();
+    if (details) {
+      onLatchCriteriaMet(details);
+    }
+  };
+  function teardownObservers() {
+    var _observer;
+    (_observer = observer) === null || _observer === void 0 || _observer.disconnect();
+    observer = undefined;
+  }
+  if (isPerformanceObserverLongTaskAvailable()) {
+    try {
+      observer = new PerformanceObserver(function (list) {
+        var _iterator = _createForOfIteratorHelper(list.getEntries()),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var entry = _step.value;
+            if (policy.isLatched()) {
+              return;
+            }
+            handleEvaluation(policy.recordLongTask(entry.duration));
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      });
+      observer.observe({
+        entryTypes: ['longtask']
+      });
+    } catch (_unused) {
+      // `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: function noteDocumentChange(_ref2) {
+      var nodeSizeDelta = _ref2.nodeSizeDelta,
+        isDocumentReplaced = _ref2.isDocumentReplaced;
+      if (destroyed || policy.isLatched()) {
+        return;
+      }
+      if (isDocumentReplaced || policy.isBulkChange(nodeSizeDelta)) {
+        policy.suppress();
+      }
+    },
+    measureInput: function measureInput() {
+      if (destroyed || policy.isLatched() || !isPerformanceAPIAvailable()) {
+        return;
+      }
+      var 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(function () {
+        if (destroyed || policy.isLatched()) {
+          return;
+        }
+        handleEvaluation(policy.recordInputLatency(now() - start));
+      });
+    },
+    destroy: function destroy() {
+      destroyed = true;
+      teardownObservers();
+    }
+  };
+};