@atlaskit/editor-plugin-autocomplete 9.0.0 → 9.2.0

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

@@ -13,10 +13,13 @@ import { PluginKey } from '@atlaskit/editor-prosemirror/state';
 import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
 import { CTC_STYLES, ctcTag, isAutocompleteDebugEnabled, isAutocompleteDebugVerbose } from './debug-mode';
 import { createGhostTextDecorationSet } from './ghost-text-decoration';
+// Type-only, so the harvester chunk is still reached exclusively through the
+// dynamic import in `ensureInlineCodeHarvester`.
+
 import { createLocalSlowLaneClient } from './local-slow-lane-client';
 import { loadGrammarDataAsync } from './scoring-pipeline';
 import { clearDefaultSlowLaneClient, createSlowLaneClient, getDefaultSlowLaneClientStatus, isWordBoundary, setDefaultSlowLaneClient } from './slow-lane-client';
-import { predict, loadDefaultVocabulary, loadVectorsAsync, incrementSessionFreq, ingestDocumentPage, getLastPredictionDebug, noteSuggestionAccepted } from './text-predictor';
+import { predict, loadDefaultVocabulary, loadVectorsAsync, incrementSessionFreq, ingestDocumentPage, getLastPredictionDebug, getLastPredictionOutcome, isSurfaceInAcceptCooldown, noteSuggestionAccepted, resetSessionBoosts } from './text-predictor';
 export var autocompletePluginKey = new PluginKey('autocomplete');
 var PREDICTION_COALESCE_MS = 0;
 var GHOST_DECISION_BUDGET_MS = 100;
@@ -27,6 +30,32 @@ var CONTEXT_REFRESH_THROTTLE_MS = 1000;
 // version of the (potentially hundreds-of-KB) page content for the plugin's
 // lifetime. Eviction is FIFO; a re-ingest of an evicted text is harmless.
 var MAX_INGESTED_CONTEXT_TEXTS = 50;
+// Re-prime callback of every mounted editor. The harvested set and the L1
+// boosts are shared by all of them, and more than one is mounted routinely — a
+// comment box alongside its replies, or a comment box alongside the chat input.
+// Membership doubles as the mount count, so a teardown only clears the shared
+// stores once the last editor has gone.
+//
+// Decision: one pot, shared across hosts. Terms harvested in a comment box can
+// be offered in the chat input and the other way round. Both are content from
+// the page the reader is looking at, so the mixing is between things they can
+// already see; partitioning the boosts would mean a per-host overlay on every
+// trie node, which the scoring path reads on every keystroke.
+var mountedEditors = new Set();
+// The scope that shared learning belongs to, as last reported by a host that
+// scopes its context. Held here rather than per editor because the data it
+// guards is shared and some hosts replace one editor with another across a
+// navigation: an instance-local key would read as unset on exactly the change it
+// exists to catch, while the previous scope's terms carried on in these globals.
+// Undefined until a scoping host says otherwise. An editor that sends no key
+// still shares the pot being emptied, so it is re-primed from the context it
+// already holds rather than left with learning it can no longer see.
+var contextScopeKey;
+// Set by whichever editor first finished importing the harvester chunk. The
+// reset paths go through this rather than their own copy, because the editor
+// that has to clear the set is not always one that imported it — the set is one
+// per module, and nothing can be in it unless some editor got this far.
+var loadedInlineCodeHarvester = null;
 // Caps how many times the word-boundary path will retry getContext() while the
 // parent comment is still missing. Combined with the 1s throttle this gives a
 // ~5s window to cover a still-loading comment thread, then stops permanently so
@@ -103,10 +132,14 @@ var advanceGhostThroughTypedCharacter = function advanceGhostThroughTypedCharact
     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.
+    // describe the suggestion that was originally committed. The replaced
+    // prefix grows with the keystroke: it is the run the insertion overwrites,
+    // and the user has just typed one more character of it.
     suggestion: _objectSpread(_objectSpread({}, suggestion), {}, {
       ghostText: remaining,
       position: nextPosition
+    }, suggestion.replacesTypedPrefixLength === undefined ? {} : {
+      replacesTypedPrefixLength: suggestion.replacesTypedPrefixLength + 1
     })
   });
 };
@@ -141,9 +174,12 @@ var getTextBeforeCursor = function getTextBeforeCursor(state) {
   }
   return fullText.slice(-maxChars);
 };
-var getTrailingSurfacePrefixLength = function getTrailingSurfacePrefixLength(text) {
+var getTrailingSurfaceToken = function getTrailingSurfaceToken(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;
+  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]) !== null && _text$trimEnd$match$ !== void 0 ? _text$trimEnd$match$ : '';
+};
+var getTrailingSurfacePrefixLength = function getTrailingSurfacePrefixLength(text) {
+  return getTrailingSurfaceToken(text).length;
 };
 
 /**
@@ -157,11 +193,13 @@ var setAutocompleteMeta = function setAutocompleteMeta(tr, meta) {
  * Apply a ghost text suggestion to the editor state.
  */
 var lastShownGhostText = '';
-var showGhostText = function showGhostText(view, prediction, position, revision, decisionStartedAt) {
+var showGhostText = function showGhostText(view, prediction, position, revision, decisionStartedAt, replacesTypedPrefixLength) {
   try {
     var state = view.state,
       dispatch = view.dispatch;
-    var suggestion = {
+    var suggestion = _objectSpread(_objectSpread({}, replacesTypedPrefixLength === undefined ? {} : {
+      replacesTypedPrefixLength: replacesTypedPrefixLength
+    }), {}, {
       decisionLatencyMs: performance.now() - decisionStartedAt,
       evidenceTier: prediction.evidenceTier,
       ghostText: prediction.text,
@@ -175,7 +213,7 @@ var showGhostText = function showGhostText(view, prediction, position, revision,
       surface: prediction.surface,
       termType: prediction.termType,
       winnerMargin: prediction.winnerMargin
-    };
+    });
     var decorationSet = createGhostTextDecorationSet(state.doc, position, prediction.text);
     var tr = setAutocompleteMeta(state.tr, {
       ghostText: prediction.text,
@@ -230,10 +268,31 @@ var acceptGhostText = function acceptGhostText(state, dispatch) {
   }
   if (dispatch) {
     try {
+      var _suggestion$replacesT;
       var ghostText = pluginState.ghostText,
         ghostPosition = pluginState.ghostPosition,
         suggestion = pluginState.suggestion;
-      var tr = state.tr.insertText(ghostText, ghostPosition);
+      // Replacing back over the typed prefix rewrites it in the surface's own
+      // casing; every other path appends and leaves the prefix untouched.
+      var replaceFrom = Math.max(0, ghostPosition - Math.min((_suggestion$replacesT = suggestion.replacesTypedPrefixLength) !== null && _suggestion$replacesT !== void 0 ? _suggestion$replacesT : 0, ghostPosition));
+      var tr = state.tr;
+      if (replaceFrom === ghostPosition) {
+        tr = tr.insertText(ghostText, ghostPosition);
+      } else {
+        tr = tr.insertText(suggestion.surface, replaceFrom, ghostPosition);
+        // Only the harvested path replaces, and what authorized it was the
+        // surface being marked as code somewhere in the session. Inserting it
+        // as plain text loses that, so the identifier the user accepted reads
+        // as prose while the same identifier they typed by hand does not.
+        var codeMark = state.schema.marks.code;
+        if (codeMark) {
+          tr = tr.addMark(replaceFrom, replaceFrom + suggestion.surface.length, codeMark.create());
+          // The backtick input rule never ran, so nothing else will close this
+          // mark. Without dropping it from the stored set the next character
+          // the user types continues the code span.
+          tr = tr.removeStoredMark(codeMark);
+        }
+      }
       tr = setAutocompleteMeta(tr, {
         ghostText: '',
         ghostPosition: -1,
@@ -321,6 +380,71 @@ var getLeadingTextCharacter = function getLeadingTextCharacter(text) {
   }
   return String.fromCodePoint(firstCodePoint);
 };
+
+/**
+ * The one verdict a harvested surface may speak on.
+ *
+ * `no-candidate` is the only abstention that means no vocabulary reaches the
+ * prefix at all. Every other one — a margin the model cannot clear, a rival
+ * still being read — describes known words in contention, where a session
+ * surface with no score behind it would be overruling the ranker rather than
+ * filling a gap it left.
+ */
+var HARVEST_ELIGIBLE_ABSTAIN_REASON = 'no-candidate';
+
+/**
+ * Whether the scored path has finished with this exact prefix and found nothing.
+ *
+ * The 100ms deadline expiring is not the same answer: it means the ranker was
+ * still working, and displaying then would race a suggestion that is about to
+ * arrive. So the harvest path reads the recorded verdict rather than the clock.
+ */
+var scoredPathFinishedEmpty = function scoredPathFinishedEmpty(textBefore) {
+  var outcome = getLastPredictionOutcome();
+  return outcome !== null && outcome.textBefore === textBefore && !outcome.awaitingAsyncEvidence && outcome.abstainReason === HARVEST_ELIGIBLE_ABSTAIN_REASON;
+};
+
+/**
+ * Whether the surface is already sitting immediately before the typed prefix.
+ *
+ * Completing `ml-s` to `ml-studio` right after `ml-studio` produces the echo the
+ * scored path's repetition guard exists to stop, and this path does not go
+ * through arbitration to inherit it.
+ */
+var repeatsPrecedingText = function repeatsPrecedingText(match, textBefore) {
+  var trimmed = textBefore.trimEnd();
+  var preceding = trimmed.slice(0, trimmed.length - match.typedPrefixLength).trimEnd();
+  return preceding.toLowerCase().endsWith(match.surface.toLowerCase());
+};
+
+/**
+ * Dress a harvested match as a prediction so it commits through the same path as
+ * a scored one.
+ *
+ * The scoring fields are zeroed rather than invented: there is no posterior, no
+ * margin and no shortlist behind this surface, and `session-harvest` on the
+ * evidence tier is what says so wherever the snapshot is read.
+ */
+var buildHarvestPrediction = function buildHarvestPrediction(match) {
+  return {
+    evidenceDepth: {
+      totalChars: 0,
+      totalTokens: 0,
+      verifiedChars: 0,
+      verifiedTokens: 0
+    },
+    evidenceTier: 'session-harvest',
+    meanTokenLogProbability: 0,
+    poolHeldExtension: false,
+    posterior: 0,
+    rankScore: 0,
+    shortlistSize: 0,
+    surface: match.surface,
+    termType: 'word',
+    text: match.ghostText,
+    winnerMargin: 0
+  };
+};
 var isEnglishLocale = function isEnglishLocale(locale) {
   if (!locale) {
     return false;
@@ -332,6 +456,7 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
   var surface = (_options$surface = options === null || options === void 0 ? void 0 : options.surface) !== null && _options$surface !== void 0 ? _options$surface : 'editor';
   var 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;
   var isAutocompleteEnabled = isEnglishLocale(locale);
+  var isInlineCodeHarvestEnabled = isAutocompleteEnabled && (options === null || options === void 0 ? void 0 : options.harvestInlineCode) === true;
   var debounceTimer = null;
   var decisionDeadlineTimer = null;
   var hasIngestedPage = false;
@@ -374,14 +499,26 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
     }
     return options !== null && options !== void 0 && options.useLocalModel ? 'localLlm' : 'server';
   };
-  var fireSuggestionDismissedAnalytics = function fireSuggestionDismissedAnalytics(reason) {
+
+  /**
+   * Which path produced a given suggestion.
+   *
+   * A harvested surface is reported as `harvest` rather than by the slow-lane
+   * state it happened to be shown under, so its views and acceptances stay
+   * separable from the scored path's and cannot quietly move the headline
+   * acceptance rate.
+   */
+  var completionSourceFor = function completionSourceFor(suggestion) {
+    return (suggestion === null || suggestion === void 0 ? void 0 : suggestion.evidenceTier) === 'session-harvest' ? 'harvest' : getCompletionSource();
+  };
+  var fireSuggestionDismissedAnalytics = function fireSuggestionDismissedAnalytics(reason, suggestion) {
     var _api$analytics;
     api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 || _api$analytics.actions.fireAnalyticsEvent({
       action: ACTION.SUGGESTION_DISMISSED,
       actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
       eventType: EVENT_TYPE.TRACK,
       attributes: {
-        completionSource: getCompletionSource(),
+        completionSource: completionSourceFor(suggestion),
         reason: reason,
         surface: surface
       }
@@ -436,7 +573,7 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
       actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
       eventType: EVENT_TYPE.TRACK,
       attributes: {
-        completionSource: getCompletionSource(),
+        completionSource: completionSourceFor(suggestion),
         suggestionLength: suggestionLength,
         typedLength: typedLength,
         kssDelta: kssDelta,
@@ -502,6 +639,10 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
   var registeredSlowLaneStatus = getDefaultSlowLaneClientStatus();
   ctcTag('init', "slow lane registered \xB7 id=".concat(slowLaneClientId, " \xB7 selected=").concat(slowLaneClientKind, " \xB7 canonical=").concat(registeredSlowLaneStatus.canonicalScoringSupported ? 'yes' : 'no', " \xB7 ready=").concat((_registeredSlowLaneSt = registeredSlowLaneStatus.localModelReady) !== null && _registeredSlowLaneSt !== void 0 ? _registeredSlowLaneSt : 'n/a'), slowLaneClientKind === 'localLlm' ? CTC_STYLES.good : CTC_STYLES.warn);
   var contextRequestInFlight = false;
+  // A read the host asked for while another was open, kept so it can be made
+  // once that one settles. One slot, not a queue: a burst of notifications only
+  // ever means "read again", and the last of them describes the current state.
+  var queuedContextRefreshSource;
   var lastContextRefreshAt = 0;
   // Bounds the word-boundary retry loop so it terminates even when the editor is
   // not in a comment thread (parentCommentContent never resolves).
@@ -509,7 +650,163 @@ 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;
+
+  // Context text waiting on the harvester chunk, the vocabulary, or both. The
+  // harvester drops surfaces the vocabulary already holds, so intake before the
+  // load has settled would admit ordinary words no one needs completed.
+  var pendingHarvestTexts = new Set();
+  // Separate from `sessionIngestedContextTexts` because the two consumers settle
+  // at different times: reply occurrences accumulate, so text fed twice would
+  // count twice.
+  var harvestedContextTexts = new Set();
+  var inlineCodeHarvester = null;
+  var inlineCodeHarvesterPromise;
+  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 flushPendingHarvestTexts = function flushPendingHarvestTexts() {
+    var harvester = inlineCodeHarvester;
+    if (!harvester || !isVocabularyReady || destroyed || pendingHarvestTexts.size === 0) {
+      return;
+    }
+    var _iterator2 = _createForOfIteratorHelper(pendingHarvestTexts),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var text = _step2.value;
+        if (!harvestedContextTexts.has(text)) {
+          harvester.harvestInlineCodeFromText(text);
+          addBoundedContextText(harvestedContextTexts, text);
+        }
+        pendingHarvestTexts.delete(text);
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    harvester.logInlineCodeHarvest('context');
+  };
+
+  /**
+   * Load the harvester chunk, once, and only for a host that asked for it.
+   *
+   * Kept off the critical path in the same way the vocabulary and vector loads
+   * are: nothing is requested until the editor is focused, so a session that
+   * never types in the chat pays nothing for the feature.
+   */
+  var ensureInlineCodeHarvester = function ensureInlineCodeHarvester() {
+    if (!isInlineCodeHarvestEnabled || destroyed) {
+      return Promise.resolve(null);
+    }
+    inlineCodeHarvesterPromise !== null && inlineCodeHarvesterPromise !== void 0 ? inlineCodeHarvesterPromise : inlineCodeHarvesterPromise = import( /* webpackChunkName: "@atlaskit-internal_editor-plugin-autocomplete-inline-code-harvester" */
+    './inline-code-harvester').then(function (module) {
+      if (destroyed) {
+        return null;
+      }
+      inlineCodeHarvester = module;
+      loadedInlineCodeHarvester = module;
+      flushPendingHarvestTexts();
+      return module;
+    }).catch(function (error) {
+      // Clear the promise so a later focus can retry; the queued text is
+      // still held and is fed by whichever attempt succeeds.
+      inlineCodeHarvesterPromise = undefined;
+      logException(error, {
+        location: 'editor-plugin-autocomplete/loadInlineCodeHarvester'
+      });
+      return null;
+    });
+    return inlineCodeHarvesterPromise;
+  };
+
+  /**
+   * Re-read the document's code-marked spans.
+   *
+   * The backtick input rule consumes both delimiters on the closing tick, so a
+   * finished span in the live document is only findable through its mark — and
+   * only by walking, since a mark carries no notification.
+   */
+  var harvestDocument = function harvestDocument(doc, trigger) {
+    if (!isInlineCodeHarvestEnabled || destroyed) {
+      return;
+    }
+    var harvester = inlineCodeHarvester;
+    if (!harvester) {
+      void ensureInlineCodeHarvester();
+      return;
+    }
+    if (!isVocabularyReady) {
+      return;
+    }
+    harvester.harvestInlineCodeFromDoc(doc);
+    harvester.logInlineCodeHarvest(trigger);
+  };
+  var ensureVocabularyReady = function ensureVocabularyReady() {
+    var _options$useLocalMode;
+    if (isVocabularyReady) {
+      flushPendingSessionContext();
+      flushPendingHarvestTexts();
+      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();
+      flushPendingHarvestTexts();
+    }).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()) {
@@ -519,14 +816,134 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
     // eslint-disable-next-line no-console
     console.log('%c[CTC:signal]%c getContext resolved', CTC_STYLES.brand, CTC_STYLES.body, {
       source: source,
+      scope: context === null || context === void 0 ? void 0 : context.contextScopeKey,
       hasParentComment: !!(context !== null && context !== void 0 && context.parentCommentContent),
       parentCommentPreview: context === null || context === void 0 || (_context$parentCommen = context.parentCommentContent) === null || _context$parentCommen === void 0 ? void 0 : _context$parentCommen.slice(0, 80),
       siblingCount: (_context$siblingComme4 = context === null || context === void 0 || (_context$siblingComme5 = context.siblingCommentsContents) === null || _context$siblingComme5 === void 0 ? void 0 : _context$siblingComme5.length) !== null && _context$siblingComme4 !== void 0 ? _context$siblingComme4 : 0,
       hasFullPage: !!(context !== null && context !== void 0 && context.fullPageContent)
     });
   };
+  var ingestContextText = function ingestContextText(text) {
+    if (!text) {
+      return;
+    }
+    if (!sessionIngestedContextTexts.has(text)) {
+      addBoundedContextText(pendingSessionContextTexts, text);
+    }
+    // Queued unconditionally rather than only once the chunk is present:
+    // context usually resolves in the same tick the load starts, and text
+    // dropped for arriving early is a reply that can never be harvested.
+    if (isInlineCodeHarvestEnabled && !harvestedContextTexts.has(text)) {
+      addBoundedContextText(pendingHarvestTexts, text);
+    }
+  };
+  var ingestResolvedContext = function ingestResolvedContext() {
+    var _resolvedContext, _resolvedContext2, _resolvedContext$sibl, _resolvedContext3;
+    ingestContextText((_resolvedContext = resolvedContext) === null || _resolvedContext === void 0 ? void 0 : _resolvedContext.fullPageContent);
+    ingestContextText((_resolvedContext2 = resolvedContext) === null || _resolvedContext2 === void 0 ? void 0 : _resolvedContext2.parentCommentContent);
+    var _iterator3 = _createForOfIteratorHelper((_resolvedContext$sibl = (_resolvedContext3 = resolvedContext) === null || _resolvedContext3 === void 0 ? void 0 : _resolvedContext3.siblingCommentsContents) !== null && _resolvedContext$sibl !== void 0 ? _resolvedContext$sibl : []),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var siblingCommentContent = _step3.value;
+        ingestContextText(siblingCommentContent);
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+    flushPendingSessionContext();
+    flushPendingHarvestTexts();
+  };
+
+  /**
+   * Put back what this editor had contributed to the pot another editor just
+   * emptied.
+   *
+   * The scope that ended belongs to the host that reported it, not to everyone
+   * sharing these globals. Without this an editor alongside it — a comment box
+   * under a chat panel that switched conversation — is left with none of its
+   * learning and no way back to it: the dedupe sets below are per editor, so
+   * its own page reads as already ingested and is skipped from then on.
+   *
+   * Nothing is re-fetched. The context this editor resolved is still held, and
+   * what it describes has not changed just because another host moved on.
+   *
+   * Only for an editor that reported no scope. One that did is party to the
+   * same scope system and the scope just dropped may well be its own: a
+   * Confluence page transition mounts the incoming editor before tearing down
+   * the outgoing one, and the outgoing one is still holding the page that was
+   * left. Putting that back is exactly what the eviction was for.
+   */
+  var reprimeSessionLearning = function reprimeSessionLearning() {
+    var _resolvedContext4;
+    if (destroyed || ((_resolvedContext4 = resolvedContext) === null || _resolvedContext4 === void 0 ? void 0 : _resolvedContext4.contextScopeKey) !== undefined) {
+      return;
+    }
+    pendingSessionContextTexts.clear();
+    sessionIngestedContextTexts.clear();
+    pendingHarvestTexts.clear();
+    harvestedContextTexts.clear();
+    ingestResolvedContext();
+    if (currentView) {
+      harvestDocument(currentView.state.doc, 'reprime');
+    }
+  };
+
+  /**
+   * Drop everything learned for the scope that just ended.
+   *
+   * Both stores are claims about what is being discussed, and neither survives
+   * the discussion changing: L1 boosts would keep a page's words ranked above
+   * the next page's, and the harvested set holds one conversation's content.
+   * The dedupe sets go too, so the context that arrives next is treated as
+   * unseen and re-primes both — which is what makes this safe to do on a page
+   * change, since the transcript is re-ingested along with the new page.
+   *
+   * The stores are shared, so every other mounted editor is put back in the
+   * same tick from context it already holds. Only the scope that ended is
+   * actually dropped.
+   */
+  var resetSessionScopedLearning = function resetSessionScopedLearning(reason) {
+    var _loadedInlineCodeHarv;
+    resetSessionBoosts();
+    (_loadedInlineCodeHarv = loadedInlineCodeHarvester) === null || _loadedInlineCodeHarv === void 0 || _loadedInlineCodeHarv.resetInlineCodeHarvest();
+    resolvedContext = undefined;
+    pendingSessionContextTexts.clear();
+    sessionIngestedContextTexts.clear();
+    pendingHarvestTexts.clear();
+    harvestedContextTexts.clear();
+    ctcTag('init', "session-scoped learning reset \xB7 ".concat(reason), CTC_STYLES.dim);
+    var _iterator4 = _createForOfIteratorHelper(mountedEditors),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var reprimeOther = _step4.value;
+        if (reprimeOther !== reprimeSessionLearning) {
+          reprimeOther();
+        }
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+  };
   var applyContext = function applyContext(context) {
-    var _context$siblingComme6;
+    // A host that scopes its context tells us which scope each read belongs to.
+    // A read with no recorded key to compare against only records: that is the
+    // first since the last editor went away, so there is nothing left to throw
+    // away and resetting would drop the priming focus just started. A read from
+    // a newly mounted editor is not that case — the key outlives the editor
+    // precisely so a host that remounts across a navigation still evicts.
+    if (context.contextScopeKey !== undefined && context.contextScopeKey !== contextScopeKey) {
+      if (contextScopeKey !== undefined) {
+        resetSessionScopedLearning("scope ".concat(contextScopeKey, " \u2192 ").concat(context.contextScopeKey));
+      }
+      contextScopeKey = context.contextScopeKey;
+    }
+
     // Merge rather than replace: the word-boundary retry may resolve only a
     // late-arriving field (e.g. parentCommentContent) without re-sending
     // fullPageContent, so replacing would drop previously resolved context.
@@ -538,38 +955,10 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
       return value !== undefined;
     }));
     resolvedContext = _objectSpread(_objectSpread({}, resolvedContext), definedContext);
-    var ingestContextText = function ingestContextText(text) {
-      if (!text || ingestedContextTexts.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);
-    };
-    ingestContextText(context.fullPageContent);
-    ingestContextText(context.parentCommentContent);
-    var _iterator = _createForOfIteratorHelper((_context$siblingComme6 = context.siblingCommentsContents) !== null && _context$siblingComme6 !== void 0 ? _context$siblingComme6 : []),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var siblingCommentContent = _step.value;
-        ingestContextText(siblingCommentContent);
-      }
+    ingestResolvedContext();
 
-      // 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);
-    } finally {
-      _iterator.f();
-    }
+    // 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));
     }
@@ -580,11 +969,23 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
    * (no getContext, a request already in flight, or throttled). Callers that
    * track a retry budget should only count attempts where this returns true.
    */
-  var refreshContext = function refreshContext(_ref5) {
+  var _refreshContext = function refreshContext(_ref5) {
     var source = _ref5.source,
       _ref5$allowThrottle = _ref5.allowThrottle,
       allowThrottle = _ref5$allowThrottle === void 0 ? true : _ref5$allowThrottle;
-    if (!(options !== null && options !== void 0 && options.getContext) || contextRequestInFlight) {
+    if (!(options !== null && options !== void 0 && options.getContext)) {
+      return false;
+    }
+    if (contextRequestInFlight) {
+      // Only the reads that bypass the throttle are worth keeping: those are
+      // the ones the host asked for by name, and a scope change travels among
+      // them with no second channel to arrive on, so losing one would strand
+      // the eviction until something else happened to move. A word-boundary
+      // poll is a retry loop for context that has not landed yet, and the read
+      // already open will bring it.
+      if (!allowThrottle) {
+        queuedContextRefreshSource = source;
+      }
       return false;
     }
     var now = Date.now();
@@ -611,6 +1012,14 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
       });
     }).finally(function () {
       contextRequestInFlight = false;
+      var queuedSource = queuedContextRefreshSource;
+      queuedContextRefreshSource = undefined;
+      if (queuedSource !== undefined && !destroyed) {
+        _refreshContext({
+          source: queuedSource,
+          allowThrottle: false
+        });
+      }
     });
     return true;
   };
@@ -643,6 +1052,48 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
     }
     cancelActiveDecision();
   };
+
+  /**
+   * Offer a harvested inline-code surface on a prefix the scored path left
+   * empty. Returns whether one was committed.
+   */
+  var commitHarvestedSuggestion = function commitHarvestedSuggestion(view, decision) {
+    var harvester = inlineCodeHarvester;
+    if (!harvester || !isInlineCodeHarvestEnabled) {
+      return false;
+    }
+    if (!scoredPathFinishedEmpty(decision.textBefore)) {
+      return false;
+    }
+    var typedPrefix = getTrailingSurfaceToken(decision.textBefore);
+    var match = harvester.findHarvestedCompletion(typedPrefix);
+    if (!match) {
+      return false;
+    }
+    if (isSurfaceInAcceptCooldown(match.surface) || repeatsPrecedingText(match, decision.textBefore)) {
+      return false;
+    }
+    var suggestion = showGhostText(view, buildHarvestPrediction(match), decision.position, decision.revision, decision.startedAt, match.typedPrefixLength);
+    if (!suggestion) {
+      return false;
+    }
+    cancelActiveDecision();
+    ctcTag('harvest', "offered \"".concat(match.surface, "\" for \"").concat(typedPrefix, "\" \xB7 ").concat(match.collapsedBy, " \xB7 ").concat(match.replyOccurrences, " reply / ").concat(match.documentSpans, " doc sightings").concat(match.rivalSurfaces.length > 0 ? " \xB7 over ".concat(match.rivalSurfaces.join(', ')) : ''), CTC_STYLES.lm);
+    if (suggestion.ghostText !== lastShownGhostText) {
+      var _api$analytics5;
+      lastShownGhostText = suggestion.ghostText;
+      api === null || api === void 0 || (_api$analytics5 = api.analytics) === null || _api$analytics5 === void 0 || _api$analytics5.actions.fireAnalyticsEvent({
+        action: ACTION.SUGGESTION_VIEWED,
+        actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
+        eventType: EVENT_TYPE.TRACK,
+        attributes: {
+          completionSource: completionSourceFor(suggestion),
+          surface: surface
+        }
+      });
+    }
+    return true;
+  };
   var evaluateActiveDecision = function evaluateActiveDecision(view, revision) {
     var decision = activeDecision;
     if (!decision || decision.revision !== revision || !isDecisionCurrent(view, decision)) {
@@ -679,8 +1130,11 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
       }
       var 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.
+        // Only where the scored path has finished and come away with nothing
+        // does a harvested surface get to answer; otherwise remain in
+        // `collecting` until an async signal arrives or the hard deadline
+        // expires. We never display a provisional fallback.
+        commitHarvestedSuggestion(view, decision);
         return;
       }
       var readyAtMs = performance.now() - decision.startedAt;
@@ -720,14 +1174,14 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
         });
       }
       if (suggestion.ghostText !== lastShownGhostText) {
-        var _api$analytics5;
+        var _api$analytics6;
         lastShownGhostText = suggestion.ghostText;
-        api === null || api === void 0 || (_api$analytics5 = api.analytics) === null || _api$analytics5 === void 0 || _api$analytics5.actions.fireAnalyticsEvent({
+        api === null || api === void 0 || (_api$analytics6 = api.analytics) === null || _api$analytics6 === void 0 || _api$analytics6.actions.fireAnalyticsEvent({
           action: ACTION.SUGGESTION_VIEWED,
           actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
           eventType: EVENT_TYPE.TRACK,
           attributes: {
-            completionSource: getCompletionSource(),
+            completionSource: completionSourceFor(suggestion),
             surface: surface
           }
         });
@@ -911,11 +1365,13 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
           });
         },
         Escape: function Escape(state, dispatch) {
+          var _autocompletePluginKe;
+          var dismissed = (_autocompletePluginKe = autocompletePluginKey.getState(state)) === null || _autocompletePluginKe === void 0 ? void 0 : _autocompletePluginKe.suggestion;
           var didClear = clearGhostText(state, dispatch);
           if (didClear) {
             cancelActiveDecision();
             dismissedContext = getTextBeforeCursor(state);
-            fireSuggestionDismissedAnalytics('escape');
+            fireSuggestionDismissedAnalytics('escape', dismissed !== null && dismissed !== void 0 ? dismissed : null);
           }
           return didClear;
         }
@@ -929,7 +1385,7 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
           if (pluginState !== null && pluginState !== void 0 && pluginState.ghostText) {
             clearGhostText(view.state, view.dispatch);
             cancelActiveDecision();
-            fireSuggestionDismissedAnalytics('blur');
+            fireSuggestionDismissedAnalytics('blur', pluginState.suggestion);
           }
           return false;
         },
@@ -938,12 +1394,14 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
             return false;
           }
           if (!event.target.closest('[data-autocomplete-ghost="true"]')) {
+            var _autocompletePluginKe2;
+            var dismissed = (_autocompletePluginKe2 = autocompletePluginKey.getState(view.state)) === null || _autocompletePluginKe2 === void 0 ? void 0 : _autocompletePluginKe2.suggestion;
             var didClear = clearGhostText(view.state, view.dispatch);
             if (didClear) {
               cancelActiveDecision();
               dismissedContext = getTextBeforeCursor(view.state);
               lastShownGhostText = '';
-              fireSuggestionDismissedAnalytics('click');
+              fireSuggestionDismissedAnalytics('click', dismissed !== null && dismissed !== void 0 ? dismissed : null);
             }
             return false;
           }
@@ -959,17 +1417,19 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
           }
           return accepted;
         },
-        focus: function focus() {
-          var _options$useLocalMode, _options$useLocalMode2, _options$useLocalMode3;
+        focus: function focus(view) {
+          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
+          void ensureVocabularyReady();
+          // First point at which the session is known to be using the input,
+          // which is where the rest of the artifacts are requested too.
+          void ensureInlineCodeHarvester().then(function () {
+            return harvestDocument(view.state.doc, 'focus');
           }).catch(function (error) {
             logException(error, {
-              location: 'editor-plugin-autocomplete/loadDefaultVocabulary'
+              location: 'editor-plugin-autocomplete/harvestDocument'
             });
           });
           loadVectorsAsync({
@@ -990,7 +1450,7 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
           });
           if (!hasIngestedPage) {
             hasIngestedPage = true;
-            refreshContext({
+            _refreshContext({
               source: 'focus',
               allowThrottle: false
             });
@@ -1003,12 +1463,14 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
       // Capture up front so a subscription notification before the first PM
       // transaction can still drive slowLaneClient.updateContext (gated on currentView).
       currentView = editorView;
+      mountedEditors.add(reprimeSessionLearning);
 
       // Push channel for hosts that keep producing context after mount (e.g. Rovo chat).
       if (isAutocompleteEnabled && options !== null && options !== void 0 && options.subscribeToContextUpdates) {
         unsubscribeFromContextUpdates = options.subscribeToContextUpdates(function () {
-          // Bypass throttle for freshness; the in-flight guard prevents overlap.
-          refreshContext({
+          // Bypass throttle for freshness; a read still open defers this one
+          // rather than overlapping it.
+          _refreshContext({
             source: 'subscription',
             allowThrottle: false
           });
@@ -1033,19 +1495,24 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
             maybeUpdateSessionFrequency(view, prevState);
             var textBefore = getTextBeforeCursor(view.state);
             if (isWordBoundary(textBefore)) {
-              var _resolvedContext;
+              var _resolvedContext5;
               slowLaneClient.updateContext(buildSlowLaneText(view.state.doc.textContent, resolvedContext));
 
+              // The backtick input rule has fired by the time a span is
+              // finished, so a word boundary is the earliest point the mark
+              // exists to be found.
+              harvestDocument(view.state.doc, 'word-boundary');
+
               // Context may not have resolved on first focus (e.g. comment
               // thread still loading). Retry on word boundaries until we have
               // the parent comment, throttled so we don't refetch constantly
               // and capped so non-comment editors stop retrying entirely.
               // Skipped for push-channel hosts (subscribeToContextUpdates): they
               // never grow parentCommentContent, so polling only burns the budget.
-              if (!(options !== null && options !== void 0 && options.subscribeToContextUpdates) && !((_resolvedContext = resolvedContext) !== null && _resolvedContext !== void 0 && _resolvedContext.parentCommentContent) && wordBoundaryRefreshAttempts < MAX_CONTEXT_REFRESH_ATTEMPTS) {
+              if (!(options !== null && options !== void 0 && options.subscribeToContextUpdates) && !((_resolvedContext5 = resolvedContext) !== null && _resolvedContext5 !== void 0 && _resolvedContext5.parentCommentContent) && wordBoundaryRefreshAttempts < MAX_CONTEXT_REFRESH_ATTEMPTS) {
                 // Only count the attempt when a fetch actually started, so an
                 // in-flight or throttled no-op doesn't burn the retry budget.
-                if (refreshContext({
+                if (_refreshContext({
                   source: 'word-boundary'
                 })) {
                   wordBoundaryRefreshAttempts++;
@@ -1069,7 +1536,35 @@ export var createAutocompletePlugin = function createAutocompletePlugin(options,
           if (hasDestroy(slowLaneClient)) {
             slowLaneClient.destroy();
           }
-          ingestedContextTexts.clear();
+          queuedContextRefreshSource = undefined;
+          pendingSessionContextTexts.clear();
+          sessionIngestedContextTexts.clear();
+          pendingHarvestTexts.clear();
+          harvestedContextTexts.clear();
+          // The harvested set holds one conversation's user and assistant
+          // content, and the L1 boosts describe what that conversation was
+          // about. Both live at module scope, so they have to be emptied here
+          // or they leak into whichever editor mounts next — but only once no
+          // editor is left to be using them. The scope key goes with them, and
+          // only with them: clearing it while another editor is still mounted
+          // would leave that editor's next read looking like a first one, with
+          // nothing to compare against and everything still loaded.
+          mountedEditors.delete(reprimeSessionLearning);
+          if (mountedEditors.size === 0) {
+            var _loadedInlineCodeHarv2;
+            (_loadedInlineCodeHarv2 = loadedInlineCodeHarvester) === null || _loadedInlineCodeHarv2 === void 0 || _loadedInlineCodeHarv2.resetInlineCodeHarvest();
+            // Only for a host that scopes its context, which is the one asking
+            // for its learning to end with the conversation. A host that sends
+            // no scope has boosts belonging to the page it is on, and that page
+            // outlives an editor being unmounted — a Confluence comment box is
+            // closed far more often than the page under it changes.
+            if (contextScopeKey !== undefined) {
+              resetSessionBoosts();
+              contextScopeKey = undefined;
+            }
+          }
+          inlineCodeHarvester = null;
+          inlineCodeHarvesterPromise = undefined;
         }
       };
     }