@atlaskit/editor-plugin-autocomplete 9.0.0 → 9.2.0

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

@@ -25,14 +25,17 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * Falls back to cold mode (freq-only) when vectors not yet loaded.
  *
  * Session personalization (L1): words the user types are incrementally boosted
- * via incrementSessionFreq(), called on word boundaries from the plugin.
+ * via incrementSessionFreq(), called on word boundaries from the plugin, and
+ * words in ingested context text via ingestDocumentPage(). What the session has
+ * boosted is visible at any time from the console: `__atlCtcDebug__.session()`,
+ * or `__atlCtcDebug__.session('poll')` for one family — see inspectSessionBoosts.
  */
 
 import { EXPERIENCE_NAME, failExp, startExp, succeedExp } from '../analytics/ufo';
 import { fetchAutocompleteArtifactBinary, fetchAutocompleteArtifactJson } from './artifact-loader';
 import { ARTIFACT_NAME } from './artifacts-manifest';
 import { createCanonicalContextPositionCache, deriveCanonicalCandidateContext, deriveWhitespaceBoundaryContext, logSoftmaxAt, logSumExp, selectBoundaryPrimeRequests } from './canonical-lm-scoring';
-import { CTC_STYLES, ctcSection, ctcTag, isAutocompleteDebugEnabled, isAutocompleteDebugVerbose } from './debug-mode';
+import { CTC_STYLES, ctcSection, ctcTag, isAutocompleteDebugEnabled, isAutocompleteDebugVerbose, registerCtcSessionInspector } from './debug-mode';
 import { loadGrammarDataAsync, rankCandidates, STAGE1_WEIGHT, STAGE2_WEIGHT, MIN_STAGE1_SCORE, MIN_WINNER_MARGIN } from './scoring-pipeline';
 import { getBoundaryLmState, getCanonicalSurfaceCount, getCanonicalSurfaceTokenIds, getDefaultSlowLaneClientStatus, getProgressiveSurfaceEvidence, getStoredContextInput, getStoredContextVector, getStoredLmLogits, getSurfaceScore, isCanonicalSurfaceScoringSupported, primeBoundaryLm, requestProgressiveSurfaceScores } from './slow-lane-client';
 
@@ -184,6 +187,18 @@ var DEBUG_TEXT_TAIL_CHARS = 120;
  * is vocabulary coverage.
  */
 
+/**
+ * What the scored path concluded, recorded on every evaluation whether or not
+ * debug is on.
+ *
+ * This exists for the inline-code harvester, which may only offer a harvested
+ * surface once the scored path has finished and come away empty. The reason is
+ * the load-bearing part: `no-candidate` means no vocabulary reaches this prefix
+ * at all, while `winner-margin` means two known words the model cannot yet
+ * separate — the first is a gap worth filling and the second is a prefix
+ * ambiguous enough that filling it would be a guess.
+ */
+
 /**
  * A candidate paired with the length of the already-typed prefix it completes.
  * For a single word this is the current partial token length; for a phrase it
@@ -211,6 +226,17 @@ var WeightedWordTrie = /*#__PURE__*/function () {
   function WeightedWordTrie() {
     _classCallCheck(this, WeightedWordTrie);
     _defineProperty(this, "root", new TrieNode());
+    /**
+     * Every node a session boost has been written to.
+     *
+     * Kept because dropping the boosts is no longer a rare event — it happens
+     * each time the reader changes page or conversation — and walking a vocabulary
+     * of tens of thousands of words to find the few hundred that were touched
+     * costs about 10ms of main thread every time. The two writers below are the
+     * only way a `sessionFreq` moves, so keeping this in step costs one Set
+     * insertion on a path that is already descending the trie.
+     */
+    _defineProperty(this, "boostedNodes", new Set());
     /** Highest tenantFreq seen — used to normalize freq scores at query time */
     _defineProperty(this, "maxTenantFreq", 1);
   }
@@ -327,6 +353,13 @@ var WeightedWordTrie = /*#__PURE__*/function () {
       return node.word !== null ? node : null;
     }
 
+    /** Whether this exact surface is stored as a terminal word. */
+  }, {
+    key: "hasWord",
+    value: function hasWord(word) {
+      return this.findNode(word) !== null;
+    }
+
     /**
      * Set the session frequency for a word.
      * Returns true if the word exists in the trie.
@@ -339,6 +372,7 @@ var WeightedWordTrie = /*#__PURE__*/function () {
         return false;
       }
       node.sessionFreq = count;
+      this.boostedNodes.add(node);
       return true;
     }
 
@@ -354,8 +388,90 @@ var WeightedWordTrie = /*#__PURE__*/function () {
         return false;
       }
       node.sessionFreq += 1;
+      this.boostedNodes.add(node);
       return true;
     }
+
+    /**
+     * Zero every session boost, in the number of words boosted rather than the
+     * number of words known.
+     */
+  }, {
+    key: "clearSessionBoosts",
+    value: function clearSessionBoosts() {
+      var _iterator5 = _createForOfIteratorHelper(this.boostedNodes),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var node = _step5.value;
+          node.sessionFreq = 0;
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+      this.boostedNodes.clear();
+    }
+
+    /**
+     * Every word carrying a session boost, optionally limited to one prefix's
+     * subtree. Unlike `getCandidates` a word equal to the prefix is included,
+     * since the question here is what the session holds rather than what could
+     * still be typed.
+     *
+     * Walks the trie rather than reading `boostedNodes`, since a prefix answer is
+     * a subtree question and this only runs when a human asks it.
+     */
+  }, {
+    key: "collectSessionBoosted",
+    value: function collectSessionBoosted() {
+      var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      var node = this.root;
+      var _iterator6 = _createForOfIteratorHelper(prefix.toLowerCase()),
+        _step6;
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var char = _step6.value;
+          var next = node.children.get(char);
+          if (!next) {
+            return [];
+          }
+          node = next;
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+      var boosted = [];
+      var stack = [node];
+      while (stack.length > 0) {
+        var current = stack.pop();
+        if (!current) {
+          continue;
+        }
+        if (current.word !== null && current.sessionFreq > 0) {
+          boosted.push({
+            word: current.word,
+            node: current
+          });
+        }
+        var _iterator7 = _createForOfIteratorHelper(current.children.values()),
+          _step7;
+        try {
+          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+            var child = _step7.value;
+            stack.push(child);
+          }
+        } catch (err) {
+          _iterator7.e(err);
+        } finally {
+          _iterator7.f();
+        }
+      }
+      return boosted;
+    }
   }]);
 }(); // L1/L2 Trie (Session + Atlassian Domain)
 var wordTrie = new WeightedWordTrie();
@@ -377,19 +493,19 @@ var phraseTrie = new WeightedWordTrie();
  * expects a simple array of strings: ["about", "above", "actually", ...]
  */
 export var initL3Vocabulary = function initL3Vocabulary(l3Words) {
-  var _iterator5 = _createForOfIteratorHelper(l3Words),
-    _step5;
+  var _iterator8 = _createForOfIteratorHelper(l3Words),
+    _step8;
   try {
-    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-      var word = _step5.value;
+    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+      var word = _step8.value;
       // Insert with a tiny baseline frequency so it mathematically
       // loses to any domain word in Stage 1, but still scores above 0.
       l3Trie.insert(word, L3_BASELINE_FREQ, 0, 0);
     }
   } catch (err) {
-    _iterator5.e(err);
+    _iterator8.e(err);
   } finally {
-    _iterator5.f();
+    _iterator8.f();
   }
   recallGeneration++;
   ctcTag('init', "L3 general English loaded: ".concat(l3Words.length, " words"));
@@ -415,6 +531,15 @@ var phraseTermCount = 0;
 var maxBigramFreq = 1;
 var maxPhraseFreq = 1;
 var lastPredictionDebug = null;
+var lastPredictionOutcome = null;
+var recordPredictionOutcome = function recordPredictionOutcome(outcome) {
+  lastPredictionOutcome = outcome;
+};
+
+/** The verdict from the most recent `predict` call. Always populated. */
+export var getLastPredictionOutcome = function getLastPredictionOutcome() {
+  return lastPredictionOutcome;
+};
 
 // ── Stabilization (QI-2): post-accept cooldown + whole-surface repetition ────
 // Two guards that stop the accept→echo (`end to end` → `end to end to end`) and
@@ -446,6 +571,22 @@ export var noteSuggestionAccepted = function noteSuggestionAccepted(surface) {
   }
 };
 
+/**
+ * Whether `surface` is the one the user just accepted and is still inside its
+ * cooldown window.
+ *
+ * Read-only, unlike the advance inside `predict`: the cooldown is measured in
+ * predictions, and a caller asking whether it is active must not consume one of
+ * them. Exported for the harvest path, which displays without going through
+ * arbitration and so would otherwise re-offer what was just accepted.
+ */
+export var isSurfaceInAcceptCooldown = function isSurfaceInAcceptCooldown(surface) {
+  if (!acceptCooldown || acceptCooldown.surface !== surface.trim().toLowerCase()) {
+    return false;
+  }
+  return acceptCooldown.predictionsSince <= COOLDOWN_KEYSTROKES || performance.now() - acceptCooldown.ts < COOLDOWN_MS;
+};
+
 /** Get vector for a word from the store. */
 var getWordVector = function getWordVector(word) {
   if (!vectorStore) {
@@ -470,20 +611,20 @@ var computeContextVectorLocal = function computeContextVectorLocal(textBefore) {
   var tokens = tokenize(textBefore);
   var words = tokens.slice(-CONTEXT_WORDS);
   var vectors = [];
-  var _iterator6 = _createForOfIteratorHelper(words),
-    _step6;
+  var _iterator9 = _createForOfIteratorHelper(words),
+    _step9;
   try {
-    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-      var word = _step6.value;
+    for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+      var word = _step9.value;
       var _v = getWordVector(word);
       if (_v) {
         vectors.push(_v);
       }
     }
   } catch (err) {
-    _iterator6.e(err);
+    _iterator9.e(err);
   } finally {
-    _iterator6.f();
+    _iterator9.f();
   }
   if (vectors.length === 0) {
     return null;
@@ -516,11 +657,11 @@ var getContextVectorForScoring = function getContextVectorForScoring(textBefore)
 var tokenize = function tokenize(text) {
   var tokens = [];
   // eslint-disable-next-line @atlassian/perf-linting/no-expensive-split-replace
-  var _iterator7 = _createForOfIteratorHelper(text.toLowerCase().split(WHITESPACE_SPLIT_REGEX)),
-    _step7;
+  var _iterator0 = _createForOfIteratorHelper(text.toLowerCase().split(WHITESPACE_SPLIT_REGEX)),
+    _step0;
   try {
-    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
-      var raw = _step7.value;
+    for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
+      var raw = _step0.value;
       // eslint-disable-next-line @atlassian/perf-linting/no-expensive-split-replace
       var clean = raw.replace(PUNCTUATION_BOUNDARY_REGEX, '');
       if (clean.length >= 2) {
@@ -528,9 +669,9 @@ var tokenize = function tokenize(text) {
       }
     }
   } catch (err) {
-    _iterator7.e(err);
+    _iterator0.e(err);
   } finally {
-    _iterator7.f();
+    _iterator0.f();
   }
   return tokens;
 };
@@ -634,11 +775,11 @@ var getPhraseCandidates = function getPhraseCandidates(trimmed) {
       window: windowPrefix,
       matches: matches.length
     });
-    var _iterator8 = _createForOfIteratorHelper(matches),
-      _step8;
+    var _iterator1 = _createForOfIteratorHelper(matches),
+      _step1;
     try {
-      for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
-        var _match = _step8.value;
+      for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
+        var _match = _step1.value;
         if (seen.has(_match.word)) {
           continue;
         }
@@ -651,9 +792,9 @@ var getPhraseCandidates = function getPhraseCandidates(trimmed) {
         });
       }
     } catch (err) {
-      _iterator8.e(err);
+      _iterator1.e(err);
     } finally {
-      _iterator8.f();
+      _iterator1.f();
     }
   }
   logPhrasePath();
@@ -698,17 +839,17 @@ export var getLastPredictionDebug = function getLastPredictionDebug() {
   return lastPredictionDebug;
 };
 export var initVocabulary = function initVocabulary(vocabulary) {
-  var _iterator9 = _createForOfIteratorHelper(vocabulary.terms),
-    _step9;
+  var _iterator10 = _createForOfIteratorHelper(vocabulary.terms),
+    _step10;
   try {
-    for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
-      var term = _step9.value;
+    for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+      var term = _step10.value;
       wordTrie.insert(term.word, term.freq, term.docFreq, term.authorFreq);
     }
   } catch (err) {
-    _iterator9.e(err);
+    _iterator10.e(err);
   } finally {
-    _iterator9.f();
+    _iterator10.f();
   }
   isInitialized = true;
   recallGeneration++;
@@ -759,6 +900,36 @@ export var incrementSessionFreq = function incrementSessionFreq(word) {
   wordTrie.incrementSessionFreq(word);
 };
 
+/**
+ * Drop every L1 boost this session has accumulated.
+ *
+ * The vocabulary itself is left alone: only `sessionFreq` is cleared, so the
+ * tenant and generic frequencies a boost was sitting on top of survive. Called
+ * when the plugin decides the session it was learning for has ended — a new
+ * conversation, or a different page — since a boost is a claim about what is
+ * being discussed and that claim does not carry over.
+ */
+export var resetSessionBoosts = function resetSessionBoosts() {
+  wordTrie.clearSessionBoosts();
+  // Anything memoized against the old boosts is now describing a session that
+  // no longer exists.
+  recallGeneration++;
+};
+
+/**
+ * Which vocabulary already holds this surface, if any.
+ *
+ * Used by the inline-code harvester to drop terms the scored path can already
+ * serve, so that harvesting stays limited to words with no route to a
+ * suggestion today.
+ */
+export var lookupVocabularySource = function lookupVocabularySource(word) {
+  if (wordTrie.hasWord(word)) {
+    return 'l2';
+  }
+  return l3Trie.hasWord(word) ? 'l3' : null;
+};
+
 /**
  * Prime session frequencies from a document page string.
  *
@@ -775,23 +946,23 @@ export var ingestDocumentPage = function ingestDocumentPage(pageContent) {
   }
   var words = tokenize(pageContent);
   var validBoostedWords = new Set();
-  var _iterator0 = _createForOfIteratorHelper(words),
-    _step0;
+  var _iterator11 = _createForOfIteratorHelper(words),
+    _step11;
   try {
-    for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
-      var word = _step0.value;
+    for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+      var word = _step11.value;
       var didBoost = wordTrie.incrementSessionFreq(word);
       if (didBoost) {
         validBoostedWords.add(word);
       }
     }
   } catch (err) {
-    _iterator0.e(err);
+    _iterator11.e(err);
   } finally {
-    _iterator0.f();
+    _iterator11.f();
   }
   if (isAutocompleteDebugEnabled() && validBoostedWords.size > 0) {
-    ctcTag('init', "L1 session primed ".concat(validBoostedWords.size, " words from page"), CTC_STYLES.brand);
+    ctcTag('init', "L1 session primed ".concat(validBoostedWords.size, " words from page \xB7 __atlCtcDebug__.session() to inspect"), CTC_STYLES.brand);
     if (isAutocompleteDebugVerbose()) {
       // eslint-disable-next-line no-console
       console.dir(Array.from(validBoostedWords).sort());
@@ -799,6 +970,57 @@ export var ingestDocumentPage = function ingestDocumentPage(pageContent) {
   }
 };
 
+/**
+ * How many boosted words `inspectSessionBoosts` lists.
+ *
+ * A page ingest can boost thousands, and a list that long is not read. The
+ * strongest boosts are the ones that change an ordering, and `boosted` still
+ * reports the full size, so the cap loses nothing but volume.
+ */
+var MAX_LISTED_SESSION_WORDS = 100;
+/**
+ * Read the session's L1 boosts, optionally narrowed to a prefix.
+ *
+ * Installed as `__atlCtcDebug__.session()`, with `__atlCtcDebug__.session('poll')`
+ * to ask about one family. Returned rather than logged, so the console renders it
+ * as an inspectable object and a caller can assert on it.
+ *
+ * Only words the vocabulary already holds can carry a boost, because both writers
+ * go through `incrementSessionFreq` and it only finds existing nodes. An ingested
+ * word absent from the vocabulary is therefore missing from here and always will
+ * be — that gap is what the inline-code harvester covers, and those surfaces show
+ * up under `__atlCtcDebug__.harvest()` instead.
+ */
+export var inspectSessionBoosts = function inspectSessionBoosts(prefix) {
+  var boosted = wordTrie.collectSessionBoosted(prefix !== null && prefix !== void 0 ? prefix : '');
+  return _objectSpread(_objectSpread({
+    boosted: boosted.length,
+    limit: MAX_LISTED_SESSION_WORDS
+  }, prefix === undefined ? {} : {
+    prefix: prefix
+  }), {}, {
+    words: boosted.sort(function (a, b) {
+      return b.node.sessionFreq - a.node.sessionFreq || a.word.localeCompare(b.word, 'en', {
+        numeric: true,
+        sensitivity: 'base'
+      });
+    }).slice(0, MAX_LISTED_SESSION_WORDS).map(function (_ref) {
+      var node = _ref.node,
+        word = _ref.word;
+      return {
+        sessionFreq: node.sessionFreq,
+        sessionOnly: node.tenantFreq === 0,
+        surface: word,
+        tenantFreq: node.tenantFreq
+      };
+    })
+  });
+};
+
+// At module scope so the console answers before the first keystroke, which is
+// when someone reaching for it usually asks.
+registerCtcSessionInspector(inspectSessionBoosts);
+
 /**
  * Result of a prediction: the ghost tail to insert plus an immutable record of
  * the evidence that authorized the UI commitment.
@@ -830,20 +1052,20 @@ var computeCanonicalRecall = function computeCanonicalRecall(trimmed, currentWor
     var existingWords = new Set(wordCandidates.map(function (c) {
       return c.word;
     }));
-    var _iterator1 = _createForOfIteratorHelper(l3Candidates),
-      _step1;
+    var _iterator12 = _createForOfIteratorHelper(l3Candidates),
+      _step12;
     try {
-      for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
-        var l3c = _step1.value;
+      for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+        var l3c = _step12.value;
         if (wordCandidates.length >= MAX_CANDIDATES) break;
         if (!existingWords.has(l3c.word)) {
           wordCandidates.push(l3c);
         }
       }
     } catch (err) {
-      _iterator1.e(err);
+      _iterator12.e(err);
     } finally {
-      _iterator1.f();
+      _iterator12.f();
     }
   }
 
@@ -855,9 +1077,9 @@ var computeCanonicalRecall = function computeCanonicalRecall(trimmed, currentWor
   // Unify: a word completes the current partial token; a phrase completes its
   // matched multi-word window. Track the prefix length per term so the ghost
   // tail is sliced correctly regardless of term type.
-  var matched = [].concat(_toConsumableArray(wordCandidates.map(function (_ref) {
-    var word = _ref.word,
-      node = _ref.node;
+  var matched = [].concat(_toConsumableArray(wordCandidates.map(function (_ref2) {
+    var word = _ref2.word,
+      node = _ref2.node;
     return {
       word: word,
       node: node,
@@ -870,19 +1092,19 @@ var computeCanonicalRecall = function computeCanonicalRecall(trimmed, currentWor
     return _objectSpread(_objectSpread({}, candidate), deriveCanonicalCandidateContext(trimmed, candidate.matchedPrefixLen, candidate.word, getCanonicalSurfaceTokenIds, candidate.surfaceStart, positionCache));
   });
   var prefixLenByWord = new Map();
-  var _iterator10 = _createForOfIteratorHelper(canonicalMatched),
-    _step10;
+  var _iterator13 = _createForOfIteratorHelper(canonicalMatched),
+    _step13;
   try {
-    for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
-      var m = _step10.value;
+    for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+      var m = _step13.value;
       if (!prefixLenByWord.has(m.word)) {
         prefixLenByWord.set(m.word, m.matchedPrefixLen);
       }
     }
   } catch (err) {
-    _iterator10.e(err);
+    _iterator13.e(err);
   } finally {
-    _iterator10.f();
+    _iterator13.f();
   }
   return {
     canonicalMatched: canonicalMatched,
@@ -921,6 +1143,14 @@ export var predict = function predict(textBefore) {
     void loadDefaultVocabulary({
       source: 'predict'
     }).catch(function () {});
+    // Awaiting, not empty-handed: with no vocabulary loaded the harvester's own
+    // intake filter has not been applied to anything either.
+    recordPredictionOutcome({
+      abstainReason: 'not-initialized',
+      awaitingAsyncEvidence: true,
+      scoredCandidateCount: 0,
+      textBefore: textBefore
+    });
     return null;
   }
   var t0 = performance.now();
@@ -949,11 +1179,23 @@ export var predict = function predict(textBefore) {
         priority: 0
       }));
     }
+    recordPredictionOutcome({
+      abstainReason: 'prefetch',
+      awaitingAsyncEvidence: true,
+      scoredCandidateCount: 0,
+      textBefore: textBefore
+    });
     return null;
   }
   var trimmed = textBefore.trimEnd();
   var trailingSurfaceToken = (_trimmed$match$ = (_trimmed$match = trimmed.match(TRAILING_SURFACE_TOKEN_REGEX)) === null || _trimmed$match === void 0 ? void 0 : _trimmed$match[0]) !== null && _trimmed$match$ !== void 0 ? _trimmed$match$ : '';
   if (trailingSurfaceToken.length === 0) {
+    recordPredictionOutcome({
+      abstainReason: 'no-surface-token',
+      awaitingAsyncEvidence: false,
+      scoredCandidateCount: 0,
+      textBefore: textBefore
+    });
     return null;
   }
   var currentWord = trailingSurfaceToken;
@@ -964,6 +1206,14 @@ export var predict = function predict(textBefore) {
 
   // If every trie was empty for this prefix
   if (canonicalMatched.length === 0) {
+    // Terminal, and the only verdict that says the vocabulary has no claim on
+    // this prefix at all — which is what makes it the harvester's cue.
+    recordPredictionOutcome({
+      abstainReason: 'no-candidate',
+      awaitingAsyncEvidence: false,
+      scoredCandidateCount: 0,
+      textBefore: textBefore
+    });
     if (isAutocompleteDebugEnabled()) {
       // eslint-disable-next-line no-console
       console.log("%c[CTC]%c \u2014 abstain: no matches for \"".concat(currentWord, "\""), CTC_STYLES.brand, CTC_STYLES.body);
@@ -976,9 +1226,9 @@ export var predict = function predict(textBefore) {
   var mode = contextVector ? 'warm' : 'cold';
 
   // Build ScoringCandidate array from matched terms (words + phrases)
-  var scoringCandidates = canonicalMatched.map(function (_ref2) {
-    var word = _ref2.word,
-      node = _ref2.node;
+  var scoringCandidates = canonicalMatched.map(function (_ref3) {
+    var word = _ref3.word,
+      node = _ref3.node;
     return {
       word: word,
       tenantFreq: node.tenantFreq,
@@ -998,9 +1248,9 @@ export var predict = function predict(textBefore) {
   var currentWordSeparator = (_canonicalMatched$fin = canonicalMatched.find(function (candidate) {
     return candidate.node.termType === 'word';
   })) === null || _canonicalMatched$fin === void 0 ? void 0 : _canonicalMatched$fin.separatorKind;
-  var prefixLmLogits = lmLogits && currentWordSeparator === 'whitespace' ? Object.fromEntries(Object.entries(lmLogits).filter(function (_ref3) {
-    var _ref4 = _slicedToArray(_ref3, 1),
-      word = _ref4[0];
+  var prefixLmLogits = lmLogits && currentWordSeparator === 'whitespace' ? Object.fromEntries(Object.entries(lmLogits).filter(function (_ref4) {
+    var _ref5 = _slicedToArray(_ref4, 1),
+      word = _ref5[0];
     return word.startsWith(prefix);
   })) : null;
   var canonicalScoringSupported = isCanonicalSurfaceScoringSupported();
@@ -1011,29 +1261,29 @@ export var predict = function predict(textBefore) {
   }))).sort();
   var familyKey = eligibleContextKeys.join("\x01");
   var primeRequests = selectBoundaryPrimeRequests(familyKey, canonicalMatched, PHRASE_MAX_WORDS);
-  var _iterator11 = _createForOfIteratorHelper(primeRequests),
-    _step11;
+  var _iterator14 = _createForOfIteratorHelper(primeRequests),
+    _step14;
   try {
-    for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
-      var request = _step11.value;
+    for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+      var request = _step14.value;
       primeBoundaryLm(request);
     }
   } catch (err) {
-    _iterator11.e(err);
+    _iterator14.e(err);
   } finally {
-    _iterator11.f();
+    _iterator14.f();
   }
   var runtimeBySurface = new Map(canonicalMatched.map(function (candidate) {
     return [candidate.word, candidate];
   }));
   var canonicalEvidence = new Map();
   var firstTokenGroups = new Map();
-  var _iterator12 = _createForOfIteratorHelper(canonicalMatched),
-    _step12;
+  var _iterator15 = _createForOfIteratorHelper(canonicalMatched),
+    _step15;
   try {
-    for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+    for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
       var _firstTokenGroups$get;
-      var _candidate = _step12.value;
+      var _candidate = _step15.value;
       if (_candidate.canonicalTokenIds === null) {
         continue;
       }
@@ -1061,28 +1311,28 @@ export var predict = function predict(textBefore) {
       firstTokenGroups.set(_candidate.contextKey, _group2);
     }
   } catch (err) {
-    _iterator12.e(err);
+    _iterator15.e(err);
   } finally {
-    _iterator12.f();
+    _iterator15.f();
   }
-  var _iterator13 = _createForOfIteratorHelper(firstTokenGroups),
-    _step13;
+  var _iterator16 = _createForOfIteratorHelper(firstTokenGroups),
+    _step16;
   try {
-    for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
-      var _step13$value = _slicedToArray(_step13.value, 2),
-        _contextKey = _step13$value[0],
-        _group3 = _step13$value[1];
+    for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
+      var _step16$value = _slicedToArray(_step16.value, 2),
+        _contextKey = _step16$value[0],
+        _group3 = _step16$value[1];
       var boundary = getBoundaryLmState(_contextKey);
       if (!boundary) {
         continue;
       }
       var maxLogit = -Infinity;
-      var _iterator20 = _createForOfIteratorHelper(_group3),
-        _step20;
+      var _iterator23 = _createForOfIteratorHelper(_group3),
+        _step23;
       try {
-        for (_iterator20.s(); !(_step20 = _iterator20.n()).done;) {
+        for (_iterator23.s(); !(_step23 = _iterator23.n()).done;) {
           var _candidate2$canonical;
-          var _candidate2 = _step20.value;
+          var _candidate2 = _step23.value;
           var tokenId = (_candidate2$canonical = _candidate2.canonicalTokenIds) === null || _candidate2$canonical === void 0 ? void 0 : _candidate2$canonical[0];
           var rawLogit = tokenId === undefined ? undefined : boundary.rawLogits[tokenId];
           if (rawLogit !== undefined && Number.isFinite(rawLogit) && rawLogit > maxLogit) {
@@ -1090,19 +1340,19 @@ export var predict = function predict(textBefore) {
           }
         }
       } catch (err) {
-        _iterator20.e(err);
+        _iterator23.e(err);
       } finally {
-        _iterator20.f();
+        _iterator23.f();
       }
       if (!Number.isFinite(maxLogit)) {
         continue;
       }
-      var _iterator21 = _createForOfIteratorHelper(_group3),
-        _step21;
+      var _iterator24 = _createForOfIteratorHelper(_group3),
+        _step24;
       try {
-        for (_iterator21.s(); !(_step21 = _iterator21.n()).done;) {
+        for (_iterator24.s(); !(_step24 = _iterator24.n()).done;) {
           var _candidate3$canonical, _candidate3$canonical2, _candidate3$canonical3;
-          var _candidate3 = _step21.value;
+          var _candidate3 = _step24.value;
           var _tokenId = (_candidate3$canonical = _candidate3.canonicalTokenIds) === null || _candidate3$canonical === void 0 ? void 0 : _candidate3$canonical[0];
           var _rawLogit = _tokenId === undefined ? undefined : boundary.rawLogits[_tokenId];
           if (_rawLogit === undefined || !Number.isFinite(_rawLogit)) {
@@ -1141,15 +1391,15 @@ export var predict = function predict(textBefore) {
           });
         }
       } catch (err) {
-        _iterator21.e(err);
+        _iterator24.e(err);
       } finally {
-        _iterator21.f();
+        _iterator24.f();
       }
     }
   } catch (err) {
-    _iterator13.e(err);
+    _iterator16.e(err);
   } finally {
-    _iterator13.f();
+    _iterator16.f();
   }
   var _rankCandidates = rankCandidates(scoringCandidates, contextVector, function (w) {
       return getWordVector(w);
@@ -1170,12 +1420,12 @@ export var predict = function predict(textBefore) {
   });
   if (canonicalScoringSupported && progressiveEligible.length > 0) {
     var byContext = new Map();
-    var _iterator14 = _createForOfIteratorHelper(progressiveEligible),
-      _step14;
+    var _iterator17 = _createForOfIteratorHelper(progressiveEligible),
+      _step17;
     try {
-      for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+      for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
         var _byContext$get;
-        var candidate = _step14.value;
+        var candidate = _step17.value;
         var runtime = runtimeBySurface.get(candidate.word);
         if (!runtime || runtime.canonicalTokenIds === null) {
           continue;
@@ -1188,25 +1438,25 @@ export var predict = function predict(textBefore) {
         byContext.set(runtime.contextKey, group);
       }
     } catch (err) {
-      _iterator14.e(err);
+      _iterator17.e(err);
     } finally {
-      _iterator14.f();
+      _iterator17.f();
     }
-    var _iterator15 = _createForOfIteratorHelper(byContext),
-      _step15;
+    var _iterator18 = _createForOfIteratorHelper(byContext),
+      _step18;
     try {
-      for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
-        var _step15$value = _slicedToArray(_step15.value, 2),
-          contextKey = _step15$value[0],
-          _group = _step15$value[1];
+      for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
+        var _step18$value = _slicedToArray(_step18.value, 2),
+          contextKey = _step18$value[0],
+          _group = _step18$value[1];
         requestProgressiveSurfaceScores({
           familyKey: familyKey,
           contextKey: contextKey,
           prompt: _group[0].runtime.contextBeforeSurface,
-          candidates: _group.map(function (_ref5) {
+          candidates: _group.map(function (_ref6) {
             var _runtime$canonicalTok;
-            var runtime = _ref5.runtime,
-              rankHint = _ref5.rankHint;
+            var runtime = _ref6.runtime,
+              rankHint = _ref6.rankHint;
             return {
               surface: runtime.word,
               tokenIds: (_runtime$canonicalTok = runtime.canonicalTokenIds) !== null && _runtime$canonicalTok !== void 0 ? _runtime$canonicalTok : [],
@@ -1216,9 +1466,9 @@ export var predict = function predict(textBefore) {
         });
       }
     } catch (err) {
-      _iterator15.e(err);
+      _iterator18.e(err);
     } finally {
-      _iterator15.f();
+      _iterator18.f();
     }
   }
 
@@ -1307,12 +1557,12 @@ export var predict = function predict(textBefore) {
   var contextRequestedCount = new Map();
   var bestTotalByContext = new Map();
   var bestCandidateByContext = new Map();
-  var _iterator16 = _createForOfIteratorHelper(ranked),
-    _step16;
+  var _iterator19 = _createForOfIteratorHelper(ranked),
+    _step19;
   try {
-    for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
+    for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
       var _contextRequestedCoun2, _judged$total;
-      var _candidate4 = _step16.value;
+      var _candidate4 = _step19.value;
       var _runtime = runtimeBySurface.get(_candidate4.word);
       if (!_runtime || _runtime.canonicalTokenIds === null) {
         continue;
@@ -1351,9 +1601,9 @@ export var predict = function predict(textBefore) {
      * costs one lookup per space rather than a comparison against every member.
      */
   } catch (err) {
-    _iterator16.e(err);
+    _iterator19.e(err);
   } finally {
-    _iterator16.f();
+    _iterator19.f();
   }
   var extendsAPoolMember = function extendsAPoolMember(surface, pool) {
     for (var space = surface.indexOf(' '); space !== -1; space = surface.indexOf(' ', space + 1)) {
@@ -1388,22 +1638,22 @@ export var predict = function predict(textBefore) {
   // it continues, because the cap alone would leave it looking exactly as
   // certain as its prefix while saying nothing about its own tail.
   var underReadExtensions = new Set();
-  var _iterator17 = _createForOfIteratorHelper(contextSurfaces),
-    _step17;
+  var _iterator20 = _createForOfIteratorHelper(contextSurfaces),
+    _step20;
   try {
-    for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
-      var _step17$value = _slicedToArray(_step17.value, 2),
-        _contextKey2 = _step17$value[0],
-        _surfaces = _step17$value[1];
+    for (_iterator20.s(); !(_step20 = _iterator20.n()).done;) {
+      var _step20$value = _slicedToArray(_step20.value, 2),
+        _contextKey2 = _step20$value[0],
+        _surfaces = _step20$value[1];
       var pool = new Set(_surfaces);
-      var _iterator22 = _createForOfIteratorHelper(_toConsumableArray(_surfaces).sort(function (a, b) {
+      var _iterator25 = _createForOfIteratorHelper(_toConsumableArray(_surfaces).sort(function (a, b) {
           return a.length - b.length;
         })),
-        _step22;
+        _step25;
       try {
-        for (_iterator22.s(); !(_step22 = _iterator22.n()).done;) {
+        for (_iterator25.s(); !(_step25 = _iterator25.n()).done;) {
           var _getProgressiveSurfac, _getProgressiveSurfac2, _runtimeBySurface$get8, _runtimeBySurface$get9;
-          var surface = _step22.value;
+          var surface = _step25.value;
           var own = optimisticTotalByWord.get(surface);
           if (own === undefined) {
             continue;
@@ -1435,9 +1685,9 @@ export var predict = function predict(textBefore) {
           }
         }
       } catch (err) {
-        _iterator22.e(err);
+        _iterator25.e(err);
       } finally {
-        _iterator22.f();
+        _iterator25.f();
       }
     }
 
@@ -1450,9 +1700,9 @@ export var predict = function predict(textBefore) {
      * depths.
      */
   } catch (err) {
-    _iterator17.e(err);
+    _iterator20.e(err);
   } finally {
-    _iterator17.f();
+    _iterator20.f();
   }
   var judgedEvidenceFor = function judgedEvidenceFor(candidate) {
     return underReadExtensions.has(candidate.word) ? null : readJudgedEvidence(candidate);
@@ -1479,20 +1729,20 @@ export var predict = function predict(textBefore) {
   // `contextTotals`, so how contested a context is still counts every scored
   // candidate.
   var logSumExpByContext = new Map();
-  var _iterator18 = _createForOfIteratorHelper(contextSurfaces),
-    _step18;
+  var _iterator21 = _createForOfIteratorHelper(contextSurfaces),
+    _step21;
   try {
-    for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
-      var _step18$value = _slicedToArray(_step18.value, 2),
-        _contextKey3 = _step18$value[0],
-        _surfaces2 = _step18$value[1];
+    for (_iterator21.s(); !(_step21 = _iterator21.n()).done;) {
+      var _step21$value = _slicedToArray(_step21.value, 2),
+        _contextKey3 = _step21$value[0],
+        _surfaces2 = _step21$value[1];
       var _pool = new Set(_surfaces2);
       var minimalTotals = [];
-      var _iterator23 = _createForOfIteratorHelper(_surfaces2),
-        _step23;
+      var _iterator26 = _createForOfIteratorHelper(_surfaces2),
+        _step26;
       try {
-        for (_iterator23.s(); !(_step23 = _iterator23.n()).done;) {
-          var _surface = _step23.value;
+        for (_iterator26.s(); !(_step26 = _iterator26.n()).done;) {
+          var _surface = _step26.value;
           var total = optimisticTotalByWord.get(_surface);
           if (total !== undefined && !extendsAPoolMember(_surface, _pool)) {
             minimalTotals.push(total);
@@ -1501,9 +1751,9 @@ export var predict = function predict(textBefore) {
         // An extension is strictly longer than what it extends, so the shortest
         // member of any non-empty pool is always minimal and this is never empty.
       } catch (err) {
-        _iterator23.e(err);
+        _iterator26.e(err);
       } finally {
-        _iterator23.f();
+        _iterator26.f();
       }
       logSumExpByContext.set(_contextKey3, logSumExp(minimalTotals));
     }
@@ -1515,9 +1765,9 @@ export var predict = function predict(textBefore) {
      * eventual posterior, or a verified total for the posterior itself.
      */
   } catch (err) {
-    _iterator18.e(err);
+    _iterator21.e(err);
   } finally {
-    _iterator18.f();
+    _iterator21.f();
   }
   var posteriorFor = function posteriorFor(candidate, total) {
     var runtime = runtimeBySurface.get(candidate.word);
@@ -1647,9 +1897,9 @@ export var predict = function predict(textBefore) {
   // The gate is the model's own confidence in the surface; the blended score
   // only orders what has already cleared it, so a strong corpus prior can no
   // longer carry a surface the model is unsure of onto the screen.
-  .filter(function (_ref6) {
-    var candidate = _ref6.candidate,
-      posterior = _ref6.posterior;
+  .filter(function (_ref7) {
+    var candidate = _ref7.candidate,
+      posterior = _ref7.posterior;
     return posterior >= MIN_LM_POSTERIOR[candidate.termType];
   });
   /**
@@ -1677,15 +1927,15 @@ export var predict = function predict(textBefore) {
   // cleared both. A candidate refused here stays in `ranked` and so still
   // counts as competition below — promoting the runner-up in place of an
   // implausible leader would show something worse, not something better.
-  var plausible = gateCleared.filter(function (_ref7) {
-    var candidate = _ref7.candidate;
+  var plausible = gateCleared.filter(function (_ref8) {
+    var candidate = _ref8.candidate;
     return isPlausibleSurface(candidate);
   });
   // Applied after the gate rather than folded into it, so the two populations
   // stay separable: a surface refused here cleared its threshold and was
   // refused for having had nothing to clear it against.
-  var eligible = plausible.filter(function (_ref8) {
-    var candidate = _ref8.candidate;
+  var eligible = plausible.filter(function (_ref9) {
+    var candidate = _ref9.candidate;
     return !canonicalLmSupported || scoredPoolSize(candidate) >= MIN_SCORED_POOL_SIZE || requestedPoolSize(candidate) <= 1;
   }).sort(function (a, b) {
     return b.score - a.score;
@@ -1807,6 +2057,12 @@ export var predict = function predict(textBefore) {
     return ranked.some(hasJudgeableEvidence) ? 'below-posterior-gate' : 'no-evidence';
   };
   var abstainReason = resolveAbstainReason();
+  recordPredictionOutcome({
+    abstainReason: abstainReason,
+    awaitingAsyncEvidence: hasUnresolvedPotential && !clearsWinnerMargin,
+    scoredCandidateCount: ranked.length,
+    textBefore: textBefore
+  });
 
   // The leader is the best-supported candidate, not the selected one: an
   // evaluation that showed nothing is exactly the one whose posterior needs
@@ -1851,9 +2107,9 @@ export var predict = function predict(textBefore) {
       'below-posterior-gate': "posterior below ".concat(MIN_LM_POSTERIOR[((_posteriorLeader$cand = posteriorLeader === null || posteriorLeader === void 0 ? void 0 : posteriorLeader.candidate) !== null && _posteriorLeader$cand !== void 0 ? _posteriorLeader$cand : ranked[0]).termType], " (best ").concat(((_posteriorLeader$post = posteriorLeader === null || posteriorLeader === void 0 ? void 0 : posteriorLeader.posterior) !== null && _posteriorLeader$post !== void 0 ? _posteriorLeader$post : 0).toFixed(2), ")"),
       'cold-competitor': 'competitor has no LM evidence yet',
       'empty-completion': 'empty completion',
-      'implausible-surface': "mean per-token log-probability below ".concat(MIN_MEAN_TOKEN_LOG_PROBABILITY, " (best ").concat(gateCleared.map(function (_ref9) {
+      'implausible-surface': "mean per-token log-probability below ".concat(MIN_MEAN_TOKEN_LOG_PROBABILITY, " (best ").concat(gateCleared.map(function (_ref0) {
         var _judgedEvidenceFor$me, _judgedEvidenceFor4;
-        var candidate = _ref9.candidate;
+        var candidate = _ref0.candidate;
         return (_judgedEvidenceFor$me = (_judgedEvidenceFor4 = judgedEvidenceFor(candidate)) === null || _judgedEvidenceFor4 === void 0 ? void 0 : _judgedEvidenceFor4.mean) !== null && _judgedEvidenceFor$me !== void 0 ? _judgedEvidenceFor$me : -Infinity;
       }).reduce(function (best, mean) {
         return Math.max(best, mean);
@@ -1862,6 +2118,9 @@ export var predict = function predict(textBefore) {
       'missing-artifact': 'canonical artifact coverage missing',
       'no-candidate': 'nothing cleared scoring',
       'no-evidence': 'full-surface evidence absent',
+      // Recorded at the two exits above this block, so they never print here.
+      'no-surface-token': 'no trailing surface token',
+      'not-initialized': 'vocabulary not loaded',
       prefetch: "prefetch: ".concat(currentWord.length, "/").concat(DISPLAY_MIN_PREFIX_LENGTH, " chars"),
       'short-completion': "completion shorter than ".concat(MIN_SUGGESTION_LENGTH, " chars"),
       'unresolved-rival': 'expanding plausible token-prefix groups',
@@ -1941,10 +2200,10 @@ export var predict = function predict(textBefore) {
     if (verbose && logitCount > 0 && lmLogits) {
       var rawLmTop = Object.entries(lmLogits).sort(function (a, b) {
         return b[1] - a[1];
-      }).slice(0, 5).map(function (_ref0) {
-        var _ref1 = _slicedToArray(_ref0, 2),
-          word = _ref1[0],
-          score = _ref1[1];
+      }).slice(0, 5).map(function (_ref1) {
+        var _ref10 = _slicedToArray(_ref1, 2),
+          word = _ref10[0],
+          score = _ref10[1];
         return "".concat(word, ":").concat(score.toFixed(3));
       }).join(', ');
       ctcSection('  rawLM', "\uD83E\uDDE0 ".concat(rawLmTop));
@@ -1956,17 +2215,17 @@ export var predict = function predict(textBefore) {
       bigram: 0,
       phrase: 0
     };
-    var _iterator19 = _createForOfIteratorHelper(canonicalMatched),
-      _step19;
+    var _iterator22 = _createForOfIteratorHelper(canonicalMatched),
+      _step22;
     try {
-      for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
-        var m = _step19.value;
+      for (_iterator22.s(); !(_step22 = _iterator22.n()).done;) {
+        var m = _step22.value;
         genByType[m.node.termType] += 1;
       }
     } catch (err) {
-      _iterator19.e(err);
+      _iterator22.e(err);
     } finally {
-      _iterator19.f();
+      _iterator22.f();
     }
     ctcSection('GENERATE', "matched ".concat(canonicalMatched.length, " \u2192 word:").concat(genByType.word, " bigram:").concat(genByType.bigram, " phrase:").concat(genByType.phrase).concat(canonicalLmSupported ? ' · display needs exact surface evidence' : ''));
 
@@ -2025,8 +2284,8 @@ export var predict = function predict(textBefore) {
         return judgedPosterior(candidate) >= MIN_LM_POSTERIOR[termType];
       });
       var plausiblePassed = floorPassed.filter(isPlausibleSurface);
-      return "".concat(termType, " m:").concat(genByType[termType], " r:").concat(typeRanked.length, " exact:").concat(exact.length, " abs:").concat(absolute.length, " stable:").concat(stabilized.length, " suffix:").concat(longEnough.length, " floor:").concat(floorPassed.length, " plausible:").concat(plausiblePassed.length, " eligible:").concat(eligible.filter(function (_ref10) {
-        var candidate = _ref10.candidate;
+      return "".concat(termType, " m:").concat(genByType[termType], " r:").concat(typeRanked.length, " exact:").concat(exact.length, " abs:").concat(absolute.length, " stable:").concat(stabilized.length, " suffix:").concat(longEnough.length, " floor:").concat(floorPassed.length, " plausible:").concat(plausiblePassed.length, " eligible:").concat(eligible.filter(function (_ref11) {
+        var candidate = _ref11.candidate;
         return candidate.termType === termType;
       }).length);
     };
@@ -2035,11 +2294,11 @@ export var predict = function predict(textBefore) {
     // One line per context: how many candidates share the normaliser, and how
     // much of the mass the leader holds. A leader well under its threshold
     // means the context is contested, which is the abstention we want.
-    var contextLeaders = Array.from(bestCandidateByContext.entries()).slice(0, PHRASE_MAX_WORDS).map(function (_ref11) {
+    var contextLeaders = Array.from(bestCandidateByContext.entries()).slice(0, PHRASE_MAX_WORDS).map(function (_ref12) {
       var _contextTotals$get$le2, _contextTotals$get2;
-      var _ref12 = _slicedToArray(_ref11, 2),
-        contextKey = _ref12[0],
-        leader = _ref12[1];
+      var _ref13 = _slicedToArray(_ref12, 2),
+        contextKey = _ref13[0],
+        leader = _ref13[1];
       var shortlistSize = (_contextTotals$get$le2 = (_contextTotals$get2 = contextTotals.get(contextKey)) === null || _contextTotals$get2 === void 0 ? void 0 : _contextTotals$get2.length) !== null && _contextTotals$get$le2 !== void 0 ? _contextTotals$get$le2 : 0;
       var evidenceKind = hasExactEvidence(leader) ? 'exact' : 'upper';
       return "".concat(contextKey.slice(0, 32), " \u2192 n=").concat(shortlistSize, " ").concat(leader.termType, ":\"").concat(leader.word, "\" ").concat(evidenceKind, " p=").concat(optimisticPosterior(leader).toFixed(3), "/").concat(MIN_LM_POSTERIOR[leader.termType]);
@@ -2269,7 +2528,7 @@ var normalizePhraseArtifact = function normalizePhraseArtifact(payload) {
   return null;
 };
 export var loadVectorsAsync = /*#__PURE__*/function () {
-  var _ref13 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(options) {
+  var _ref14 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(options) {
     var _options$isLocalLLM;
     var isLocalLLM, surface, buffer, float32, wordIndexPayload, wordIndex, nWords, dim, _t;
     return _regeneratorRuntime.wrap(function (_context) {
@@ -2344,7 +2603,7 @@ export var loadVectorsAsync = /*#__PURE__*/function () {
     }, _callee, null, [[2, 5]]);
   }));
   return function loadVectorsAsync(_x) {
-    return _ref13.apply(this, arguments);
+    return _ref14.apply(this, arguments);
   };
 }();
 export var initVectors = function initVectors(store) {
@@ -2368,7 +2627,7 @@ export var initVectors = function initVectors(store) {
  *   A promise that resolves once both fetches have settled
  */
 export var loadPhraseArtifacts = /*#__PURE__*/function () {
-  var _ref14 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(options) {
+  var _ref15 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(options) {
     var _options$isLocalLLM2;
     var isLocalLLM, loadOne, _yield$Promise$allSet, _yield$Promise$allSet2, bigramsResult, phrasesResult, bigramCount, phraseCount;
     return _regeneratorRuntime.wrap(function (_context3) {
@@ -2386,7 +2645,7 @@ export var loadPhraseArtifacts = /*#__PURE__*/function () {
             isLocalLLM: isLocalLLM
           });
           loadOne = /*#__PURE__*/function () {
-            var _ref15 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(artifactName, termType, label) {
+            var _ref16 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(artifactName, termType, label) {
               var payload, normalized;
               return _regeneratorRuntime.wrap(function (_context2) {
                 while (1) switch (_context2.prev = _context2.next) {
@@ -2415,7 +2674,7 @@ export var loadPhraseArtifacts = /*#__PURE__*/function () {
               }, _callee2);
             }));
             return function loadOne(_x3, _x4, _x5) {
-              return _ref15.apply(this, arguments);
+              return _ref16.apply(this, arguments);
             };
           }();
           _context3.next = 2;
@@ -2457,7 +2716,7 @@ export var loadPhraseArtifacts = /*#__PURE__*/function () {
     }, _callee3);
   }));
   return function loadPhraseArtifacts(_x2) {
-    return _ref14.apply(this, arguments);
+    return _ref15.apply(this, arguments);
   };
 }();
 var vocabularyLoadPromise;
@@ -2523,10 +2782,10 @@ export var loadDefaultVocabulary = function loadDefaultVocabulary(options) {
           _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
           vocabularyData = _yield$Promise$all2[0];
           l3VocabularyData = _yield$Promise$all2[1];
-          terms = Object.entries(vocabularyData.words).map(function (_ref17) {
-            var _ref18 = _slicedToArray(_ref17, 2),
-              word = _ref18[0],
-              stats = _ref18[1];
+          terms = Object.entries(vocabularyData.words).map(function (_ref18) {
+            var _ref19 = _slicedToArray(_ref18, 2),
+              word = _ref19[0],
+              stats = _ref19[1];
             return {
               word: word,
               freq: stats.freq,