@atlaskit/editor-plugin-autocomplete 2.3.0 → 2.5.0

package/dist/es2019/pm-plugins/local-slow-lane-client.js

@@ -0,0 +1,355 @@
+/**
+ * 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.
+ */
+
+import { isAutocompleteDebugEnabled } from './debug-mode';
+import { isWordBoundary } from './slow-lane-client';
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+// Same return type as createSlowLaneClient for drop-in compatibility
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const DEFAULT_DEBOUNCE_MS = 300;
+export 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 const LOCAL_MLC_HF_MODEL_REPO = 'https://huggingface.co/mlc-ai/SmolLM2-135M-Instruct-q0f16-MLC';
+export 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 const HUGGINGFACE_TB_SMOLLM_ADD_BASICS_REPO = 'https://huggingface.co/HuggingFaceTB/smollm-135M-instruct-add-basics-q0f16-MLC';
+
+// ─── Factory ─────────────────────────────────────────────────────────────────
+
+/**
+ * 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 const createLocalSlowLaneClient = (config = {}) => {
+  const {
+    debounceMs = DEFAULT_DEBOUNCE_MS,
+    onUpdate,
+    onStatus,
+    modelId = LOCAL_MLC_MODEL_ID,
+    customModelConfig
+  } = config;
+
+  // ── State ──────────────────────────────────────────────────────────────
+  let storedContextVector = null;
+  let storedLmLogits = null;
+  let debounceTimer = null;
+  let lastRequestedText = '';
+  let requestCounter = 0;
+  let latestRequestId = -1;
+  let ready = false;
+  let destroyed = false;
+  let initFailed = false;
+  let engine = null;
+  let engineInitPromise = null;
+  const unloadEngine = engineToUnload => {
+    engineToUnload.unload().catch(error => {
+      if (isAutocompleteDebugEnabled()) {
+        // eslint-disable-next-line no-console
+        console.log('%c[LocalSlowLane] %cFailed to unload engine', 'color: #9c27b0; font-weight: bold;', 'color: inherit;', error);
+      }
+    });
+  };
+
+  // ── Engine initialisation ──────────────────────────────────────────────
+
+  const initProgressCallback = progress => {
+    const message = `[${(progress.progress * 100).toFixed(0)}%] ${progress.text}`;
+    if (isAutocompleteDebugEnabled()) {
+      // eslint-disable-next-line no-console
+      console.log(`%c[LocalSlowLane] %c🔄 ${message}`, 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
+    }
+    onStatus === null || onStatus === void 0 ? void 0 : onStatus(message);
+  };
+  const initEngine = async () => {
+    try {
+      if (isAutocompleteDebugEnabled()) {
+        // eslint-disable-next-line no-console
+        console.log(`%c[LocalSlowLane] %c🚀 Initialising MLC engine with model: ${modelId}`, 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
+      }
+      onStatus === null || onStatus === void 0 ? void 0 : onStatus(`Initialising model: ${modelId}…`);
+      if (!('gpu' in navigator)) {
+        throw new Error('WebGPU not supported');
+      }
+      const {
+        CreateMLCEngine,
+        prebuiltAppConfig
+      } = await import( /* webpackChunkName: "@atlaskit-internal_editor-plugin-autocomplete-mlc-web-llm" */'@mlc-ai/web-llm');
+      const customModelRecord = customModelConfig ? {
+        model: customModelConfig.model,
+        model_id: modelId,
+        model_lib: customModelConfig.modelLib,
+        low_resource_required: true,
+        required_features: ['shader-f16'],
+        ...(customModelConfig.vramRequiredMB !== undefined ? {
+          vram_required_MB: customModelConfig.vramRequiredMB
+        } : {}),
+        ...(customModelConfig.contextWindowSize !== undefined ? {
+          overrides: {
+            context_window_size: customModelConfig.contextWindowSize
+          }
+        } : {})
+      } : undefined;
+      const appConfig = {
+        model_list: [...prebuiltAppConfig.model_list, ...(customModelRecord ? [customModelRecord] : [])]
+      };
+      engine = await CreateMLCEngine(modelId, {
+        appConfig,
+        initProgressCallback
+      });
+      if (destroyed) {
+        // destroy() was called while we were loading — clean up
+        unloadEngine(engine);
+        engine = null;
+        return;
+      }
+      ready = true;
+      if (isAutocompleteDebugEnabled()) {
+        // eslint-disable-next-line no-console
+        console.log('%c[LocalSlowLane] %c✅ MLC engine loaded and ready', 'color: #9c27b0; font-weight: bold;', 'color: #4caf50;');
+      }
+      onStatus === null || onStatus === void 0 ? void 0 : onStatus('Model loaded and ready.');
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      ready = false;
+      if (isAutocompleteDebugEnabled()) {
+        // eslint-disable-next-line no-console
+        console.log(`[LocalSlowLane] Engine initialisation failed: ${errorMsg}`);
+      }
+      onStatus === null || onStatus === void 0 ? void 0 : onStatus(`Engine initialisation failed: ${errorMsg}`);
+      engineInitPromise = null;
+      initFailed = true;
+    }
+  };
+  const ensureEngineInitialized = () => {
+    if (initFailed) {
+      return Promise.resolve();
+    }
+    if (!engineInitPromise) {
+      engineInitPromise = initEngine();
+    }
+    return engineInitPromise;
+  };
+
+  // ── Inference ──────────────────────────────────────────────────────────
+
+  /**
+   * Run a single forward pass to extract next-token logit probabilities.
+   *
+   * We use the chat completions API with `max_tokens: 1` and `logprobs: true`
+   * to get the model's next-token distribution without generating text.
+   * This is the cheapest possible inference call — a single forward pass.
+   */
+  const runInference = async (text, requestId) => {
+    if (!engine || destroyed) {
+      return;
+    }
+    try {
+      var _response$choices, _response$choices$, _response$choices$$lo;
+      // Use chat completion with logprobs to get next-token distribution
+      const response = await engine.chat.completions.create({
+        messages: [{
+          role: 'user',
+          content: text
+        }],
+        max_tokens: 1,
+        logprobs: true,
+        top_logprobs: 5,
+        temperature: 0
+      });
+
+      // Discard stale results
+      if (requestId < latestRequestId || destroyed) {
+        return;
+      }
+
+      // ── Extract LM logits ───────────────────────────────────────
+      const lmLogits = {};
+      const logprobsContent = (_response$choices = response.choices) === null || _response$choices === void 0 ? void 0 : (_response$choices$ = _response$choices[0]) === null || _response$choices$ === void 0 ? void 0 : (_response$choices$$lo = _response$choices$.logprobs) === null || _response$choices$$lo === void 0 ? void 0 : _response$choices$$lo.content;
+      if (logprobsContent && logprobsContent.length > 0) {
+        const tokenLogprobs = logprobsContent[0];
+
+        // Add the top token
+        if (tokenLogprobs.token) {
+          const token = tokenLogprobs.token.trim().toLowerCase();
+          if (token.length > 0 && /^[a-z]/iu.test(token)) {
+            lmLogits[token] = Math.exp(tokenLogprobs.logprob);
+          }
+        }
+
+        // Add alternative tokens from top_logprobs
+        if (tokenLogprobs.top_logprobs) {
+          for (const alt of tokenLogprobs.top_logprobs) {
+            const token = alt.token.trim().toLowerCase();
+            if (token.length > 0 && /^[a-z]/iu.test(token)) {
+              lmLogits[token] = Math.exp(alt.logprob);
+            }
+          }
+        }
+      }
+      storedLmLogits = Object.keys(lmLogits).length > 0 ? lmLogits : null;
+
+      // ── Semantic vector ─────────────────────────────────────────
+      // SmolLM is a generative model, not an embedding model, so we
+      // don't get a true semantic vector. We generate a lightweight
+      // pseudo-embedding from the logit distribution for compatibility
+      // with the existing scoring pipeline.
+      //
+      // For a production implementation, you would use a dedicated
+      // embedding model (e.g. via web-llm's embeddings API with an
+      // embedding-specific model).
+      if (storedLmLogits) {
+        const logitValues = Object.values(storedLmLogits);
+        storedContextVector = new Float32Array(logitValues);
+      } else {
+        storedContextVector = null;
+      }
+      if (isAutocompleteDebugEnabled()) {
+        // eslint-disable-next-line no-console
+        console.groupCollapsed(`%c[LocalSlowLane] %c📥 Inference result (request #${requestId})`, 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
+        // eslint-disable-next-line no-console
+        console.log(storedContextVector ? `✅ pseudo-vector: ${storedContextVector.length} dims` : '❌ No vector');
+        // eslint-disable-next-line no-console
+        console.log(storedLmLogits ? `✅ lm_logits: ${Object.keys(storedLmLogits).length} tokens` : '❌ No lm_logits');
+        if (storedLmLogits) {
+          const topTokens = Object.entries(storedLmLogits).sort(([, a], [, b]) => b - a).slice(0, 10);
+          // eslint-disable-next-line no-console
+          console.log('Top 10 predictions:', topTokens.map(([t, p]) => `${t}: ${(p * 100).toFixed(1)}%`).join(', '));
+        }
+        // eslint-disable-next-line no-console
+        console.groupEnd();
+      }
+      onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate({
+        textLength: text.length,
+        hasVector: storedContextVector !== null,
+        hasLmLogits: storedLmLogits !== null
+      });
+    } catch (err) {
+      // Discard errors for stale requests
+      if (requestId < latestRequestId) {
+        return;
+      }
+      storedContextVector = null;
+      storedLmLogits = null;
+      onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate({
+        textLength: text.length,
+        hasVector: false,
+        hasLmLogits: false
+      });
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      if (isAutocompleteDebugEnabled()) {
+        // eslint-disable-next-line no-console
+        console.log(`%c[LocalSlowLane] %c❌ Inference error (request #${requestId}): ${errorMsg}`, 'color: #9c27b0; font-weight: bold;', 'color: #f44336;');
+      }
+    }
+  };
+
+  // ── Context update (debounced) ─────────────────────────────────────────
+
+  const doUpdateContext = text => {
+    if (destroyed || !text || text.trim().length === 0) {
+      return;
+    }
+    const requestId = ++requestCounter;
+    latestRequestId = requestId;
+    if (isAutocompleteDebugEnabled()) {
+      // eslint-disable-next-line no-console
+      console.groupCollapsed(`%c[LocalSlowLane] %c📤 Context update (request #${requestId}) | ${text.length} chars`, 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
+      const lines = text.split('\n');
+      lines.forEach((line, i) => {
+        // eslint-disable-next-line no-console
+        console.log(`  ${i === lines.length - 1 ? '▶' : ' '} ${line}`);
+      });
+      // eslint-disable-next-line no-console
+      console.groupEnd();
+    }
+    void ensureEngineInitialized().then(() => runInference(text, requestId)).catch(() => {});
+  };
+  const updateContextDebounced = text => {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    lastRequestedText = text;
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      doUpdateContext(lastRequestedText);
+    }, debounceMs);
+  };
+
+  // ── Public API (same shape as createSlowLaneClient) ────────────────────
+  return {
+    updateContext: updateContextDebounced,
+    getContextVector: () => storedContextVector,
+    getLmLogits: () => storedLmLogits,
+    setContextVector: vector => {
+      storedContextVector = vector;
+    },
+    setLmLogits: logits => {
+      storedLmLogits = logits;
+    },
+    isWordBoundary,
+    isReady: () => ready,
+    destroy: () => {
+      destroyed = true;
+      ready = false;
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+      }
+      if (engine) {
+        const engineToUnload = engine;
+        engine = null;
+        unloadEngine(engineToUnload);
+      }
+      engineInitPromise = null;
+      storedContextVector = null;
+      storedLmLogits = null;
+    }
+  };
+};

package/dist/es2019/pm-plugins/slow-lane-client.js

@@ -7,6 +7,7 @@
  *   Response: { semantic_vector: number[], lm_logits: Record<string, number> }
  */
 
+import { abortExp, EXPERIENCE_NAME, failExp, startExp, succeedExp } from '../analytics/ufo';
 import { isAutocompleteDebugEnabled } from './debug-mode';
 
 // ─── Types ───────────────────────────────────────────────────────────────────
@@ -54,7 +55,9 @@ export const createSlowLaneClient = config => {
   let lastRequestedText = '';
   let storedContextVector = null;
   let storedLmLogits = null;
-  const doUpdateContext = async text => {
+  let requestSeq = 0;
+  let inflightRequestId = null;
+  const doUpdateContext = async (text, requestId) => {
     if (!text || text.trim().length === 0) {
       return;
     }
@@ -65,6 +68,9 @@ export const createSlowLaneClient = config => {
       text,
       session_id: sessionId
     };
+    startExp(EXPERIENCE_NAME.SLOW_LANE_FETCH, requestId, {
+      textLength: text.length
+    });
     if (isAutocompleteDebugEnabled()) {
       // eslint-disable-next-line no-console
       console.groupCollapsed(`%c[SlowLane] %c📤 Sending context | ${text.length} chars`, 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
@@ -84,6 +90,10 @@ export const createSlowLaneClient = config => {
       if (!res.ok) {
         storedContextVector = null;
         storedLmLogits = null;
+        failExp(EXPERIENCE_NAME.SLOW_LANE_FETCH, requestId, {
+          status: res.status,
+          errorType: 'http_error'
+        });
         if (isAutocompleteDebugEnabled()) {
           // eslint-disable-next-line no-console
           console.log(`%c[SlowLane] %c❌ Request failed (${res.status})`, 'color: #9c27b0; font-weight: bold;', 'color: #f44336;');
@@ -111,6 +121,11 @@ export const createSlowLaneClient = config => {
         // eslint-disable-next-line no-console
         console.groupEnd();
       }
+      succeedExp(EXPERIENCE_NAME.SLOW_LANE_FETCH, requestId, {
+        textLength: text.length,
+        hasVector: storedContextVector !== null,
+        hasLmLogits: storedLmLogits !== null
+      });
       onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate({
         textLength: text.length,
         hasVector: storedContextVector !== null,
@@ -120,10 +135,17 @@ export const createSlowLaneClient = config => {
     } catch (e) {
       storedContextVector = null;
       storedLmLogits = null;
+      failExp(EXPERIENCE_NAME.SLOW_LANE_FETCH, requestId, {
+        errorType: 'network'
+      });
       if (isAutocompleteDebugEnabled()) {
         // eslint-disable-next-line no-console
         console.log('%c[SlowLane] %c❌ Network error — context cleared', 'color: #9c27b0; font-weight: bold;', 'color: #f44336;');
       }
+    } finally {
+      if (inflightRequestId === requestId) {
+        inflightRequestId = null;
+      }
     }
   };
   const updateContextDebounced = text => {
@@ -133,7 +155,12 @@ export const createSlowLaneClient = config => {
     lastRequestedText = text;
     debounceTimer = setTimeout(() => {
       debounceTimer = null;
-      doUpdateContext(lastRequestedText);
+      if (inflightRequestId !== null) {
+        abortExp(EXPERIENCE_NAME.SLOW_LANE_FETCH, inflightRequestId, 'superseded');
+      }
+      const requestId = String(++requestSeq);
+      inflightRequestId = requestId;
+      doUpdateContext(lastRequestedText, requestId);
     }, debounceMs);
   };
   return {

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

@@ -16,6 +16,8 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
  * 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';
@@ -566,11 +568,15 @@ export const loadVectorsAsync = async options => {
     return;
   }
   vectorsLoadStarted = true;
+  startExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton');
   let url;
   try {
     url = await options.getBinaryUrl();
   } catch (e) {
     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:', e);
     return;
@@ -579,6 +585,10 @@ export const loadVectorsAsync = async options => {
     const res = await fetch(url);
     if (!res.ok) {
       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: ${res.status}`);
       return;
@@ -593,6 +603,11 @@ export const loadVectorsAsync = async options => {
       wordIndex,
       dim
     };
+    succeedExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', {
+      wordCount: nWords,
+      dim,
+      sizeBytes: float32.byteLength
+    });
     if (isAutocompleteDebugEnabled()) {
       // eslint-disable-next-line no-console
       console.log('[text-predictor] Vectors loaded:', {
@@ -603,6 +618,9 @@ export const loadVectorsAsync = async options => {
     }
   } catch (e) {
     vectorsLoadStarted = false;
+    failExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', {
+      errorType: 'network'
+    });
     // eslint-disable-next-line no-console
     console.warn('[text-predictor] Failed to load vectors:', e);
   }
@@ -611,19 +629,34 @@ export const initVectors = store => {
   vectorStore = store;
 };
 export const loadDefaultVocabulary = () => {
-  // 1. Load the Atlassian Domain (L2)
-  const data = vocabularyData;
-  const terms = Object.entries(data.words).map(([word, stats]) => ({
-    word,
-    freq: stats.freq,
-    docFreq: stats.doc_freq,
-    authorFreq: stats.author_freq
-  }));
-  initVocabulary({
-    terms
-  });
-
-  // 2. Load General English (L3)
-  const l3Words = l3VocabularyData;
-  initL3Vocabulary(l3Words);
+  if (isInitialized) {
+    return;
+  }
+  startExp(EXPERIENCE_NAME.LOAD_VOCABULARY, 'singleton');
+  try {
+    // 1. Load the Atlassian Domain (L2)
+    const data = vocabularyData;
+    const terms = Object.entries(data.words).map(([word, stats]) => ({
+      word,
+      freq: stats.freq,
+      docFreq: stats.doc_freq,
+      authorFreq: stats.author_freq
+    }));
+    initVocabulary({
+      terms
+    });
+
+    // 2. Load General English (L3)
+    const 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/esm/analytics/ufo.js

@@ -0,0 +1,105 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/**
+ * 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, 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 var EXPERIENCE_NAME = {
+  SLOW_LANE_FETCH: 'slow-lane-fetch',
+  LOAD_VOCABULARY: 'load-vocabulary',
+  LOAD_VECTORS: 'load-vectors'
+};
+var isUfoEnabled = function isUfoEnabled() {
+  var _process;
+  return !((_process = process) !== null && _process !== void 0 && (_process = _process.env) !== null && _process !== void 0 && _process.REACT_SSR);
+};
+var operationConfig = {
+  platform: {
+    component: 'editor-plugin-autocomplete'
+  },
+  type: ExperienceTypes.Operation,
+  performanceType: ExperiencePerformanceTypes.Custom,
+  performanceConfig: {
+    histogram: _defineProperty({}, ExperiencePerformanceTypes.Custom, {
+      duration: '50_100_250_500_1000_2000_4000'
+    })
+  }
+};
+var experiences = _defineProperty(_defineProperty(_defineProperty({}, 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 var startExp = function startExp(name, id, metadata) {
+  if (!isUfoEnabled()) {
+    return;
+  }
+  try {
+    var instance = experiences[name].getInstance(id);
+    instance.start();
+    if (metadata) {
+      instance.addMetadata(metadata);
+    }
+  } catch (_unused) {
+    // UFO errors must never break the plugin
+  }
+};
+export var succeedExp = function succeedExp(name, id, metadata) {
+  if (!isUfoEnabled()) {
+    return;
+  }
+  try {
+    experiences[name].getInstance(id).success({
+      metadata: metadata
+    });
+  } catch (_unused2) {
+    // UFO errors must never break the plugin
+  }
+};
+export var failExp = function failExp(name, id, metadata) {
+  if (!isUfoEnabled()) {
+    return;
+  }
+  try {
+    experiences[name].getInstance(id).failure({
+      metadata: metadata
+    });
+  } catch (_unused3) {
+    // UFO errors must never break the plugin
+  }
+};
+export var abortExp = function abortExp(name, id, reason) {
+  if (!isUfoEnabled()) {
+    return;
+  }
+  try {
+    experiences[name].getInstance(id).abort(reason ? {
+      metadata: {
+        reason: reason
+      }
+    } : undefined);
+  } catch (_unused4) {
+    // UFO errors must never break the plugin
+  }
+};

package/dist/esm/entry-points/autocompletePlugin.js

@@ -0,0 +1,2 @@
+/* eslint-disable @atlaskit/editor/no-re-export */
+export { autocompletePlugin } from '../autocompletePlugin';

package/dist/esm/entry-points/src-pm-plugins-autocomplete-plugin.js

@@ -0,0 +1,2 @@
+/* eslint-disable @atlaskit/editor/no-re-export */
+export { autocompletePluginKey, createAutocompletePlugin } from '../pm-plugins/autocomplete-plugin';

package/dist/esm/entry-points/src-pm-plugins-slow-lane-client.js

@@ -0,0 +1,2 @@
+/* eslint-disable @atlaskit/editor/no-re-export */
+export { createSlowLaneClient, getStoredContextVector, getStoredLmLogits, isWordBoundary, setDefaultSlowLaneClient } from '../pm-plugins/slow-lane-client';

package/dist/esm/entry-points/src-pm-plugins-text-predictor.js

@@ -0,0 +1,2 @@
+/* eslint-disable @atlaskit/editor/no-re-export */
+export { getLastPredictionDebug, getPredictorStatus, incrementSessionFreq, ingestDocumentPage, initL3Vocabulary, initVectors, initVocabulary, loadDefaultVocabulary, loadVectorsAsync, predict } from '../pm-plugins/text-predictor';