@atlaskit/editor-plugin-autocomplete 9.0.0 → 9.1.0

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

@@ -511,7 +511,63 @@ export const createAutocompletePlugin = (options, api) => {
   // Set when the plugin is torn down so in-flight getContext() resolutions don't
   // mutate the global text-predictor state after destruction.
   let destroyed = false;
-  const ingestedContextTexts = new Set();
+  // L1 ingestion cannot run before the vocabulary has loaded: `incrementSessionFreq`
+  // only touches trie nodes that already exist, so an empty trie silently rejects
+  // every word. Text that arrives first — which a page usually does, since the
+  // chat resolves it on focus in the same tick as the load starts — is held here
+  // and applied once the load has settled.
+  const pendingSessionContextTexts = new Set();
+  const sessionIngestedContextTexts = new Set();
+  let isVocabularyReady = false;
+  let vocabularyLoadPromise;
+  const addBoundedContextText = (texts, text) => {
+    texts.add(text);
+    // Evict oldest entries (Set preserves insertion order) to bound memory.
+    while (texts.size > MAX_INGESTED_CONTEXT_TEXTS) {
+      const oldest = texts.values().next().value;
+      if (oldest === undefined) {
+        break;
+      }
+      texts.delete(oldest);
+    }
+  };
+  const flushPendingSessionContext = () => {
+    if (!isVocabularyReady || destroyed) {
+      return;
+    }
+    for (const text of pendingSessionContextTexts) {
+      if (!sessionIngestedContextTexts.has(text)) {
+        ingestDocumentPage(text);
+        addBoundedContextText(sessionIngestedContextTexts, text);
+      }
+      pendingSessionContextTexts.delete(text);
+    }
+  };
+  const ensureVocabularyReady = () => {
+    var _options$useLocalMode;
+    if (isVocabularyReady) {
+      flushPendingSessionContext();
+      return Promise.resolve();
+    }
+    vocabularyLoadPromise ??= loadDefaultVocabulary({
+      isLocalLLM: (_options$useLocalMode = options === null || options === void 0 ? void 0 : options.useLocalModel) !== null && _options$useLocalMode !== void 0 ? _options$useLocalMode : false,
+      surface
+    }).then(() => {
+      if (destroyed) {
+        return;
+      }
+      isVocabularyReady = true;
+      flushPendingSessionContext();
+    }).catch(error => {
+      // Do not consume the pending text on failure. A later focus retries the
+      // load and can still apply the original context exactly once.
+      vocabularyLoadPromise = undefined;
+      logException(error, {
+        location: 'editor-plugin-autocomplete/loadDefaultVocabulary'
+      });
+    });
+    return vocabularyLoadPromise;
+  };
   const logContextResolved = (source, context) => {
     var _context$parentCommen, _context$siblingComme4, _context$siblingComme5;
     if (!isAutocompleteDebugEnabled()) {
@@ -539,19 +595,10 @@ export const createAutocompletePlugin = (options, api) => {
       ...definedContext
     };
     const ingestContextText = text => {
-      if (!text || ingestedContextTexts.has(text)) {
+      if (!text || sessionIngestedContextTexts.has(text)) {
         return;
       }
-      ingestedContextTexts.add(text);
-      // Evict oldest entries (Set preserves insertion order) to bound memory.
-      while (ingestedContextTexts.size > MAX_INGESTED_CONTEXT_TEXTS) {
-        const oldest = ingestedContextTexts.values().next().value;
-        if (oldest === undefined) {
-          break;
-        }
-        ingestedContextTexts.delete(oldest);
-      }
-      ingestDocumentPage(text);
+      addBoundedContextText(pendingSessionContextTexts, text);
     };
     ingestContextText(context.fullPageContent);
     ingestContextText(context.parentCommentContent);
@@ -559,6 +606,7 @@ export const createAutocompletePlugin = (options, api) => {
       var _context$siblingComme6;
       ingestContextText(siblingCommentContent);
     }
+    flushPendingSessionContext();
 
     // Context arrived after word boundaries may already have fired. Re-send
     // slow-lane context immediately so the next inference includes the thread.
@@ -962,18 +1010,11 @@ export const createAutocompletePlugin = (options, api) => {
           return accepted;
         },
         focus: () => {
-          var _options$useLocalMode, _options$useLocalMode2, _options$useLocalMode3;
+          var _options$useLocalMode2, _options$useLocalMode3;
           if (!isAutocompleteEnabled) {
             return false;
           }
-          loadDefaultVocabulary({
-            isLocalLLM: (_options$useLocalMode = options === null || options === void 0 ? void 0 : options.useLocalModel) !== null && _options$useLocalMode !== void 0 ? _options$useLocalMode : false,
-            surface
-          }).catch(error => {
-            logException(error, {
-              location: 'editor-plugin-autocomplete/loadDefaultVocabulary'
-            });
-          });
+          void ensureVocabularyReady();
           loadVectorsAsync({
             isLocalLLM: (_options$useLocalMode2 = options === null || options === void 0 ? void 0 : options.useLocalModel) !== null && _options$useLocalMode2 !== void 0 ? _options$useLocalMode2 : false,
             surface
@@ -1071,7 +1112,8 @@ export const createAutocompletePlugin = (options, api) => {
           if (hasDestroy(slowLaneClient)) {
             slowLaneClient.destroy();
           }
-          ingestedContextTexts.clear();
+          pendingSessionContextTexts.clear();
+          sessionIngestedContextTexts.clear();
         }
       };
     }

package/dist/es2019/pm-plugins/debug-mode.js

@@ -89,7 +89,7 @@ const printLegend = verbose => {
   // eslint-disable-next-line no-console
   console.log('%cPlanes%c    [CTC:init] loads · [CTC:signal] semantic/network · [CTC:model] primes/exact · [CTC:model-cost] prefill/decode · [CTC:readiness] deadline progress', CTC_STYLES.section, CTC_STYLES.body);
   // eslint-disable-next-line no-console
-  console.log('%cInspect%c   __atlCtcDebug__.enable("verbose") · .disable()', CTC_STYLES.section, CTC_STYLES.body);
+  console.log('%cInspect%c   __atlCtcDebug__.enable("verbose") · .disable() · .session() (L1 boosts, narrow to a family with .session("poll"))', CTC_STYLES.section, CTC_STYLES.body);
   // eslint-disable-next-line no-console
   console.groupEnd();
 };
@@ -133,5 +133,20 @@ export const isAutocompleteDebugVerbose = () => {
   return (_getDebugApi$isVerbos = (_getDebugApi2 = getDebugApi()) === null || _getDebugApi2 === void 0 ? void 0 : _getDebugApi2.isVerbose()) !== null && _getDebugApi$isVerbos !== void 0 ? _getDebugApi$isVerbos : false;
 };
 
+/**
+ * Hang the L1 session-boost snapshot off the console API.
+ *
+ * Unlike the log helpers this is available whether or not debug is enabled:
+ * inspecting state on demand is not logging, and asking someone to turn on
+ * logging and retype to find out what the session already holds defeats the
+ * point of being able to ask.
+ */
+export const registerCtcSessionInspector = inspect => {
+  const api = getDebugApi();
+  if (api) {
+    api.session = inspect;
+  }
+};
+
 // Eagerly install so the console API is available on load, regardless of call order.
 getDebugApi();

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

@@ -13,14 +13,17 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
  * 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';
 
@@ -298,6 +301,44 @@ class WeightedWordTrie {
     node.sessionFreq += 1;
     return true;
   }
+
+  /**
+   * 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.
+   */
+  collectSessionBoosted(prefix = '') {
+    let node = this.root;
+    for (const char of prefix.toLowerCase()) {
+      const next = node.children.get(char);
+      if (!next) {
+        return [];
+      }
+      node = next;
+    }
+    const boosted = [];
+    const stack = [node];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (!current) {
+        continue;
+      }
+      if (current.word !== null && current.sessionFreq > 0) {
+        boosted.push({
+          word: current.word,
+          node: current
+        });
+      }
+      for (const child of current.children.values()) {
+        stack.push(child);
+      }
+    }
+    return boosted;
+  }
 }
 
 // L1/L2 Trie (Session + Atlassian Domain)
@@ -672,7 +713,7 @@ export const ingestDocumentPage = pageContent => {
     }
   }
   if (isAutocompleteDebugEnabled() && validBoostedWords.size > 0) {
-    ctcTag('init', `L1 session primed ${validBoostedWords.size} words from page`, CTC_STYLES.brand);
+    ctcTag('init', `L1 session primed ${validBoostedWords.size} words from page · __atlCtcDebug__.session() to inspect`, CTC_STYLES.brand);
     if (isAutocompleteDebugVerbose()) {
       // eslint-disable-next-line no-console
       console.dir(Array.from(validBoostedWords).sort());
@@ -680,6 +721,53 @@ export const 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.
+ */
+const MAX_LISTED_SESSION_WORDS = 50;
+/**
+ * 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.
+ */
+export const inspectSessionBoosts = prefix => {
+  const boosted = wordTrie.collectSessionBoosted(prefix !== null && prefix !== void 0 ? prefix : '');
+  return {
+    boosted: boosted.length,
+    limit: MAX_LISTED_SESSION_WORDS,
+    ...(prefix === undefined ? {} : {
+      prefix
+    }),
+    words: boosted.sort((a, b) => b.node.sessionFreq - a.node.sessionFreq || a.word.localeCompare(b.word, 'en', {
+      numeric: true,
+      sensitivity: 'base'
+    })).slice(0, MAX_LISTED_SESSION_WORDS).map(({
+      node,
+      word
+    }) => ({
+      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.

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

@@ -509,7 +509,72 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
   // Set when the plugin is torn down so in-flight getContext() resolutions don't
   // mutate the global text-predictor state after destruction.
   var destroyed = false;
-  var ingestedContextTexts = new Set();
+  // L1 ingestion cannot run before the vocabulary has loaded: `incrementSessionFreq`
+  // only touches trie nodes that already exist, so an empty trie silently rejects
+  // every word. Text that arrives first — which a page usually does, since the
+  // chat resolves it on focus in the same tick as the load starts — is held here
+  // and applied once the load has settled.
+  var pendingSessionContextTexts = new Set();
+  var sessionIngestedContextTexts = new Set();
+  var isVocabularyReady = false;
+  var vocabularyLoadPromise;
+  var addBoundedContextText = function addBoundedContextText(texts, text) {
+    texts.add(text);
+    // Evict oldest entries (Set preserves insertion order) to bound memory.
+    while (texts.size > MAX_INGESTED_CONTEXT_TEXTS) {
+      var oldest = texts.values().next().value;
+      if (oldest === undefined) {
+        break;
+      }
+      texts.delete(oldest);
+    }
+  };
+  var flushPendingSessionContext = function flushPendingSessionContext() {
+    if (!isVocabularyReady || destroyed) {
+      return;
+    }
+    var _iterator = _createForOfIteratorHelper(pendingSessionContextTexts),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var text = _step.value;
+        if (!sessionIngestedContextTexts.has(text)) {
+          ingestDocumentPage(text);
+          addBoundedContextText(sessionIngestedContextTexts, text);
+        }
+        pendingSessionContextTexts.delete(text);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  };
+  var ensureVocabularyReady = function ensureVocabularyReady() {
+    var _options$useLocalMode;
+    if (isVocabularyReady) {
+      flushPendingSessionContext();
+      return Promise.resolve();
+    }
+    vocabularyLoadPromise !== null && vocabularyLoadPromise !== void 0 ? vocabularyLoadPromise : vocabularyLoadPromise = loadDefaultVocabulary({
+      isLocalLLM: (_options$useLocalMode = options === null || options === void 0 ? void 0 : options.useLocalModel) !== null && _options$useLocalMode !== void 0 ? _options$useLocalMode : false,
+      surface: surface
+    }).then(function () {
+      if (destroyed) {
+        return;
+      }
+      isVocabularyReady = true;
+      flushPendingSessionContext();
+    }).catch(function (error) {
+      // Do not consume the pending text on failure. A later focus retries the
+      // load and can still apply the original context exactly once.
+      vocabularyLoadPromise = undefined;
+      logException(error, {
+        location: 'editor-plugin-autocomplete/loadDefaultVocabulary'
+      });
+    });
+    return vocabularyLoadPromise;
+  };
   var logContextResolved = function logContextResolved(source, context) {
     var _context$parentCommen, _context$siblingComme4, _context$siblingComme5;
     if (!isAutocompleteDebugEnabled()) {
@@ -539,37 +604,29 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
     }));
     resolvedContext = _objectSpread(_objectSpread({}, resolvedContext), definedContext);
     var ingestContextText = function ingestContextText(text) {
-      if (!text || ingestedContextTexts.has(text)) {
+      if (!text || sessionIngestedContextTexts.has(text)) {
         return;
       }
-      ingestedContextTexts.add(text);
-      // Evict oldest entries (Set preserves insertion order) to bound memory.
-      while (ingestedContextTexts.size > MAX_INGESTED_CONTEXT_TEXTS) {
-        var oldest = ingestedContextTexts.values().next().value;
-        if (oldest === undefined) {
-          break;
-        }
-        ingestedContextTexts.delete(oldest);
-      }
-      ingestDocumentPage(text);
+      addBoundedContextText(pendingSessionContextTexts, text);
     };
     ingestContextText(context.fullPageContent);
     ingestContextText(context.parentCommentContent);
-    var _iterator = _createForOfIteratorHelper((_context$siblingComme6 = context.siblingCommentsContents) !== null && _context$siblingComme6 !== void 0 ? _context$siblingComme6 : []),
-      _step;
+    var _iterator2 = _createForOfIteratorHelper((_context$siblingComme6 = context.siblingCommentsContents) !== null && _context$siblingComme6 !== void 0 ? _context$siblingComme6 : []),
+      _step2;
     try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var siblingCommentContent = _step.value;
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var siblingCommentContent = _step2.value;
         ingestContextText(siblingCommentContent);
       }
-
-      // Context arrived after word boundaries may already have fired. Re-send
-      // slow-lane context immediately so the next inference includes the thread.
     } catch (err) {
-      _iterator.e(err);
+      _iterator2.e(err);
     } finally {
-      _iterator.f();
+      _iterator2.f();
     }
+    flushPendingSessionContext();
+
+    // Context arrived after word boundaries may already have fired. Re-send
+    // slow-lane context immediately so the next inference includes the thread.
     if (currentView) {
       slowLaneClient.updateContext(buildSlowLaneText(currentView.state.doc.textContent, resolvedContext));
     }
@@ -960,18 +1017,11 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
           return accepted;
         },
         focus: function focus() {
-          var _options$useLocalMode, _options$useLocalMode2, _options$useLocalMode3;
+          var _options$useLocalMode2, _options$useLocalMode3;
           if (!isAutocompleteEnabled) {
             return false;
           }
-          loadDefaultVocabulary({
-            isLocalLLM: (_options$useLocalMode = options === null || options === void 0 ? void 0 : options.useLocalModel) !== null && _options$useLocalMode !== void 0 ? _options$useLocalMode : false,
-            surface: surface
-          }).catch(function (error) {
-            logException(error, {
-              location: 'editor-plugin-autocomplete/loadDefaultVocabulary'
-            });
-          });
+          void ensureVocabularyReady();
           loadVectorsAsync({
             isLocalLLM: (_options$useLocalMode2 = options === null || options === void 0 ? void 0 : options.useLocalModel) !== null && _options$useLocalMode2 !== void 0 ? _options$useLocalMode2 : false,
             surface: surface
@@ -1069,7 +1119,8 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
           if (hasDestroy(slowLaneClient)) {
             slowLaneClient.destroy();
           }
-          ingestedContextTexts.clear();
+          pendingSessionContextTexts.clear();
+          sessionIngestedContextTexts.clear();
         }
       };
     }

package/dist/esm/pm-plugins/debug-mode.js

@@ -90,7 +90,7 @@ var printLegend = function printLegend(verbose) {
   // eslint-disable-next-line no-console
   console.log('%cPlanes%c    [CTC:init] loads · [CTC:signal] semantic/network · [CTC:model] primes/exact · [CTC:model-cost] prefill/decode · [CTC:readiness] deadline progress', CTC_STYLES.section, CTC_STYLES.body);
   // eslint-disable-next-line no-console
-  console.log('%cInspect%c   __atlCtcDebug__.enable("verbose") · .disable()', CTC_STYLES.section, CTC_STYLES.body);
+  console.log('%cInspect%c   __atlCtcDebug__.enable("verbose") · .disable() · .session() (L1 boosts, narrow to a family with .session("poll"))', CTC_STYLES.section, CTC_STYLES.body);
   // eslint-disable-next-line no-console
   console.groupEnd();
 };
@@ -138,5 +138,20 @@ export var isAutocompleteDebugVerbose = function isAutocompleteDebugVerbose() {
   return (_getDebugApi$isVerbos = (_getDebugApi2 = getDebugApi()) === null || _getDebugApi2 === void 0 ? void 0 : _getDebugApi2.isVerbose()) !== null && _getDebugApi$isVerbos !== void 0 ? _getDebugApi$isVerbos : false;
 };
 
+/**
+ * Hang the L1 session-boost snapshot off the console API.
+ *
+ * Unlike the log helpers this is available whether or not debug is enabled:
+ * inspecting state on demand is not logging, and asking someone to turn on
+ * logging and retype to find out what the session already holds defeats the
+ * point of being able to ask.
+ */
+export var registerCtcSessionInspector = function registerCtcSessionInspector(inspect) {
+  var api = getDebugApi();
+  if (api) {
+    api.session = inspect;
+  }
+};
+
 // Eagerly install so the console API is available on load, regardless of call order.
 getDebugApi();