@atlaskit/editor-plugin-autocomplete 6.0.0 → 8.0.0

package/dist/es2019/pm-plugins/scoring-pipeline.js

@@ -3,11 +3,14 @@
  *
  * Operates synchronously on pre-loaded data. Each stage gracefully degrades
  * when its required data isn't available (cold → warm → full warm).
+ *
+ * The grammar/POS payloads are fetched from the CDN by loadGrammarDataAsync, so
+ * the grammar filter is a pass-through until that resolves.
  */
 
-import posTagsData from './data/combined_l2_l3_pos_tags.json';
-import ghostPosTagsData from './data/ghost_pos_tags.json';
-import grammarTransitionsData from './data/grammar_transitions_10k.json';
+import { EXPERIENCE_NAME, failExp, startExp, succeedExp } from '../analytics/ufo';
+import { ARTIFACT_NAME, fetchArtifactJson } from './artifacts-manifest';
+import { isAutocompleteDebugEnabled } from './debug-mode';
 
 // ─── Types ──────────────────────────────────────────────────
 
@@ -28,17 +31,93 @@ const L1_SESSION_CAP = 1.2;
 // at 0.00024) from triggering re-ranking.
 const LM_GATE_THRESHOLD = 0.0005;
 
-// ─── Grammar Data (loaded once on import) ───────────────────
+// ─── Grammar Data (fetched once from the CDN) ────────────────
+
+let posTags = new Map();
 
-const posTags = new Map(Object.entries(posTagsData));
-const grammarTransitions = grammarTransitionsData;
+/**
+ * GHOST POS DICTIONARY
+ * A mapping of common structural English words that were stripped from the main
+ * domain vocabulary. This allows the grammar filter to understand context
+ * without suggesting these words to the user.
+ */
+let ghostPosTags = {};
 
 /**
- * Precomputed map from each POS tag to the set of allowed next POS tags.
- * Built once at module load from grammarTransitions so applyGrammarFilter
- * never re-iterates the transition rules per call.
+ * Precomputed map from each POS tag to the set of allowed next POS tags, so
+ * applyGrammarFilter never re-iterates the transition rules per call.
  */
-const precomputedAllowedByPos = new Map(Object.entries(grammarTransitions.transitions).map(([pos, rule]) => [pos, new Set(rule.allowed)]));
+let precomputedAllowedByPos = new Map();
+let grammarDataPromise;
+const setGrammarData = data => {
+  var _data$grammarTransiti;
+  posTags = new Map(Object.entries(data.posTags));
+  ghostPosTags = data.ghostPosTags;
+  precomputedAllowedByPos = new Map(Object.entries((_data$grammarTransiti = data.grammarTransitions.transitions) !== null && _data$grammarTransiti !== void 0 ? _data$grammarTransiti : {}).map(([pos, rule]) => [pos, new Set(rule.allowed)]));
+};
+export const isGrammarDataLoaded = () => precomputedAllowedByPos.size > 0;
+
+/**
+ * Fetch the POS tag and grammar transition payloads from the CDN.
+ *
+ * Safe to call repeatedly: the in-flight promise is shared, and a failure is not
+ * cached so a later call can retry.
+ */
+export const loadGrammarDataAsync = options => {
+  var _options$isLocalLLM;
+  if (grammarDataPromise) {
+    return grammarDataPromise;
+  }
+  const isLocalLLM = (_options$isLocalLLM = options === null || options === void 0 ? void 0 : options.isLocalLLM) !== null && _options$isLocalLLM !== void 0 ? _options$isLocalLLM : false;
+  const surface = options === null || options === void 0 ? void 0 : options.surface;
+  grammarDataPromise = (async () => {
+    startExp(EXPERIENCE_NAME.LOAD_GRAMMAR, 'singleton', {
+      isLocalLLM,
+      ...(surface ? {
+        surface
+      } : {})
+    });
+    try {
+      const [posTagsData, ghostPosTagsData, grammarTransitionsData] = await Promise.all([fetchArtifactJson(ARTIFACT_NAME.POS_TAGS), fetchArtifactJson(ARTIFACT_NAME.GHOST_POS_TAGS), fetchArtifactJson(ARTIFACT_NAME.GRAMMAR_TRANSITIONS)]);
+      if ((grammarTransitionsData === null || grammarTransitionsData === void 0 ? void 0 : grammarTransitionsData.transitions) == null) {
+        throw new Error(`[scoring-pipeline] ${ARTIFACT_NAME.GRAMMAR_TRANSITIONS} is missing its \`transitions\` wrapper`);
+      }
+      setGrammarData({
+        posTags: posTagsData !== null && posTagsData !== void 0 ? posTagsData : {},
+        ghostPosTags: ghostPosTagsData !== null && ghostPosTagsData !== void 0 ? ghostPosTagsData : {},
+        grammarTransitions: grammarTransitionsData
+      });
+      succeedExp(EXPERIENCE_NAME.LOAD_GRAMMAR, 'singleton', {
+        isLocalLLM,
+        posTagCount: posTags.size,
+        transitionCount: precomputedAllowedByPos.size,
+        ...(surface ? {
+          surface
+        } : {})
+      });
+      if (isAutocompleteDebugEnabled()) {
+        // eslint-disable-next-line no-console
+        console.log('[scoring-pipeline] Grammar data loaded:', {
+          posTagCount: posTags.size,
+          ghostPosTagCount: Object.keys(ghostPosTags).length,
+          transitionCount: precomputedAllowedByPos.size
+        });
+      }
+    } catch (e) {
+      failExp(EXPERIENCE_NAME.LOAD_GRAMMAR, 'singleton', {
+        isLocalLLM,
+        errorType: 'network',
+        ...(surface ? {
+          surface
+        } : {})
+      });
+      // Allow a later call to retry the load rather than caching the failure.
+      grammarDataPromise = undefined;
+      throw e;
+    }
+  })();
+  return grammarDataPromise;
+};
 
 // ─── Math ───────────────────────────────────────────────────
 
@@ -87,18 +166,15 @@ function scoreStage1(candidate, contextVector, getWordVector, maxTenantFreq) {
 
 // ─── Grammar Filter ─────────────────────────────────────────
 
-/**
- * GHOST POS DICTIONARY
- * A hardcoded mapping of common structural English words that were stripped
- * from the main domain vocabulary. This allows the grammar filter to understand
- * context without suggesting these words to the user.
- */
-const ghostPosTags = ghostPosTagsData;
 function applyGrammarFilter(candidates, previousWord) {
-  if (!previousWord) return {
-    filtered: candidates,
-    grammarMeta: null
-  };
+  // Pass everything through until loadGrammarDataAsync resolves — filtering on a
+  // partially loaded ruleset would drop valid candidates.
+  if (!previousWord || !isGrammarDataLoaded()) {
+    return {
+      filtered: candidates,
+      grammarMeta: null
+    };
+  }
   const lowerPrev = previousWord.toLowerCase();
   const prevTags = ghostPosTags[lowerPrev] || posTags.get(lowerPrev);
   if (!prevTags || prevTags.length === 0) {

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

@@ -18,9 +18,10 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
 import { EXPERIENCE_NAME, failExp, startExp, succeedExp } from '../analytics/ufo';
 
-// The vocabulary, L3 and word-index JSON payloads are dynamically imported in
-// loadDefaultVocabulary / loadVectorsAsync so their (large) contents stay out of
-// the editor's main chunk and only load when autocomplete is initialised.
+// The vocabulary, L3 and word-index payloads are fetched from the CDN in
+// loadDefaultVocabulary / loadVectorsAsync so their (large) contents never enter
+// the editor's bundle and only load when autocomplete is initialised.
+import { ARTIFACT_NAME, fetchArtifactJson, getArtifactUrl } from './artifacts-manifest';
 import { isAutocompleteDebugEnabled } from './debug-mode';
 import { rankCandidates, STAGE1_WEIGHT, STAGE2_WEIGHT, MIN_STAGE1_SCORE } from './scoring-pipeline';
 import { getStoredContextVector, getStoredLmLogits } from './slow-lane-client';
@@ -553,51 +554,11 @@ export const predict = textBefore => {
 
 // ─── Data Loading ────────────────────────────────────────────────────────────
 
-/**
- * Unwrap a dynamically imported JSON module to its parsed value, handling both
- * interop modes AFM's bundler chain emits: a `.default`-wrapped namespace
- * (classic webpack) and a named-exports namespace (webpack 5 / atlaspack JSON
- * modules, where `default` can be a misleading scalar). Named exports are
- * preferred when present. The caller declares the JSON `shape` because a dense
- * array and a sparse numeric-keyed object are emitted identically as named
- * exports. Kept in lock-step with the matching helper in local-slow-lane-client.ts.
- */
-function unwrapJsonModule(mod, shape) {
-  if (mod == null || typeof mod !== 'object') {
-    return null;
-  }
-  const namespace = mod;
-  const ownKeys = Object.keys(namespace).filter(k => k !== 'default' && k !== '__esModule');
-  if (ownKeys.length > 0) {
-    if (shape === 'array') {
-      const len = ownKeys.length;
-      const arr = new Array(len);
-      for (let i = 0; i < len; i++) {
-        arr[i] = namespace[String(i)];
-      }
-      return arr;
-    }
-    const obj = {};
-    for (const k of ownKeys) {
-      obj[k] = namespace[k];
-    }
-    return obj;
-  }
-  if ('default' in namespace && namespace.default != null) {
-    return namespace.default;
-  }
-  return null;
-}
 export const loadVectorsAsync = async options => {
   var _options$isLocalLLM;
   if (vectorStore || vectorsLoadStarted) {
     return;
   }
-  if (!(options !== null && options !== void 0 && options.getBinaryUrl)) {
-    // eslint-disable-next-line no-console
-    console.warn('[text-predictor] loadVectorsAsync called without a getBinaryUrl — vectors will not load. Pass getVectorsBinaryUrl via plugin options.');
-    return;
-  }
   const isLocalLLM = (_options$isLocalLLM = options === null || options === void 0 ? void 0 : options.isLocalLLM) !== null && _options$isLocalLLM !== void 0 ? _options$isLocalLLM : false;
   const surface = options === null || options === void 0 ? void 0 : options.surface;
   vectorsLoadStarted = true;
@@ -609,7 +570,7 @@ export const loadVectorsAsync = async options => {
   });
   let url;
   try {
-    url = await options.getBinaryUrl();
+    url = await getArtifactUrl(ARTIFACT_NAME.WORD_VECTORS);
   } catch (e) {
     vectorsLoadStarted = false;
     failExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', {
@@ -624,7 +585,6 @@ export const loadVectorsAsync = async options => {
     return;
   }
   try {
-    var _wordIndexOuter$index;
     const res = await fetch(url);
     if (!res.ok) {
       vectorsLoadStarted = false;
@@ -643,16 +603,18 @@ export const loadVectorsAsync = async options => {
     const buffer = await res.arrayBuffer();
     const float32 = new Float32Array(buffer);
 
-    // word_index_10k.json is wrapped as `{ "index": {…} }` so no real entry
-    // (e.g. the word "default") can shadow the synthetic ESM `default` export
-    // the bundler creates for dynamically-imported JSON.
-    const wordIndexModule = await import( /* webpackChunkName: "@atlaskit-internal_editor-plugin-autocomplete-word-index-10k" */'./data/word_index_10k.json');
-    const wordIndexOuter = unwrapJsonModule(wordIndexModule, 'object');
-    const wordIndex = (_wordIndexOuter$index = wordIndexOuter === null || wordIndexOuter === void 0 ? void 0 : wordIndexOuter.index) !== null && _wordIndexOuter$index !== void 0 ? _wordIndexOuter$index : {};
+    // The word index is published either bare or wrapped as `{ "index": {…} }`
+    // (the wrapper exists so no real entry, e.g. the word "default", can shadow
+    // a bundler-synthesised ESM export). Detect the wrapper by value type, not
+    // by key presence — "index" is itself a plausible vocabulary word, and in a
+    // bare index every value is a number.
+    const wordIndexPayload = await fetchArtifactJson(ARTIFACT_NAME.WORD_INDEX);
+    const wrappedIndex = wordIndexPayload === null || wordIndexPayload === void 0 ? void 0 : wordIndexPayload.index;
+    const wordIndex = typeof wrappedIndex === 'object' && wrappedIndex !== null ? wrappedIndex : wordIndexPayload !== null && wordIndexPayload !== void 0 ? wordIndexPayload : {};
     const nWords = Object.keys(wordIndex).length;
     if (nWords === 0) {
       // eslint-disable-next-line no-console
-      console.warn('[text-predictor] word_index_10k.json missing its `index` wrapper — wordIndex is empty, semantic scoring will be a no-op.');
+      console.warn(`[text-predictor] ${ARTIFACT_NAME.WORD_INDEX} was empty — semantic scoring will be a no-op.`);
     }
     const dim = float32.length / nWords;
     vectorStore = {
@@ -712,13 +674,9 @@ export const loadDefaultVocabulary = options => {
       } : {})
     });
     try {
-      // The L2 vocabulary and L3 word list are code-split into their own async
-      // chunks so they stay out of the editor's main bundle.
-      const [vocabularyModule, l3VocabularyModule] = await Promise.all([import( /* webpackChunkName: "@atlaskit-internal_editor-plugin-autocomplete-vocabulary-10k" */'./data/vocabulary_10k.json'), import( /* webpackChunkName: "@atlaskit-internal_editor-plugin-autocomplete-l3-vocabulary" */'./data/l3_vocabulary.json')]);
-      const vocabularyData = unwrapJsonModule(vocabularyModule, 'object');
-      const l3VocabularyData = unwrapJsonModule(l3VocabularyModule, 'array');
+      const [vocabularyData, l3VocabularyData] = await Promise.all([fetchArtifactJson(ARTIFACT_NAME.VOCABULARY), fetchArtifactJson(ARTIFACT_NAME.L3_VOCABULARY)]);
       if ((vocabularyData === null || vocabularyData === void 0 ? void 0 : vocabularyData.words) == null || !Array.isArray(l3VocabularyData)) {
-        throw new Error('[text-predictor] vocabulary JSON modules could not be unwrapped');
+        throw new Error(`[text-predictor] unexpected vocabulary payload — ` + `${ARTIFACT_NAME.VOCABULARY} ${(vocabularyData === null || vocabularyData === void 0 ? void 0 : vocabularyData.words) == null ? 'is missing its `words` wrapper' : 'is valid'}, ` + `${ARTIFACT_NAME.L3_VOCABULARY} ${Array.isArray(l3VocabularyData) ? 'is valid' : 'is not an array'}`);
       }
       const terms = Object.entries(vocabularyData.words).map(([word, stats]) => ({
         word,
@@ -745,7 +703,7 @@ export const loadDefaultVocabulary = options => {
     } catch (e) {
       failExp(EXPERIENCE_NAME.LOAD_VOCABULARY, 'singleton', {
         isLocalLLM,
-        errorType: 'parse_error',
+        errorType: 'load_error',
         ...(surface ? {
           surface
         } : {})

package/dist/esm/analytics/ufo.js

@@ -34,7 +34,8 @@ import { ConcurrentExperience, ExperiencePerformanceTypes, ExperienceTypes } fro
 export var EXPERIENCE_NAME = {
   SLOW_LANE_FETCH: 'slow-lane-fetch',
   LOAD_VOCABULARY: 'load-vocabulary',
-  LOAD_VECTORS: 'load-vectors'
+  LOAD_VECTORS: 'load-vectors',
+  LOAD_GRAMMAR: 'load-grammar'
 };
 var isUfoEnabled = function isUfoEnabled() {
   var _process;
@@ -52,7 +53,7 @@ var operationConfig = {
     })
   }
 };
-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));
+var experiences = _defineProperty(_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)), EXPERIENCE_NAME.LOAD_GRAMMAR, new ConcurrentExperience(EXPERIENCE_NAME.LOAD_GRAMMAR, operationConfig));
 export var startExp = function startExp(name, id, metadata) {
   if (!isUfoEnabled()) {
     return;

package/dist/esm/pm-plugins/artifacts-manifest.js

@@ -0,0 +1,204 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+/**
+ * Artifacts Manifest Client: resolves the autocomplete model artifacts hosted on
+ * the CDN.
+ *
+ * `GET /gateway/api/v1/autocomplete/artifacts` returns one presigned CDN URL per
+ * artifact for the tenant's active model version:
+ *
+ *   { activeVersion, artifacts: [{ name, url, contentType, sizeBytes, checksum }] }
+ *
+ * Every loader in the plugin resolves its payload through here, so no model data
+ * is bundled with the package.
+ */
+
+import { isAutocompleteDebugEnabled } from './debug-mode';
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+/**
+ * Manifest artifact names. These are the manifest's lookup keys and are
+ * hyphenated, unlike the underscored filenames the artifacts are generated from.
+ */
+export var ARTIFACT_NAME = {
+  FIRST_TOKEN_TO_WORDS: 'first-token-to-words.json',
+  GHOST_POS_TAGS: 'ghost-pos-tags.json',
+  GRAMMAR_TRANSITIONS: 'grammar-transitions-10k.json',
+  L3_VOCABULARY: 'l3-vocabulary.json',
+  POS_TAGS: 'combined-l2-l3-pos-tags.json',
+  VOCABULARY: 'vocabulary-10k.json',
+  WORD_INDEX: 'word-index-10k.json',
+  WORD_VECTORS: 'word-vectors-10k.bin'
+};
+
+/** A single entry in the artifacts manifest. */
+
+/** Response body of the artifacts endpoint. */
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+var MANIFEST_ENDPOINT = '/gateway/api/v1/autocomplete/artifacts';
+
+/**
+ * Presigned artifact URLs expire ~10 minutes after the manifest is issued, so
+ * the manifest is re-requested well inside that window instead of being cached
+ * for the session and handing out dead URLs to a late loader.
+ */
+var MANIFEST_TTL_MS = 5 * 60 * 1000;
+
+// ─── Manifest ────────────────────────────────────────────────────────────────
+
+var manifestPromise;
+var manifestRequestedAt = 0;
+
+/** Test-only: drops the memoised manifest so the next lookup re-requests it. */
+export var resetArtifactsManifestCache = function resetArtifactsManifestCache() {
+  manifestPromise = undefined;
+  manifestRequestedAt = 0;
+};
+var requestManifest = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var res, body;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 1;
+          return fetch(MANIFEST_ENDPOINT, {
+            method: 'GET',
+            headers: {
+              'x-experience-id': 'confluence-smart-typeahead-artifacts',
+              'x-product': 'confluence'
+            }
+          });
+        case 1:
+          res = _context.sent;
+          if (res.ok) {
+            _context.next = 2;
+            break;
+          }
+          throw new Error("[autocomplete-artifacts] Manifest request failed: ".concat(res.status));
+        case 2:
+          _context.next = 3;
+          return res.json();
+        case 3:
+          body = _context.sent;
+          if (!(!Array.isArray(body === null || body === void 0 ? void 0 : body.artifacts) || body.artifacts.length === 0)) {
+            _context.next = 4;
+            break;
+          }
+          throw new Error('[autocomplete-artifacts] Manifest response contained no artifacts');
+        case 4:
+          if (isAutocompleteDebugEnabled()) {
+            // eslint-disable-next-line no-console
+            console.log('[autocomplete-artifacts] Manifest loaded:', {
+              activeVersion: body.activeVersion,
+              names: body.artifacts.map(function (artifact) {
+                return artifact.name;
+              })
+            });
+          }
+          return _context.abrupt("return", new Map(body.artifacts.map(function (artifact) {
+            return [artifact.name, artifact];
+          })));
+        case 5:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function requestManifest() {
+    return _ref.apply(this, arguments);
+  };
+}();
+var getManifest = function getManifest() {
+  if (manifestPromise && Date.now() - manifestRequestedAt < MANIFEST_TTL_MS) {
+    return manifestPromise;
+  }
+  manifestRequestedAt = Date.now();
+  manifestPromise = requestManifest().catch(function (e) {
+    // Never cache a rejection — a transient failure would otherwise stop every
+    // later loader in the session from retrying.
+    resetArtifactsManifestCache();
+    throw e;
+  });
+  return manifestPromise;
+};
+
+// ─── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Resolve the CDN URL for an artifact.
+ *
+ * :raises Error: when the manifest cannot be fetched or omits the artifact.
+ */
+export var getArtifactUrl = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(name) {
+    var _manifest$get;
+    var manifest, url;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.next = 1;
+          return getManifest();
+        case 1:
+          manifest = _context2.sent;
+          url = (_manifest$get = manifest.get(name)) === null || _manifest$get === void 0 ? void 0 : _manifest$get.url;
+          if (url) {
+            _context2.next = 2;
+            break;
+          }
+          throw new Error("[autocomplete-artifacts] Manifest has no URL for \"".concat(name, "\""));
+        case 2:
+          return _context2.abrupt("return", url);
+        case 3:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function getArtifactUrl(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+/**
+ * Download and parse a JSON artifact. The presigned URL carries its own auth
+ * token, so the request is sent without Atlassian headers or credentials.
+ *
+ * :raises Error: when the manifest lookup or the download fails.
+ */
+export var fetchArtifactJson = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(name) {
+    var url, res;
+    return _regeneratorRuntime.wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.next = 1;
+          return getArtifactUrl(name);
+        case 1:
+          url = _context3.sent;
+          _context3.next = 2;
+          return fetch(url);
+        case 2:
+          res = _context3.sent;
+          if (res.ok) {
+            _context3.next = 3;
+            break;
+          }
+          throw new Error("[autocomplete-artifacts] Failed to download \"".concat(name, "\": ").concat(res.status));
+        case 3:
+          _context3.next = 4;
+          return res.json();
+        case 4:
+          return _context3.abrupt("return", _context3.sent);
+        case 5:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return function fetchArtifactJson(_x2) {
+    return _ref3.apply(this, arguments);
+  };
+}();

package/dist/esm/pm-plugins/autocomplete-plugin.js

@@ -14,6 +14,7 @@ import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
 import { isAutocompleteDebugEnabled } from './debug-mode';
 import { createGhostTextDecorationSet } from './ghost-text-decoration';
 import { createLocalSlowLaneClient } from './local-slow-lane-client';
+import { loadGrammarDataAsync } from './scoring-pipeline';
 import { createSlowLaneClient, setDefaultSlowLaneClient, isWordBoundary } from './slow-lane-client';
 import { predict, loadDefaultVocabulary, loadVectorsAsync, incrementSessionFreq, ingestDocumentPage } from './text-predictor';
 export var autocompletePluginKey = new PluginKey('autocomplete');
@@ -671,7 +672,7 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
           return accepted;
         },
         focus: function focus() {
-          var _options$useLocalMode, _options$useLocalMode2;
+          var _options$useLocalMode, _options$useLocalMode2, _options$useLocalMode3;
           if (!isAutocompleteEnabled) {
             return false;
           }
@@ -684,7 +685,6 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
             });
           });
           loadVectorsAsync({
-            getBinaryUrl: options === null || options === void 0 ? void 0 : options.getVectorsBinaryUrl,
             isLocalLLM: (_options$useLocalMode2 = options === null || options === void 0 ? void 0 : options.useLocalModel) !== null && _options$useLocalMode2 !== void 0 ? _options$useLocalMode2 : false,
             surface: surface
           }).catch(function (error) {
@@ -692,6 +692,14 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
               location: 'editor-plugin-autocomplete/loadVectorsAsync'
             });
           });
+          loadGrammarDataAsync({
+            isLocalLLM: (_options$useLocalMode3 = options === null || options === void 0 ? void 0 : options.useLocalModel) !== null && _options$useLocalMode3 !== void 0 ? _options$useLocalMode3 : false,
+            surface: surface
+          }).catch(function (error) {
+            logException(error, {
+              location: 'editor-plugin-autocomplete/loadGrammarDataAsync'
+            });
+          });
           if (!hasIngestedPage) {
             hasIngestedPage = true;
             refreshContext({