@atlaskit/editor-plugin-autocomplete 6.0.0 → 8.0.0

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

@@ -1,16 +1,15 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import _typeof from "@babel/runtime/helpers/typeof";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 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 _regeneratorRuntime from "@babel/runtime/regenerator";
 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 _regeneratorRuntime from "@babel/runtime/regenerator";
 /**
  * Local Slow Lane Client: On-device inference via @mlc-ai/web-llm.
  *
@@ -49,6 +48,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  */
 
 import { abortExp, EXPERIENCE_NAME, failExp, startExp, succeedExp } from '../analytics/ufo';
+import { ARTIFACT_NAME, fetchArtifactJson } from './artifacts-manifest';
 import { isAutocompleteDebugEnabled } from './debug-mode';
 import { isWordBoundary } from './slow-lane-client';
 
@@ -236,88 +236,9 @@ var prefixMapTokenIds = [];
 var bePayloadDataPromise;
 
 /**
- * Unwrap a dynamically imported JSON module to the parsed JSON value, working
- * across the two interop modes AFM's bundler chain emits:
- *
- *   1. **`.default`-wrapped namespace** — classic webpack (and Jest) hang the
- *      JSON value under the `default` export.
- *   2. **Named-exports namespace** — webpack 5 / atlaspack with JSON
- *      named-exports (or native ESM JSON modules) expose each top-level key as
- *      a named export and shadow `default`, so `mod.default` can be `undefined`
- *      (or some unrelated value) even though `mod` itself holds the data.
- *
- * The caller MUST declare the underlying JSON shape via `shape` because, in
- * named-exports mode, a dense array `["a","b"]` and a sparse numeric-keyed
- * object `{"5":"a","12":"b"}` are emitted identically (`{"0":..}` / `{"5":..}`);
- * no runtime heuristic can tell them apart, so only the caller knows which:
- *
- *   - `'object'` — the JSON is a `{...}` (including sparse maps keyed by integer
- *     IDs). The named exports are rebuilt into a plain object so `Object.entries`
- *     yields the real keys, not synthetic array indices.
- *   - `'array'` — the JSON is a `[...]`, reconstructed from the `0..n-1` indices.
- *
- * :param mod: The raw module object returned by `await import('./*.json')`.
- * :param shape: `'object'` if the source JSON is `{...}`, `'array'` if `[...]`.
- * :returns: The parsed JSON value, or `null` if neither interop mode applies.
- */
-function unwrapJsonModule(mod, shape) {
-  if (mod == null || _typeof(mod) !== 'object') {
-    return null;
-  }
-  var namespace = mod;
-
-  // Compute the named-export own-keys (strip synthetic markers).
-  var ownKeys = Object.keys(namespace).filter(function (k) {
-    return k !== 'default' && k !== '__esModule';
-  });
-
-  // PREFER named exports when present — they always reflect the JSON's real
-  // top-level keys / indices, regardless of what `default` happens to be.
-  // Under JSON named-exports mode `default` is not necessarily the parsed
-  // value (e.g. for `{"service": 0, ...}` it can be the number `0`, with the
-  // real data in the named exports), so taking `default` first would corrupt it.
-  if (ownKeys.length > 0) {
-    if (shape === 'array') {
-      // JSON arrays are dense; reconstruct from `0..length-1` indices.
-      var len = ownKeys.length;
-      var arr = new Array(len);
-      for (var i = 0; i < len; i++) {
-        arr[i] = namespace[String(i)];
-      }
-      return arr;
-    }
-    // shape === 'object'. Rebuild a plain object from the (stripped) own
-    // keys so callers can `Object.entries()` it without iterating over
-    // `default` / `__esModule`, and to detach from the module-namespace
-    // object (which is sealed/non-extensible on some bundler outputs).
-    var obj = {};
-    var _iterator = _createForOfIteratorHelper(ownKeys),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var k = _step.value;
-        obj[k] = namespace[k];
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
-    }
-    return obj;
-  }
-
-  // Fallback: no named exports — classic webpack JSON-module interop where
-  // the whole parsed JSON value is hung under `default`. Trust it.
-  if ('default' in namespace && namespace.default != null) {
-    return namespace.default;
-  }
-  return null;
-}
-
-/**
- * Lazily load and build the BE-parity lookup tables from their JSON payloads.
- * The dynamic imports are split into their own async chunks so neither file is
- * bundled into the editor's main chunk unless local inference is initialised.
+ * Lazily load and build the BE-parity lookup tables from their CDN payloads.
+ * Both artifacts are fetched on demand so neither is downloaded unless local
+ * inference is initialised.
  *
  * :returns:
  *   A promise that resolves once `firstTokenToWords`, `l2Words` and
@@ -326,24 +247,22 @@ function unwrapJsonModule(mod, shape) {
 var loadBePayloadData = function loadBePayloadData() {
   if (!bePayloadDataPromise) {
     bePayloadDataPromise = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-      var _yield$Promise$all, _yield$Promise$all2, firstTokenToWordsModule, vocabularyModule, firstTokenToWordsData, vocabularyData;
+      var _yield$Promise$all, _yield$Promise$all2, firstTokenToWordsData, vocabularyData;
       return _regeneratorRuntime.wrap(function (_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
             _context.next = 1;
-            return Promise.all([import( /* webpackChunkName: "@atlaskit-internal_editor-plugin-autocomplete-first-token-to-words" */'./data/first_token_to_words.json'), import( /* webpackChunkName: "@atlaskit-internal_editor-plugin-autocomplete-vocabulary-10k" */'./data/vocabulary_10k.json')]);
+            return Promise.all([fetchArtifactJson(ARTIFACT_NAME.FIRST_TOKEN_TO_WORDS), fetchArtifactJson(ARTIFACT_NAME.VOCABULARY)]);
           case 1:
             _yield$Promise$all = _context.sent;
             _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
-            firstTokenToWordsModule = _yield$Promise$all2[0];
-            vocabularyModule = _yield$Promise$all2[1];
-            firstTokenToWordsData = unwrapJsonModule(firstTokenToWordsModule, 'object');
-            vocabularyData = unwrapJsonModule(vocabularyModule, 'object');
+            firstTokenToWordsData = _yield$Promise$all2[0];
+            vocabularyData = _yield$Promise$all2[1];
             if (!(firstTokenToWordsData == null || (vocabularyData === null || vocabularyData === void 0 ? void 0 : vocabularyData.words) == null)) {
               _context.next = 2;
               break;
             }
-            throw new Error("[LocalSlowLane] JSON module could not be unwrapped \u2014 " + "firstTokenToWordsData=".concat(firstTokenToWordsData == null ? 'null/undefined' : 'defined', ", ") + "vocabularyData=".concat(vocabularyData == null ? 'null/undefined' : vocabularyData.words == null ? 'defined but missing .words' : 'defined'));
+            throw new Error("[LocalSlowLane] unexpected artifact payload \u2014 " + "firstTokenToWordsData=".concat(firstTokenToWordsData == null ? 'null/undefined' : 'defined', ", ") + "vocabularyData=".concat(vocabularyData == null ? 'null/undefined' : vocabularyData.words == null ? 'defined but missing .words' : 'defined'));
           case 2:
             firstTokenToWords = new Map(Object.entries(firstTokenToWordsData).map(function (_ref2) {
               var _ref3 = _slicedToArray(_ref2, 2),
@@ -400,28 +319,28 @@ export var computeBePayload = function computeBePayload(rawLogits, prefixMap, do
   var validTokenIds = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : prefixMapTokenIds;
   // 1. Numerically-stable masked softmax over validTokenIds only.
   var maxLogit = -Infinity;
-  var _iterator2 = _createForOfIteratorHelper(validTokenIds),
-    _step2;
+  var _iterator = _createForOfIteratorHelper(validTokenIds),
+    _step;
   try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var id = _step2.value;
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var id = _step.value;
       var v = rawLogits[id];
       if (v > maxLogit) {
         maxLogit = v;
       }
     }
   } catch (err) {
-    _iterator2.e(err);
+    _iterator.e(err);
   } finally {
-    _iterator2.f();
+    _iterator.f();
   }
   var sumExp = 0;
   var expByToken = new Map();
-  var _iterator3 = _createForOfIteratorHelper(validTokenIds),
-    _step3;
+  var _iterator2 = _createForOfIteratorHelper(validTokenIds),
+    _step2;
   try {
-    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-      var _id = _step3.value;
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _id = _step2.value;
       var e = Math.exp(rawLogits[_id] - maxLogit);
       expByToken.set(_id, e);
       sumExp += e;
@@ -430,53 +349,53 @@ export var computeBePayload = function computeBePayload(rawLogits, prefixMap, do
     // 2. Prefix expansion with max aggregation (probabilities sum to 1 over the
     //    masked subset, so divide each token's exp by sumExp on the fly).
   } catch (err) {
-    _iterator3.e(err);
+    _iterator2.e(err);
   } finally {
-    _iterator3.f();
+    _iterator2.f();
   }
   var wordProbs = new Map();
-  var _iterator4 = _createForOfIteratorHelper(prefixMap),
-    _step4;
+  var _iterator3 = _createForOfIteratorHelper(prefixMap),
+    _step3;
   try {
-    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
       var _expByToken$get;
-      var _step4$value = _slicedToArray(_step4.value, 2),
-        _id2 = _step4$value[0],
-        words = _step4$value[1];
+      var _step3$value = _slicedToArray(_step3.value, 2),
+        _id2 = _step3$value[0],
+        words = _step3$value[1];
       var _p = sumExp > 0 ? ((_expByToken$get = expByToken.get(_id2)) !== null && _expByToken$get !== void 0 ? _expByToken$get : 0) / sumExp : 0;
-      var _iterator9 = _createForOfIteratorHelper(words),
-        _step9;
+      var _iterator8 = _createForOfIteratorHelper(words),
+        _step8;
       try {
-        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
           var _wordProbs$get2;
-          var _w = _step9.value;
+          var _w = _step8.value;
           var prev = (_wordProbs$get2 = wordProbs.get(_w)) !== null && _wordProbs$get2 !== void 0 ? _wordProbs$get2 : 0;
           if (_p > prev) {
             wordProbs.set(_w, _p);
           }
         }
       } catch (err) {
-        _iterator9.e(err);
+        _iterator8.e(err);
       } finally {
-        _iterator9.f();
+        _iterator8.f();
       }
     }
 
     // 3. Split into L2 / L3 and reserve the top L2 slots unconditionally.
   } catch (err) {
-    _iterator4.e(err);
+    _iterator3.e(err);
   } finally {
-    _iterator4.f();
+    _iterator3.f();
   }
   var l2Matches = [];
   var l3Matches = [];
-  var _iterator5 = _createForOfIteratorHelper(wordProbs),
-    _step5;
+  var _iterator4 = _createForOfIteratorHelper(wordProbs),
+    _step4;
   try {
-    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-      var _step5$value = _slicedToArray(_step5.value, 2),
-        _w2 = _step5$value[0],
-        _p2 = _step5$value[1];
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var _step4$value = _slicedToArray(_step4.value, 2),
+        _w2 = _step4$value[0],
+        _p2 = _step4$value[1];
       if (domainWords.has(_w2)) {
         l2Matches.push([_w2, _p2]);
       } else {
@@ -484,9 +403,9 @@ export var computeBePayload = function computeBePayload(rawLogits, prefixMap, do
       }
     }
   } catch (err) {
-    _iterator5.e(err);
+    _iterator4.e(err);
   } finally {
-    _iterator5.f();
+    _iterator4.f();
   }
   l2Matches.sort(function (a, b) {
     return b[1] - a[1];
@@ -499,19 +418,19 @@ export var computeBePayload = function computeBePayload(rawLogits, prefixMap, do
   // it directly rather than allocating a Set and scanning every entry on this
   // hot path (runs ~every word boundary while typing).
   var pool = [];
-  var _iterator6 = _createForOfIteratorHelper(l2Matches.slice(BE_PARITY.RESERVED_L2_SLOTS)),
-    _step6;
+  var _iterator5 = _createForOfIteratorHelper(l2Matches.slice(BE_PARITY.RESERVED_L2_SLOTS)),
+    _step5;
   try {
-    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-      var _step6$value = _slicedToArray(_step6.value, 2),
-        _w3 = _step6$value[0],
-        _p3 = _step6$value[1];
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var _step5$value = _slicedToArray(_step5.value, 2),
+        _w3 = _step5$value[0],
+        _p3 = _step5$value[1];
       pool.push([_w3, Math.log(Math.max(_p3, 1e-10)) + BE_PARITY.L2_BIAS]);
     }
   } catch (err) {
-    _iterator6.e(err);
+    _iterator5.e(err);
   } finally {
-    _iterator6.f();
+    _iterator5.f();
   }
   for (var _i = 0, _l3Matches = l3Matches; _i < _l3Matches.length; _i++) {
     var _l3Matches$_i = _slicedToArray(_l3Matches[_i], 2),
@@ -544,33 +463,33 @@ export var computeBePayload = function computeBePayload(rawLogits, prefixMap, do
     }
     result[key] = prob;
   };
-  var _iterator7 = _createForOfIteratorHelper(reserved),
-    _step7;
+  var _iterator6 = _createForOfIteratorHelper(reserved),
+    _step6;
   try {
-    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
-      var _step7$value = _slicedToArray(_step7.value, 2),
-        _w4 = _step7$value[0],
-        _p4 = _step7$value[1];
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var _step6$value = _slicedToArray(_step6.value, 2),
+        _w4 = _step6$value[0],
+        _p4 = _step6$value[1];
       addEntry(_w4, _p4, true);
     }
   } catch (err) {
-    _iterator7.e(err);
+    _iterator6.e(err);
   } finally {
-    _iterator7.f();
+    _iterator6.f();
   }
-  var _iterator8 = _createForOfIteratorHelper(poolWinners),
-    _step8;
+  var _iterator7 = _createForOfIteratorHelper(poolWinners),
+    _step7;
   try {
-    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
       var _wordProbs$get3;
-      var _step8$value = _slicedToArray(_step8.value, 1),
-        _w5 = _step8$value[0];
+      var _step7$value = _slicedToArray(_step7.value, 1),
+        _w5 = _step7$value[0];
       addEntry(_w5, (_wordProbs$get3 = wordProbs.get(_w5)) !== null && _wordProbs$get3 !== void 0 ? _wordProbs$get3 : 0, false);
     }
   } catch (err) {
-    _iterator8.e(err);
+    _iterator7.e(err);
   } finally {
-    _iterator8.f();
+    _iterator7.f();
   }
   if (isAutocompleteDebugEnabled()) {
     var topReserved = reserved.slice(0, 5).map(function (_ref4) {

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

@@ -1,17 +1,25 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 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 _regeneratorRuntime from "@babel/runtime/regenerator";
+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; }
 /**
  * Scoring Pipeline: Stage 1 (Semantic + Frequency), Grammar Filter, Stage 2 (LM Re-ranking).
  *
  * 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 ──────────────────────────────────────────────────
 
@@ -32,22 +40,119 @@ var L1_SESSION_CAP = 1.2;
 // at 0.00024) from triggering re-ranking.
 var LM_GATE_THRESHOLD = 0.0005;
 
-// ─── Grammar Data (loaded once on import) ───────────────────
+// ─── Grammar Data (fetched once from the CDN) ────────────────
+
+var posTags = new Map();
+
+/**
+ * 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.
+ */
+var ghostPosTags = {};
 
-var posTags = new Map(Object.entries(posTagsData));
-var grammarTransitions = grammarTransitionsData;
+/**
+ * Precomputed map from each POS tag to the set of allowed next POS tags, so
+ * applyGrammarFilter never re-iterates the transition rules per call.
+ */
+var precomputedAllowedByPos = new Map();
+var grammarDataPromise;
+var setGrammarData = function 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(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      pos = _ref2[0],
+      rule = _ref2[1];
+    return [pos, new Set(rule.allowed)];
+  }));
+};
+export var isGrammarDataLoaded = function isGrammarDataLoaded() {
+  return precomputedAllowedByPos.size > 0;
+};
 
 /**
- * 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.
+ * 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.
  */
-var precomputedAllowedByPos = new Map(Object.entries(grammarTransitions.transitions).map(function (_ref) {
-  var _ref2 = _slicedToArray(_ref, 2),
-    pos = _ref2[0],
-    rule = _ref2[1];
-  return [pos, new Set(rule.allowed)];
-}));
+export var loadGrammarDataAsync = function loadGrammarDataAsync(options) {
+  var _options$isLocalLLM;
+  if (grammarDataPromise) {
+    return grammarDataPromise;
+  }
+  var isLocalLLM = (_options$isLocalLLM = options === null || options === void 0 ? void 0 : options.isLocalLLM) !== null && _options$isLocalLLM !== void 0 ? _options$isLocalLLM : false;
+  var surface = options === null || options === void 0 ? void 0 : options.surface;
+  grammarDataPromise = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var _yield$Promise$all, _yield$Promise$all2, posTagsData, ghostPosTagsData, grammarTransitionsData, _t;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          startExp(EXPERIENCE_NAME.LOAD_GRAMMAR, 'singleton', _objectSpread({
+            isLocalLLM: isLocalLLM
+          }, surface ? {
+            surface: surface
+          } : {}));
+          _context.prev = 1;
+          _context.next = 2;
+          return Promise.all([fetchArtifactJson(ARTIFACT_NAME.POS_TAGS), fetchArtifactJson(ARTIFACT_NAME.GHOST_POS_TAGS), fetchArtifactJson(ARTIFACT_NAME.GRAMMAR_TRANSITIONS)]);
+        case 2:
+          _yield$Promise$all = _context.sent;
+          _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 3);
+          posTagsData = _yield$Promise$all2[0];
+          ghostPosTagsData = _yield$Promise$all2[1];
+          grammarTransitionsData = _yield$Promise$all2[2];
+          if (!((grammarTransitionsData === null || grammarTransitionsData === void 0 ? void 0 : grammarTransitionsData.transitions) == null)) {
+            _context.next = 3;
+            break;
+          }
+          throw new Error("[scoring-pipeline] ".concat(ARTIFACT_NAME.GRAMMAR_TRANSITIONS, " is missing its `transitions` wrapper"));
+        case 3:
+          setGrammarData({
+            posTags: posTagsData !== null && posTagsData !== void 0 ? posTagsData : {},
+            ghostPosTags: ghostPosTagsData !== null && ghostPosTagsData !== void 0 ? ghostPosTagsData : {},
+            grammarTransitions: grammarTransitionsData
+          });
+          succeedExp(EXPERIENCE_NAME.LOAD_GRAMMAR, 'singleton', _objectSpread({
+            isLocalLLM: isLocalLLM,
+            posTagCount: posTags.size,
+            transitionCount: precomputedAllowedByPos.size
+          }, surface ? {
+            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
+            });
+          }
+          _context.next = 5;
+          break;
+        case 4:
+          _context.prev = 4;
+          _t = _context["catch"](1);
+          failExp(EXPERIENCE_NAME.LOAD_GRAMMAR, 'singleton', _objectSpread({
+            isLocalLLM: isLocalLLM,
+            errorType: 'network'
+          }, surface ? {
+            surface: surface
+          } : {}));
+          // Allow a later call to retry the load rather than caching the failure.
+          grammarDataPromise = undefined;
+          throw _t;
+        case 5:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[1, 4]]);
+  }))();
+  return grammarDataPromise;
+};
 
 // ─── Math ───────────────────────────────────────────────────
 
@@ -96,18 +201,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.
- */
-var 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
+    };
+  }
   var lowerPrev = previousWord.toLowerCase();
   var prevTags = ghostPosTags[lowerPrev] || posTags.get(lowerPrev);
   if (!prevTags || prevTags.length === 0) {