@atlaskit/editor-plugin-autocomplete 8.0.0 → 9.1.0

package/dist/es2019/pm-plugins/scoring-pipeline.js

@@ -14,6 +14,11 @@ import { isAutocompleteDebugEnabled } from './debug-mode';
 
 // ─── Types ──────────────────────────────────────────────────
 
+/**
+ * A completion term is `(term, termType)`. `word` is the v1 default; `bigram`
+ * (2 tokens) and `phrase` (3 tokens) are multi-word units mined by the producer.
+ */
+
 /** Metadata returned by the grammar filter for debug logging in the caller. */
 
 // ─── Scoring Constants ──────────────────────────────────────
@@ -21,9 +26,25 @@ import { isAutocompleteDebugEnabled } from './debug-mode';
 const ALPHA = 0.5;
 const BETA = 0.5;
 const NEUTRAL_SCORE = 0.5;
+// Multiplicative Stage-1 boost applied to a multi-word term proportional to its
+// (clamped [0,1]) NPMI association, so a strongly-collocated phrase outranks a
+// coincidental word sequence of comparable freq/semantics. Tunable.
+const ASSOCIATION_BOOST = 0.5;
 export const STAGE1_WEIGHT = 0.35;
 export const STAGE2_WEIGHT = 0.65;
 export const MIN_STAGE1_SCORE = 0.35;
+/**
+ * How far the leading candidate must sit above the runner-up on the blended
+ * score before a ghost is committed.
+ *
+ * Lives beside the weights it is measured in, because it is only meaningful on
+ * that scale — and because both the arbitration that applies it and the
+ * scheduler that decides when reading more tokens can no longer change the
+ * outcome have to use the same number. When those two drifted apart, the
+ * scheduler stopped early on a margin the arbitration did not recognise and the
+ * abstention that followed was invisible from either side.
+ */
+export const MIN_WINNER_MARGIN = 0.08;
 const L1_SESSION_CAP = 1.2;
 // Minimum prefix-payload max LM probability before Stage 2 activates.
 // Below this threshold the LM signal is too weak to suppress Stage 1 — finalScore
@@ -42,13 +63,32 @@ let posTags = new Map();
  * without suggesting these words to the user.
  */
 let ghostPosTags = {};
+let grammarDataPromise;
 
 /**
  * Precomputed map from each POS tag to the set of allowed next POS tags, so
  * applyGrammarFilter never re-iterates the transition rules per call.
  */
 let precomputedAllowedByPos = new Map();
-let grammarDataPromise;
+const isPosTagsRecord = payload => {
+  if (payload == null || typeof payload !== 'object') {
+    return false;
+  }
+  return Object.values(payload).every(value => Array.isArray(value) && value.every(entry => typeof entry === 'string'));
+};
+const isGrammarTransitions = payload => {
+  if (payload == null || typeof payload !== 'object') {
+    return false;
+  }
+  const transitions = payload.transitions;
+  if (transitions == null || typeof transitions !== 'object') {
+    return false;
+  }
+  return Object.values(transitions).every(value => {
+    const allowed = value === null || value === void 0 ? void 0 : value.allowed;
+    return Array.isArray(allowed) && allowed.every(entry => typeof entry === 'string');
+  });
+};
 const setGrammarData = data => {
   var _data$grammarTransiti;
   posTags = new Map(Object.entries(data.posTags));
@@ -79,12 +119,24 @@ export const loadGrammarDataAsync = options => {
     });
     try {
       const [posTagsData, ghostPosTagsData, grammarTransitionsData] = await Promise.all([fetchArtifactJson(ARTIFACT_NAME.POS_TAGS), fetchArtifactJson(ARTIFACT_NAME.GHOST_POS_TAGS), fetchArtifactJson(ARTIFACT_NAME.GRAMMAR_TRANSITIONS)]);
+
+      // A missing wrapper and a malformed ruleset are reported separately: the
+      // first points at the publishing step, the second at the payload itself.
       if ((grammarTransitionsData === null || grammarTransitionsData === void 0 ? void 0 : grammarTransitionsData.transitions) == null) {
         throw new Error(`[scoring-pipeline] ${ARTIFACT_NAME.GRAMMAR_TRANSITIONS} is missing its \`transitions\` wrapper`);
       }
+      if (!isGrammarTransitions(grammarTransitionsData)) {
+        throw new Error(`[scoring-pipeline] ${ARTIFACT_NAME.GRAMMAR_TRANSITIONS} payload shape was invalid`);
+      }
+      if (!isPosTagsRecord(posTagsData)) {
+        throw new Error(`[scoring-pipeline] ${ARTIFACT_NAME.POS_TAGS} payload shape was invalid`);
+      }
+      if (!isPosTagsRecord(ghostPosTagsData)) {
+        throw new Error(`[scoring-pipeline] ${ARTIFACT_NAME.GHOST_POS_TAGS} payload shape was invalid`);
+      }
       setGrammarData({
-        posTags: posTagsData !== null && posTagsData !== void 0 ? posTagsData : {},
-        ghostPosTags: ghostPosTagsData !== null && ghostPosTagsData !== void 0 ? ghostPosTagsData : {},
+        posTags: posTagsData,
+        ghostPosTags: ghostPosTagsData,
         grammarTransitions: grammarTransitionsData
       });
       succeedExp(EXPERIENCE_NAME.LOAD_GRAMMAR, 'singleton', {
@@ -198,7 +250,16 @@ function applyGrammarFilter(candidates, previousWord) {
   const filtered = [];
   const dropped = [];
   for (const entry of candidates) {
-    const candidateTags = posTags.get(entry.candidate.word.toLowerCase());
+    // The producer validates a multi-word term's *internal* grammar offline
+    // (boundary-clean, noun-headed, AUP-passed — spec §9), but nothing judges
+    // the transition into it. Exempting multi-word terms therefore let a noun
+    // this filter had just rejected re-enter wrapped in a bigram — "be" [AUX]
+    // dropped "quality" and then displayed "quality assurance". Only the term's
+    // first word takes part in the transition, so gate every term on that.
+    const surface = entry.candidate.word;
+    const firstSpace = surface.indexOf(' ');
+    const transitionWord = firstSpace === -1 ? surface : surface.slice(0, firstSpace);
+    const candidateTags = posTags.get(transitionWord.toLowerCase());
 
     // If candidate has no tags (unknown word), let it pass to be safe
     if (!candidateTags || candidateTags.length === 0) {
@@ -239,20 +300,35 @@ function getLmScore(word, lmLogits) {
 
 // ─── Public API ─────────────────────────────────────────────
 
-export function rankCandidates(candidates, contextVector, getWordVector, lmLogits, maxTenantFreq, previousWord) {
+/**
+ * Apply Stage 1, grammar, and nullable context-local LM evidence to candidates.
+ */
+export function rankCandidates(candidates, contextVector, getWordVector, lmLogits, maxFreqByType, previousWord, getCanonicalLmEvidence) {
   var _grammarMeta$dropped;
   // Stage 1
   const stage1Results = candidates.map(candidate => {
+    var _candidate$termType;
+    const termType = (_candidate$termType = candidate.termType) !== null && _candidate$termType !== void 0 ? _candidate$termType : 'word';
+    // Normalize freq within the candidate's own term-type population so a
+    // phrase (whose absolute counts are far below top unigrams) isn't crushed
+    // by the unigram max.
+    const maxFreq = maxFreqByType[termType] || 1;
     const {
       semanticScore,
       freqScore,
       stage1Score
-    } = scoreStage1(candidate, contextVector, getWordVector, maxTenantFreq);
+    } = scoreStage1(candidate, contextVector, getWordVector, maxFreq);
+    // Multi-word units get an NPMI association boost (Stage-1 only).
+    let adjustedStage1 = stage1Score;
+    if (termType !== 'word' && typeof candidate.association === 'number') {
+      const assoc = Math.max(0, Math.min(1, candidate.association));
+      adjustedStage1 = stage1Score * (1 + ASSOCIATION_BOOST * assoc);
+    }
     return {
       candidate,
       semanticScore,
       freqScore,
-      stage1Score
+      stage1Score: adjustedStage1
     };
   });
   const stage1Survivors = [];
@@ -277,26 +353,74 @@ export function rankCandidates(candidates, contextVector, getWordVector, lmLogit
     const values = Object.values(lmLogits);
     if (values.length > 0) lmMax = Math.max(...values);
   }
+  const canonicalEvidenceBySurface = new Map();
+  const maxLmRankingValueByTierAndContext = new Map();
+  for (const entry of filtered) {
+    var _getCanonicalLmEviden;
+    const evidence = (_getCanonicalLmEviden = getCanonicalLmEvidence === null || getCanonicalLmEvidence === void 0 ? void 0 : getCanonicalLmEvidence(entry.candidate.word)) !== null && _getCanonicalLmEviden !== void 0 ? _getCanonicalLmEviden : null;
+    if (!evidence) {
+      continue;
+    }
+    canonicalEvidenceBySurface.set(entry.candidate.word, evidence);
+    const rankingValue = evidence.source === 'canonical-full-surface' ? evidence.meanTokenLogProbability : evidence.rawLogit;
+    if (rankingValue !== undefined && Number.isFinite(rankingValue)) {
+      var _maxLmRankingValueByT;
+      const key = `${evidence.source}\u0000${evidence.contextKey}`;
+      const current = (_maxLmRankingValueByT = maxLmRankingValueByTierAndContext.get(key)) !== null && _maxLmRankingValueByT !== void 0 ? _maxLmRankingValueByT : -Infinity;
+      if (rankingValue > current) {
+        maxLmRankingValueByTierAndContext.set(key, rankingValue);
+      }
+    }
+  }
   const scored = filtered.map(entry => {
+    var _entry$candidate$term, _canonicalEvidenceByS;
+    const termType = (_entry$candidate$term = entry.candidate.termType) !== null && _entry$candidate$term !== void 0 ? _entry$candidate$term : 'word';
+    const isMultiWord = termType !== 'word';
     let lmScore = 0;
     let finalScore = entry.stage1Score;
-    if (lmLogits && lmMax >= LM_GATE_THRESHOLD) {
+    let lmEvidence = (_canonicalEvidenceByS = canonicalEvidenceBySurface.get(entry.candidate.word)) !== null && _canonicalEvidenceByS !== void 0 ? _canonicalEvidenceByS : null;
+    if (lmEvidence) {
+      const rankingValue = lmEvidence.source === 'canonical-full-surface' ? lmEvidence.meanTokenLogProbability : lmEvidence.rawLogit;
+      const maxRankingValue = maxLmRankingValueByTierAndContext.get(`${lmEvidence.source}\u0000${lmEvidence.contextKey}`);
+      if (rankingValue !== undefined && maxRankingValue !== undefined) {
+        lmEvidence = {
+          ...lmEvidence,
+          score: Math.exp(rankingValue - maxRankingValue)
+        };
+      }
+    }
+    if (lmEvidence) {
+      lmScore = lmEvidence.score;
+      finalScore = STAGE1_WEIGHT * entry.stage1Score + STAGE2_WEIGHT * lmScore;
+    } else if (!isMultiWord && lmLogits && lmMax >= LM_GATE_THRESHOLD) {
+      // Backward-compatible network slow-lane path.
       const rawLm = getLmScore(entry.candidate.word, lmLogits);
       if (rawLm !== 0) {
         const logitDiff = Math.log(rawLm) - Math.log(lmMax);
         lmScore = Math.exp(logitDiff);
+        lmEvidence = {
+          contextKey: 'network',
+          score: lmScore,
+          separatorKind: 'whitespace',
+          source: 'network-logit',
+          totalSurfaceCharCount: entry.candidate.word.length,
+          // The legacy BE word map does not report canonical token depth.
+          totalTokenCount: 0,
+          verifiedCharCount: 0,
+          verifiedTokenCount: 0
+        };
+        finalScore = STAGE1_WEIGHT * entry.stage1Score + STAGE2_WEIGHT * lmScore;
       }
-      // Words absent from the prefix-filtered payload get lmScore = 0,
-      // not 0.05, so they don't outrank genuine LM predictions.
-
-      finalScore = STAGE1_WEIGHT * entry.stage1Score + STAGE2_WEIGHT * lmScore;
     }
     return {
       word: entry.candidate.word,
       freqScore: entry.freqScore,
       semanticScore: entry.semanticScore,
       lmScore,
-      finalScore
+      lmEvidence,
+      finalScore,
+      stage1Score: entry.stage1Score,
+      termType
     };
   });
   scored.sort((a, b) => {

package/dist/es2019/pm-plugins/slow-lane-client.js

@@ -8,7 +8,8 @@
  */
 
 import { abortExp, EXPERIENCE_NAME, failExp, startExp, succeedExp } from '../analytics/ufo';
-import { isAutocompleteDebugEnabled } from './debug-mode';
+import { buildAutocompleteGatewayUrl } from './artifact-loader';
+import { CTC_STYLES, ctcTag } from './debug-mode';
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -20,8 +21,6 @@ import { isAutocompleteDebugEnabled } from './debug-mode';
 
 // eslint-disable-next-line require-unicode-regexp
 const WORD_BOUNDARY_CHARS = /[\s.,;:!?]/;
-// eslint-disable-next-line require-unicode-regexp
-const TRAILING_SLASH_REGEX = /\/$/;
 const DEFAULT_DEBOUNCE_MS = 300;
 
 /**
@@ -56,6 +55,7 @@ export const createSlowLaneClient = config => {
   };
   let debounceTimer = null;
   let lastRequestedText = '';
+  let storedContextInput = null;
   let storedContextVector = null;
   let storedLmLogits = null;
   let requestSeq = 0;
@@ -64,7 +64,7 @@ export const createSlowLaneClient = config => {
     if (!text || text.trim().length === 0) {
       return;
     }
-    const url = `${baseUrl.replace(TRAILING_SLASH_REGEX, '')}${endpoint}`;
+    const url = buildAutocompleteGatewayUrl(endpoint, baseUrl);
     const payload = {
       text,
       session_id: sessionId
@@ -76,16 +76,7 @@ export const createSlowLaneClient = config => {
         surface
       } : {})
     });
-    if (isAutocompleteDebugEnabled()) {
-      // eslint-disable-next-line no-console
-      console.groupCollapsed(`%c[SlowLane] %c📤 Sending context | ${text.length} chars`, 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
-      text.split('\n').forEach((line, i, arr) => {
-        // eslint-disable-next-line no-console
-        console.log(`  ${i === arr.length - 1 ? '▶' : ' '} ${line}`);
-      });
-      // eslint-disable-next-line no-console
-      console.groupEnd();
-    }
+    ctcTag('signal', `📤 network context sent · ${text.length} chars`, CTC_STYLES.section);
     try {
       const res = await fetchFn(url, {
         method: 'POST',
@@ -93,6 +84,7 @@ export const createSlowLaneClient = config => {
         body: JSON.stringify(payload)
       });
       if (!res.ok) {
+        storedContextInput = null;
         storedContextVector = null;
         storedLmLogits = null;
         failExp(EXPERIENCE_NAME.SLOW_LANE_FETCH, requestId, {
@@ -103,33 +95,23 @@ export const createSlowLaneClient = config => {
             surface
           } : {})
         });
-        if (isAutocompleteDebugEnabled()) {
-          // eslint-disable-next-line no-console
-          console.log(`%c[SlowLane] %c❌ Request failed (${res.status})`, 'color: #9c27b0; font-weight: bold;', 'color: #f44336;');
-        }
+        ctcTag('signal', `❌ network request failed (${res.status})`, CTC_STYLES.bad);
         return;
       }
       const data = await res.json();
       if (data.semantic_vector && Array.isArray(data.semantic_vector)) {
         storedContextVector = new Float32Array(data.semantic_vector);
+        storedContextInput = text;
       } else {
         storedContextVector = null;
+        storedContextInput = null;
       }
       if (data.lm_logits && typeof data.lm_logits === 'object') {
         storedLmLogits = data.lm_logits;
       } else {
         storedLmLogits = null;
       }
-      if (isAutocompleteDebugEnabled()) {
-        // eslint-disable-next-line no-console
-        console.groupCollapsed(`%c[SlowLane] %c📥 Response received`, 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
-        // eslint-disable-next-line no-console
-        console.log(storedContextVector ? `✅ semantic_vector: ${storedContextVector.length} dims` : '❌ No semantic_vector');
-        // eslint-disable-next-line no-console
-        console.log(storedLmLogits ? `✅ lm_logits: ${Object.keys(storedLmLogits).length} tokens` : '❌ No lm_logits');
-        // eslint-disable-next-line no-console
-        console.groupEnd();
-      }
+      ctcTag('signal', `📥 network response · ${storedContextVector ? `semantic ✅ ${storedContextVector.length}d` : 'semantic ❌'} · ${storedLmLogits ? `logits ✅ ${Object.keys(storedLmLogits).length}tok` : 'logits ❌'}`, CTC_STYLES.section);
       succeedExp(EXPERIENCE_NAME.SLOW_LANE_FETCH, requestId, {
         textLength: text.length,
         hasVector: storedContextVector !== null,
@@ -146,6 +128,7 @@ export const createSlowLaneClient = config => {
       });
       // eslint-disable-next-line no-unused-vars
     } catch (e) {
+      storedContextInput = null;
       storedContextVector = null;
       storedLmLogits = null;
       failExp(EXPERIENCE_NAME.SLOW_LANE_FETCH, requestId, {
@@ -155,10 +138,7 @@ export const createSlowLaneClient = config => {
           surface
         } : {})
       });
-      if (isAutocompleteDebugEnabled()) {
-        // eslint-disable-next-line no-console
-        console.log('%c[SlowLane] %c❌ Network error — context cleared', 'color: #9c27b0; font-weight: bold;', 'color: #f44336;');
-      }
+      ctcTag('signal', '❌ network error — context cleared', CTC_STYLES.bad);
     } finally {
       if (inflightRequestId === requestId) {
         inflightRequestId = null;
@@ -187,9 +167,11 @@ export const createSlowLaneClient = config => {
   };
   return {
     updateContext: updateContextDebounced,
+    getContextInput: () => storedContextInput,
     getContextVector: () => storedContextVector,
     getLmLogits: () => storedLmLogits,
     setContextVector: vector => {
+      storedContextInput = null;
       storedContextVector = vector;
     },
     setLmLogits: logits => {
@@ -199,14 +181,89 @@ export const createSlowLaneClient = config => {
   };
 };
 let defaultSlowLaneClient = null;
-export const setDefaultSlowLaneClient = client => {
+let defaultSlowLaneClientRegistration = null;
+const supportsCanonicalSurfaceScoring = client => typeof (client === null || client === void 0 ? void 0 : client.primeBoundaryLm) === 'function' && typeof (client === null || client === void 0 ? void 0 : client.requestProgressiveSurfaceScores) === 'function';
+export const setDefaultSlowLaneClient = (client, registration) => {
   defaultSlowLaneClient = client;
+  defaultSlowLaneClientRegistration = client ? registration !== null && registration !== void 0 ? registration : {
+    clientId: 'untracked',
+    kind: supportsCanonicalSurfaceScoring(client) ? 'localLlm' : 'server'
+  } : null;
+};
+
+/**
+ * Clear the shared client only when the caller still owns the registration.
+ *
+ * Multiple editor instances can briefly overlap during a React/editor remount.
+ * An older instance must not disconnect the newer instance when its delayed
+ * teardown runs after the newer client has registered.
+ */
+export const clearDefaultSlowLaneClient = client => {
+  if (defaultSlowLaneClient !== client) {
+    return false;
+  }
+  defaultSlowLaneClient = null;
+  defaultSlowLaneClientRegistration = null;
+  return true;
+};
+export const getDefaultSlowLaneClientStatus = () => {
+  var _defaultSlowLaneClien, _defaultSlowLaneClien2, _defaultSlowLaneClien3, _defaultSlowLaneClien4, _defaultSlowLaneClien5, _defaultSlowLaneClien6, _defaultSlowLaneClien7;
+  const canonicalScoringSupported = supportsCanonicalSurfaceScoring(defaultSlowLaneClient);
+  const isLocalClient = ((_defaultSlowLaneClien = defaultSlowLaneClientRegistration) === null || _defaultSlowLaneClien === void 0 ? void 0 : _defaultSlowLaneClien.kind) === 'localLlm';
+  return {
+    registered: defaultSlowLaneClient !== null,
+    clientId: (_defaultSlowLaneClien2 = (_defaultSlowLaneClien3 = defaultSlowLaneClientRegistration) === null || _defaultSlowLaneClien3 === void 0 ? void 0 : _defaultSlowLaneClien3.clientId) !== null && _defaultSlowLaneClien2 !== void 0 ? _defaultSlowLaneClien2 : null,
+    clientKind: (_defaultSlowLaneClien4 = (_defaultSlowLaneClien5 = defaultSlowLaneClientRegistration) === null || _defaultSlowLaneClien5 === void 0 ? void 0 : _defaultSlowLaneClien5.kind) !== null && _defaultSlowLaneClien4 !== void 0 ? _defaultSlowLaneClien4 : null,
+    canonicalScoringSupported,
+    localModelReady: isLocalClient && typeof ((_defaultSlowLaneClien6 = defaultSlowLaneClient) === null || _defaultSlowLaneClien6 === void 0 ? void 0 : _defaultSlowLaneClien6.isReady) === 'function' ? defaultSlowLaneClient.isReady() : null,
+    canonicalSurfaceCount: canonicalScoringSupported && typeof ((_defaultSlowLaneClien7 = defaultSlowLaneClient) === null || _defaultSlowLaneClien7 === void 0 ? void 0 : _defaultSlowLaneClien7.getCanonicalSurfaceCount) === 'function' ? defaultSlowLaneClient.getCanonicalSurfaceCount() : null
+  };
 };
 export const getStoredContextVector = () => {
-  var _defaultSlowLaneClien, _defaultSlowLaneClien2;
-  return (_defaultSlowLaneClien = (_defaultSlowLaneClien2 = defaultSlowLaneClient) === null || _defaultSlowLaneClien2 === void 0 ? void 0 : _defaultSlowLaneClien2.getContextVector()) !== null && _defaultSlowLaneClien !== void 0 ? _defaultSlowLaneClien : null;
+  var _defaultSlowLaneClien8, _defaultSlowLaneClien9;
+  return (_defaultSlowLaneClien8 = (_defaultSlowLaneClien9 = defaultSlowLaneClient) === null || _defaultSlowLaneClien9 === void 0 ? void 0 : _defaultSlowLaneClien9.getContextVector()) !== null && _defaultSlowLaneClien8 !== void 0 ? _defaultSlowLaneClien8 : null;
+};
+export const getStoredContextInput = () => {
+  var _defaultSlowLaneClien0, _defaultSlowLaneClien1, _defaultSlowLaneClien10;
+  return (_defaultSlowLaneClien0 = (_defaultSlowLaneClien1 = defaultSlowLaneClient) === null || _defaultSlowLaneClien1 === void 0 ? void 0 : (_defaultSlowLaneClien10 = _defaultSlowLaneClien1.getContextInput) === null || _defaultSlowLaneClien10 === void 0 ? void 0 : _defaultSlowLaneClien10.call(_defaultSlowLaneClien1)) !== null && _defaultSlowLaneClien0 !== void 0 ? _defaultSlowLaneClien0 : null;
 };
 export const getStoredLmLogits = () => {
-  var _defaultSlowLaneClien3, _defaultSlowLaneClien4;
-  return (_defaultSlowLaneClien3 = (_defaultSlowLaneClien4 = defaultSlowLaneClient) === null || _defaultSlowLaneClien4 === void 0 ? void 0 : _defaultSlowLaneClien4.getLmLogits()) !== null && _defaultSlowLaneClien3 !== void 0 ? _defaultSlowLaneClien3 : null;
+  var _defaultSlowLaneClien11, _defaultSlowLaneClien12;
+  return (_defaultSlowLaneClien11 = (_defaultSlowLaneClien12 = defaultSlowLaneClient) === null || _defaultSlowLaneClien12 === void 0 ? void 0 : _defaultSlowLaneClien12.getLmLogits()) !== null && _defaultSlowLaneClien11 !== void 0 ? _defaultSlowLaneClien11 : null;
+};
+export const getBoundaryLmState = contextKey => {
+  var _defaultSlowLaneClien13, _defaultSlowLaneClien14, _defaultSlowLaneClien15;
+  return (_defaultSlowLaneClien13 = (_defaultSlowLaneClien14 = defaultSlowLaneClient) === null || _defaultSlowLaneClien14 === void 0 ? void 0 : (_defaultSlowLaneClien15 = _defaultSlowLaneClien14.getBoundaryLmState) === null || _defaultSlowLaneClien15 === void 0 ? void 0 : _defaultSlowLaneClien15.call(_defaultSlowLaneClien14, contextKey)) !== null && _defaultSlowLaneClien13 !== void 0 ? _defaultSlowLaneClien13 : null;
+};
+export const getCanonicalSurfaceTokenIds = surface => {
+  var _defaultSlowLaneClien16, _defaultSlowLaneClien17, _defaultSlowLaneClien18;
+  return (_defaultSlowLaneClien16 = (_defaultSlowLaneClien17 = defaultSlowLaneClient) === null || _defaultSlowLaneClien17 === void 0 ? void 0 : (_defaultSlowLaneClien18 = _defaultSlowLaneClien17.getCanonicalSurfaceTokenIds) === null || _defaultSlowLaneClien18 === void 0 ? void 0 : _defaultSlowLaneClien18.call(_defaultSlowLaneClien17, surface)) !== null && _defaultSlowLaneClien16 !== void 0 ? _defaultSlowLaneClien16 : null;
+};
+export const getSurfaceScore = (contextKey, surface) => {
+  var _defaultSlowLaneClien19, _defaultSlowLaneClien20, _defaultSlowLaneClien21;
+  return (_defaultSlowLaneClien19 = (_defaultSlowLaneClien20 = defaultSlowLaneClient) === null || _defaultSlowLaneClien20 === void 0 ? void 0 : (_defaultSlowLaneClien21 = _defaultSlowLaneClien20.getSurfaceScore) === null || _defaultSlowLaneClien21 === void 0 ? void 0 : _defaultSlowLaneClien21.call(_defaultSlowLaneClien20, contextKey, surface)) !== null && _defaultSlowLaneClien19 !== void 0 ? _defaultSlowLaneClien19 : null;
+};
+export const getProgressiveSurfaceEvidence = (contextKey, surface) => {
+  var _defaultSlowLaneClien22, _defaultSlowLaneClien23, _defaultSlowLaneClien24;
+  return (_defaultSlowLaneClien22 = (_defaultSlowLaneClien23 = defaultSlowLaneClient) === null || _defaultSlowLaneClien23 === void 0 ? void 0 : (_defaultSlowLaneClien24 = _defaultSlowLaneClien23.getProgressiveSurfaceEvidence) === null || _defaultSlowLaneClien24 === void 0 ? void 0 : _defaultSlowLaneClien24.call(_defaultSlowLaneClien23, contextKey, surface)) !== null && _defaultSlowLaneClien22 !== void 0 ? _defaultSlowLaneClien22 : null;
+};
+export const primeBoundaryLm = input => {
+  var _defaultSlowLaneClien25, _defaultSlowLaneClien26;
+  (_defaultSlowLaneClien25 = defaultSlowLaneClient) === null || _defaultSlowLaneClien25 === void 0 ? void 0 : (_defaultSlowLaneClien26 = _defaultSlowLaneClien25.primeBoundaryLm) === null || _defaultSlowLaneClien26 === void 0 ? void 0 : _defaultSlowLaneClien26.call(_defaultSlowLaneClien25, input);
+};
+export const requestProgressiveSurfaceScores = input => {
+  var _defaultSlowLaneClien27, _defaultSlowLaneClien28;
+  (_defaultSlowLaneClien27 = defaultSlowLaneClient) === null || _defaultSlowLaneClien27 === void 0 ? void 0 : (_defaultSlowLaneClien28 = _defaultSlowLaneClien27.requestProgressiveSurfaceScores) === null || _defaultSlowLaneClien28 === void 0 ? void 0 : _defaultSlowLaneClien28.call(_defaultSlowLaneClien27, input);
+};
+export const isCanonicalSurfaceScoringSupported = () => supportsCanonicalSurfaceScoring(defaultSlowLaneClient);
+
+/**
+ * How many surfaces the canonical token map currently holds. Goes from zero to
+ * its final size once the artifact lands, which is the only point at which
+ * `getCanonicalSurfaceTokenIds` starts answering — so callers memoising over
+ * that lookup can use this to detect the transition.
+ */
+export const getCanonicalSurfaceCount = () => {
+  var _defaultSlowLaneClien29, _defaultSlowLaneClien30, _defaultSlowLaneClien31;
+  return (_defaultSlowLaneClien29 = (_defaultSlowLaneClien30 = defaultSlowLaneClient) === null || _defaultSlowLaneClien30 === void 0 ? void 0 : (_defaultSlowLaneClien31 = _defaultSlowLaneClien30.getCanonicalSurfaceCount) === null || _defaultSlowLaneClien31 === void 0 ? void 0 : _defaultSlowLaneClien31.call(_defaultSlowLaneClien30)) !== null && _defaultSlowLaneClien29 !== void 0 ? _defaultSlowLaneClien29 : 0;
 };