@atlaskit/editor-plugin-autocomplete 3.5.0 → 3.6.1

package/dist/esm/pm-plugins/local-slow-lane-client.js

@@ -55,6 +55,19 @@ import { isWordBoundary } from './slow-lane-client';
 
 // Same return type as createSlowLaneClient for drop-in compatibility
 
+/**
+ * Why the local engine failed to load/start.
+ *
+ * The first three are user-machine limitations (WebGPU missing, no compatible
+ * GPU adapter, GPU lacks the `shader-f16` feature the model needs);
+ * `insufficient_memory` is hit when weights don't fit in VRAM. The rest cover
+ * delivery/runtime failures unrelated to hardware.
+ */
+
+/** Snapshot of the machine's WebGPU support, used to explain hardware limits. */
+
+// Minimal WebGPU shape: lib.dom types aren't guaranteed in this build target.
+
 // ─── Constants ───────────────────────────────────────────────────────────────
 
 var DEFAULT_DEBOUNCE_MS = 300;
@@ -601,6 +614,8 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
     debounceMs = _config$debounceMs === void 0 ? DEFAULT_DEBOUNCE_MS : _config$debounceMs,
     onUpdate = config.onUpdate,
     onStatus = config.onStatus,
+    onLoadError = config.onLoadError,
+    onLoadSuccess = config.onLoadSuccess,
     _config$modelId = config.modelId,
     modelId = _config$modelId === void 0 ? LOCAL_MLC_CAUSAL_MODEL_ID : _config$modelId,
     customModelConfig = config.customModelConfig;
@@ -647,28 +662,191 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
     }
     onStatus === null || onStatus === void 0 || onStatus(message);
   };
-  var initEngine = /*#__PURE__*/function () {
+  var bytesToMB = function bytesToMB(bytes) {
+    return typeof bytes === 'number' ? Math.round(bytes / (1024 * 1024)) : undefined;
+  };
+
+  /**
+   * Inspect the machine's WebGPU support so a load failure can be attributed
+   * to a concrete hardware/browser limitation rather than a generic error.
+   */
+  var probeWebGpuCapabilities = /*#__PURE__*/function () {
     var _ref8 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
-      var _yield$Promise$all3, _yield$Promise$all4, _yield$Promise$all4$, MLCEngineCtor, prebuiltAppConfig, customModelRecord, appConfig, newEngine, errorMsg, _t;
+      var gpu, _adapter$limits, _adapter$limits2, adapter, vendor, architecture, _adapter$info, _adapter$requestAdapt, info, _t, _t2, _t3;
       return _regeneratorRuntime.wrap(function (_context2) {
         while (1) switch (_context2.prev = _context2.next) {
           case 0:
-            _context2.prev = 0;
-            if (isAutocompleteDebugEnabled()) {
-              // eslint-disable-next-line no-console
-              console.log("%c[LocalSlowLane] %c\uD83D\uDE80 Initialising MLC engine with models: ".concat(modelId, " (LM) + ").concat(LOCAL_MLC_EMBEDDING_MODEL_ID, " (embedder)"), 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
-            }
-            onStatus === null || onStatus === void 0 || onStatus("Initialising models: ".concat(modelId, " + ").concat(LOCAL_MLC_EMBEDDING_MODEL_ID, "\u2026"));
-            if ('gpu' in navigator) {
+            gpu = navigator.gpu;
+            if (gpu) {
               _context2.next = 1;
               break;
             }
-            throw new Error('WebGPU not supported');
+            return _context2.abrupt("return", {
+              available: false
+            });
           case 1:
+            _context2.prev = 1;
             _context2.next = 2;
-            return Promise.all([import( /* webpackChunkName: "@atlaskit-internal_editor-plugin-autocomplete-mlc-web-llm" */'@mlc-ai/web-llm'), loadBePayloadData()]);
+            return gpu.requestAdapter();
+          case 2:
+            adapter = _context2.sent;
+            if (adapter) {
+              _context2.next = 3;
+              break;
+            }
+            return _context2.abrupt("return", {
+              available: true,
+              adapterAvailable: false
+            });
+          case 3:
+            _context2.prev = 3;
+            if (!((_adapter$info = adapter.info) !== null && _adapter$info !== void 0)) {
+              _context2.next = 4;
+              break;
+            }
+            _t = _adapter$info;
+            _context2.next = 6;
+            break;
+          case 4:
+            _context2.next = 5;
+            return (_adapter$requestAdapt = adapter.requestAdapterInfo) === null || _adapter$requestAdapt === void 0 ? void 0 : _adapter$requestAdapt.call(adapter);
+          case 5:
+            _t = _context2.sent;
+          case 6:
+            info = _t;
+            vendor = (info === null || info === void 0 ? void 0 : info.vendor) || undefined;
+            architecture = (info === null || info === void 0 ? void 0 : info.architecture) || undefined;
+            _context2.next = 8;
+            break;
+          case 7:
+            _context2.prev = 7;
+            _t2 = _context2["catch"](3);
+          case 8:
+            return _context2.abrupt("return", {
+              available: true,
+              adapterAvailable: true,
+              shaderF16Supported: adapter.features.has('shader-f16'),
+              maxBufferSizeMB: bytesToMB((_adapter$limits = adapter.limits) === null || _adapter$limits === void 0 ? void 0 : _adapter$limits.maxBufferSize),
+              maxStorageBufferBindingSizeMB: bytesToMB((_adapter$limits2 = adapter.limits) === null || _adapter$limits2 === void 0 ? void 0 : _adapter$limits2.maxStorageBufferBindingSize),
+              vendor: vendor,
+              architecture: architecture
+            });
+          case 9:
+            _context2.prev = 9;
+            _t3 = _context2["catch"](1);
+            return _context2.abrupt("return", {
+              available: true,
+              adapterAvailable: false
+            });
+          case 10:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, null, [[1, 9], [3, 7]]);
+    }));
+    return function probeWebGpuCapabilities() {
+      return _ref8.apply(this, arguments);
+    };
+  }();
+
+  /** Map an MLC/WebLLM engine-creation error message to a coarse reason. */
+  var classifyEngineError = function classifyEngineError(message) {
+    var lower = message.toLowerCase();
+    if (lower.includes('loading chunk') || lower.includes('dynamically imported module') || lower.includes('dynamic import')) {
+      return 'module_load_failed';
+    }
+    if (lower.includes('out of memory') ||
+    // eslint-disable-next-line require-unicode-regexp
+    /\boom\b/.test(lower) || lower.includes('allocation') || lower.includes('exceeds') || lower.includes('buffer size') || lower.includes('not enough memory')) {
+      return 'insufficient_memory';
+    }
+    // Pre-flight already returns missing_shader_f16 when the feature is absent,
+    // so only match the exact feature token here — not bare 'shader' (compile
+    // errors) or bare 'f16' (present in model ids like q0f16-MLC).
+    if (lower.includes('shader-f16') || lower.includes('shader_f16')) {
+      return 'missing_shader_f16';
+    }
+    if (lower.includes('fetch') || lower.includes('network') || lower.includes('download') || lower.includes('http') || lower.includes('cache')) {
+      return 'model_download_failed';
+    }
+    return 'init_failed';
+  };
+
+  // Canonical, controlled failure descriptions. We never emit the raw engine
+  // error into analytics — it can embed customer-context URLs/paths (HOT-120175)
+  // — so the analytics `message` is always one of these fixed strings.
+  var LOAD_FAILURE_MESSAGE = {
+    webgpu_unavailable: 'WebGPU is not available in this browser',
+    webgpu_no_adapter: 'No compatible WebGPU adapter found',
+    missing_shader_f16: 'GPU does not support the shader-f16 feature',
+    insufficient_memory: 'Insufficient GPU memory to load the model',
+    model_download_failed: 'Failed to download model assets',
+    module_load_failed: 'Failed to load the web-llm runtime module',
+    init_failed: 'Model engine failed to initialise'
+  };
+  var handleLoadFailure = function handleLoadFailure(reason, capabilities, debugDetail) {
+    ready = false;
+    var message = LOAD_FAILURE_MESSAGE[reason];
+    if (isAutocompleteDebugEnabled()) {
+      // eslint-disable-next-line no-console
+      console.log("[LocalSlowLane] Engine initialisation failed (".concat(reason, "): ").concat(debugDetail !== null && debugDetail !== void 0 ? debugDetail : message));
+    }
+    onStatus === null || onStatus === void 0 || onStatus("Engine initialisation failed: ".concat(message));
+    onLoadError === null || onLoadError === void 0 || onLoadError({
+      reason: reason,
+      message: message,
+      modelId: modelId,
+      embeddingModelId: LOCAL_MLC_EMBEDDING_MODEL_ID,
+      capabilities: capabilities
+    });
+    engineInitPromise = null;
+    initFailed = true;
+  };
+  var initEngine = /*#__PURE__*/function () {
+    var _ref9 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+      var capabilities, startTime, _yield$Promise$all3, _yield$Promise$all4, _yield$Promise$all4$, MLCEngineCtor, prebuiltAppConfig, customModelRecord, appConfig, newEngine, loadDurationMs, errorMsg, _t4;
+      return _regeneratorRuntime.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.next = 1;
+            return probeWebGpuCapabilities();
+          case 1:
+            capabilities = _context3.sent;
+            if (capabilities.available) {
+              _context3.next = 2;
+              break;
+            }
+            handleLoadFailure('webgpu_unavailable', capabilities);
+            return _context3.abrupt("return");
           case 2:
-            _yield$Promise$all3 = _context2.sent;
+            if (!(capabilities.adapterAvailable === false)) {
+              _context3.next = 3;
+              break;
+            }
+            handleLoadFailure('webgpu_no_adapter', capabilities);
+            return _context3.abrupt("return");
+          case 3:
+            if (!(capabilities.shaderF16Supported === false)) {
+              _context3.next = 4;
+              break;
+            }
+            handleLoadFailure('missing_shader_f16', capabilities);
+            return _context3.abrupt("return");
+          case 4:
+            startTime = performance.now();
+            _context3.prev = 5;
+            if (isAutocompleteDebugEnabled()) {
+              // eslint-disable-next-line no-console
+              console.log("%c[LocalSlowLane] %c\uD83D\uDE80 Initialising MLC engine with models: ".concat(modelId, " (LM) + ").concat(LOCAL_MLC_EMBEDDING_MODEL_ID, " (embedder)"), 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
+            }
+            onStatus === null || onStatus === void 0 || onStatus("Initialising models: ".concat(modelId, " + ").concat(LOCAL_MLC_EMBEDDING_MODEL_ID, "\u2026"));
+
+            // Fetch the web-llm runtime and the BE-parity lookup tables in parallel;
+            // both are dynamically imported so they stay out of the main editor chunk.
+            _context3.next = 6;
+            return Promise.all([import( /* webpackChunkName: "@atlaskit-internal_editor-plugin-autocomplete-mlc-web-llm" */'@mlc-ai/web-llm'), loadBePayloadData()]);
+          case 6:
+            _yield$Promise$all3 = _context3.sent;
             _yield$Promise$all4 = _slicedToArray(_yield$Promise$all3, 1);
             _yield$Promise$all4$ = _yield$Promise$all4[0];
             MLCEngineCtor = _yield$Promise$all4$.MLCEngine;
@@ -696,19 +874,20 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
               initProgressCallback: initProgressCallback,
               logitProcessorRegistry: new Map([[modelId, lmLogitsCapture]])
             });
-            _context2.next = 3;
+            _context3.next = 7;
             return newEngine.reload([modelId, LOCAL_MLC_EMBEDDING_MODEL_ID]);
-          case 3:
+          case 7:
             if (!destroyed) {
-              _context2.next = 4;
+              _context3.next = 8;
               break;
             }
             // destroy() was called while we were loading — clean up
             unloadEngine(newEngine);
-            return _context2.abrupt("return");
-          case 4:
+            return _context3.abrupt("return");
+          case 8:
             engine = newEngine;
             ready = true;
+            loadDurationMs = Math.round(performance.now() - startTime);
             if (isAutocompleteDebugEnabled()) {
               // eslint-disable-next-line no-console
               console.log('%c[LocalSlowLane] %c✅ Both models loaded and ready', 'color: #9c27b0; font-weight: bold;', 'color: #4caf50;');
@@ -720,28 +899,27 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
               console.log('%c[LocalSlowLane] %c🔢 Embedder     →', 'color: #9c27b0; font-weight: bold;', 'color: #009688; font-weight: bold;', LOCAL_MLC_EMBEDDING_MODEL_ID);
             }
             onStatus === null || onStatus === void 0 || onStatus('Model loaded and ready.');
-            _context2.next = 6;
+            onLoadSuccess === null || onLoadSuccess === void 0 || onLoadSuccess({
+              modelId: modelId,
+              embeddingModelId: LOCAL_MLC_EMBEDDING_MODEL_ID,
+              loadDurationMs: loadDurationMs,
+              capabilities: capabilities
+            });
+            _context3.next = 10;
             break;
-          case 5:
-            _context2.prev = 5;
-            _t = _context2["catch"](0);
-            errorMsg = _t instanceof Error ? _t.message : String(_t);
-            ready = false;
-            if (isAutocompleteDebugEnabled()) {
-              // eslint-disable-next-line no-console
-              console.log("[LocalSlowLane] Engine initialisation failed: ".concat(errorMsg));
-            }
-            onStatus === null || onStatus === void 0 || onStatus("Engine initialisation failed: ".concat(errorMsg));
-            engineInitPromise = null;
-            initFailed = true;
-          case 6:
+          case 9:
+            _context3.prev = 9;
+            _t4 = _context3["catch"](5);
+            errorMsg = _t4 instanceof Error ? _t4.message : String(_t4);
+            handleLoadFailure(classifyEngineError(errorMsg), capabilities, errorMsg);
+          case 10:
           case "end":
-            return _context2.stop();
+            return _context3.stop();
         }
-      }, _callee2, null, [[0, 5]]);
+      }, _callee3, null, [[5, 9]]);
     }));
     return function initEngine() {
-      return _ref8.apply(this, arguments);
+      return _ref9.apply(this, arguments);
     };
   }();
   var ensureEngineInitialized = function ensureEngineInitialized() {
@@ -768,16 +946,16 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
    *     384-d semantic vector (passage-encoded; see `wrapForArctic`).
    */
   var runInference = /*#__PURE__*/function () {
-    var _ref9 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(text, requestId) {
-      var lmText, semanticText, arcticInput, captureCompletionTime, _data, tStart, tLmDone, tEmbDone, _yield$Promise$all5, _yield$Promise$all6, embeddingResponse, rawLogits, payload, embedding, sumSq, i, topTokens, errorMsg, _t2;
-      return _regeneratorRuntime.wrap(function (_context3) {
-        while (1) switch (_context3.prev = _context3.next) {
+    var _ref0 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(text, requestId) {
+      var lmText, semanticText, arcticInput, captureCompletionTime, _data, tStart, tLmDone, tEmbDone, _yield$Promise$all5, _yield$Promise$all6, embeddingResponse, rawLogits, payload, embedding, sumSq, i, topTokens, errorMsg, _t5;
+      return _regeneratorRuntime.wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
           case 0:
             if (!(!engine || destroyed)) {
-              _context3.next = 1;
+              _context4.next = 1;
               break;
             }
-            return _context3.abrupt("return");
+            return _context4.abrupt("return");
           case 1:
             // Clear the capture buffer so we read only this pass's logits. The engine
             // serialises per-model requests and updateContext is debounced, so the
@@ -804,11 +982,11 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
               // eslint-disable-next-line no-console
               console.log("%c[LocalSlowLane] %c\uD83E\uDDE0 LM input (".concat(lmText.length, " chars, ").concat(splitOnWhitespace(lmText).length, " words): \"").concat(lmText.length > 100 ? "".concat(lmText.slice(0, 100), "\u2026") : lmText, "\""), 'color: #9c27b0; font-weight: bold;', 'color: #2196f3;');
             }
-            _context3.prev = 2;
+            _context4.prev = 2;
             tStart = performance.now();
             tLmDone = 0;
             tEmbDone = 0;
-            _context3.next = 3;
+            _context4.next = 3;
             return Promise.all([captureCompletionTime(engine.completions.create({
               model: modelId,
               prompt: lmText,
@@ -824,7 +1002,7 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
               tEmbDone = resolvedAt;
             })]);
           case 3:
-            _yield$Promise$all5 = _context3.sent;
+            _yield$Promise$all5 = _context4.sent;
             _yield$Promise$all6 = _slicedToArray(_yield$Promise$all5, 2);
             embeddingResponse = _yield$Promise$all6[1];
             if (isAutocompleteDebugEnabled()) {
@@ -834,10 +1012,10 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
 
             // Discard stale results
             if (!(requestId < latestRequestId || destroyed)) {
-              _context3.next = 4;
+              _context4.next = 4;
               break;
             }
-            return _context3.abrupt("return");
+            return _context4.abrupt("return");
           case 4:
             // ── LM logits: whole-word BE-parity payload ──────────────────
             rawLogits = lmLogitsCapture.captured;
@@ -871,17 +1049,17 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
               // eslint-disable-next-line no-console
               console.log(storedLmLogits ? "\u2705 lm_logits: ".concat(Object.keys(storedLmLogits).length, " words") : '❌ No lm_logits');
               if (storedLmLogits) {
-                topTokens = Object.entries(storedLmLogits).sort(function (_ref0, _ref1) {
-                  var _ref10 = _slicedToArray(_ref0, 2),
-                    a = _ref10[1];
+                topTokens = Object.entries(storedLmLogits).sort(function (_ref1, _ref10) {
                   var _ref11 = _slicedToArray(_ref1, 2),
-                    b = _ref11[1];
+                    a = _ref11[1];
+                  var _ref12 = _slicedToArray(_ref10, 2),
+                    b = _ref12[1];
                   return b - a;
                 }).slice(0, 10); // eslint-disable-next-line no-console
-                console.log('Top 10 predictions:', topTokens.map(function (_ref12) {
-                  var _ref13 = _slicedToArray(_ref12, 2),
-                    t = _ref13[0],
-                    p = _ref13[1];
+                console.log('Top 10 predictions:', topTokens.map(function (_ref13) {
+                  var _ref14 = _slicedToArray(_ref13, 2),
+                    t = _ref14[0],
+                    p = _ref14[1];
                   return "".concat(t, ": ").concat((p * 100).toFixed(1), "%");
                 }).join(', '));
               }
@@ -893,16 +1071,16 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
               hasVector: storedContextVector !== null,
               hasLmLogits: storedLmLogits !== null
             });
-            _context3.next = 7;
+            _context4.next = 7;
             break;
           case 5:
-            _context3.prev = 5;
-            _t2 = _context3["catch"](2);
+            _context4.prev = 5;
+            _t5 = _context4["catch"](2);
             if (!(requestId < latestRequestId || destroyed)) {
-              _context3.next = 6;
+              _context4.next = 6;
               break;
             }
-            return _context3.abrupt("return");
+            return _context4.abrupt("return");
           case 6:
             storedContextVector = null;
             storedLmLogits = null;
@@ -911,19 +1089,19 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
               hasVector: false,
               hasLmLogits: false
             });
-            errorMsg = _t2 instanceof Error ? _t2.message : String(_t2);
+            errorMsg = _t5 instanceof Error ? _t5.message : String(_t5);
             if (isAutocompleteDebugEnabled()) {
               // eslint-disable-next-line no-console
               console.log("%c[LocalSlowLane] %c\u274C Inference error (request #".concat(requestId, "): ").concat(errorMsg), 'color: #9c27b0; font-weight: bold;', 'color: #f44336;');
             }
           case 7:
           case "end":
-            return _context3.stop();
+            return _context4.stop();
         }
-      }, _callee3, null, [[2, 5]]);
+      }, _callee4, null, [[2, 5]]);
     }));
     return function runInference(_x, _x2) {
-      return _ref9.apply(this, arguments);
+      return _ref0.apply(this, arguments);
     };
   }();
 

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

@@ -729,7 +729,8 @@ var unwrapJsonModule = function unwrapJsonModule(mod, shape) {
 };
 export var loadVectorsAsync = /*#__PURE__*/function () {
   var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(options) {
-    var url, _wordIndexOuter$index, res, buffer, float32, wordIndexModule, wordIndexOuter, wordIndex, nWords, dim, _t, _t2;
+    var _options$isLocalLLM;
+    var isLocalLLM, url, _wordIndexOuter$index, res, buffer, float32, wordIndexModule, wordIndexOuter, wordIndex, nWords, dim, _t, _t2;
     return _regeneratorRuntime.wrap(function (_context) {
       while (1) switch (_context.prev = _context.next) {
         case 0:
@@ -747,8 +748,11 @@ export var loadVectorsAsync = /*#__PURE__*/function () {
           console.warn('[text-predictor] loadVectorsAsync called without a getBinaryUrl — vectors will not load. Pass getVectorsBinaryUrl via plugin options.');
           return _context.abrupt("return");
         case 2:
+          isLocalLLM = (_options$isLocalLLM = options === null || options === void 0 ? void 0 : options.isLocalLLM) !== null && _options$isLocalLLM !== void 0 ? _options$isLocalLLM : false;
           vectorsLoadStarted = true;
-          startExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton');
+          startExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', {
+            isLocalLLM: isLocalLLM
+          });
           _context.prev = 3;
           _context.next = 4;
           return options.getBinaryUrl();
@@ -761,6 +765,7 @@ export var loadVectorsAsync = /*#__PURE__*/function () {
           _t = _context["catch"](3);
           vectorsLoadStarted = false;
           failExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', {
+            isLocalLLM: isLocalLLM,
             errorType: 'resolve_url'
           });
           // eslint-disable-next-line no-console
@@ -778,6 +783,7 @@ export var loadVectorsAsync = /*#__PURE__*/function () {
           }
           vectorsLoadStarted = false;
           failExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', {
+            isLocalLLM: isLocalLLM,
             status: res.status,
             errorType: 'http_error'
           });
@@ -810,6 +816,7 @@ export var loadVectorsAsync = /*#__PURE__*/function () {
             dim: dim
           };
           succeedExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', {
+            isLocalLLM: isLocalLLM,
             wordCount: nWords,
             dim: dim,
             sizeBytes: float32.byteLength
@@ -829,6 +836,7 @@ export var loadVectorsAsync = /*#__PURE__*/function () {
           _t2 = _context["catch"](6);
           vectorsLoadStarted = false;
           failExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', {
+            isLocalLLM: isLocalLLM,
             errorType: 'network'
           });
           // eslint-disable-next-line no-console
@@ -847,19 +855,23 @@ export var initVectors = function initVectors(store) {
   vectorStore = store;
 };
 var vocabularyLoadPromise;
-export var loadDefaultVocabulary = function loadDefaultVocabulary() {
+export var loadDefaultVocabulary = function loadDefaultVocabulary(options) {
+  var _options$isLocalLLM2;
   if (isInitialized) {
     return Promise.resolve();
   }
   if (vocabularyLoadPromise) {
     return vocabularyLoadPromise;
   }
+  var isLocalLLM = (_options$isLocalLLM2 = options === null || options === void 0 ? void 0 : options.isLocalLLM) !== null && _options$isLocalLLM2 !== void 0 ? _options$isLocalLLM2 : false;
   vocabularyLoadPromise = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
     var _yield$Promise$all, _yield$Promise$all2, vocabularyModule, l3VocabularyModule, vocabularyData, l3VocabularyData, terms, _t3;
     return _regeneratorRuntime.wrap(function (_context2) {
       while (1) switch (_context2.prev = _context2.next) {
         case 0:
-          startExp(EXPERIENCE_NAME.LOAD_VOCABULARY, 'singleton');
+          startExp(EXPERIENCE_NAME.LOAD_VOCABULARY, 'singleton', {
+            isLocalLLM: isLocalLLM
+          });
           _context2.prev = 1;
           _context2.next = 2;
           return Promise.all([import( /* webpackChunkName: "@atlaskit-internal_editor-plugin-autocomplete-vocabulary-10k" */'./data/vocabulary_10k.json'), import( /* webpackChunkName: "@atlaskit-internal_editor-plugin-autocomplete-l3-vocabulary" */'./data/l3_vocabulary.json')]);
@@ -894,6 +906,7 @@ export var loadDefaultVocabulary = function loadDefaultVocabulary() {
             terms: terms
           });
           succeedExp(EXPERIENCE_NAME.LOAD_VOCABULARY, 'singleton', {
+            isLocalLLM: isLocalLLM,
             l2WordCount: terms.length,
             l3WordCount: l3VocabularyData.length
           });
@@ -903,6 +916,7 @@ export var loadDefaultVocabulary = function loadDefaultVocabulary() {
           _context2.prev = 4;
           _t3 = _context2["catch"](1);
           failExp(EXPERIENCE_NAME.LOAD_VOCABULARY, 'singleton', {
+            isLocalLLM: isLocalLLM,
             errorType: 'parse_error'
           });
           // Allow a later call to retry the load rather than caching the failure.

package/dist/types/pm-plugins/local-slow-lane-client.d.ts

@@ -60,6 +60,10 @@ export interface LocalSlowLaneClientConfig {
      * `customModelConfig` with the model URL and WASM library URL.
      */
     modelId?: string;
+    /** Callback fired when the engine fails to load/start. */
+    onLoadError?: (error: LocalSlowLaneLoadError) => void;
+    /** Callback fired when the engine successfully loads and is ready. */
+    onLoadSuccess?: (info: LocalSlowLaneLoadSuccess) => void;
     /** Callback fired with status messages (model loading progress, etc.). */
     onStatus?: (message: string) => void;
     /** Callback fired when inference returns new results. */
@@ -81,6 +85,54 @@ export interface LocalSlowLaneClient {
     setLmLogits: (logits: Record<string, number> | null) => void;
     updateContext: (text: string) => void;
 }
+/**
+ * Why the local engine failed to load/start.
+ *
+ * The first three are user-machine limitations (WebGPU missing, no compatible
+ * GPU adapter, GPU lacks the `shader-f16` feature the model needs);
+ * `insufficient_memory` is hit when weights don't fit in VRAM. The rest cover
+ * delivery/runtime failures unrelated to hardware.
+ */
+export type LocalSlowLaneLoadErrorReason = 'webgpu_unavailable' | 'webgpu_no_adapter' | 'missing_shader_f16' | 'insufficient_memory' | 'model_download_failed' | 'module_load_failed' | 'init_failed';
+/** Snapshot of the machine's WebGPU support, used to explain hardware limits. */
+export interface WebGpuCapabilities {
+    /** Whether `navigator.gpu.requestAdapter()` returned a usable adapter. */
+    adapterAvailable?: boolean;
+    /** GPU architecture reported by the adapter (e.g. "metal-3", "rdna2"). */
+    architecture?: string;
+    /** Whether `navigator.gpu` exists at all. */
+    available: boolean;
+    /** Largest single GPU buffer the adapter allows, in MB. */
+    maxBufferSizeMB?: number;
+    /** Largest storage-buffer binding the adapter allows, in MB. */
+    maxStorageBufferBindingSizeMB?: number;
+    /** Whether the adapter exposes the `shader-f16` feature the model requires. */
+    shaderF16Supported?: boolean;
+    /** GPU vendor reported by the adapter (e.g. "apple", "intel"). */
+    vendor?: string;
+}
+export interface LocalSlowLaneLoadError {
+    /** WebGPU support snapshot — explains hardware limitations behind the failure. */
+    capabilities: WebGpuCapabilities;
+    /** Semantic embedder loaded alongside the causal LM (loads atomically). */
+    embeddingModelId: string;
+    /** Canonical, controlled failure description (never raw error text). */
+    message: string;
+    /** Causal LM identifier that failed to load. */
+    modelId: string;
+    /** Coarse, privacy-safe failure category. */
+    reason: LocalSlowLaneLoadErrorReason;
+}
+export interface LocalSlowLaneLoadSuccess {
+    /** WebGPU support snapshot for the machine that loaded the model. */
+    capabilities: WebGpuCapabilities;
+    /** Semantic embedder loaded alongside the causal LM (loads atomically). */
+    embeddingModelId: string;
+    /** Model engine load time in ms (excludes the WebGPU capability probe). */
+    loadDurationMs: number;
+    /** Causal LM identifier that loaded. */
+    modelId: string;
+}
 export declare const LOCAL_MLC_CAUSAL_MODEL_ID = "SmolLM2-135M-Instruct-q0f16-MLC";
 /**
  * MLC ID for the semantic embedder (Snowflake Arctic Embed S, batch=4 variant).

package/dist/types/pm-plugins/text-predictor.d.ts

@@ -82,7 +82,10 @@ export declare const ingestDocumentPage: (pageContent: string | undefined) => vo
 export declare const predict: (textBefore: string) => string | null;
 export declare const loadVectorsAsync: (options?: {
     getBinaryUrl?: () => Promise<string>;
+    isLocalLLM?: boolean;
 }) => Promise<void>;
 export declare const initVectors: (store: VectorStore) => void;
-export declare const loadDefaultVocabulary: () => Promise<void>;
+export declare const loadDefaultVocabulary: (options?: {
+    isLocalLLM?: boolean;
+}) => Promise<void>;
 export {};