loadPretrainedModel function domain exported ~ 54.5%

export async function loadPretrainedModel(): Promise<void> {
  if (_pretrained) return;
  if (_pretrainedLoadPromise) return _pretrainedLoadPromise;

  _pretrainedLoadPromise = (async () => {
    try {
      await loadTfModule();

      // Step 1: Try runtime-trained model (user dataset, options page)
      const runtimeModel = await loadRuntimeModel();
      if (runtimeModel) {
        _pretrained = runtimeModel;
        await loadLearnedVectors();
        log.info(
          TF_MESSAGES.modelLoaded.runtime(
            runtimeModel.labels.length,
            runtimeModel.vocab.size,
            _learnedVectors.length,
          ),
        );
        return;
      }

      // Step 2: Fall back to bundled model files
      const tf = await loadTfModule();
      const base = chrome.runtime.getURL("");
      const [model, vocabRaw, labelsRaw] = await Promise.all([
        tf.loadLayersModel(`${base}${TF_CONFIG.model.json}`),
        fetch(`${base}${TF_CONFIG.model.vocab}`).then(
          (r) => r.json() as Promise<Record<string, number>>,
        ),
        fetch(`${base}${TF_CONFIG.model.labels}`).then(
          (r) => r.json() as Promise<string[]>,
        ),
      ]);
      _pretrained = {
        model,
        vocab: new Map(Object.entries(vocabRaw)),
        labels: labelsRaw as FieldType[],
      };
      await loadLearnedVectors();

      log.info(
        TF_MESSAGES.modelLoaded.bundled(
          labelsRaw.length,
          _pretrained.vocab.size,
          _learnedVectors.length,
        ),
      );
    } catch (err) {
      log.error(TF_MESSAGES.modelLoadFailed.error, err);
      log.warn(TF_MESSAGES.modelLoadFailed.fallback);
    }
  })();

  return _pretrainedLoadPromise;
}