@atlaskit/editor-plugin-autocomplete 9.1.0 → 9.2.1

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

@@ -187,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
@@ -214,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);
   }
@@ -330,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.
@@ -342,6 +372,7 @@ var WeightedWordTrie = /*#__PURE__*/function () {
         return false;
       }
       node.sessionFreq = count;
+      this.boostedNodes.add(node);
       return true;
     }
 
@@ -357,28 +388,51 @@ 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 instead of reading an index, so nothing has to be kept in
-     * step on the write path for the sake of being able to ask.
+     * 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 _iterator5 = _createForOfIteratorHelper(prefix.toLowerCase()),
-        _step5;
+      var _iterator6 = _createForOfIteratorHelper(prefix.toLowerCase()),
+        _step6;
       try {
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-          var char = _step5.value;
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var char = _step6.value;
           var next = node.children.get(char);
           if (!next) {
             return [];
@@ -386,9 +440,9 @@ var WeightedWordTrie = /*#__PURE__*/function () {
           node = next;
         }
       } catch (err) {
-        _iterator5.e(err);
+        _iterator6.e(err);
       } finally {
-        _iterator5.f();
+        _iterator6.f();
       }
       var boosted = [];
       var stack = [node];
@@ -403,17 +457,17 @@ var WeightedWordTrie = /*#__PURE__*/function () {
             node: current
           });
         }
-        var _iterator6 = _createForOfIteratorHelper(current.children.values()),
-          _step6;
+        var _iterator7 = _createForOfIteratorHelper(current.children.values()),
+          _step7;
         try {
-          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-            var child = _step6.value;
+          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+            var child = _step7.value;
             stack.push(child);
           }
         } catch (err) {
-          _iterator6.e(err);
+          _iterator7.e(err);
         } finally {
-          _iterator6.f();
+          _iterator7.f();
         }
       }
       return boosted;
@@ -439,19 +493,19 @@ var phraseTrie = new WeightedWordTrie();
  * expects a simple array of strings: ["about", "above", "actually", ...]
  */
 export var initL3Vocabulary = function initL3Vocabulary(l3Words) {
-  var _iterator7 = _createForOfIteratorHelper(l3Words),
-    _step7;
+  var _iterator8 = _createForOfIteratorHelper(l3Words),
+    _step8;
   try {
-    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
-      var word = _step7.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) {
-    _iterator7.e(err);
+    _iterator8.e(err);
   } finally {
-    _iterator7.f();
+    _iterator8.f();
   }
   recallGeneration++;
   ctcTag('init', "L3 general English loaded: ".concat(l3Words.length, " words"));
@@ -477,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
@@ -508,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) {
@@ -532,20 +611,20 @@ var computeContextVectorLocal = function computeContextVectorLocal(textBefore) {
   var tokens = tokenize(textBefore);
   var words = tokens.slice(-CONTEXT_WORDS);
   var vectors = [];
-  var _iterator8 = _createForOfIteratorHelper(words),
-    _step8;
+  var _iterator9 = _createForOfIteratorHelper(words),
+    _step9;
   try {
-    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
-      var word = _step8.value;
+    for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+      var word = _step9.value;
       var _v = getWordVector(word);
       if (_v) {
         vectors.push(_v);
       }
     }
   } catch (err) {
-    _iterator8.e(err);
+    _iterator9.e(err);
   } finally {
-    _iterator8.f();
+    _iterator9.f();
   }
   if (vectors.length === 0) {
     return null;
@@ -578,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 _iterator9 = _createForOfIteratorHelper(text.toLowerCase().split(WHITESPACE_SPLIT_REGEX)),
-    _step9;
+  var _iterator0 = _createForOfIteratorHelper(text.toLowerCase().split(WHITESPACE_SPLIT_REGEX)),
+    _step0;
   try {
-    for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
-      var raw = _step9.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) {
@@ -590,9 +669,9 @@ var tokenize = function tokenize(text) {
       }
     }
   } catch (err) {
-    _iterator9.e(err);
+    _iterator0.e(err);
   } finally {
-    _iterator9.f();
+    _iterator0.f();
   }
   return tokens;
 };
@@ -696,11 +775,11 @@ var getPhraseCandidates = function getPhraseCandidates(trimmed) {
       window: windowPrefix,
       matches: matches.length
     });
-    var _iterator0 = _createForOfIteratorHelper(matches),
-      _step0;
+    var _iterator1 = _createForOfIteratorHelper(matches),
+      _step1;
     try {
-      for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
-        var _match = _step0.value;
+      for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
+        var _match = _step1.value;
         if (seen.has(_match.word)) {
           continue;
         }
@@ -713,9 +792,9 @@ var getPhraseCandidates = function getPhraseCandidates(trimmed) {
         });
       }
     } catch (err) {
-      _iterator0.e(err);
+      _iterator1.e(err);
     } finally {
-      _iterator0.f();
+      _iterator1.f();
     }
   }
   logPhrasePath();
@@ -760,17 +839,17 @@ export var getLastPredictionDebug = function getLastPredictionDebug() {
   return lastPredictionDebug;
 };
 export var initVocabulary = function initVocabulary(vocabulary) {
-  var _iterator1 = _createForOfIteratorHelper(vocabulary.terms),
-    _step1;
+  var _iterator10 = _createForOfIteratorHelper(vocabulary.terms),
+    _step10;
   try {
-    for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
-      var term = _step1.value;
+    for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+      var term = _step10.value;
       wordTrie.insert(term.word, term.freq, term.docFreq, term.authorFreq);
     }
   } catch (err) {
-    _iterator1.e(err);
+    _iterator10.e(err);
   } finally {
-    _iterator1.f();
+    _iterator10.f();
   }
   isInitialized = true;
   recallGeneration++;
@@ -821,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.
  *
@@ -837,20 +946,20 @@ export var ingestDocumentPage = function ingestDocumentPage(pageContent) {
   }
   var words = tokenize(pageContent);
   var validBoostedWords = new Set();
-  var _iterator10 = _createForOfIteratorHelper(words),
-    _step10;
+  var _iterator11 = _createForOfIteratorHelper(words),
+    _step11;
   try {
-    for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
-      var word = _step10.value;
+    for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+      var word = _step11.value;
       var didBoost = wordTrie.incrementSessionFreq(word);
       if (didBoost) {
         validBoostedWords.add(word);
       }
     }
   } catch (err) {
-    _iterator10.e(err);
+    _iterator11.e(err);
   } finally {
-    _iterator10.f();
+    _iterator11.f();
   }
   if (isAutocompleteDebugEnabled() && validBoostedWords.size > 0) {
     ctcTag('init', "L1 session primed ".concat(validBoostedWords.size, " words from page \xB7 __atlCtcDebug__.session() to inspect"), CTC_STYLES.brand);
@@ -868,7 +977,7 @@ export var ingestDocumentPage = function ingestDocumentPage(pageContent) {
  * 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 = 50;
+var MAX_LISTED_SESSION_WORDS = 100;
 /**
  * Read the session's L1 boosts, optionally narrowed to a prefix.
  *
@@ -879,7 +988,8 @@ var MAX_LISTED_SESSION_WORDS = 50;
  * 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.
+ * 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 : '');
@@ -942,20 +1052,20 @@ var computeCanonicalRecall = function computeCanonicalRecall(trimmed, currentWor
     var existingWords = new Set(wordCandidates.map(function (c) {
       return c.word;
     }));
-    var _iterator11 = _createForOfIteratorHelper(l3Candidates),
-      _step11;
+    var _iterator12 = _createForOfIteratorHelper(l3Candidates),
+      _step12;
     try {
-      for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
-        var l3c = _step11.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) {
-      _iterator11.e(err);
+      _iterator12.e(err);
     } finally {
-      _iterator11.f();
+      _iterator12.f();
     }
   }
 
@@ -982,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 _iterator12 = _createForOfIteratorHelper(canonicalMatched),
-    _step12;
+  var _iterator13 = _createForOfIteratorHelper(canonicalMatched),
+    _step13;
   try {
-    for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
-      var m = _step12.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) {
-    _iterator12.e(err);
+    _iterator13.e(err);
   } finally {
-    _iterator12.f();
+    _iterator13.f();
   }
   return {
     canonicalMatched: canonicalMatched,
@@ -1033,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();
@@ -1061,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;
@@ -1076,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);
@@ -1123,29 +1261,29 @@ export var predict = function predict(textBefore) {
   }))).sort();
   var familyKey = eligibleContextKeys.join("\x01");
   var primeRequests = selectBoundaryPrimeRequests(familyKey, canonicalMatched, PHRASE_MAX_WORDS);
-  var _iterator13 = _createForOfIteratorHelper(primeRequests),
-    _step13;
+  var _iterator14 = _createForOfIteratorHelper(primeRequests),
+    _step14;
   try {
-    for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
-      var request = _step13.value;
+    for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+      var request = _step14.value;
       primeBoundaryLm(request);
     }
   } catch (err) {
-    _iterator13.e(err);
+    _iterator14.e(err);
   } finally {
-    _iterator13.f();
+    _iterator14.f();
   }
   var runtimeBySurface = new Map(canonicalMatched.map(function (candidate) {
     return [candidate.word, candidate];
   }));
   var canonicalEvidence = new Map();
   var firstTokenGroups = new Map();
-  var _iterator14 = _createForOfIteratorHelper(canonicalMatched),
-    _step14;
+  var _iterator15 = _createForOfIteratorHelper(canonicalMatched),
+    _step15;
   try {
-    for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+    for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
       var _firstTokenGroups$get;
-      var _candidate = _step14.value;
+      var _candidate = _step15.value;
       if (_candidate.canonicalTokenIds === null) {
         continue;
       }
@@ -1173,28 +1311,28 @@ export var predict = function predict(textBefore) {
       firstTokenGroups.set(_candidate.contextKey, _group2);
     }
   } catch (err) {
-    _iterator14.e(err);
+    _iterator15.e(err);
   } finally {
-    _iterator14.f();
+    _iterator15.f();
   }
-  var _iterator15 = _createForOfIteratorHelper(firstTokenGroups),
-    _step15;
+  var _iterator16 = _createForOfIteratorHelper(firstTokenGroups),
+    _step16;
   try {
-    for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
-      var _step15$value = _slicedToArray(_step15.value, 2),
-        _contextKey = _step15$value[0],
-        _group3 = _step15$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 _iterator22 = _createForOfIteratorHelper(_group3),
-        _step22;
+      var _iterator23 = _createForOfIteratorHelper(_group3),
+        _step23;
       try {
-        for (_iterator22.s(); !(_step22 = _iterator22.n()).done;) {
+        for (_iterator23.s(); !(_step23 = _iterator23.n()).done;) {
           var _candidate2$canonical;
-          var _candidate2 = _step22.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) {
@@ -1202,19 +1340,19 @@ export var predict = function predict(textBefore) {
           }
         }
       } catch (err) {
-        _iterator22.e(err);
+        _iterator23.e(err);
       } finally {
-        _iterator22.f();
+        _iterator23.f();
       }
       if (!Number.isFinite(maxLogit)) {
         continue;
       }
-      var _iterator23 = _createForOfIteratorHelper(_group3),
-        _step23;
+      var _iterator24 = _createForOfIteratorHelper(_group3),
+        _step24;
       try {
-        for (_iterator23.s(); !(_step23 = _iterator23.n()).done;) {
+        for (_iterator24.s(); !(_step24 = _iterator24.n()).done;) {
           var _candidate3$canonical, _candidate3$canonical2, _candidate3$canonical3;
-          var _candidate3 = _step23.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)) {
@@ -1253,15 +1391,15 @@ export var predict = function predict(textBefore) {
           });
         }
       } catch (err) {
-        _iterator23.e(err);
+        _iterator24.e(err);
       } finally {
-        _iterator23.f();
+        _iterator24.f();
       }
     }
   } catch (err) {
-    _iterator15.e(err);
+    _iterator16.e(err);
   } finally {
-    _iterator15.f();
+    _iterator16.f();
   }
   var _rankCandidates = rankCandidates(scoringCandidates, contextVector, function (w) {
       return getWordVector(w);
@@ -1282,12 +1420,12 @@ export var predict = function predict(textBefore) {
   });
   if (canonicalScoringSupported && progressiveEligible.length > 0) {
     var byContext = new Map();
-    var _iterator16 = _createForOfIteratorHelper(progressiveEligible),
-      _step16;
+    var _iterator17 = _createForOfIteratorHelper(progressiveEligible),
+      _step17;
     try {
-      for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
+      for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
         var _byContext$get;
-        var candidate = _step16.value;
+        var candidate = _step17.value;
         var runtime = runtimeBySurface.get(candidate.word);
         if (!runtime || runtime.canonicalTokenIds === null) {
           continue;
@@ -1300,17 +1438,17 @@ export var predict = function predict(textBefore) {
         byContext.set(runtime.contextKey, group);
       }
     } catch (err) {
-      _iterator16.e(err);
+      _iterator17.e(err);
     } finally {
-      _iterator16.f();
+      _iterator17.f();
     }
-    var _iterator17 = _createForOfIteratorHelper(byContext),
-      _step17;
+    var _iterator18 = _createForOfIteratorHelper(byContext),
+      _step18;
     try {
-      for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
-        var _step17$value = _slicedToArray(_step17.value, 2),
-          contextKey = _step17$value[0],
-          _group = _step17$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,
@@ -1328,9 +1466,9 @@ export var predict = function predict(textBefore) {
         });
       }
     } catch (err) {
-      _iterator17.e(err);
+      _iterator18.e(err);
     } finally {
-      _iterator17.f();
+      _iterator18.f();
     }
   }
 
@@ -1419,12 +1557,12 @@ export var predict = function predict(textBefore) {
   var contextRequestedCount = new Map();
   var bestTotalByContext = new Map();
   var bestCandidateByContext = new Map();
-  var _iterator18 = _createForOfIteratorHelper(ranked),
-    _step18;
+  var _iterator19 = _createForOfIteratorHelper(ranked),
+    _step19;
   try {
-    for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
+    for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
       var _contextRequestedCoun2, _judged$total;
-      var _candidate4 = _step18.value;
+      var _candidate4 = _step19.value;
       var _runtime = runtimeBySurface.get(_candidate4.word);
       if (!_runtime || _runtime.canonicalTokenIds === null) {
         continue;
@@ -1463,9 +1601,9 @@ export var predict = function predict(textBefore) {
      * costs one lookup per space rather than a comparison against every member.
      */
   } catch (err) {
-    _iterator18.e(err);
+    _iterator19.e(err);
   } finally {
-    _iterator18.f();
+    _iterator19.f();
   }
   var extendsAPoolMember = function extendsAPoolMember(surface, pool) {
     for (var space = surface.indexOf(' '); space !== -1; space = surface.indexOf(' ', space + 1)) {
@@ -1500,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 _iterator19 = _createForOfIteratorHelper(contextSurfaces),
-    _step19;
+  var _iterator20 = _createForOfIteratorHelper(contextSurfaces),
+    _step20;
   try {
-    for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
-      var _step19$value = _slicedToArray(_step19.value, 2),
-        _contextKey2 = _step19$value[0],
-        _surfaces = _step19$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 _iterator24 = _createForOfIteratorHelper(_toConsumableArray(_surfaces).sort(function (a, b) {
+      var _iterator25 = _createForOfIteratorHelper(_toConsumableArray(_surfaces).sort(function (a, b) {
           return a.length - b.length;
         })),
-        _step24;
+        _step25;
       try {
-        for (_iterator24.s(); !(_step24 = _iterator24.n()).done;) {
+        for (_iterator25.s(); !(_step25 = _iterator25.n()).done;) {
           var _getProgressiveSurfac, _getProgressiveSurfac2, _runtimeBySurface$get8, _runtimeBySurface$get9;
-          var surface = _step24.value;
+          var surface = _step25.value;
           var own = optimisticTotalByWord.get(surface);
           if (own === undefined) {
             continue;
@@ -1547,9 +1685,9 @@ export var predict = function predict(textBefore) {
           }
         }
       } catch (err) {
-        _iterator24.e(err);
+        _iterator25.e(err);
       } finally {
-        _iterator24.f();
+        _iterator25.f();
       }
     }
 
@@ -1562,9 +1700,9 @@ export var predict = function predict(textBefore) {
      * depths.
      */
   } catch (err) {
-    _iterator19.e(err);
+    _iterator20.e(err);
   } finally {
-    _iterator19.f();
+    _iterator20.f();
   }
   var judgedEvidenceFor = function judgedEvidenceFor(candidate) {
     return underReadExtensions.has(candidate.word) ? null : readJudgedEvidence(candidate);
@@ -1591,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 _iterator20 = _createForOfIteratorHelper(contextSurfaces),
-    _step20;
+  var _iterator21 = _createForOfIteratorHelper(contextSurfaces),
+    _step21;
   try {
-    for (_iterator20.s(); !(_step20 = _iterator20.n()).done;) {
-      var _step20$value = _slicedToArray(_step20.value, 2),
-        _contextKey3 = _step20$value[0],
-        _surfaces2 = _step20$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 _iterator25 = _createForOfIteratorHelper(_surfaces2),
-        _step25;
+      var _iterator26 = _createForOfIteratorHelper(_surfaces2),
+        _step26;
       try {
-        for (_iterator25.s(); !(_step25 = _iterator25.n()).done;) {
-          var _surface = _step25.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);
@@ -1613,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) {
-        _iterator25.e(err);
+        _iterator26.e(err);
       } finally {
-        _iterator25.f();
+        _iterator26.f();
       }
       logSumExpByContext.set(_contextKey3, logSumExp(minimalTotals));
     }
@@ -1627,9 +1765,9 @@ export var predict = function predict(textBefore) {
      * eventual posterior, or a verified total for the posterior itself.
      */
   } catch (err) {
-    _iterator20.e(err);
+    _iterator21.e(err);
   } finally {
-    _iterator20.f();
+    _iterator21.f();
   }
   var posteriorFor = function posteriorFor(candidate, total) {
     var runtime = runtimeBySurface.get(candidate.word);
@@ -1919,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
@@ -1974,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',
@@ -2068,17 +2215,17 @@ export var predict = function predict(textBefore) {
       bigram: 0,
       phrase: 0
     };
-    var _iterator21 = _createForOfIteratorHelper(canonicalMatched),
-      _step21;
+    var _iterator22 = _createForOfIteratorHelper(canonicalMatched),
+      _step22;
     try {
-      for (_iterator21.s(); !(_step21 = _iterator21.n()).done;) {
-        var m = _step21.value;
+      for (_iterator22.s(); !(_step22 = _iterator22.n()).done;) {
+        var m = _step22.value;
         genByType[m.node.termType] += 1;
       }
     } catch (err) {
-      _iterator21.e(err);
+      _iterator22.e(err);
     } finally {
-      _iterator21.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' : ''));