@atlaskit/editor-plugin-autocomplete 8.0.0 → 9.1.0

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

@@ -4,14 +4,15 @@ import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 import { keydownHandler } from '@atlaskit/editor-prosemirror/keymap';
 import { PluginKey } from '@atlaskit/editor-prosemirror/state';
 import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
-import { isAutocompleteDebugEnabled } from './debug-mode';
+import { CTC_STYLES, ctcTag, isAutocompleteDebugEnabled, isAutocompleteDebugVerbose } from './debug-mode';
 import { createGhostTextDecorationSet } from './ghost-text-decoration';
 import { createLocalSlowLaneClient } from './local-slow-lane-client';
 import { loadGrammarDataAsync } from './scoring-pipeline';
-import { createSlowLaneClient, setDefaultSlowLaneClient, isWordBoundary } from './slow-lane-client';
-import { predict, loadDefaultVocabulary, loadVectorsAsync, incrementSessionFreq, ingestDocumentPage } from './text-predictor';
+import { clearDefaultSlowLaneClient, createSlowLaneClient, getDefaultSlowLaneClientStatus, isWordBoundary, setDefaultSlowLaneClient } from './slow-lane-client';
+import { predict, loadDefaultVocabulary, loadVectorsAsync, incrementSessionFreq, ingestDocumentPage, getLastPredictionDebug, noteSuggestionAccepted } from './text-predictor';
 export const autocompletePluginKey = new PluginKey('autocomplete');
-const DEBOUNCE_MS = 150;
+const PREDICTION_COALESCE_MS = 0;
+const GHOST_DECISION_BUDGET_MS = 100;
 const NETWORK_SLOW_LANE_DEBOUNCE_MS = 300;
 const LOCAL_SLOW_LANE_DEBOUNCE_MS = 100;
 const CONTEXT_REFRESH_THROTTLE_MS = 1000;
@@ -26,18 +27,82 @@ const MAX_INGESTED_CONTEXT_TEXTS = 50;
 // on every word boundary for the plugin's lifetime.
 const MAX_CONTEXT_REFRESH_ATTEMPTS = 5;
 const INLINE_LEAF_TEXT = ' ';
+let slowLaneClientInstanceSequence = 0;
 
-// eslint-disable-next-line require-unicode-regexp
-const TRAILING_NON_BOUNDARY_TOKEN_REGEX = /([^\s.,;:!?]*)$/;
 // eslint-disable-next-line require-unicode-regexp
 const WORD_BOUNDARY_CHARS_REGEX = /[\s.,;:!?]/;
+const TRAILING_SURFACE_PREFIX_REGEX = /[\p{L}\p{N}_'-]+$/u;
 const hasDestroy = client => 'destroy' in client && typeof client.destroy === 'function';
 const createInitialState = () => ({
   ghostText: '',
   ghostPosition: -1,
-  decorationSet: DecorationSet.empty
+  decorationSet: DecorationSet.empty,
+  suggestion: null
+});
+const clearGhostState = pluginState => ({
+  ...pluginState,
+  ghostText: '',
+  ghostPosition: -1,
+  decorationSet: DecorationSet.empty,
+  suggestion: null
 });
 
+/**
+ * Keep a displayed ghost alive when the user types the character it already
+ * predicted.
+ *
+ * Clearing on every document change throws away a suggestion the keystroke just
+ * confirmed, and the replacement decision has to re-earn it from an empty state
+ * inside the budget — which it often misses, so the ghost blinks out mid-word.
+ * It is worse for multi-word surfaces: typing the space in `machine learning`
+ * empties the current word, and the display gate refuses to show anything again
+ * until three characters of `learning` exist.
+ *
+ * A confirming keystroke is not new information about the prediction, so the
+ * ghost simply advances by one character and the still-running decision is free
+ * to replace it with something better. Anything else — a different character,
+ * a paste, a deletion, an edit elsewhere — clears as before.
+ */
+const advanceGhostThroughTypedCharacter = (tr, pluginState) => {
+  const {
+    ghostPosition,
+    ghostText,
+    suggestion
+  } = pluginState;
+  if (ghostText.length < 2 || ghostPosition < 0 || !suggestion) {
+    // A one-character tail leaves nothing to show after advancing.
+    return null;
+  }
+
+  // Exactly one character longer, with the cursor sitting just past the ghost
+  // anchor: together these identify a single insertion made at the anchor
+  // rather than a paste or an edit elsewhere in the document.
+  if (tr.doc.content.size - tr.before.content.size !== 1) {
+    return null;
+  }
+  if (!tr.selection.empty || tr.selection.from !== ghostPosition + 1) {
+    return null;
+  }
+  if (tr.doc.textBetween(ghostPosition, ghostPosition + 1) !== ghostText[0]) {
+    return null;
+  }
+  const remaining = ghostText.slice(1);
+  const nextPosition = ghostPosition + 1;
+  return {
+    ...pluginState,
+    ghostText: remaining,
+    ghostPosition: nextPosition,
+    decorationSet: createGhostTextDecorationSet(tr.doc, nextPosition, remaining),
+    // `surface` stays the full candidate so cooldown and analytics still
+    // describe the suggestion that was originally committed.
+    suggestion: {
+      ...suggestion,
+      ghostText: remaining,
+      position: nextPosition
+    }
+  };
+};
+
 /**
  * Extract text content before the cursor from the current document.
  * Returns the last ~200 characters for context.
@@ -70,6 +135,10 @@ const getTextBeforeCursor = state => {
   }
   return fullText.slice(-maxChars);
 };
+const getTrailingSurfacePrefixLength = text => {
+  var _text$trimEnd$match$, _text$trimEnd$match;
+  return (_text$trimEnd$match$ = (_text$trimEnd$match = text.trimEnd().match(TRAILING_SURFACE_PREFIX_REGEX)) === null || _text$trimEnd$match === void 0 ? void 0 : _text$trimEnd$match[0].length) !== null && _text$trimEnd$match$ !== void 0 ? _text$trimEnd$match$ : 0;
+};
 
 /**
  * Set the autocomplete state via a transaction metadata.
@@ -82,23 +151,41 @@ const setAutocompleteMeta = (tr, meta) => {
  * Apply a ghost text suggestion to the editor state.
  */
 let lastShownGhostText = '';
-const showGhostText = (view, text, position) => {
+const showGhostText = (view, prediction, position, revision, decisionStartedAt) => {
   try {
     const {
       state,
       dispatch
     } = view;
-    const decorationSet = createGhostTextDecorationSet(state, position, text);
+    const suggestion = {
+      decisionLatencyMs: performance.now() - decisionStartedAt,
+      evidenceTier: prediction.evidenceTier,
+      ghostText: prediction.text,
+      meanTokenLogProbability: prediction.meanTokenLogProbability,
+      poolHeldExtension: prediction.poolHeldExtension,
+      position,
+      posterior: prediction.posterior,
+      rankScore: prediction.rankScore,
+      revision,
+      shortlistSize: prediction.shortlistSize,
+      surface: prediction.surface,
+      termType: prediction.termType,
+      winnerMargin: prediction.winnerMargin
+    };
+    const decorationSet = createGhostTextDecorationSet(state.doc, position, prediction.text);
     const tr = setAutocompleteMeta(state.tr, {
-      ghostText: text,
+      ghostText: prediction.text,
       ghostPosition: position,
-      decorationSet
+      decorationSet,
+      suggestion
     });
     dispatch(tr);
+    return suggestion;
   } catch (error) {
     logException(error, {
       location: 'editor-plugin-autocomplete/showGhostText'
     });
+    return null;
   }
 };
 
@@ -115,7 +202,8 @@ const clearGhostText = (state, dispatch) => {
       const tr = setAutocompleteMeta(state.tr, {
         ghostText: '',
         ghostPosition: -1,
-        decorationSet: DecorationSet.empty
+        decorationSet: DecorationSet.empty,
+        suggestion: null
       });
       dispatch(tr);
     } catch (error) {
@@ -133,40 +221,43 @@ const clearGhostText = (state, dispatch) => {
  */
 const acceptGhostText = (state, dispatch) => {
   const pluginState = autocompletePluginKey.getState(state);
-  if (!pluginState || !pluginState.ghostText) {
-    return false;
+  if (!(pluginState !== null && pluginState !== void 0 && pluginState.suggestion) || !pluginState.ghostText) {
+    return null;
   }
   if (dispatch) {
     try {
       const {
         ghostText,
-        ghostPosition
+        ghostPosition,
+        suggestion
       } = pluginState;
       let tr = state.tr.insertText(ghostText, ghostPosition);
       tr = setAutocompleteMeta(tr, {
         ghostText: '',
         ghostPosition: -1,
-        decorationSet: DecorationSet.empty
+        decorationSet: DecorationSet.empty,
+        suggestion: null
       });
       dispatch(tr);
+      return suggestion;
     } catch (error) {
       logException(error, {
         location: 'editor-plugin-autocomplete/acceptGhostText'
       });
-      return false;
+      return null;
     }
   }
-  return true;
+  return pluginState.suggestion;
 };
 const acceptGhostTextWithAnalytics = (state, dispatch, onAccepted) => {
-  var _pluginState$ghostTex;
-  const pluginState = autocompletePluginKey.getState(state);
-  const ghostText = (_pluginState$ghostTex = pluginState === null || pluginState === void 0 ? void 0 : pluginState.ghostText) !== null && _pluginState$ghostTex !== void 0 ? _pluginState$ghostTex : '';
-  const accepted = acceptGhostText(state, dispatch);
-  if (accepted) {
-    onAccepted(ghostText);
+  const acceptedSuggestion = acceptGhostText(state, dispatch);
+  if (acceptedSuggestion) {
+    // Start the post-accept cooldown so the just-accepted unit isn't immediately
+    // re-offered (QI-2 echo, e.g. `end to end` → `end to end to end`).
+    noteSuggestionAccepted(acceptedSuggestion.surface);
+    onAccepted(acceptedSuggestion);
   }
-  return accepted;
+  return acceptedSuggestion !== null;
 };
 
 /**
@@ -228,14 +319,6 @@ const getLeadingTextCharacter = text => {
   }
   return String.fromCodePoint(firstCodePoint);
 };
-const getTypedLengthForPrediction = textBefore => {
-  var _textBefore$match$, _textBefore$match;
-  if (isWordBoundary(textBefore)) {
-    return 0;
-  }
-  const trailingToken = (_textBefore$match$ = (_textBefore$match = textBefore.match(TRAILING_NON_BOUNDARY_TOKEN_REGEX)) === null || _textBefore$match === void 0 ? void 0 : _textBefore$match[1]) !== null && _textBefore$match$ !== void 0 ? _textBefore$match$ : '';
-  return trailingToken.length;
-};
 const isEnglishLocale = locale => {
   if (!locale) {
     return false;
@@ -243,11 +326,12 @@ const isEnglishLocale = locale => {
   return locale.toLowerCase().startsWith('en');
 };
 export const createAutocompletePlugin = (options, api) => {
-  var _options$surface, _options$locale;
+  var _options$surface, _options$locale, _registeredSlowLaneSt;
   const surface = (_options$surface = options === null || options === void 0 ? void 0 : options.surface) !== null && _options$surface !== void 0 ? _options$surface : 'editor';
   const locale = (_options$locale = options === null || options === void 0 ? void 0 : options.locale) !== null && _options$locale !== void 0 ? _options$locale : typeof navigator !== 'undefined' ? navigator.language : undefined;
   const isAutocompleteEnabled = isEnglishLocale(locale);
   let debounceTimer = null;
+  let decisionDeadlineTimer = null;
   let hasIngestedPage = false;
   let resolvedContext;
   /**
@@ -257,6 +341,10 @@ export const createAutocompletePlugin = (options, api) => {
    */
   let currentView = null;
   let unsubscribeFromContextUpdates;
+  // "Prime, don't ask-and-read": semantic, Tier-A, and Tier-B results land
+  // asynchronously, often with no following keystroke. Re-run prediction when
+  // they arrive so the caches are consumed immediately.
+  let reschedulePredictionOnSlowLaneResult = null;
   /**
    * Set after accepting a suggestion so the next doc-change update
    * skips scheduling a new prediction for the just-inserted text.
@@ -270,8 +358,8 @@ export const createAutocompletePlugin = (options, api) => {
    * re-showing the same suggestion. Resets to null as soon as the text changes.
    */
   let dismissedContext = null;
-  let lastSuggestionTypedLength = 0;
-  let lastSuggestionLength = 0;
+  let decisionRevision = 0;
+  let activeDecision;
 
   /**
    * cold  → no slow-lane vector received yet; frequency-only trie scoring
@@ -338,10 +426,10 @@ export const createAutocompletePlugin = (options, api) => {
       }
     });
   };
-  const fireSuggestionInsertedAnalytics = ghostText => {
+  const fireSuggestionInsertedAnalytics = suggestion => {
     var _api$analytics4;
-    const typedLength = lastSuggestionTypedLength;
-    const suggestionLength = lastSuggestionLength || typedLength + ghostText.length;
+    const typedLength = Math.max(0, suggestion.surface.length - suggestion.ghostText.length);
+    const suggestionLength = suggestion.surface.length;
     const kssDelta = suggestionLength - typedLength;
     api === null || api === void 0 ? void 0 : (_api$analytics4 = api.analytics) === null || _api$analytics4 === void 0 ? void 0 : _api$analytics4.actions.fireAnalyticsEvent({
       action: ACTION.SUGGESTION_INSERTED,
@@ -360,13 +448,61 @@ export const createAutocompletePlugin = (options, api) => {
     debounceMs: LOCAL_SLOW_LANE_DEBOUNCE_MS,
     onLoadSuccess: fireLocalModelLoadedAnalytics,
     onLoadError: fireLocalModelLoadFailedAnalytics,
+    // Re-run prediction for each independently scheduled model result.
+    onUpdate: () => {
+      var _reschedulePrediction;
+      return (_reschedulePrediction = reschedulePredictionOnSlowLaneResult) === null || _reschedulePrediction === void 0 ? void 0 : _reschedulePrediction({
+        kind: 'semantic'
+      });
+    },
+    onBoundaryLmUpdate: ({
+      contextKey,
+      familyKey,
+      latencyMs
+    }) => {
+      var _reschedulePrediction2;
+      return (_reschedulePrediction2 = reschedulePredictionOnSlowLaneResult) === null || _reschedulePrediction2 === void 0 ? void 0 : _reschedulePrediction2({
+        contextKey,
+        familyKey,
+        kind: 'boundary',
+        latencyMs
+      });
+    },
+    onSurfaceScoreUpdate: ({
+      contextKey,
+      familyKey,
+      latencyMs
+    }) => {
+      var _reschedulePrediction3;
+      return (_reschedulePrediction3 = reschedulePredictionOnSlowLaneResult) === null || _reschedulePrediction3 === void 0 ? void 0 : _reschedulePrediction3({
+        contextKey,
+        familyKey,
+        kind: 'surface',
+        latencyMs
+      });
+    },
     surface
   }) : createSlowLaneClient({
     baseUrl: '',
     debounceMs: NETWORK_SLOW_LANE_DEBOUNCE_MS,
+    // Re-run prediction when the BE semantic vector / LM logits land so
+    // warm-mode unigram ranking applies without waiting for a keystroke.
+    onUpdate: () => {
+      var _reschedulePrediction4;
+      return (_reschedulePrediction4 = reschedulePredictionOnSlowLaneResult) === null || _reschedulePrediction4 === void 0 ? void 0 : _reschedulePrediction4({
+        kind: 'semantic'
+      });
+    },
     surface
   });
-  setDefaultSlowLaneClient(slowLaneClient);
+  const slowLaneClientKind = options !== null && options !== void 0 && options.useLocalModel ? 'localLlm' : 'server';
+  const slowLaneClientId = `${surface}:${slowLaneClientKind}:${++slowLaneClientInstanceSequence}`;
+  setDefaultSlowLaneClient(slowLaneClient, {
+    clientId: slowLaneClientId,
+    kind: slowLaneClientKind
+  });
+  const registeredSlowLaneStatus = getDefaultSlowLaneClientStatus();
+  ctcTag('init', `slow lane registered · id=${slowLaneClientId} · selected=${slowLaneClientKind} · canonical=${registeredSlowLaneStatus.canonicalScoringSupported ? 'yes' : 'no'} · ready=${(_registeredSlowLaneSt = registeredSlowLaneStatus.localModelReady) !== null && _registeredSlowLaneSt !== void 0 ? _registeredSlowLaneSt : 'n/a'}`, slowLaneClientKind === 'localLlm' ? CTC_STYLES.good : CTC_STYLES.warn);
   let contextRequestInFlight = false;
   let lastContextRefreshAt = 0;
   // Bounds the word-boundary retry loop so it terminates even when the editor is
@@ -375,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()) {
@@ -383,7 +575,7 @@ export const createAutocompletePlugin = (options, api) => {
     }
 
     // eslint-disable-next-line no-console
-    console.log('%c[Autocomplete] %cgetContext resolved', 'color: #00b8d9; font-weight: bold;', 'color: inherit;', {
+    console.log('%c[CTC:signal]%c getContext resolved', CTC_STYLES.brand, CTC_STYLES.body, {
       source,
       hasParentComment: !!(context !== null && context !== void 0 && context.parentCommentContent),
       parentCommentPreview: context === null || context === void 0 ? void 0 : (_context$parentCommen = context.parentCommentContent) === null || _context$parentCommen === void 0 ? void 0 : _context$parentCommen.slice(0, 80),
@@ -403,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);
@@ -423,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.
@@ -470,77 +654,239 @@ export const createAutocompletePlugin = (options, api) => {
     });
     return true;
   };
-
-  /**
-   * Schedule a prediction after a short debounce.
-   * Tier 1 predictions are synchronous (<0.1ms) but we still debounce
-   * to avoid unnecessary work on rapid keystrokes.
-   */
-  const schedulePrediction = view => {
+  const clearDecisionTimers = () => {
     if (debounceTimer) {
       clearTimeout(debounceTimer);
+      debounceTimer = null;
     }
-    debounceTimer = setTimeout(() => {
-      try {
-        const {
-          state
-        } = view;
-        const {
-          selection
-        } = state;
-        if (!selection.empty) {
-          return;
-        }
+    if (decisionDeadlineTimer) {
+      clearTimeout(decisionDeadlineTimer);
+      decisionDeadlineTimer = null;
+    }
+  };
+  const cancelActiveDecision = () => {
+    clearDecisionTimers();
+    activeDecision = undefined;
+  };
+  const isDecisionSnapshotCurrent = (view, decision) => {
+    const {
+      state
+    } = view;
+    return state.selection.empty && state.selection.from === decision.position && getTextBeforeCursor(state) === decision.textBefore;
+  };
+  const isDecisionCurrent = (view, decision) => {
+    var _activeDecision;
+    return ((_activeDecision = activeDecision) === null || _activeDecision === void 0 ? void 0 : _activeDecision.revision) === decision.revision && isDecisionSnapshotCurrent(view, decision);
+  };
+  const expireActiveDecision = decision => {
+    var _activeDecision2;
+    if (((_activeDecision2 = activeDecision) === null || _activeDecision2 === void 0 ? void 0 : _activeDecision2.revision) !== decision.revision) {
+      return;
+    }
+    cancelActiveDecision();
+  };
+  const evaluateActiveDecision = (view, revision) => {
+    const decision = activeDecision;
+    if (!decision || decision.revision !== revision || !isDecisionCurrent(view, decision)) {
+      return;
+    }
+    if (performance.now() > decision.deadlineAt) {
+      expireActiveDecision(decision);
+      return;
+    }
+    decision.evaluations++;
+    try {
+      const {
+        state
+      } = view;
+      const {
+        selection
+      } = state;
 
-        // Suppress suggestions when the cursor is mid-word — only offer
-        // completions when the cursor is at the trailing edge of a token.
-        // nodeAfter correctly handles inline atoms (mentions, emojis) where
-        // parentOffset and textContent indices diverge.
-        const nodeAfter = selection.$from.nodeAfter;
-        const charAfterCursor = nodeAfter !== null && nodeAfter !== void 0 && nodeAfter.isText ? getLeadingTextCharacter(nodeAfter.text) : undefined;
-        // Only suppress for Unicode letters, digits, and underscore — hyphens,
-        // apostrophes, and similar punctuation are valid left-edge boundaries
-        // and should not block suggestions (e.g. cursor before '-' in compound-word).
-        if (charAfterCursor && isMidWordCharacter(charAfterCursor)) {
-          return;
-        }
-        const textBefore = getTextBeforeCursor(state);
+      // Suppress suggestions when the cursor is mid-word — only offer
+      // completions when the cursor is at the trailing edge of a token.
+      const nodeAfter = selection.$from.nodeAfter;
+      const charAfterCursor = nodeAfter !== null && nodeAfter !== void 0 && nodeAfter.isText ? getLeadingTextCharacter(nodeAfter.text) : undefined;
+      if (charAfterCursor && isMidWordCharacter(charAfterCursor)) {
+        cancelActiveDecision();
+        return;
+      }
+      if (decision.textBefore === dismissedContext) {
+        cancelActiveDecision();
+        return;
+      }
+      dismissedContext = null;
 
-        // Suppress re-showing the same suggestion the user just dismissed.
-        // Once the text context changes (user types or deletes), this clears automatically.
-        if (textBefore === dismissedContext) {
-          return;
-        }
-        dismissedContext = null;
-        if (textBefore.trim().length < 3) {
-          return;
+      // Two characters are enough to prefetch the canonical shortlist. The
+      // predictor itself withholds display until the three-character gate.
+      if (decision.textBefore.trim().length < 2) {
+        cancelActiveDecision();
+        return;
+      }
+      const prediction = predict(decision.textBefore);
+      if (!prediction || prediction.text.length === 0) {
+        // Remain in `collecting` until an async signal arrives or the hard
+        // deadline expires. We never display a provisional fallback.
+        return;
+      }
+      const readyAtMs = performance.now() - decision.startedAt;
+      if (readyAtMs > GHOST_DECISION_BUDGET_MS) {
+        cancelActiveDecision();
+        if (isAutocompleteDebugEnabled()) {
+          // eslint-disable-next-line no-console
+          console.log('%c[CTC:budget]%c fully gated after render deadline (render suppressed)', CTC_STYLES.section, CTC_STYLES.body, {
+            revision: decision.revision,
+            readyAtMs,
+            surface: prediction.surface
+          });
         }
-        const prediction = predict(textBefore);
-        if (prediction && prediction.length > 0) {
-          const typedLength = getTypedLengthForPrediction(textBefore);
-          lastSuggestionTypedLength = typedLength;
-          lastSuggestionLength = typedLength + prediction.length;
-          showGhostText(view, prediction, selection.from);
-          if (prediction !== lastShownGhostText) {
-            var _api$analytics5;
-            lastShownGhostText = prediction;
-            api === null || api === void 0 ? void 0 : (_api$analytics5 = api.analytics) === null || _api$analytics5 === void 0 ? void 0 : _api$analytics5.actions.fireAnalyticsEvent({
-              action: ACTION.SUGGESTION_VIEWED,
-              actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
-              eventType: EVENT_TYPE.TRACK,
-              attributes: {
-                completionSource: getCompletionSource(),
-                surface
-              }
-            });
+        return;
+      }
+      const suggestion = showGhostText(view, prediction, decision.position, decision.revision, decision.startedAt);
+      if (!suggestion) {
+        cancelActiveDecision();
+        return;
+      }
+      cancelActiveDecision();
+      if (isAutocompleteDebugEnabled()) {
+        // eslint-disable-next-line no-console
+        console.log('%c[CTC:decision]%c committed immutable ghost', CTC_STYLES.brand, CTC_STYLES.body, {
+          revision: suggestion.revision,
+          surface: suggestion.surface,
+          ghostText: suggestion.ghostText,
+          evidenceTier: suggestion.evidenceTier,
+          rankScore: suggestion.rankScore,
+          winnerMargin: suggestion.winnerMargin,
+          decisionLatencyMs: suggestion.decisionLatencyMs,
+          budgetMs: GHOST_DECISION_BUDGET_MS,
+          typedPrefixLength: getTrailingSurfacePrefixLength(decision.textBefore),
+          evaluations: decision.evaluations,
+          asyncSignals: decision.asyncSignals,
+          readyWithinBudget: suggestion.decisionLatencyMs <= GHOST_DECISION_BUDGET_MS
+        });
+      }
+      if (suggestion.ghostText !== lastShownGhostText) {
+        var _api$analytics5;
+        lastShownGhostText = suggestion.ghostText;
+        api === null || api === void 0 ? void 0 : (_api$analytics5 = api.analytics) === null || _api$analytics5 === void 0 ? void 0 : _api$analytics5.actions.fireAnalyticsEvent({
+          action: ACTION.SUGGESTION_VIEWED,
+          actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
+          eventType: EVENT_TYPE.TRACK,
+          attributes: {
+            completionSource: getCompletionSource(),
+            surface
           }
-        }
-      } catch (error) {
-        logException(error, {
-          location: 'editor-plugin-autocomplete/schedulePrediction'
         });
       }
-    }, DEBOUNCE_MS);
+    } catch (error) {
+      cancelActiveDecision();
+      logException(error, {
+        location: 'editor-plugin-autocomplete/evaluateActiveDecision'
+      });
+    }
+  };
+  const beginPredictionDecision = view => {
+    cancelActiveDecision();
+    const {
+      state
+    } = view;
+    if (!state.selection.empty) {
+      return;
+    }
+    const startedAt = performance.now();
+    const textBefore = getTextBeforeCursor(state);
+    const revision = ++decisionRevision;
+    activeDecision = {
+      asyncSignals: 0,
+      deadlineAt: startedAt + GHOST_DECISION_BUDGET_MS,
+      evaluations: 0,
+      position: state.selection.from,
+      revision,
+      startedAt,
+      textBefore
+    };
+    if (isAutocompleteDebugEnabled()) {
+      // eslint-disable-next-line no-console
+      console.log('%c[CTC:decision]%c collecting', CTC_STYLES.brand, CTC_STYLES.body, {
+        revision,
+        budgetMs: GHOST_DECISION_BUDGET_MS,
+        coalesceMs: PREDICTION_COALESCE_MS,
+        typedPrefixLength: getTrailingSurfacePrefixLength(activeDecision.textBefore),
+        textBefore: activeDecision.textBefore.slice(-80)
+      });
+    }
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      evaluateActiveDecision(view, revision);
+    }, PREDICTION_COALESCE_MS);
+    decisionDeadlineTimer = setTimeout(() => {
+      var _activeDecision3;
+      decisionDeadlineTimer = null;
+      if (((_activeDecision3 = activeDecision) === null || _activeDecision3 === void 0 ? void 0 : _activeDecision3.revision) === revision) {
+        const expiredDecision = activeDecision;
+        if (isAutocompleteDebugEnabled()) {
+          const elapsedMs = performance.now() - expiredDecision.startedAt;
+          const predictionDebug = getLastPredictionDebug();
+          const matchingPredictionDebug = (predictionDebug === null || predictionDebug === void 0 ? void 0 : predictionDebug.textBefore) === expiredDecision.textBefore ? predictionDebug : null;
+          const abstentionPrefix = '— abstain: ';
+          const predictorDecision = matchingPredictionDebug === null || matchingPredictionDebug === void 0 ? void 0 : matchingPredictionDebug.decision;
+          const predictorReason = predictorDecision !== null && predictorDecision !== void 0 && predictorDecision.startsWith(abstentionPrefix) ? predictorDecision.slice(abstentionPrefix.length) : predictorDecision;
+          const decisionMessage = predictorReason && !(matchingPredictionDebug !== null && matchingPredictionDebug !== void 0 && matchingPredictionDebug.awaitingAsyncEvidence) ? `abstain: ${predictorReason}` : `abstain: ${GHOST_DECISION_BUDGET_MS}ms decision budget expired${predictorReason ? ` · ${predictorReason}` : ''}`;
+          // eslint-disable-next-line no-console
+          console.log(`%c[CTC:decision]%c ${decisionMessage}`, CTC_STYLES.brand, CTC_STYLES.body, {
+            revision,
+            budgetMs: GHOST_DECISION_BUDGET_MS,
+            elapsedMs,
+            typedPrefixLength: getTrailingSurfacePrefixLength(expiredDecision.textBefore),
+            evaluations: expiredDecision.evaluations,
+            asyncSignals: expiredDecision.asyncSignals,
+            textBefore: expiredDecision.textBefore.slice(-80),
+            predictorDecision: predictorReason !== null && predictorReason !== void 0 ? predictorReason : null
+          });
+        }
+        expireActiveDecision(expiredDecision);
+      }
+    }, GHOST_DECISION_BUDGET_MS);
+  };
+
+  // Async semantic/canonical results may complete the active decision, but they
+  // never create a new decision or replace an already committed ghost.
+  reschedulePredictionOnSlowLaneResult = signal => {
+    if (destroyed || !currentView) {
+      return;
+    }
+    if (!activeDecision) {
+      return;
+    }
+    const revision = activeDecision.revision;
+    const elapsedMs = performance.now() - activeDecision.startedAt;
+    const remainingMs = activeDecision.deadlineAt - performance.now();
+    if (remainingMs < 0) {
+      const expiredDecision = activeDecision;
+      expireActiveDecision(expiredDecision);
+      return;
+    }
+    activeDecision.asyncSignals++;
+    if (isAutocompleteDebugVerbose()) {
+      // eslint-disable-next-line no-console
+      console.log('%c[CTC:readiness]%c async evidence signal', CTC_STYLES.section, CTC_STYLES.body, {
+        ...signal,
+        revision,
+        elapsedMs,
+        remainingMs: Math.max(0, remainingMs),
+        typedPrefixLength: getTrailingSurfacePrefixLength(activeDecision.textBefore),
+        withinBudget: remainingMs >= 0
+      });
+    }
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      if (currentView) {
+        evaluateActiveDecision(currentView, revision);
+      }
+    }, 0);
   };
   const maybeUpdateSessionFrequency = (view, prevState) => {
     const newText = getTextBeforeCursor(view.state);
@@ -579,22 +925,14 @@ export const createAutocompletePlugin = (options, api) => {
           };
         }
 
-        // A new prediction is scheduled from view.update.
+        // A new prediction is scheduled from view.update either way; the
+        // surviving ghost only covers the gap until it commits.
         if (tr.docChanged) {
-          return {
-            ...pluginState,
-            ghostText: '',
-            ghostPosition: -1,
-            decorationSet: DecorationSet.empty
-          };
+          var _advanceGhostThroughT;
+          return (_advanceGhostThroughT = advanceGhostThroughTypedCharacter(tr, pluginState)) !== null && _advanceGhostThroughT !== void 0 ? _advanceGhostThroughT : clearGhostState(pluginState);
         }
         if (tr.selectionSet && pluginState.ghostText) {
-          return {
-            ...pluginState,
-            ghostText: '',
-            ghostPosition: -1,
-            decorationSet: DecorationSet.empty
-          };
+          return clearGhostState(pluginState);
         }
         return pluginState;
       }
@@ -607,22 +945,25 @@ export const createAutocompletePlugin = (options, api) => {
       },
       handleKeyDown: keydownHandler({
         Tab: (state, dispatch) => {
-          return acceptGhostTextWithAnalytics(state, dispatch, ghostText => {
+          return acceptGhostTextWithAnalytics(state, dispatch, suggestion => {
             justAccepted = true;
             lastShownGhostText = '';
-            fireSuggestionInsertedAnalytics(ghostText);
+            cancelActiveDecision();
+            fireSuggestionInsertedAnalytics(suggestion);
           });
         },
         ArrowRight: (state, dispatch) => {
-          return acceptGhostTextWithAnalytics(state, dispatch, ghostText => {
+          return acceptGhostTextWithAnalytics(state, dispatch, suggestion => {
             justAccepted = true;
             lastShownGhostText = '';
-            fireSuggestionInsertedAnalytics(ghostText);
+            cancelActiveDecision();
+            fireSuggestionInsertedAnalytics(suggestion);
           });
         },
         Escape: (state, dispatch) => {
           const didClear = clearGhostText(state, dispatch);
           if (didClear) {
+            cancelActiveDecision();
             dismissedContext = getTextBeforeCursor(state);
             fireSuggestionDismissedAnalytics('escape');
           }
@@ -637,6 +978,7 @@ export const createAutocompletePlugin = (options, api) => {
           const pluginState = autocompletePluginKey.getState(view.state);
           if (pluginState !== null && pluginState !== void 0 && pluginState.ghostText) {
             clearGhostText(view.state, view.dispatch);
+            cancelActiveDecision();
             fireSuggestionDismissedAnalytics('blur');
           }
           return false;
@@ -648,6 +990,7 @@ export const createAutocompletePlugin = (options, api) => {
           if (!event.target.closest('[data-autocomplete-ghost="true"]')) {
             const didClear = clearGhostText(view.state, view.dispatch);
             if (didClear) {
+              cancelActiveDecision();
               dismissedContext = getTextBeforeCursor(view.state);
               lastShownGhostText = '';
               fireSuggestionDismissedAnalytics('click');
@@ -655,10 +998,11 @@ export const createAutocompletePlugin = (options, api) => {
             return false;
           }
           event.preventDefault();
-          const accepted = acceptGhostTextWithAnalytics(view.state, view.dispatch, ghostText => {
+          const accepted = acceptGhostTextWithAnalytics(view.state, view.dispatch, suggestion => {
             justAccepted = true;
             lastShownGhostText = '';
-            fireSuggestionInsertedAnalytics(ghostText);
+            cancelActiveDecision();
+            fireSuggestionInsertedAnalytics(suggestion);
           });
           if (accepted) {
             view.focus();
@@ -666,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
@@ -733,9 +1070,7 @@ export const createAutocompletePlugin = (options, api) => {
               // Snapshot the post-acceptance text so follow-up transactions hit
               // the dismissedContext guard and abort until the user types again.
               dismissedContext = getTextBeforeCursor(view.state);
-              if (debounceTimer) {
-                clearTimeout(debounceTimer);
-              }
+              cancelActiveDecision();
               return;
             }
             maybeUpdateSessionFrequency(view, prevState);
@@ -760,7 +1095,9 @@ export const createAutocompletePlugin = (options, api) => {
                 }
               }
             }
-            schedulePrediction(view);
+            beginPredictionDecision(view);
+          } else if (!prevState.selection.eq(view.state.selection)) {
+            cancelActiveDecision();
           }
         },
         destroy: () => {
@@ -769,14 +1106,14 @@ export const createAutocompletePlugin = (options, api) => {
           currentView = null;
           (_unsubscribeFromConte = unsubscribeFromContextUpdates) === null || _unsubscribeFromConte === void 0 ? void 0 : _unsubscribeFromConte();
           unsubscribeFromContextUpdates = undefined;
-          if (debounceTimer) {
-            clearTimeout(debounceTimer);
-          }
+          cancelActiveDecision();
+          const releasedDefaultClient = clearDefaultSlowLaneClient(slowLaneClient);
+          ctcTag('init', `slow lane teardown · id=${slowLaneClientId} · default=${releasedDefaultClient ? 'released' : 'retained newer owner'}`, releasedDefaultClient ? CTC_STYLES.dim : CTC_STYLES.warn);
           if (hasDestroy(slowLaneClient)) {
             slowLaneClient.destroy();
           }
-          ingestedContextTexts.clear();
-          setDefaultSlowLaneClient(null);
+          pendingSessionContextTexts.clear();
+          sessionIngestedContextTexts.clear();
         }
       };
     }