@atlaskit/editor-plugin-autocomplete 2.4.0 → 2.5.0

package/dist/esm/pm-plugins/text-predictor.js

@@ -24,6 +24,8 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * via incrementSessionFreq(), called on word boundaries from the plugin.
  */
 
+import { EXPERIENCE_NAME, failExp, startExp, succeedExp } from '../analytics/ufo';
+
 // import bigramsData from './data/bigrams.json';
 import l3VocabularyData from './data/l3_vocabulary.json';
 import vocabularyData from './data/vocabulary_10k.json';
@@ -706,38 +708,46 @@ export var loadVectorsAsync = /*#__PURE__*/function () {
           return _context.abrupt("return");
         case 5:
           vectorsLoadStarted = true;
-          _context.prev = 6;
-          _context.next = 9;
+          startExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton');
+          _context.prev = 7;
+          _context.next = 10;
           return options.getBinaryUrl();
-        case 9:
+        case 10:
           url = _context.sent;
-          _context.next = 17;
+          _context.next = 19;
           break;
-        case 12:
-          _context.prev = 12;
-          _context.t0 = _context["catch"](6);
+        case 13:
+          _context.prev = 13;
+          _context.t0 = _context["catch"](7);
           vectorsLoadStarted = false;
+          failExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', {
+            errorType: 'resolve_url'
+          });
           // eslint-disable-next-line no-console
           console.warn('[text-predictor] Failed to resolve vectors URL:', _context.t0);
           return _context.abrupt("return");
-        case 17:
-          _context.prev = 17;
-          _context.next = 20;
+        case 19:
+          _context.prev = 19;
+          _context.next = 22;
           return fetch(url);
-        case 20:
+        case 22:
           res = _context.sent;
           if (res.ok) {
-            _context.next = 25;
+            _context.next = 28;
             break;
           }
           vectorsLoadStarted = false;
+          failExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', {
+            status: res.status,
+            errorType: 'http_error'
+          });
           // eslint-disable-next-line no-console
           console.warn("[text-predictor] Failed to load vectors: ".concat(res.status));
           return _context.abrupt("return");
-        case 25:
-          _context.next = 27;
+        case 28:
+          _context.next = 30;
           return res.arrayBuffer();
-        case 27:
+        case 30:
           buffer = _context.sent;
           float32 = new Float32Array(buffer);
           wordIndex = wordIndexData;
@@ -748,6 +758,11 @@ export var loadVectorsAsync = /*#__PURE__*/function () {
             wordIndex: wordIndex,
             dim: dim
           };
+          succeedExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', {
+            wordCount: nWords,
+            dim: dim,
+            sizeBytes: float32.byteLength
+          });
           if (isAutocompleteDebugEnabled()) {
             // eslint-disable-next-line no-console
             console.log('[text-predictor] Vectors loaded:', {
@@ -756,19 +771,22 @@ export var loadVectorsAsync = /*#__PURE__*/function () {
               sizeBytes: float32.byteLength
             });
           }
-          _context.next = 40;
+          _context.next = 45;
           break;
-        case 36:
-          _context.prev = 36;
-          _context.t1 = _context["catch"](17);
+        case 40:
+          _context.prev = 40;
+          _context.t1 = _context["catch"](19);
           vectorsLoadStarted = false;
+          failExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', {
+            errorType: 'network'
+          });
           // eslint-disable-next-line no-console
           console.warn('[text-predictor] Failed to load vectors:', _context.t1);
-        case 40:
+        case 45:
         case "end":
           return _context.stop();
       }
-    }, _callee, null, [[6, 12], [17, 36]]);
+    }, _callee, null, [[7, 13], [19, 40]]);
   }));
   return function loadVectorsAsync(_x) {
     return _ref6.apply(this, arguments);
@@ -778,24 +796,39 @@ export var initVectors = function initVectors(store) {
   vectorStore = store;
 };
 export var loadDefaultVocabulary = function loadDefaultVocabulary() {
-  // 1. Load the Atlassian Domain (L2)
-  var data = vocabularyData;
-  var terms = Object.entries(data.words).map(function (_ref7) {
-    var _ref8 = _slicedToArray(_ref7, 2),
-      word = _ref8[0],
-      stats = _ref8[1];
-    return {
-      word: word,
-      freq: stats.freq,
-      docFreq: stats.doc_freq,
-      authorFreq: stats.author_freq
-    };
-  });
-  initVocabulary({
-    terms: terms
-  });
+  if (isInitialized) {
+    return;
+  }
+  startExp(EXPERIENCE_NAME.LOAD_VOCABULARY, 'singleton');
+  try {
+    // 1. Load the Atlassian Domain (L2)
+    var data = vocabularyData;
+    var terms = Object.entries(data.words).map(function (_ref7) {
+      var _ref8 = _slicedToArray(_ref7, 2),
+        word = _ref8[0],
+        stats = _ref8[1];
+      return {
+        word: word,
+        freq: stats.freq,
+        docFreq: stats.doc_freq,
+        authorFreq: stats.author_freq
+      };
+    });
+    initVocabulary({
+      terms: terms
+    });
 
-  // 2. Load General English (L3)
-  var l3Words = l3VocabularyData;
-  initL3Vocabulary(l3Words);
+    // 2. Load General English (L3)
+    var l3Words = l3VocabularyData;
+    initL3Vocabulary(l3Words);
+    succeedExp(EXPERIENCE_NAME.LOAD_VOCABULARY, 'singleton', {
+      l2WordCount: terms.length,
+      l3WordCount: l3Words.length
+    });
+  } catch (e) {
+    failExp(EXPERIENCE_NAME.LOAD_VOCABULARY, 'singleton', {
+      errorType: 'parse_error'
+    });
+    throw e;
+  }
 };

package/dist/types/analytics/ufo.d.ts

@@ -0,0 +1,38 @@
+/**
+ * UFO experience tracking helpers for `@atlaskit/editor-plugin-autocomplete`.
+ *
+ * Pattern follows `packages/linking-platform/smart-card/src/state/analytics/ufoExperiences.ts`
+ * (ConcurrentExperience keyed per request/instance) plus a try/catch safety wrap
+ * inspired by `packages/editor/collab-provider/src/analytics/ufo.ts` so a UFO
+ * runtime error can never break the autocomplete feature.
+ *
+ * Experience names must be registered in DataPortal's `task` attribute before
+ * they can power FE Reliability SLOs:
+ * https://hello.atlassian.net/wiki/spaces/AA6/pages/3961393753
+ */
+import { type CustomData } from '@atlaskit/ufo';
+/**
+ * Experience name strings are surfaced downstream by the UFO pipeline as
+ * `platform.fe.<type>.<platform.component>.<name>` (e.g.
+ * `platform.fe.operation.editor-plugin-autocomplete.slow-lane-fetch`), so
+ * names here should be short, dot-free, and must not repeat the component
+ * name. This matches the convention used by `@atlaskit/emoji`'s
+ * `ufoExperiences` map (e.g. `'emoji-rendered'`).
+ */
+/**
+ * Only experiences with meaningful async work and a real success/failure
+ * outcome belong on UFO (which measures latency and success rate for FE
+ * Reliability SLOs). Per-keystroke suggestion lifecycle counters (viewed /
+ * inserted / dismissed) are tracked via analytics-next instead — they would
+ * otherwise emit zero-duration events on every word boundary.
+ */
+export declare const EXPERIENCE_NAME: {
+    readonly SLOW_LANE_FETCH: "slow-lane-fetch";
+    readonly LOAD_VOCABULARY: "load-vocabulary";
+    readonly LOAD_VECTORS: "load-vectors";
+};
+export type AutocompleteExperienceName = (typeof EXPERIENCE_NAME)[keyof typeof EXPERIENCE_NAME];
+export declare const startExp: (name: AutocompleteExperienceName, id: string, metadata?: CustomData) => void;
+export declare const succeedExp: (name: AutocompleteExperienceName, id: string, metadata?: CustomData) => void;
+export declare const failExp: (name: AutocompleteExperienceName, id: string, metadata?: CustomData) => void;
+export declare const abortExp: (name: AutocompleteExperienceName, id: string, reason?: string) => void;

package/dist/types/pm-plugins/autocomplete-plugin.d.ts

@@ -40,5 +40,10 @@ export interface AutocompletePluginOptions {
      * Use this to serve vectors from a CDN or media service in production.
      */
     getVectorsBinaryUrl?: () => Promise<string>;
+    /**
+     * When true, uses on-device inference via WebGPU (MLC WebLLM) instead of
+     * the network-based slow-lane backend. Defaults to false (network client).
+     */
+    useLocalModel?: boolean;
 }
 export declare const createAutocompletePlugin: (options?: AutocompletePluginOptions, api?: ExtractInjectionAPI<AutocompletePlugin>) => SafePlugin<AutocompletePluginState>;

package/dist/types/pm-plugins/local-slow-lane-client.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Local Slow Lane Client: On-device inference via @mlc-ai/web-llm.
+ *
+ * Drop-in replacement for the network-based slow-lane-client.  Instead of
+ * calling a backend API, this client uses MLC WebLLM to run a small language
+ * model (SmolLM 135M) directly in the browser via WebGPU.
+ *
+ * ── Why main thread (no Web Worker)? ─────────────────────────────────────
+ * SmolLM 135M is small enough (~270 MB weights, 350-400 MB VRAM) that
+ * WebGPU inference on the main thread is production-viable:
+ *
+ *   - WebGPU GPU compute is inherently async (doesn't block the main thread)
+ *   - CPU overhead (tokenization + post-processing) is only 5-10 ms
+ *   - Single forward pass latency is 50-150 ms — well within autocomplete
+ *     expectations (~250 ms between word boundaries)
+ *
+ * This avoids all the complexity of Web Workers:
+ *   - No CSP workarounds (blob URLs, inline scripts)
+ *   - No bundler configuration (worker-plugin, import.meta.url)
+ *   - No message passing protocol
+ *   - Standard npm import — just works
+ *
+ * ── Interface ────────────────────────────────────────────────────────────
+ * Same shape as createSlowLaneClient so text-predictor.ts needs zero changes.
+ * The client exposes getContextVector() and getLmLogits() which are populated
+ * asynchronously after each updateContext() call.
+ */
+export interface LocalSlowLaneClientConfig {
+    /**
+     * Optional custom model registration for models not in web-llm's
+     * built-in list. When provided, the model is appended to the app
+     * config before engine creation.
+     */
+    customModelConfig?: {
+        /** Context window size override (optional) */
+        contextWindowSize?: number;
+        /** HuggingFace URL to the model weights (e.g. "https://huggingface.co/HuggingFaceTB/smollm-135M-instruct-add-basics-q0f16-MLC") */
+        model: string;
+        /** URL to the compiled WASM library for this model architecture */
+        modelLib: string;
+        /** VRAM required in MB (optional, for resource planning) */
+        vramRequiredMB?: number;
+    };
+    /** Debounce interval in ms before sending context for inference. */
+    debounceMs?: number;
+    /**
+     * MLC model identifier.
+     * Defaults to the built-in SmolLM2-135M-Instruct-q0f16-MLC.
+     *
+     * To use a custom HuggingFace model, provide both `modelId` and
+     * `customModelConfig` with the model URL and WASM library URL.
+     */
+    modelId?: string;
+    /** Callback fired with status messages (model loading progress, etc.). */
+    onStatus?: (message: string) => void;
+    /** Callback fired when inference returns new results. */
+    onUpdate?: (opts: {
+        hasLmLogits: boolean;
+        hasVector: boolean;
+        textLength: number;
+    }) => void;
+}
+export interface LocalSlowLaneClient {
+    /** Clean up resources. */
+    destroy: () => void;
+    getContextVector: () => Float32Array | null;
+    getLmLogits: () => Record<string, number> | null;
+    /** Whether the model is loaded and ready for inference. */
+    isReady: () => boolean;
+    isWordBoundary: (text: string) => boolean;
+    setContextVector: (vector: Float32Array | null) => void;
+    setLmLogits: (logits: Record<string, number> | null) => void;
+    updateContext: (text: string) => void;
+}
+export declare const LOCAL_MLC_MODEL_ID = "SmolLM2-135M-Instruct-q0f16-MLC";
+/** HF root for the default weights (includes `tensor-cache.json` for WebLLM 0.2+). */
+export declare const LOCAL_MLC_HF_MODEL_REPO = "https://huggingface.co/mlc-ai/SmolLM2-135M-Instruct-q0f16-MLC";
+export declare const LOCAL_MLC_MODEL_LIB_WASM_NAME = "SmolLM2-135M-Instruct-q0f16-ctx4k_cs1k-webgpu.wasm";
+/**
+ * Original target repo (add-basics fine-tune). **Not compatible with WebLLM 0.2.x** (no `tensor-cache.json`).
+ * @see module doc above
+ */
+export declare const HUGGINGFACE_TB_SMOLLM_ADD_BASICS_REPO = "https://huggingface.co/HuggingFaceTB/smollm-135M-instruct-add-basics-q0f16-MLC";
+/**
+ * Create a local slow-lane client powered by MLC WebLLM.
+ *
+ * The engine is initialised lazily — model weights are downloaded (and cached
+ * in IndexedDB) on first use. Subsequent page loads skip the download.
+ *
+ * Usage:
+ * ```ts
+ * const client = createLocalSlowLaneClient({ debounceMs: 300 });
+ * // On word boundaries:
+ * client.updateContext(docText);
+ * // In scoring pipeline:
+ * const vec = client.getContextVector();
+ * const logits = client.getLmLogits();
+ * // On plugin teardown:
+ * client.destroy();
+ * ```
+ */
+export declare const createLocalSlowLaneClient: (config?: LocalSlowLaneClientConfig) => LocalSlowLaneClient;

package/dist/types-ts4.5/analytics/ufo.d.ts

@@ -0,0 +1,38 @@
+/**
+ * UFO experience tracking helpers for `@atlaskit/editor-plugin-autocomplete`.
+ *
+ * Pattern follows `packages/linking-platform/smart-card/src/state/analytics/ufoExperiences.ts`
+ * (ConcurrentExperience keyed per request/instance) plus a try/catch safety wrap
+ * inspired by `packages/editor/collab-provider/src/analytics/ufo.ts` so a UFO
+ * runtime error can never break the autocomplete feature.
+ *
+ * Experience names must be registered in DataPortal's `task` attribute before
+ * they can power FE Reliability SLOs:
+ * https://hello.atlassian.net/wiki/spaces/AA6/pages/3961393753
+ */
+import { type CustomData } from '@atlaskit/ufo';
+/**
+ * Experience name strings are surfaced downstream by the UFO pipeline as
+ * `platform.fe.<type>.<platform.component>.<name>` (e.g.
+ * `platform.fe.operation.editor-plugin-autocomplete.slow-lane-fetch`), so
+ * names here should be short, dot-free, and must not repeat the component
+ * name. This matches the convention used by `@atlaskit/emoji`'s
+ * `ufoExperiences` map (e.g. `'emoji-rendered'`).
+ */
+/**
+ * Only experiences with meaningful async work and a real success/failure
+ * outcome belong on UFO (which measures latency and success rate for FE
+ * Reliability SLOs). Per-keystroke suggestion lifecycle counters (viewed /
+ * inserted / dismissed) are tracked via analytics-next instead — they would
+ * otherwise emit zero-duration events on every word boundary.
+ */
+export declare const EXPERIENCE_NAME: {
+    readonly SLOW_LANE_FETCH: "slow-lane-fetch";
+    readonly LOAD_VOCABULARY: "load-vocabulary";
+    readonly LOAD_VECTORS: "load-vectors";
+};
+export type AutocompleteExperienceName = (typeof EXPERIENCE_NAME)[keyof typeof EXPERIENCE_NAME];
+export declare const startExp: (name: AutocompleteExperienceName, id: string, metadata?: CustomData) => void;
+export declare const succeedExp: (name: AutocompleteExperienceName, id: string, metadata?: CustomData) => void;
+export declare const failExp: (name: AutocompleteExperienceName, id: string, metadata?: CustomData) => void;
+export declare const abortExp: (name: AutocompleteExperienceName, id: string, reason?: string) => void;

package/dist/types-ts4.5/pm-plugins/autocomplete-plugin.d.ts

@@ -40,5 +40,10 @@ export interface AutocompletePluginOptions {
      * Use this to serve vectors from a CDN or media service in production.
      */
     getVectorsBinaryUrl?: () => Promise<string>;
+    /**
+     * When true, uses on-device inference via WebGPU (MLC WebLLM) instead of
+     * the network-based slow-lane backend. Defaults to false (network client).
+     */
+    useLocalModel?: boolean;
 }
 export declare const createAutocompletePlugin: (options?: AutocompletePluginOptions, api?: ExtractInjectionAPI<AutocompletePlugin>) => SafePlugin<AutocompletePluginState>;

package/dist/types-ts4.5/pm-plugins/local-slow-lane-client.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Local Slow Lane Client: On-device inference via @mlc-ai/web-llm.
+ *
+ * Drop-in replacement for the network-based slow-lane-client.  Instead of
+ * calling a backend API, this client uses MLC WebLLM to run a small language
+ * model (SmolLM 135M) directly in the browser via WebGPU.
+ *
+ * ── Why main thread (no Web Worker)? ─────────────────────────────────────
+ * SmolLM 135M is small enough (~270 MB weights, 350-400 MB VRAM) that
+ * WebGPU inference on the main thread is production-viable:
+ *
+ *   - WebGPU GPU compute is inherently async (doesn't block the main thread)
+ *   - CPU overhead (tokenization + post-processing) is only 5-10 ms
+ *   - Single forward pass latency is 50-150 ms — well within autocomplete
+ *     expectations (~250 ms between word boundaries)
+ *
+ * This avoids all the complexity of Web Workers:
+ *   - No CSP workarounds (blob URLs, inline scripts)
+ *   - No bundler configuration (worker-plugin, import.meta.url)
+ *   - No message passing protocol
+ *   - Standard npm import — just works
+ *
+ * ── Interface ────────────────────────────────────────────────────────────
+ * Same shape as createSlowLaneClient so text-predictor.ts needs zero changes.
+ * The client exposes getContextVector() and getLmLogits() which are populated
+ * asynchronously after each updateContext() call.
+ */
+export interface LocalSlowLaneClientConfig {
+    /**
+     * Optional custom model registration for models not in web-llm's
+     * built-in list. When provided, the model is appended to the app
+     * config before engine creation.
+     */
+    customModelConfig?: {
+        /** Context window size override (optional) */
+        contextWindowSize?: number;
+        /** HuggingFace URL to the model weights (e.g. "https://huggingface.co/HuggingFaceTB/smollm-135M-instruct-add-basics-q0f16-MLC") */
+        model: string;
+        /** URL to the compiled WASM library for this model architecture */
+        modelLib: string;
+        /** VRAM required in MB (optional, for resource planning) */
+        vramRequiredMB?: number;
+    };
+    /** Debounce interval in ms before sending context for inference. */
+    debounceMs?: number;
+    /**
+     * MLC model identifier.
+     * Defaults to the built-in SmolLM2-135M-Instruct-q0f16-MLC.
+     *
+     * To use a custom HuggingFace model, provide both `modelId` and
+     * `customModelConfig` with the model URL and WASM library URL.
+     */
+    modelId?: string;
+    /** Callback fired with status messages (model loading progress, etc.). */
+    onStatus?: (message: string) => void;
+    /** Callback fired when inference returns new results. */
+    onUpdate?: (opts: {
+        hasLmLogits: boolean;
+        hasVector: boolean;
+        textLength: number;
+    }) => void;
+}
+export interface LocalSlowLaneClient {
+    /** Clean up resources. */
+    destroy: () => void;
+    getContextVector: () => Float32Array | null;
+    getLmLogits: () => Record<string, number> | null;
+    /** Whether the model is loaded and ready for inference. */
+    isReady: () => boolean;
+    isWordBoundary: (text: string) => boolean;
+    setContextVector: (vector: Float32Array | null) => void;
+    setLmLogits: (logits: Record<string, number> | null) => void;
+    updateContext: (text: string) => void;
+}
+export declare const LOCAL_MLC_MODEL_ID = "SmolLM2-135M-Instruct-q0f16-MLC";
+/** HF root for the default weights (includes `tensor-cache.json` for WebLLM 0.2+). */
+export declare const LOCAL_MLC_HF_MODEL_REPO = "https://huggingface.co/mlc-ai/SmolLM2-135M-Instruct-q0f16-MLC";
+export declare const LOCAL_MLC_MODEL_LIB_WASM_NAME = "SmolLM2-135M-Instruct-q0f16-ctx4k_cs1k-webgpu.wasm";
+/**
+ * Original target repo (add-basics fine-tune). **Not compatible with WebLLM 0.2.x** (no `tensor-cache.json`).
+ * @see module doc above
+ */
+export declare const HUGGINGFACE_TB_SMOLLM_ADD_BASICS_REPO = "https://huggingface.co/HuggingFaceTB/smollm-135M-instruct-add-basics-q0f16-MLC";
+/**
+ * Create a local slow-lane client powered by MLC WebLLM.
+ *
+ * The engine is initialised lazily — model weights are downloaded (and cached
+ * in IndexedDB) on first use. Subsequent page loads skip the download.
+ *
+ * Usage:
+ * ```ts
+ * const client = createLocalSlowLaneClient({ debounceMs: 300 });
+ * // On word boundaries:
+ * client.updateContext(docText);
+ * // In scoring pipeline:
+ * const vec = client.getContextVector();
+ * const logits = client.getLmLogits();
+ * // On plugin teardown:
+ * client.destroy();
+ * ```
+ */
+export declare const createLocalSlowLaneClient: (config?: LocalSlowLaneClientConfig) => LocalSlowLaneClient;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-autocomplete",
-	"version": "2.4.0",
+	"version": "2.5.0",
 	"description": "Client-side text autocomplete plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -28,12 +28,14 @@
 	"atlaskit:src": "src/index.ts",
 	"dependencies": {
 		"@atlaskit/editor-prosemirror": "^7.3.0",
+		"@atlaskit/ufo": "^0.5.0",
 		"@babel/runtime": "^7.0.0",
+		"@mlc-ai/web-llm": "^0.2.78",
 		"compromise": "^14.15.0",
 		"wink-nlp": "^2.4.0"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^114.32.0",
+		"@atlaskit/editor-common": "^114.43.0",
 		"@atlaskit/editor-plugin-analytics": "^10.1.0",
 		"react": "^18.2.0"
 	},
@@ -49,5 +51,8 @@
 				"file-and-folder-level"
 			]
 		}
+	},
+	"devDependencies": {
+		"react": "^18.2.0"
 	}
 }

package/src/analytics/ufo.ts

@@ -0,0 +1,139 @@
+/**
+ * UFO experience tracking helpers for `@atlaskit/editor-plugin-autocomplete`.
+ *
+ * Pattern follows `packages/linking-platform/smart-card/src/state/analytics/ufoExperiences.ts`
+ * (ConcurrentExperience keyed per request/instance) plus a try/catch safety wrap
+ * inspired by `packages/editor/collab-provider/src/analytics/ufo.ts` so a UFO
+ * runtime error can never break the autocomplete feature.
+ *
+ * Experience names must be registered in DataPortal's `task` attribute before
+ * they can power FE Reliability SLOs:
+ * https://hello.atlassian.net/wiki/spaces/AA6/pages/3961393753
+ */
+
+import {
+	ConcurrentExperience,
+	type CustomData,
+	ExperiencePerformanceTypes,
+	ExperienceTypes,
+} from '@atlaskit/ufo';
+
+/**
+ * Experience name strings are surfaced downstream by the UFO pipeline as
+ * `platform.fe.<type>.<platform.component>.<name>` (e.g.
+ * `platform.fe.operation.editor-plugin-autocomplete.slow-lane-fetch`), so
+ * names here should be short, dot-free, and must not repeat the component
+ * name. This matches the convention used by `@atlaskit/emoji`'s
+ * `ufoExperiences` map (e.g. `'emoji-rendered'`).
+ */
+/**
+ * Only experiences with meaningful async work and a real success/failure
+ * outcome belong on UFO (which measures latency and success rate for FE
+ * Reliability SLOs). Per-keystroke suggestion lifecycle counters (viewed /
+ * inserted / dismissed) are tracked via analytics-next instead — they would
+ * otherwise emit zero-duration events on every word boundary.
+ */
+export const EXPERIENCE_NAME = {
+	SLOW_LANE_FETCH: 'slow-lane-fetch',
+	LOAD_VOCABULARY: 'load-vocabulary',
+	LOAD_VECTORS: 'load-vectors',
+} as const;
+
+export type AutocompleteExperienceName =
+	(typeof EXPERIENCE_NAME)[keyof typeof EXPERIENCE_NAME];
+
+const isUfoEnabled = (): boolean => !process?.env?.REACT_SSR;
+
+const operationConfig = {
+	platform: { component: 'editor-plugin-autocomplete' },
+	type: ExperienceTypes.Operation,
+	performanceType: ExperiencePerformanceTypes.Custom,
+	performanceConfig: {
+		histogram: {
+			[ExperiencePerformanceTypes.Custom]: {
+				duration: '50_100_250_500_1000_2000_4000',
+			},
+		},
+	},
+};
+
+const experiences: Record<AutocompleteExperienceName, ConcurrentExperience> = {
+	[EXPERIENCE_NAME.SLOW_LANE_FETCH]: new ConcurrentExperience(
+		EXPERIENCE_NAME.SLOW_LANE_FETCH,
+		operationConfig,
+	),
+	[EXPERIENCE_NAME.LOAD_VOCABULARY]: new ConcurrentExperience(
+		EXPERIENCE_NAME.LOAD_VOCABULARY,
+		operationConfig,
+	),
+	[EXPERIENCE_NAME.LOAD_VECTORS]: new ConcurrentExperience(
+		EXPERIENCE_NAME.LOAD_VECTORS,
+		operationConfig,
+	),
+};
+
+export const startExp = (
+	name: AutocompleteExperienceName,
+	id: string,
+	metadata?: CustomData,
+): void => {
+	if (!isUfoEnabled()) {
+		return;
+	}
+	try {
+		const instance = experiences[name].getInstance(id);
+		instance.start();
+		if (metadata) {
+			instance.addMetadata(metadata);
+		}
+	} catch {
+		// UFO errors must never break the plugin
+	}
+};
+
+export const succeedExp = (
+	name: AutocompleteExperienceName,
+	id: string,
+	metadata?: CustomData,
+): void => {
+	if (!isUfoEnabled()) {
+		return;
+	}
+	try {
+		experiences[name].getInstance(id).success({ metadata });
+	} catch {
+		// UFO errors must never break the plugin
+	}
+};
+
+export const failExp = (
+	name: AutocompleteExperienceName,
+	id: string,
+	metadata?: CustomData,
+): void => {
+	if (!isUfoEnabled()) {
+		return;
+	}
+	try {
+		experiences[name].getInstance(id).failure({ metadata });
+	} catch {
+		// UFO errors must never break the plugin
+	}
+};
+
+export const abortExp = (
+	name: AutocompleteExperienceName,
+	id: string,
+	reason?: string,
+): void => {
+	if (!isUfoEnabled()) {
+		return;
+	}
+	try {
+		experiences[name]
+			.getInstance(id)
+			.abort(reason ? { metadata: { reason } } : undefined);
+	} catch {
+		// UFO errors must never break the plugin
+	}
+};