@mikedown/core 0.1.0 → 0.3.0

package/dist/chunk-7A5HEPLK.js

@@ -0,0 +1,4910 @@
+import {
+  aiHostTier
+} from "./chunk-LXZG7IKN.js";
+import {
+  AI_CLOUD_PRIVACY,
+  AI_ENGINE_KINDS,
+  AI_ENGINE_PRESETS,
+  AI_FALLBACK_MODES,
+  AI_HOST_PRESET_FAMILY,
+  AI_HOST_PRIVACY,
+  AI_LOCAL_DETECT_TIMEOUT_MS,
+  AI_PRESET_FAMILIES,
+  AI_TASKS,
+  DEFAULT_CONTEXT_TOKENS,
+  aiConsentHost,
+  aiConsentStepNote,
+  aiErrorCopy,
+  aiProviderPolicy,
+  detectCapabilities,
+  formatModelSize,
+  generateAiId,
+  getAiTask,
+  isHostEngineKind,
+  isKnownEngineKind,
+  localDefaultModel,
+  localDetectCandidates,
+  mergeDiscoveredModels,
+  missingCapabilities,
+  modelMoeFastHint,
+  modelSizeHint,
+  presetForEngine,
+  recommendSetupPath,
+  resolveRoute,
+  serializeAiSettings,
+  thinkingChoices,
+  thinkingLevelFrom,
+  toAiError,
+  vscodeLmAvailability,
+  whatIsSent,
+  withThinkingLevel
+} from "./chunk-JZWKEBCI.js";
+import {
+  DEFAULT_LOCAL_NETWORKS,
+  detectLocality,
+  engineLocality,
+  hostOfUrl,
+  localityMismatch
+} from "./chunk-QDVY7WW6.js";
+
+// src/ai-settings-model.ts
+var AI_ENGINE_KIND_LABELS = {
+  "openai-compatible": "OpenAI-compatible",
+  lmstudio: "LM Studio",
+  ollama: "Ollama",
+  anthropic: "Anthropic",
+  openai: "OpenAI",
+  "vscode-lm": "GitHub Copilot (VS Code)"
+};
+function engineKindLabel(kind) {
+  return isKnownEngineKind(kind) ? AI_ENGINE_KIND_LABELS[kind] : `Unknown (${kind})`;
+}
+var AI_CAPABILITY_CHIPS = [
+  { flag: "chat", label: "chat", title: "Chat and instruct completions" },
+  { flag: "vision", label: "vision", title: "Image inputs" },
+  { flag: "json", label: "json", title: "JSON mode or reliable structured output" },
+  { flag: "tools", label: "tools", title: "Function calling" },
+  { flag: "fim", label: "fim", title: "Fill-in-the-middle (inline suggestions)" },
+  { flag: "embed", label: "embed", title: "Embeddings" }
+];
+var CAPABILITY_WORDS = {
+  chat: "chat",
+  stream: "streaming",
+  vision: "vision",
+  json: "JSON output",
+  tools: "tools",
+  fim: "fill-in-the-middle",
+  embed: "embeddings",
+  contextTokens: "a large enough context window"
+};
+function engineDisplayName(engine) {
+  return engine.name.trim() || engine.id;
+}
+function modelDisplayName(model) {
+  return model.label?.trim() || model.id;
+}
+function shortUrl(baseUrl) {
+  const stripped = baseUrl.trim().replace(/^[a-z][a-z0-9+.-]*:\/\//i, "");
+  const authority = stripped.split(/[/?#]/, 1)[0];
+  return authority || baseUrl.trim();
+}
+function formatTokens(tokens) {
+  const n = tokens ?? DEFAULT_CONTEXT_TOKENS;
+  if (n >= 1024 * 1024 && n % (1024 * 1024) === 0) {
+    return `${n / (1024 * 1024)}M`;
+  }
+  if (n >= 1e6 && n % 1e6 === 0) {
+    return `${n / 1e6}M`;
+  }
+  if (n >= 1024 && n % 1024 === 0) {
+    return `${n / 1024}k`;
+  }
+  if (n >= 1e3 && n % 1e3 === 0) {
+    return `${n / 1e3}k`;
+  }
+  return String(n);
+}
+function cloneAiSettings(settings) {
+  return JSON.parse(JSON.stringify(settings));
+}
+function uniqueEngineId(name, existing) {
+  const taken = new Set(existing);
+  let id = generateAiId(name);
+  while (taken.has(id)) {
+    id = generateAiId(name);
+  }
+  return id;
+}
+function engineFromPreset(preset, existingIds) {
+  const engine = {
+    id: uniqueEngineId(preset.name, existingIds),
+    name: preset.name,
+    kind: preset.kind,
+    baseUrl: preset.baseUrl,
+    enabled: true,
+    locality: "auto",
+    discovery: "auto",
+    models: []
+  };
+  if (preset.apiKeyEnv) {
+    engine.apiKeyEnv = preset.apiKeyEnv;
+  }
+  if (preset.apiKeyFile) {
+    engine.apiKeyFile = { ...preset.apiKeyFile };
+  }
+  return engine;
+}
+function groupPresets(presets) {
+  const groups = { local: [], cloud: [], host: [] };
+  for (const p of presets) {
+    groups[p.family].push(p);
+  }
+  return groups;
+}
+function withEngine(settings, engine) {
+  return { ...settings, engines: settings.engines.map((e) => e.id === engine.id ? engine : e) };
+}
+function removeEngine(settings, engineId) {
+  const tasks = {};
+  for (const [task, route] of Object.entries(settings.routing.tasks)) {
+    if (route.engineId !== engineId) {
+      tasks[task] = route;
+    }
+  }
+  const def = settings.routing.default?.engineId === engineId ? null : settings.routing.default;
+  return {
+    ...settings,
+    engines: settings.engines.filter((e) => e.id !== engineId),
+    routing: { ...settings.routing, default: def, tasks }
+  };
+}
+function removeRoutesTo(settings, engineId, modelId) {
+  const hits = (r) => !!r && r.engineId === engineId && r.modelId === modelId;
+  const tasks = {};
+  for (const [task, route] of Object.entries(settings.routing.tasks)) {
+    if (!hits(route)) {
+      tasks[task] = route;
+    }
+  }
+  return { ...settings, routing: { ...settings.routing, default: hits(settings.routing.default) ? null : settings.routing.default, tasks } };
+}
+function withModel(engine, model) {
+  return { ...engine, models: engine.models.map((m) => m.id === model.id ? model : m) };
+}
+function toggleModelCapability(model, flag) {
+  return {
+    ...model,
+    capabilities: { ...model.capabilities, [flag]: !model.capabilities[flag] },
+    capabilitiesSource: "user"
+  };
+}
+function setModelContextTokens(model, tokens) {
+  return { ...model, capabilities: { ...model.capabilities, contextTokens: tokens }, capabilitiesSource: "user" };
+}
+function parseContextTokens(text) {
+  const t = text.trim().replace(/[_,\s]/g, "");
+  if (!t) {
+    return { ok: true, value: null };
+  }
+  const m = /^(\d+(?:\.\d+)?)([kKmM]?)$/.exec(t);
+  if (!m) {
+    return { ok: false, error: "Enter a number of tokens, such as 32768 or 32k." };
+  }
+  const scale = m[2] === "" ? 1 : m[2].toLowerCase() === "k" ? 1024 : 1024 * 1024;
+  const value = Math.round(Number(m[1]) * scale);
+  if (!Number.isFinite(value) || value <= 0) {
+    return { ok: false, error: "Enter a number of tokens, such as 32768 or 32k." };
+  }
+  return { ok: true, value };
+}
+function addManualModel(engine, rawId) {
+  const id = rawId.trim();
+  if (!id) {
+    return { ok: false, error: "Enter the model id the server knows it by." };
+  }
+  if (engine.models.some((m) => m.id === id)) {
+    return { ok: false, error: `${id} is already in the list.` };
+  }
+  const model = {
+    id,
+    enabled: true,
+    capabilities: detectCapabilities(id, isKnownEngineKind(engine.kind) ? engine.kind : void 0).capabilities,
+    capabilitiesSource: "heuristic",
+    manual: true
+  };
+  return { ok: true, engine: { ...engine, models: [...engine.models, model] }, model };
+}
+function parseLocalNetworksText(text) {
+  const entries = [...new Set(text.split(/[\s,]+/).map((e) => e.trim().toLowerCase()).filter((e) => e.length > 0))];
+  if (entries.length === 0) {
+    return { ok: true, value: [...DEFAULT_LOCAL_NETWORKS] };
+  }
+  const bad = [];
+  for (const entry of entries) {
+    const numeric = /^\d/.test(entry);
+    const valid = numeric ? /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})(?:\/(\d{1,2}))?$/.test(entry) && entry.split("/")[0].split(".").every((p) => Number(p) <= 255) && Number(entry.split("/")[1] ?? 0) <= 32 : /^\.?[a-z0-9]([a-z0-9.-]*[a-z0-9])?$/.test(entry);
+    if (!valid) {
+      bad.push(entry);
+    }
+  }
+  if (bad.length > 0) {
+    return { ok: false, error: `Not a network or host name: ${bad.join(", ")}. Use an IPv4 range like 10.0.98.0/24 or a suffix like .ts.net.` };
+  }
+  return { ok: true, value: entries };
+}
+function parseRequestOverrides(text) {
+  const t = text.trim();
+  if (!t) {
+    return { ok: true, value: void 0 };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(t);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message.replace(/^JSON\.parse:\s*/, "") : "";
+    return { ok: false, error: detail ? `Not valid JSON: ${detail}` : "Not valid JSON." };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return { ok: false, error: 'Must be a JSON object, such as { "reasoning_effort": "low" }.' };
+  }
+  return { ok: true, value: parsed };
+}
+function formatRequestOverrides(value) {
+  return value && Object.keys(value).length > 0 ? JSON.stringify(value, null, 2) : "";
+}
+function mergeDiscoveryStatus(engine, status) {
+  const discovered = status.models.filter((m) => !m.missing).map((m) => {
+    const d = { id: m.id, capabilities: m.capabilities, source: m.source === "endpoint" ? "endpoint" : "heuristic" };
+    if (m.label !== void 0) {
+      d.label = m.label;
+    }
+    if (m.loaded !== void 0) {
+      d.loaded = m.loaded;
+    }
+    return d;
+  });
+  const kind = isKnownEngineKind(engine.kind) ? engine.kind : void 0;
+  return { ...engine, models: mergeDiscoveredModels(engine.models, discovered, kind) };
+}
+function connectionDiffers(a, b) {
+  if (!a || !b) {
+    return a !== b;
+  }
+  return a.kind !== b.kind || a.baseUrl !== b.baseUrl || (a.apiKeyEnv ?? "") !== (b.apiKeyEnv ?? "") || a.locality !== b.locality || a.enabled !== b.enabled || a.discovery !== b.discovery;
+}
+function changedAiPatch(original, draft) {
+  const before = serializeAiSettings(original);
+  const after = serializeAiSettings(draft);
+  const patch = {};
+  for (const [key, value] of Object.entries(after)) {
+    if (JSON.stringify(value) !== JSON.stringify(before[key])) {
+      patch[key] = value;
+    }
+  }
+  return patch;
+}
+function engineLocalityInfo(engine, localNetworks) {
+  return {
+    locality: engineLocality(engine, localNetworks),
+    detected: detectLocality(engine.baseUrl, localNetworks),
+    mismatch: localityMismatch(engine, localNetworks)
+  };
+}
+function baseUrlProblem(baseUrl) {
+  const t = baseUrl.trim();
+  if (!t) {
+    return "Enter the server address, such as http://127.0.0.1:8000/v1.";
+  }
+  if (!/^https?:\/\//i.test(t)) {
+    return "Start the address with http:// or https://.";
+  }
+  try {
+    const u = new URL(t);
+    if (!u.hostname) {
+      return "The address has no host name.";
+    }
+  } catch {
+    return "This is not a valid address.";
+  }
+  return "";
+}
+function engineIssues(engine, settings, hasKey) {
+  const issues = [];
+  if (!isKnownEngineKind(engine.kind)) {
+    issues.push({ level: "warning", code: "unsupportedKind", text: `This version does not support the engine kind "${String(engine.kind)}". It is kept, but never used.` });
+  }
+  const hostKind = isHostEngineKind(engine.kind);
+  const urlProblem = hostKind ? "" : baseUrlProblem(engine.baseUrl);
+  if (urlProblem) {
+    issues.push({ level: "warning", code: "badUrl", text: urlProblem });
+  }
+  const info = engineLocalityInfo(engine, settings.localNetworks);
+  if (!hostKind && info.locality === "cloud" && !hasKey && !engine.apiKeyEnv?.trim() && !engine.apiKeyFile?.path.trim()) {
+    issues.push({ level: "warning", code: "noKey", text: "No API key. Store one, or name the environment variable or key file that holds it." });
+  }
+  if (info.mismatch) {
+    issues.push({
+      level: "warning",
+      code: "localityMismatch",
+      text: info.locality === "cloud" ? "Pinned to cloud, but the address looks local." : "Pinned to local, but the address looks like a cloud server. Text sent to it leaves this network."
+    });
+  }
+  if (info.locality === "cloud" && !settings.allowCloud) {
+    issues.push({ level: "info", code: "cloudBlocked", text: "Blocked by Allow cloud." });
+  }
+  return issues;
+}
+var DEFAULT_ROUTE_REQUIREMENTS = { requires: { chat: true } };
+function taskRequirements(taskId) {
+  const task = getAiTask(taskId);
+  return task ? { requires: task.requires, requiresAny: task.requiresAny } : { requires: {} };
+}
+function lackingText(lacking) {
+  return `lacks ${lacking.map((c) => CAPABILITY_WORDS[c] ?? c).join(", ")}`;
+}
+function routePairs(settings, statuses, req) {
+  const statusById = new Map(statuses.map((s) => [s.engineId, s]));
+  const out = [];
+  for (const engine of settings.engines) {
+    const status = statusById.get(engine.id);
+    const isLocal = engineLocality(engine, settings.localNetworks) === "local";
+    for (const model of engine.models) {
+      const option = {
+        engineId: engine.id,
+        modelId: model.id,
+        engineName: engineDisplayName(engine),
+        modelName: modelDisplayName(model),
+        isLocal,
+        selectable: false
+      };
+      const lacking = missingCapabilities(model.capabilities, req.requires, req.requiresAny);
+      if (!isKnownEngineKind(engine.kind)) {
+        option.note = "engine kind not supported";
+      } else if (!engine.enabled) {
+        option.note = "engine is off";
+      } else if (!model.enabled) {
+        option.note = "model is off";
+      } else if (model.missing || status?.models.find((m) => m.id === model.id)?.missing) {
+        option.note = "no longer listed";
+      } else if (lacking.length > 0) {
+        option.note = lackingText(lacking);
+      } else {
+        option.selectable = true;
+        if (!isLocal && !settings.allowCloud) {
+          option.note = "blocked by Allow cloud";
+        } else if (status?.ok === false) {
+          option.note = "failed its last test";
+        }
+      }
+      out.push(option);
+    }
+  }
+  return out;
+}
+function routeKey(route) {
+  return route ? `${route.engineId}\0${route.modelId}` : "";
+}
+function parseRouteKey(key) {
+  const i = key.indexOf("\0");
+  if (i <= 0 || i === key.length - 1) {
+    return null;
+  }
+  return { engineId: key.slice(0, i), modelId: key.slice(i + 1) };
+}
+function routeLabel(settings, route) {
+  const engine = settings.engines.find((e) => e.id === route.engineId);
+  const model = engine?.models.find((m) => m.id === route.modelId);
+  return `${engine ? engineDisplayName(engine) : route.engineId} \xB7 ${model ? modelDisplayName(model) : route.modelId}`;
+}
+var PREVIEW_FEATURE = "\0aiSettingsPreview";
+function previewTaskRoute(settings, statuses, task) {
+  const probe = { ...settings, enabled: true, features: { ...settings.features, [PREVIEW_FEATURE]: { enabled: true } } };
+  return resolveRoute(probe, statuses, {}, { feature: PREVIEW_FEATURE, task });
+}
+function taskRouteNote(settings, statuses, task) {
+  const own = settings.routing.tasks[task];
+  if (!own && !settings.routing.default) {
+    return null;
+  }
+  const r = previewTaskRoute(settings, statuses, task);
+  if ("unusable" in r) {
+    if (!own) {
+      return { level: "info", text: `No model can serve this yet. ${r.reason}` };
+    }
+    const tail = settings.routing.fallback === "none" ? "Fallback is off, so this task will not run." : "No fallback can serve it either.";
+    return { level: "warning", text: `${r.reason} ${tail}` };
+  }
+  if (r.viaFallback) {
+    return { level: own ? "warning" : "info", text: `${r.reason ?? "The route is unavailable."} Falls back to ${routeLabel(settings, r)}.` };
+  }
+  return null;
+}
+function unknownRoutedTasks(settings) {
+  const known = new Set(AI_TASKS.map((t) => t.id));
+  return Object.keys(settings.routing.tasks).filter((t) => !known.has(t));
+}
+function defaultRouteForEngine(settings, statuses, engineId) {
+  const pair = routePairs(settings, statuses, DEFAULT_ROUTE_REQUIREMENTS).find((p) => p.engineId === engineId && p.selectable);
+  return pair ? { engineId: pair.engineId, modelId: pair.modelId } : null;
+}
+function hasUsableDefaultRoute(settings) {
+  const route = settings.routing.default;
+  const engine = route && settings.engines.find((e) => e.id === route.engineId);
+  if (!route || !engine || !engine.enabled || !isKnownEngineKind(engine.kind)) {
+    return false;
+  }
+  const model = engine.models.find((m) => m.id === route.modelId);
+  return !!model && model.enabled && !model.missing && model.capabilities.chat;
+}
+function addressKey(url) {
+  try {
+    const u = new URL(url.trim());
+    const host = u.hostname === "localhost" || u.hostname === "[::1]" ? "127.0.0.1" : u.hostname;
+    return `${u.protocol}//${host}:${u.port || (u.protocol === "https:" ? "443" : "80")}${u.pathname.replace(/\/+$/, "")}`.toLowerCase();
+  } catch {
+    return url.trim().toLowerCase().replace(/\/+$/, "");
+  }
+}
+function rankLocalCandidates(probes, existingEngines, presets = AI_ENGINE_PRESETS) {
+  const cards = probes.map((probe, index) => {
+    const preset = presets.find((p) => p.id === probe.presetId);
+    const engine = preset && existingEngines.find((e) => e.kind === preset.kind && addressKey(e.baseUrl) === addressKey(probe.baseUrl) && (presetForEngine(e, presets)?.id ?? preset.id) === preset.id);
+    const card = { presetId: probe.presetId, baseUrl: probe.baseUrl, running: probe.ok, alreadyAdded: !!engine };
+    if (engine) {
+      card.engineId = engine.id;
+    }
+    if (probe.ok && probe.models !== void 0) {
+      card.models = probe.models;
+    }
+    if (probe.latencyMs !== void 0) {
+      card.latencyMs = probe.latencyMs;
+    }
+    return { card, index };
+  });
+  const rank = (c) => c.alreadyAdded ? 2 : c.running ? 0 : 1;
+  return cards.sort((a, b) => rank(a.card) - rank(b.card) || (a.card.running && b.card.running ? (b.card.models ?? 0) - (a.card.models ?? 0) : 0) || a.index - b.index).map((x) => x.card);
+}
+function cloudSentNote(settings, served) {
+  if (served.isLocal) {
+    return "";
+  }
+  const engine = served.engineId ? settings.engines.find((e) => e.id === served.engineId) : void 0;
+  const host = engine ? aiConsentHost(engine) : null;
+  const what = served.feature || served.sends ? whatIsSent(served.feature, served.sends) : "";
+  if (host) {
+    return what ? ` It sent text to ${host}: ${what}.` : ` It sent text to ${host}.`;
+  }
+  return what ? ` It sent ${what}.` : "";
+}
+function servedLabels(settings, served) {
+  const engine = served.engineId ? settings.engines.find((e) => e.id === served.engineId) : void 0;
+  const model = engine?.models.find((m) => m.id === served.modelId);
+  return {
+    engine: served.engineName || (engine ? engineDisplayName(engine) : served.engineId ?? ""),
+    model: model ? modelDisplayName(model) : served.modelId,
+    warn: engine ? localityMismatch(engine, settings.localNetworks) : false
+  };
+}
+var AI_CHIP_CLICK_SETTINGS = "Click for AI settings.";
+var AI_CHIP_CLICK_CHOOSE = "Click to choose a model.";
+function indicatorTask() {
+  return getAiTask("rewrite") ? "rewrite" : AI_TASKS[0].id;
+}
+function aiNextRouteChanged(before, after, statuses) {
+  const key = (s) => {
+    const r = previewTaskRoute(s, statuses, indicatorTask());
+    return "unusable" in r ? null : `${r.engineId}
+${r.modelId}`;
+  };
+  return key(before) !== key(after);
+}
+function aiIndicatorState(input) {
+  const { settings, statuses, tier, served, viaFallback } = input;
+  if (!settings.enabled) {
+    if (settings.engines.length === 0) {
+      return null;
+    }
+    return { text: "AI: off", tone: "off", title: `AI features are turned off. ${AI_CHIP_CLICK_SETTINGS}`, fallback: false, warn: false };
+  }
+  if (served) {
+    const where2 = served.isLocal ? "local" : "cloud";
+    const l = servedLabels(settings, served);
+    const parts = [`AI: ${where2}`, l.engine, l.model].filter(Boolean);
+    const text = parts.join(" \xB7 ") + (viaFallback ? " (fallback)" : "");
+    const title = `Last request served by ${l.engine} \xB7 ${l.model}, ${served.isLocal ? "on this network" : "a cloud engine"}${viaFallback ? ", through the fallback route" : ""}.${cloudSentNote(settings, served)}${l.warn ? " Its pinned locality disagrees with its address." : ""} ${AI_CHIP_CLICK_SETTINGS}`;
+    return { text, tone: where2, title, fallback: viaFallback, warn: l.warn };
+  }
+  if (tier === 1) {
+    return { text: "AI: on", tone: "on", title: `AI features are on. ${AI_CHIP_CLICK_SETTINGS}`, fallback: false, warn: false };
+  }
+  const r = previewTaskRoute(settings, statuses, indicatorTask());
+  if ("unusable" in r) {
+    return { text: "AI: no model chosen", tone: "none", title: `${r.reason} ${AI_CHIP_CLICK_CHOOSE}`, fallback: false, warn: false };
+  }
+  const engine = settings.engines.find((e) => e.id === r.engineId);
+  const where = r.isLocal ? "local" : "cloud";
+  const label = routeLabel(settings, r);
+  const warn = engine ? localityMismatch(engine, settings.localNetworks) : false;
+  return {
+    text: `AI: ${where} \xB7 ${label}${r.viaFallback ? " (fallback)" : ""}`,
+    tone: where,
+    title: `Requests go to ${label}${r.isLocal ? "" : ", a cloud engine"}. Nothing has been sent yet. ${AI_CHIP_CLICK_SETTINGS}`,
+    fallback: r.viaFallback,
+    warn
+  };
+}
+function enginePreset(engine, localNetworks) {
+  const p = presetForEngine(engine);
+  if (p) {
+    return {
+      id: p.id,
+      name: p.name,
+      family: p.family,
+      needsKey: p.needsKey,
+      keyHint: p.keyHint,
+      ...p.keyUrl ? { keyUrl: p.keyUrl } : {},
+      ...p.pricingUrl ? { pricingUrl: p.pricingUrl } : {},
+      popular: p.popular ?? []
+    };
+  }
+  const family = engineLocality(engine, localNetworks) === "local" ? "local" : "cloud";
+  return {
+    id: "custom",
+    name: engineDisplayName(engine),
+    family,
+    needsKey: family === "cloud",
+    keyHint: family === "cloud" ? "The API key from the provider\u2019s console." : "Leave blank if the server has no auth.",
+    popular: []
+  };
+}
+function expressFields(preset) {
+  if (preset.family === "host") {
+    return { express: ["name", "models", "defaultModel", "enabled"], advanced: ["discovery", "modelsTable"] };
+  }
+  if (preset.family === "cloud") {
+    return {
+      express: ["name", "key", "models", "defaultModel", "thinking", "enabled"],
+      advanced: ["kind", "baseUrl", "locality", "keyEnv", "keyFile", "discovery", "modelsTable"]
+    };
+  }
+  const keyExpress = preset.needsKey || preset.id === "custom";
+  return {
+    express: keyExpress ? ["name", "baseUrl", "key", "models", "defaultModel", "thinking", "enabled"] : ["name", "baseUrl", "models", "defaultModel", "thinking", "enabled"],
+    advanced: keyExpress ? ["kind", "locality", "keyEnv", "keyFile", "discovery", "modelsTable"] : ["kind", "locality", "key", "keyEnv", "keyFile", "discovery", "modelsTable"]
+  };
+}
+function setupFields(preset, o = {}) {
+  const { express, advanced } = expressFields(preset);
+  const kept = express.filter((f) => f === "key" || f === "baseUrl" || f === "models");
+  if (o.key && preset.family === "local" && !kept.includes("key")) {
+    kept.splice(kept.indexOf("models"), 0, "key");
+    return { express: kept, advanced: advanced.filter((f) => f !== "key" && f !== "modelsTable") };
+  }
+  return { express: kept, advanced: advanced.filter((f) => f !== "modelsTable") };
+}
+function modelPickerOptions(engine, status, filter = "") {
+  const loaded = new Map((status?.models ?? []).map((m) => [m.id, !!m.loaded]));
+  const needle = filter.trim().toLowerCase();
+  const rows = engine.models.map((m, index) => ({
+    id: m.id,
+    name: modelDisplayName(m),
+    hasLabel: !!m.label?.trim() && m.label.trim() !== m.id,
+    enabled: m.enabled,
+    loaded: loaded.get(m.id) ?? false,
+    missing: !!(m.missing || status?.models.find((s) => s.id === m.id)?.missing),
+    manual: !!m.manual,
+    chat: !!m.capabilities.chat,
+    usable: !!(m.capabilities.chat || m.capabilities.embed),
+    index
+  })).filter((o) => !needle || o.id.toLowerCase().includes(needle) || o.name.toLowerCase().includes(needle));
+  const rank = (o) => o.missing ? 2 : engine.kind === "lmstudio" && o.loaded ? 0 : 1;
+  rows.sort((a, b) => rank(a) - rank(b) || a.index - b.index);
+  return rows.map(({ index: _index, ...o }) => o);
+}
+function modelCountLine(engine) {
+  const listed = engine.models.filter((m) => !m.missing);
+  const picked = listed.filter((m) => m.enabled).length;
+  if (listed.length === 0) {
+    return "No models yet";
+  }
+  return `${listed.length} ${listed.length === 1 ? "model" : "models"}, ${picked} picked`;
+}
+function applyDiscoveryForFamily(engine, status, family, picked = []) {
+  const merged = mergeDiscoveryStatus(engine, status);
+  const before = new Set(engine.models.map((m) => m.id));
+  const pick = new Set(picked);
+  const loaded = new Set(status.models.filter((m) => m.loaded && !m.missing).map((m) => m.id));
+  const arrivesOn = (m) => pick.has(m.id) || family === "local" && loaded.has(m.id) && (m.capabilities.chat || m.capabilities.embed);
+  let models = merged.models.map((m) => before.has(m.id) ? m : { ...m, enabled: arrivesOn(m) });
+  const hadPick = engine.models.some((m) => m.enabled && !m.missing);
+  if (family === "local" && !hadPick) {
+    const choices = models.filter((m) => !before.has(m.id)).map((m) => ({ id: m.id, chat: m.capabilities.chat, missing: m.missing, loaded: loaded.has(m.id) }));
+    const def = localDefaultModel(choices);
+    const chosen = models.find((m) => m.id === def);
+    if (chosen) {
+      models = [{ ...chosen, enabled: true }, ...models.filter((m) => m !== chosen)];
+    }
+  }
+  return { ...merged, models };
+}
+function versionOf(id) {
+  const version = [];
+  let date = 0;
+  for (const n of id.match(/\d+/g) ?? []) {
+    if (n.length >= 6) {
+      date = Math.max(date, Number(n));
+    } else {
+      version.push(Number(n));
+    }
+  }
+  return { version, date };
+}
+function compareNewest(a, b, prefer) {
+  if (prefer) {
+    const pa = prefer.test(a) ? 0 : 1;
+    const pb = prefer.test(b) ? 0 : 1;
+    if (pa !== pb) {
+      return pa - pb;
+    }
+  }
+  const va = versionOf(a);
+  const vb = versionOf(b);
+  for (let i = 0; i < Math.max(va.version.length, vb.version.length); i++) {
+    const d = (vb.version[i] ?? 0) - (va.version[i] ?? 0);
+    if (d !== 0) {
+      return d;
+    }
+  }
+  if (va.date !== vb.date) {
+    return va.date === 0 ? -1 : vb.date === 0 ? 1 : vb.date - va.date;
+  }
+  return a.length - b.length || a.localeCompare(b);
+}
+function popularModels(preset, models) {
+  const out = [];
+  for (const rule of preset.popular ?? []) {
+    const hits = models.filter((m) => !m.missing && rule.match.test(m.id) && !rule.exclude?.test(m.id) && !out.includes(m));
+    if (hits.length === 0) {
+      continue;
+    }
+    out.push(hits.slice().sort((a, b) => compareNewest(a.id, b.id, rule.prefer))[0]);
+  }
+  return out;
+}
+function autoPickDefault(preset, models) {
+  const chat = (m) => !m.missing && m.capabilities.chat;
+  const popular = popularModels(preset, models).find(chat);
+  if (popular) {
+    return popular.id;
+  }
+  const chatModels = models.filter(chat);
+  return chatModels.length === 1 ? chatModels[0].id : null;
+}
+function firstChatModelId(models) {
+  return models.find((m) => !m.missing && m.capabilities.chat)?.id ?? null;
+}
+function engineDefaultModelId(settings, engineId) {
+  const engine = settings.engines.find((e) => e.id === engineId);
+  if (!engine) {
+    return null;
+  }
+  const def = settings.routing.default;
+  if (def?.engineId === engineId && engine.models.some((m) => m.id === def.modelId)) {
+    return def.modelId;
+  }
+  return engine.models.find((m) => m.enabled && !m.missing)?.id ?? null;
+}
+function setEngineDefaultModel(settings, engineId, modelId) {
+  const engine = settings.engines.find((e) => e.id === engineId);
+  const model = engine?.models.find((m) => m.id === modelId);
+  if (!engine || !model || !model.capabilities.chat) {
+    return settings;
+  }
+  const models = [{ ...model, enabled: true }, ...engine.models.filter((m) => m.id !== modelId)];
+  const next = withEngine(settings, { ...engine, models });
+  const def = settings.routing.default;
+  if (!def || def.engineId === engineId) {
+    return { ...next, routing: { ...next.routing, default: { ...def ?? {}, engineId, modelId } } };
+  }
+  return next;
+}
+function engineNeedsModelPick(engine) {
+  if (!engine.enabled) {
+    return false;
+  }
+  const chat = engine.models.filter((m) => !m.missing && m.capabilities.chat);
+  return chat.length > 0 && !chat.some((m) => m.enabled);
+}
+function firstEngineNeedingPick(settings) {
+  return settings.engines.find(engineNeedsModelPick) ?? null;
+}
+function setModelPicked(settings, engineId, modelId, enabled) {
+  const engine = settings.engines.find((e) => e.id === engineId);
+  const model = engine?.models.find((m) => m.id === modelId);
+  if (!engine || !model) {
+    return settings;
+  }
+  const next = withEngine(settings, withModel(engine, { ...model, enabled }));
+  const def = next.routing.default;
+  if (enabled && !def && model.capabilities.chat && engine.enabled) {
+    return { ...next, routing: { ...next.routing, default: { engineId, modelId } } };
+  }
+  if (enabled || def?.engineId !== engineId || def.modelId !== modelId) {
+    return next;
+  }
+  const replacement = next.engines.find((e) => e.id === engineId)?.models.find((m) => m.enabled && !m.missing);
+  return { ...next, routing: { ...next.routing, default: replacement ? { ...def, modelId: replacement.id } : null } };
+}
+function chooseSetupModel(settings, engineId, modelId, previous) {
+  const next = setEngineDefaultModel(settings, engineId, modelId);
+  if (next === settings || !previous || previous === modelId) {
+    return next;
+  }
+  return setModelPicked(next, engineId, previous, false);
+}
+function setModelThinking(model, kind, level, local) {
+  const next = { ...model };
+  const overrides = withThinkingLevel(kind, model.requestOverrides, level, { local });
+  if (overrides) {
+    next.requestOverrides = overrides;
+  } else {
+    delete next.requestOverrides;
+  }
+  return next;
+}
+var AUTO_FETCH_KEY_DELAY_MS = 600;
+function fetchFingerprint(family, key, baseUrl) {
+  return family === "cloud" ? `key:${key.trim()}` : `url:${baseUrl.trim()}`;
+}
+var NO_FETCH = (cancelPending, fingerprint = "") => ({ fetch: false, delayMs: 0, storeKey: false, cancelPending, fingerprint });
+function autoFetchDecision(prev, next) {
+  const urlOk = next.family === "host" || !baseUrlProblem(next.baseUrl);
+  const key = next.key.trim();
+  const cloudFingerprint = fetchFingerprint("cloud", key, next.baseUrl);
+  const localFingerprint = fetchFingerprint("local", key, next.baseUrl);
+  const fingerprint = next.family === "cloud" ? cloudFingerprint : localFingerprint;
+  if (next.event === "save") {
+    return NO_FETCH(false);
+  }
+  if (next.event === "manual" || next.event === "retry") {
+    if (!urlOk || next.discovery === "manual") {
+      return NO_FETCH(false);
+    }
+    return { fetch: true, delayMs: 0, storeKey: next.family === "cloud" ? !!key : false, cancelPending: true, fingerprint };
+  }
+  if (next.discovery === "manual" || !urlOk) {
+    return NO_FETCH(next.event === "key" && !key);
+  }
+  if (next.family === "cloud") {
+    if (next.event === "open") {
+      return next.hasKey && !next.modelCount && next.neverProbed ? { fetch: true, delayMs: 0, storeKey: false, cancelPending: true, fingerprint: cloudFingerprint } : NO_FETCH(false);
+    }
+    if (next.event !== "key") {
+      return NO_FETCH(false);
+    }
+    if (!key) {
+      return NO_FETCH(true);
+    }
+    const already = (next.fetchedFor ?? prev?.fetchedFor) === cloudFingerprint;
+    if (already || prev && prev.key.trim() === key && prev.event === "key") {
+      return NO_FETCH(false, cloudFingerprint);
+    }
+    return { fetch: true, delayMs: AUTO_FETCH_KEY_DELAY_MS, storeKey: true, cancelPending: true, fingerprint: cloudFingerprint };
+  }
+  if (next.event === "open") {
+    return next.neverProbed ? { fetch: true, delayMs: 0, storeKey: false, cancelPending: true, fingerprint: localFingerprint } : NO_FETCH(false, localFingerprint);
+  }
+  if (next.event === "url") {
+    if ((next.fetchedFor ?? prev?.fetchedFor) === localFingerprint) {
+      return NO_FETCH(false, localFingerprint);
+    }
+    return { fetch: true, delayMs: 0, storeKey: false, cancelPending: true, fingerprint: localFingerprint };
+  }
+  return NO_FETCH(false);
+}
+var AUTH_TEXT = /\bHTTP 40[13]\b|unauthori[sz]ed|forbidden|invalid[^.]*\bkey|incorrect[^.]*\bkey|api key|authentication/i;
+var UNREACHABLE_TEXT = /could not reach|no answer|timed out|ECONNREFUSED|ENOTFOUND|EHOSTUNREACH|fetch failed|connection refused|network/i;
+function discoveryErrorCode(code, message) {
+  if (code && code !== "unknown") {
+    return code;
+  }
+  const text = message ?? "";
+  if (AUTH_TEXT.test(text)) {
+    return "auth";
+  }
+  if (UNREACHABLE_TEXT.test(text)) {
+    return "unreachable";
+  }
+  return "unknown";
+}
+function discoveryProblem(input) {
+  if (input.ok) {
+    return input.listed === 0 ? { kind: "empty", text: "Server is up but no models are loaded.", retry: true } : null;
+  }
+  const code = discoveryErrorCode(input.code, input.message);
+  if (input.family === "host") {
+    return { kind: code === "auth" ? "auth" : "other", text: input.message || `Could not list ${input.presetName}\u2019s models.`, retry: true };
+  }
+  if (code === "auth") {
+    return { kind: "auth", text: `Key rejected by ${shortUrl(input.baseUrl)}.`, focus: "key", retry: true };
+  }
+  if (code === "unreachable" && input.family === "local") {
+    const name = input.presetName.startsWith("Custom") ? "the server" : input.presetName;
+    return { kind: "unreachable", text: `Nothing answered at ${input.baseUrl.trim()}. Is ${name} running?`, retry: true };
+  }
+  if (code === "unreachable") {
+    return { kind: "unreachable", text: `Could not reach ${shortUrl(input.baseUrl)}.`, retry: true };
+  }
+  return { kind: "other", text: input.message ? `Could not fetch models: ${input.message}` : "Could not fetch models.", retry: true };
+}
+
+// src/ai-settings-session.ts
+var SAVE_ECHO_TIMEOUT_MS = 4e3;
+function createAiSettingsSession(options) {
+  const { ai } = options;
+  let original = cloneAiSettings(options.settings);
+  let draft = cloneAiSettings(options.settings);
+  const statuses = options.statusMap ?? new Map(options.statuses.map((s) => [s.engineId, s]));
+  const keyOverride = options.keyOverride ?? /* @__PURE__ */ new Map();
+  const deleted = /* @__PURE__ */ new Set();
+  const keysStored = /* @__PURE__ */ new Set();
+  const added = /* @__PURE__ */ new Set();
+  const getEngine = (id) => draft.engines.find((e) => e.id === id);
+  const statusList = () => [...statuses.values()];
+  const session = {
+    ai,
+    tier: aiHostTier(ai),
+    statuses,
+    options,
+    get draft() {
+      return draft;
+    },
+    set draft(next) {
+      draft = next;
+    },
+    get original() {
+      return original;
+    },
+    getEngine,
+    statusList,
+    hasKey: (id) => keyOverride.get(id) ?? statuses.get(id)?.hasKey ?? false,
+    keySource: (id) => {
+      const stored = keyOverride.get(id);
+      return stored === void 0 ? statuses.get(id)?.keySource : stored ? "stored" : void 0;
+    },
+    async setKey(id, value) {
+      if (!getEngine(id) || !ai.setSecret) {
+        return "This app cannot store keys.";
+      }
+      try {
+        await ai.setSecret(id, value);
+        keyOverride.set(id, value !== null);
+        if (value !== null) {
+          keysStored.add(id);
+        } else {
+          keysStored.delete(id);
+        }
+        return null;
+      } catch (err) {
+        return `The key could not be ${value !== null ? "stored" : "cleared"}: ${toAiError(err).message}`;
+      }
+    },
+    async ensureSaved(id) {
+      const engine = getEngine(id);
+      if (!engine || !options.saveNow) {
+        return;
+      }
+      if (!connectionDiffers(options.getHostSettings().engines.find((e) => e.id === id), engine)) {
+        return;
+      }
+      options.saveNow({ "ai.engines": serializeAiSettings(draft)["ai.engines"] });
+      await options.waitForSettings((s) => !connectionDiffers(s.engines.find((e) => e.id === id), engine), SAVE_ECHO_TIMEOUT_MS);
+    },
+    savesFirst(id) {
+      const engine = getEngine(id);
+      return !!options.saveNow && !!engine && connectionDiffers(options.getHostSettings().engines.find((e) => e.id === id), engine);
+    },
+    addEngine(engine) {
+      draft = { ...draft, engines: [...draft.engines, engine] };
+      added.add(engine.id);
+    },
+    deleteEngine(id) {
+      if (!getEngine(id)) {
+        return;
+      }
+      draft = removeEngine(draft, id);
+      deleted.add(id);
+    },
+    updateEngine(id, patch) {
+      const current = getEngine(id);
+      if (current) {
+        draft = withEngine(draft, { ...current, ...patch });
+      }
+    },
+    collect() {
+      const patch = changedAiPatch(original, draft);
+      if (options.pendingEnable && draft.enabled && Object.keys(patch).length > 0) {
+        patch["ai.enabled"] = true;
+      }
+      return patch;
+    },
+    dirty() {
+      if (Object.keys(changedAiPatch(original, draft)).length > 0) {
+        return true;
+      }
+      return options.getHostSettings().engines.some((e) => added.has(e.id) && !getEngine(e.id));
+    },
+    async refreshStatuses() {
+      if (!ai.listEngines) {
+        return false;
+      }
+      try {
+        const list = await ai.listEngines();
+        for (const s of list) {
+          statuses.set(s.engineId, s);
+        }
+        options.onStatuses(statusList());
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    fork() {
+      return { ...options, settings: cloneAiSettings(draft), statuses: statusList(), keyOverride, statusMap: statuses };
+    },
+    absorb(saved, patch) {
+      draft = cloneAiSettings(saved);
+      original = withSavedAiKeys(original, saved, patch);
+    },
+    discard() {
+      const host = options.getHostSettings();
+      if (options.saveNow && host.engines.some((e) => added.has(e.id))) {
+        const kept = { ...host, engines: host.engines.filter((e) => !added.has(e.id)) };
+        options.saveNow({ "ai.engines": serializeAiSettings(kept)["ai.engines"] });
+      }
+      if (!ai.setSecret) {
+        return;
+      }
+      const saved = new Set(host.engines.filter((e) => !added.has(e.id)).map((e) => e.id));
+      for (const id of keysStored) {
+        if (!saved.has(id)) {
+          ai.setSecret(id, null).catch(() => {
+          });
+        }
+      }
+    },
+    commit() {
+      if (ai.setSecret) {
+        for (const id of deleted) {
+          if (getEngine(id)) {
+            continue;
+          }
+          ai.setSecret(id, null).catch(() => {
+          });
+        }
+      }
+      return cloneAiSettings(draft);
+    }
+  };
+  return session;
+}
+function withSavedAiKeys(base, saved, patch) {
+  const next = { ...base };
+  const from = saved;
+  for (const key of Object.keys(patch)) {
+    const field = key.replace(/^ai\./, "");
+    if (field in from) {
+      next[field] = JSON.parse(JSON.stringify(from[field]));
+    }
+  }
+  return next;
+}
+
+// src/ai-local-setup.ts
+var AI_DETECT_LOOKING = "Looking for local AI servers\u2026";
+var AI_DETECT_NONE = "No local AI server found. Start LM Studio, Ollama or oMLX, then choose Look again.";
+var DETECT_ROUND_TRIP_MS = 1500;
+async function detectLocalServers(ai, signal) {
+  if (!ai.detectLocalServers || signal?.aborted) {
+    return null;
+  }
+  const controller = new AbortController();
+  const onAbort = () => controller.abort();
+  signal?.addEventListener("abort", onAbort, { once: true });
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      resolve(null);
+    }, AI_LOCAL_DETECT_TIMEOUT_MS + DETECT_ROUND_TRIP_MS);
+  });
+  try {
+    const probes = await Promise.race([ai.detectLocalServers(localDetectCandidates(), controller.signal), timeout]);
+    return !probes || controller.signal.aborted || !Array.isArray(probes) ? null : probes;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+  }
+}
+function bestLocalServer(probes, engines) {
+  return rankLocalCandidates(probes, engines).find((c) => c.running && !c.alreadyAdded) ?? null;
+}
+async function setUpLocalEngine(options, presetId) {
+  const preset = AI_ENGINE_PRESETS.find((p) => p.id === presetId && p.family === "local");
+  if (!preset) {
+    throw new Error("That local server is not one MikeDown knows.");
+  }
+  const { ai } = options;
+  if (!ai.discoverModels) {
+    throw new Error("This app cannot fetch models.");
+  }
+  const session = createAiSettingsSession(options);
+  const engine = engineFromPreset(preset, session.draft.engines.map((e) => e.id));
+  session.addEngine(engine);
+  const fail = (message) => {
+    session.discard();
+    throw new Error(message);
+  };
+  await session.ensureSaved(engine.id);
+  let status;
+  try {
+    status = await ai.discoverModels(engine.id);
+  } catch (err) {
+    return fail(`Could not fetch the models from ${preset.name}: ${toAiError(err).message}`);
+  }
+  if (status.ok === false) {
+    return fail(`Could not fetch the models from ${preset.name}${status.error ? `: ${status.error}` : "."}`);
+  }
+  session.statuses.set(engine.id, status);
+  options.onStatuses(session.statusList());
+  session.draft = withEngine(session.draft, applyDiscoveryForFamily(engine, status, "local"));
+  const route = defaultRouteForEngine(session.draft, session.statusList(), engine.id);
+  if (!route) {
+    const canChat = session.getEngine(engine.id)?.models.some((m) => !m.missing && m.capabilities.chat);
+    return fail(canChat ? `${preset.name} has no model loaded. Load one there, or choose Set up to pick one.` : `${preset.name} has no chat model loaded or downloaded yet.`);
+  }
+  session.draft = { ...session.draft, routing: { ...session.draft.routing, default: route } };
+  const patch = { ...session.collect(), "ai.enabled": true };
+  const settings = { ...session.commit(), enabled: true };
+  return { patch, settings, engineId: engine.id, route };
+}
+var HOST_ENGINES_TIMEOUT_MS = 3e3;
+var hardwareByHost = /* @__PURE__ */ new WeakMap();
+var scanByHost = /* @__PURE__ */ new WeakMap();
+function canScanForSetup(ai) {
+  return !!(ai.detectLocalServers || ai.hardwareInfo || ai.detectHostEngines);
+}
+var hardwareKnown = /* @__PURE__ */ new WeakMap();
+function setupHardware(ai) {
+  let info = hardwareByHost.get(ai);
+  if (!info) {
+    info = ai.hardwareInfo ? ai.hardwareInfo().then((h) => h && typeof h === "object" ? h : null, () => null) : Promise.resolve(null);
+    info = info.then((h) => {
+      if (h) {
+        hardwareKnown.set(ai, h);
+      }
+      return h;
+    });
+    hardwareByHost.set(ai, info);
+  }
+  return info;
+}
+function knownHardware(ai) {
+  return hardwareKnown.get(ai) ?? null;
+}
+async function hostEngineAvailability(ai, signal) {
+  if (!ai.detectHostEngines || signal?.aborted) {
+    return null;
+  }
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(null), HOST_ENGINES_TIMEOUT_MS);
+  });
+  try {
+    const probes = await Promise.race([ai.detectHostEngines(), timeout]);
+    return probes && Array.isArray(probes) && !signal?.aborted ? vscodeLmAvailability(probes) : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function lastSetupScan(ai) {
+  return scanByHost.get(ai) ?? null;
+}
+function plainSetupScan() {
+  return { recommendation: recommendSetupPath({ running: [], hardware: null }), probes: null, hardware: null, vscodeLm: null };
+}
+async function scanForSetup(ai, signal, probes) {
+  const [found, hardware, vscodeLm] = await Promise.all([
+    probes !== void 0 ? Promise.resolve(probes) : detectLocalServers(ai, signal),
+    setupHardware(ai),
+    hostEngineAvailability(ai, signal)
+  ]);
+  const recommendation = recommendSetupPath({ running: found ?? [], hardware, ...vscodeLm ? { vscodeLm } : {} });
+  const scan = { recommendation, probes: found, hardware, vscodeLm };
+  if (!signal?.aborted) {
+    scanByHost.set(ai, scan);
+  }
+  return scan;
+}
+
+// src/ai-settings-dom.ts
+var svg = (body, size = 14, extra = "") => `<svg width="${size}" height="${size}" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true" focusable="false"${extra}>${body}</svg>`;
+var ICONS = {
+  starOff: svg('<path d="M8 1.9l1.86 3.77 4.16.6-3.01 2.94.71 4.14L8 11.4l-3.72 1.95.71-4.14L1.98 6.27l4.16-.6z"/>'),
+  starOn: svg('<path d="M8 1.9l1.86 3.77 4.16.6-3.01 2.94.71 4.14L8 11.4l-3.72 1.95.71-4.14L1.98 6.27l4.16-.6z" fill="currentColor"/>'),
+  trash: svg('<path d="M2.5 4h11M6.5 4V2.5h3V4M4 4l.7 9.5h6.6L12 4M6.6 6.5v4.5M9.4 6.5v4.5"/>'),
+  chevron: svg('<path d="M6 4l4 4-4 4"/>', 12),
+  plus: svg('<path d="M8 3v10M3 8h10"/>', 12),
+  local: svg('<path d="M2.5 7.5L8 3l5.5 4.5M4 6.5V13h8V6.5"/>', 11),
+  cloud: svg('<path d="M4.5 12.5h7a2.75 2.75 0 0 0 .3-5.48A4 4 0 0 0 4.1 7.6 2.5 2.5 0 0 0 4.5 12.5z"/>', 11),
+  warn: svg('<path d="M8 2.2l6.2 11H1.8z"/><path d="M8 6.5v3M8 11.4v.1"/>', 12),
+  info: svg('<circle cx="8" cy="8" r="6"/><path d="M8 7.2v3.8M8 5v.1"/>', 12),
+  check: svg('<path d="M3.5 8.5l3 3 6-7"/>', 12),
+  braces: svg('<path d="M6 2.5c-1.5 0-2 .7-2 2v1.6c0 .9-.5 1.4-1.4 1.9.9.5 1.4 1 1.4 1.9v1.6c0 1.3.5 2 2 2M10 2.5c1.5 0 2 .7 2 2v1.6c0 .9.5 1.4 1.4 1.9-.9.5-1.4 1-1.4 1.9v1.6c0 1.3-.5 2-2 2"/>', 16),
+  close: svg('<path d="M4 4l8 8M12 4l-8 8"/>', 10),
+  refresh: svg('<path d="M13 8a5 5 0 1 1-1.5-3.55M13 2.5v3h-3"/>', 12),
+  search: svg('<circle cx="7" cy="7" r="4.25"/><path d="M10.2 10.2l3.3 3.3"/>', 12),
+  back: svg('<path d="M10 3.5L5.5 8l4.5 4.5"/>', 14),
+  routing: svg('<path d="M3 4h4.5a2 2 0 0 1 2 2v4a2 2 0 0 0 2 2H13M3 12h3M11 2.5L13 4l-2 1.5M11 10.5l2 1.5-2 1.5"/>', 16)
+};
+var KIND_MONOGRAMS = {
+  lmstudio: "LM",
+  ollama: "Ol",
+  anthropic: "An",
+  openai: "OA",
+  "vscode-lm": "Co"
+};
+var KNOWN_KINDS = /* @__PURE__ */ new Set(["openai-compatible", "lmstudio", "ollama", "anthropic", "openai", "vscode-lm"]);
+function kindGlyphHtml(kind, extra = "") {
+  const known = KNOWN_KINDS.has(kind);
+  const inner = !known ? "?" : kind === "openai-compatible" ? ICONS.braces : KIND_MONOGRAMS[kind] ?? "?";
+  return `<span class="ai-glyph ${extra}" data-kind="${known ? kind : "unknown"}" aria-hidden="true">${inner}</span>`;
+}
+var lowerFirst = (text) => text.charAt(0).toLowerCase() + text.slice(1);
+var AI_EXPERIMENTAL_DISCLAIMER = `AI features are experimental and may change or be removed. AI output can be wrong, so review it before you keep it. With a cloud engine, ${lowerFirst(AI_CLOUD_PRIVACY.leaves)} ${AI_CLOUD_PRIVACY.local}`;
+function experimentalBadge() {
+  return el("span", "ai-experimental-badge", "Experimental");
+}
+function experimentalDisclaimer(className = "") {
+  return el("p", `ai-disclaimer${className ? ` ${className}` : ""}`, AI_EXPERIMENTAL_DISCLAIMER);
+}
+function hostLink(label, url, openLink, className = "") {
+  const a = el("a", `ai-link-btn${className ? ` ${className}` : ""}`, label);
+  a.href = url;
+  a.target = "_blank";
+  a.rel = "noopener noreferrer";
+  a.title = url;
+  if (openLink) {
+    a.addEventListener("click", (e) => {
+      e.preventDefault();
+      openLink(url);
+    });
+  }
+  return a;
+}
+function policyLink(policy, openLink) {
+  return hostLink(policy.label, policy.url, openLink, "ai-privacy-link");
+}
+function privacyCard(source, opts = {}) {
+  const list = !source ? [] : Array.isArray(source) ? source : [source];
+  const policies = [];
+  for (const s of list) {
+    if (s.policy && !policies.some((p) => p.url === s.policy.url)) {
+      policies.push(s.policy);
+    }
+  }
+  const body = el("div", "ai-privacy-body");
+  const lines = el("ul", "ai-privacy-lines");
+  const texts = opts.hostEngine ? [AI_HOST_PRIVACY.leaves, AI_HOST_PRIVACY.terms, AI_HOST_PRIVACY.permission, AI_HOST_PRIVACY.local] : [AI_CLOUD_PRIVACY.leaves, AI_CLOUD_PRIVACY.terms, AI_CLOUD_PRIVACY.local, AI_CLOUD_PRIVACY.keys];
+  for (const text of texts) {
+    lines.append(el("li", "", text));
+  }
+  body.append(lines);
+  for (const policy of policies) {
+    const line = el("p", "ai-privacy-policy");
+    line.append(policyLink(policy, opts.openLink));
+    if (policy.note && !opts.hostEngine) {
+      line.append(el("span", "ai-privacy-policy-note", ` ${policy.note}`));
+    }
+    body.append(line);
+  }
+  if (opts.extra) {
+    body.append(el("p", "ai-privacy-extra", opts.extra));
+  }
+  const className = `ai-privacy-card${opts.className ? ` ${opts.className}` : ""}`;
+  const glyph = el("span", "ai-privacy-glyph");
+  glyph.innerHTML = ICONS.cloud;
+  if (opts.collapsed) {
+    const details = el("details", className);
+    details.open = !!opts.open;
+    const summary = el("summary", "ai-privacy-summary");
+    summary.append(glyph, el("span", "", typeof opts.collapsed === "string" ? opts.collapsed : "What is sent"));
+    details.append(summary, body);
+    if (opts.onToggle) {
+      details.addEventListener("toggle", () => opts.onToggle(details.open));
+    }
+    return details;
+  }
+  const card = el("div", className);
+  const head = el("div", "ai-privacy-head");
+  head.append(glyph, el("span", "", opts.hostEngine ? "GitHub Copilot and your text" : "Cloud engines and your text"));
+  card.append(head, body);
+  return card;
+}
+function cloudAccessBox(o) {
+  const box = el("div", "ai-cloud-access");
+  const row = el("div", "ai-cloud-access-row");
+  const toggle = switchInput(o.allowed, "Allow cloud engines", o.fk);
+  toggle.id = nextId("ai-allow-cloud");
+  const label = el("label", "ai-cloud-access-label", "Allow cloud engines");
+  label.htmlFor = toggle.id;
+  const line = el("span", "ai-cloud-access-line", "Text you ask about is sent to the provider over the internet.");
+  line.id = nextId("ai-allow-cloud-line");
+  toggle.setAttribute("aria-describedby", line.id);
+  toggle.addEventListener("change", () => o.onChange(toggle.checked));
+  const text = el("div", "ai-cloud-access-text");
+  text.append(label, line);
+  row.append(toggle, text);
+  box.append(row, privacyCard(o.presets, {
+    collapsed: "What this means",
+    open: o.open,
+    onToggle: (open) => o.onToggle?.(open),
+    openLink: o.openLink,
+    extra: aiConsentStepNote(o.hostAsks),
+    className: "ai-cloud-access-privacy"
+  }));
+  return box;
+}
+function privacyLine(onLearnMore) {
+  const line = el("p", "ai-privacy-line");
+  const glyph = el("span", "ai-privacy-glyph");
+  glyph.innerHTML = ICONS.cloud;
+  const more = button("ai-link-btn", "Learn more", { fk: "ai-privacy:learn-more" });
+  more.addEventListener("click", () => onLearnMore());
+  line.append(glyph, el("span", "", `A cloud engine sends text to the provider. ${AI_CLOUD_PRIVACY.local} `), more);
+  return line;
+}
+var uid = 0;
+var nextId = (prefix) => `${prefix}-${++uid}`;
+function el(tag, className, text) {
+  const node = document.createElement(tag);
+  if (className) {
+    node.className = className;
+  }
+  if (text !== void 0) {
+    node.textContent = text;
+  }
+  return node;
+}
+function button(className, label, opts = {}) {
+  const b = el("button", className);
+  b.type = "button";
+  if (opts.html !== void 0) {
+    b.innerHTML = opts.html;
+    if (label) {
+      b.append(el("span", "ai-btn-text", label));
+    }
+  } else {
+    b.textContent = label;
+  }
+  if (opts.ariaLabel) {
+    b.setAttribute("aria-label", opts.ariaLabel);
+  }
+  if (opts.title) {
+    b.title = opts.title;
+  }
+  if (opts.fk) {
+    b.dataset.fk = opts.fk;
+  }
+  return b;
+}
+function switchInput(checked, ariaLabel, fk) {
+  const input = el("input", "ai-switch");
+  input.type = "checkbox";
+  input.setAttribute("role", "switch");
+  input.checked = checked;
+  input.setAttribute("aria-label", ariaLabel);
+  if (fk) {
+    input.dataset.fk = fk;
+  }
+  return input;
+}
+function note(level, text, className = "") {
+  const n = el("div", `ai-note ai-note--${level}${className ? ` ${className}` : ""}`);
+  const icon = el("span", "ai-note-icon");
+  icon.innerHTML = level === "ok" ? ICONS.check : level === "info" ? ICONS.info : ICONS.warn;
+  n.append(icon, el("span", "ai-note-text", text));
+  return n;
+}
+function keepFocus(scope, rebuild) {
+  const active = document.activeElement;
+  const key = active && scope.contains(active) ? active.dataset.fk : void 0;
+  let sel = null;
+  if (key && (active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement)) {
+    try {
+      sel = [active.selectionStart, active.selectionEnd];
+    } catch {
+      sel = null;
+    }
+  }
+  const target = rebuild() ?? scope;
+  if (!key) {
+    return;
+  }
+  const next = Array.from(target.querySelectorAll("[data-fk]")).find((n) => n.dataset.fk === key);
+  if (!next) {
+    return;
+  }
+  next.focus({ preventScroll: true });
+  if (sel && (next instanceof HTMLInputElement || next instanceof HTMLTextAreaElement)) {
+    try {
+      next.setSelectionRange(sel[0], sel[1]);
+    } catch {
+    }
+  }
+}
+function statusBadge(status, busy, opts = {}) {
+  const badge = el("span", `ai-status${opts.compact ? " ai-status--compact" : ""}`);
+  const dot = el("span", "ai-status-dot");
+  dot.setAttribute("aria-hidden", "true");
+  const text = el("span", "ai-status-text");
+  let state;
+  let label;
+  let title;
+  if (busy) {
+    state = "busy";
+    label = busy === "test" ? "Testing\u2026" : "Fetching\u2026";
+    title = busy === "test" ? "Testing the connection\u2026" : "Fetching models\u2026";
+  } else if (!status || status.ok === null) {
+    state = "unknown";
+    label = "Not tested";
+    title = "Not reached yet. Open the engine and fetch its models, or choose Test connection.";
+  } else if (status.ok) {
+    state = "ok";
+    label = status.latencyMs !== void 0 ? `${Math.round(status.latencyMs)} ms` : "OK";
+    title = `Connected${status.latencyMs !== void 0 ? ` in ${Math.round(status.latencyMs)} ms` : ""} on the last test or model fetch.`;
+  } else {
+    state = "error";
+    label = "Failed";
+    title = status.error ? `Last test failed: ${status.error}` : "The last test failed.";
+  }
+  badge.dataset.state = state;
+  badge.title = title;
+  text.textContent = label;
+  badge.append(dot, text);
+  badge.setAttribute("aria-label", `Status: ${title}`);
+  badge.setAttribute("role", "img");
+  return badge;
+}
+function localityPills(engine, settings, opts = {}) {
+  const info = engineLocalityInfo(engine, settings.localNetworks);
+  const pill = el("span", `ai-pill ai-pill--${info.locality}`);
+  pill.innerHTML = info.locality === "local" ? ICONS.local : ICONS.cloud;
+  pill.append(el("span", "", info.locality === "local" ? "local" : "cloud"));
+  if (info.mismatch) {
+    pill.classList.add("ai-pill--mismatch");
+    pill.title = info.locality === "cloud" ? "Pinned to cloud, but the address looks local." : "Pinned to local, but the address looks like a cloud server.";
+  }
+  const pills = [pill];
+  if (info.locality === "cloud" && !settings.allowCloud && opts.blocked !== false) {
+    const blocked = el("span", "ai-pill ai-pill--blocked", "blocked by Allow cloud");
+    blocked.title = "Turn on Allow cloud engines to route tasks here.";
+    pills.push(blocked);
+  }
+  return pills;
+}
+
+// src/ai-engine-form.ts
+var FILTER_THRESHOLD = 8;
+var SIZE_GROUPS = [
+  { tag: "fits", title: "Runs well on this machine" },
+  { tag: "tight", title: "A tight fit" },
+  { tag: "too large", title: "Likely too large for this machine" },
+  { tag: void 0, title: "Size not in the name" }
+];
+var SIZE_TITLES = {
+  fits: "Its size should run well in this machine\u2019s memory (a 4-bit estimate).",
+  tight: "Near the limit of this machine\u2019s memory: it may run slowly.",
+  "too large": "Probably more than this machine\u2019s memory holds. You can still pick it."
+};
+var LOCALITY_LABELS = {
+  local: "Local",
+  cloud: "Cloud"
+};
+function createEngineFormController(deps) {
+  const { ai } = deps;
+  const fetches = /* @__PURE__ */ new Map();
+  const testing = /* @__PURE__ */ new Set();
+  const results = /* @__PURE__ */ new Map();
+  const keyResults = /* @__PURE__ */ new Map();
+  const advancedOpen = /* @__PURE__ */ new Set();
+  const privacyOpen = /* @__PURE__ */ new Set();
+  const keyText = /* @__PURE__ */ new Map();
+  const keyStored = /* @__PURE__ */ new Map();
+  const keyTimers = /* @__PURE__ */ new Map();
+  const pickerFilter = /* @__PURE__ */ new Map();
+  const typeOpen = /* @__PURE__ */ new Set();
+  const openOverrides = /* @__PURE__ */ new Set();
+  const showAll = /* @__PURE__ */ new Set();
+  const formPicked = /* @__PURE__ */ new Map();
+  const overrideErrors = /* @__PURE__ */ new Map();
+  const pickRequired = /* @__PURE__ */ new Set();
+  const getEngine = (id) => deps.getDraft().engines.find((e) => e.id === id);
+  const presetOf = (engine) => enginePreset(engine, deps.getDraft().localNetworks);
+  const isLocal = (engine) => engineLocalityInfo(engine, deps.getDraft().localNetworks).locality === "local";
+  function fetchState(id) {
+    let st = fetches.get(id);
+    if (!st) {
+      st = { seq: 0, running: false, again: null, problem: null, prev: null };
+      fetches.set(id, st);
+    }
+    return st;
+  }
+  function replaceEngine(engine, refresh) {
+    deps.setDraft(withEngine(deps.getDraft(), engine), refresh);
+  }
+  function updateEngine(id, patch, refresh) {
+    const current = getEngine(id);
+    if (current) {
+      replaceEngine({ ...current, ...patch }, refresh);
+    }
+  }
+  function updateModel(engineId, modelId, fn, refresh) {
+    const engine = getEngine(engineId);
+    const model = engine?.models.find((m) => m.id === modelId);
+    if (engine && model) {
+      replaceEngine(withModel(engine, fn(model)), refresh);
+    }
+  }
+  function snapshot(engine, event) {
+    const st = fetchState(engine.id);
+    const status = deps.statuses.get(engine.id);
+    return {
+      event,
+      family: presetOf(engine).family,
+      key: keyText.get(engine.id) ?? "",
+      baseUrl: engine.baseUrl,
+      discovery: engine.discovery,
+      neverProbed: !status || status.ok === null,
+      hasKey: deps.hasKey(engine.id),
+      modelCount: engine.models.length,
+      fetchedFor: st.fetchedFor
+    };
+  }
+  function trigger(id, event) {
+    const engine = getEngine(id);
+    if (!engine || !ai.discoverModels) {
+      return;
+    }
+    const st = fetchState(id);
+    const next = snapshot(engine, event);
+    const decision = autoFetchDecision(st.prev, next);
+    st.prev = next;
+    if (decision.cancelPending) {
+      window.clearTimeout(st.timer);
+      st.timer = void 0;
+    }
+    if (!decision.fetch) {
+      return;
+    }
+    if (decision.delayMs > 0) {
+      st.timer = window.setTimeout(() => {
+        st.timer = void 0;
+        void runFetch(id, event);
+      }, decision.delayMs);
+    } else {
+      void runFetch(id, event);
+    }
+  }
+  async function runFetch(id, event) {
+    const st = fetchState(id);
+    const seq = ++st.seq;
+    st.lastEvent = event;
+    if (st.running) {
+      st.again = event;
+      return;
+    }
+    const engine = getEngine(id);
+    if (!engine || !ai.discoverModels) {
+      return;
+    }
+    st.running = true;
+    st.problem = null;
+    deps.refresh(id, { form: true, head: true });
+    const preset = presetOf(engine);
+    const name = engineDisplayName(engine);
+    try {
+      const typed = (keyText.get(id) ?? "").trim();
+      if (ai.setSecret && typed && keyStored.get(id) !== typed) {
+        const error = await deps.setKey(id, typed);
+        if (error) {
+          throw new Error(error);
+        }
+        keyStored.set(id, typed);
+      }
+      await deps.ensureSaved(id);
+      const status = await ai.discoverModels(id);
+      if (!status || typeof status !== "object") {
+        throw new Error("The app returned no model list.");
+      }
+      deps.statuses.set(id, status);
+      deps.onStatuses();
+      if (seq !== st.seq) {
+        return;
+      }
+      const current = getEngine(id) ?? engine;
+      if (status.ok === false) {
+        st.problem = discoveryProblem({ family: preset.family, presetName: preset.name, baseUrl: current.baseUrl, ok: false, message: status.error, listed: 0 });
+      } else {
+        const hadPick = current.models.some((m) => m.enabled && !m.missing);
+        let draft = withEngine(deps.getDraft(), applyDiscoveryForFamily(current, status, preset.family));
+        const merged = draft.engines.find((e) => e.id === id) ?? current;
+        let picked = null;
+        if (!hadPick) {
+          picked = preset.family === "local" ? merged.models.find((m) => m.enabled && !m.missing && m.capabilities.chat)?.id ?? null : autoPickDefault(preset, merged.models) ?? (preset.family === "host" ? firstChatModelId(merged.models) : null);
+          if (picked) {
+            draft = setEngineDefaultModel(draft, id, picked);
+            formPicked.set(id, picked);
+          }
+        }
+        if (!draft.routing.default) {
+          const route = defaultRouteForEngine(draft, [...deps.statuses.values()], id);
+          if (route) {
+            draft = setEngineDefaultModel(draft, id, route.modelId);
+          }
+        }
+        const listed = merged.models.filter((m) => !m.missing).length;
+        st.problem = discoveryProblem({ family: preset.family, presetName: preset.name, baseUrl: current.baseUrl, ok: true, listed });
+        st.fetchedFor = fetchFingerprint(preset.family, keyText.get(id) ?? "", current.baseUrl);
+        forgetStoredText(id);
+        deps.setDraft(draft, { head: true, routing: true, list: !hadPick && !!picked });
+        const pickedName = picked ? modelDisplayName(merged.models.find((m) => m.id === picked) ?? { id: picked }) : "";
+        deps.announce(`${name}: ${listed} ${listed === 1 ? "model" : "models"} found${pickedName ? `. ${pickedName} picked as the default model` : ""}.`);
+      }
+    } catch (err) {
+      if (seq !== st.seq) {
+        return;
+      }
+      const e = toAiError(err);
+      const current = getEngine(id) ?? engine;
+      st.problem = discoveryProblem({ family: preset.family, presetName: preset.name, baseUrl: current.baseUrl, ok: false, code: e.code, message: e.message, listed: 0 });
+    } finally {
+      st.running = false;
+      const again = st.again;
+      st.again = null;
+      if (again && seq !== st.seq) {
+        void runFetch(id, again);
+      } else if (getEngine(id)) {
+        if (st.problem && st.problem.kind !== "empty") {
+          deps.announce(`${name}: ${st.problem.text}`);
+        }
+        deps.refresh(id, { form: true, head: true });
+        if (st.problem?.focus === "key") {
+          deps.focusKey(`eng:${id}:key`);
+          const active = document.activeElement;
+          if (active instanceof HTMLInputElement) {
+            active.select();
+          }
+        }
+      }
+    }
+  }
+  function forgetStoredText(id) {
+    const typed = keyText.get(id);
+    if (typed !== void 0 && typed.trim() === keyStored.get(id)) {
+      keyText.delete(id);
+    }
+  }
+  async function settleKey(id) {
+    window.clearTimeout(keyTimers.get(id));
+    keyTimers.delete(id);
+    const engine = getEngine(id);
+    const typed = (keyText.get(id) ?? "").trim();
+    if (!engine || !typed || keyStored.get(id) === typed || !ai.setSecret) {
+      return;
+    }
+    const error = await deps.setKey(id, typed);
+    if (error) {
+      keyResults.set(id, { level: "error", text: error });
+      deps.refresh(id, { form: true });
+      return;
+    }
+    keyStored.set(id, typed);
+    keyResults.delete(id);
+    const st = fetchState(id);
+    if (st.problem?.kind !== "auth") {
+      forgetStoredText(id);
+    }
+    if (presetOf(engine).family === "local") {
+      if (st.problem?.kind === "auth") {
+        void runFetch(id, "retry");
+      } else {
+        deps.refresh(id, { form: true });
+      }
+      return;
+    }
+    deps.refresh(id, { form: true });
+  }
+  async function runTest(id) {
+    const engine = getEngine(id);
+    if (!engine || !ai.testEngine || testing.has(id)) {
+      return;
+    }
+    const name = engineDisplayName(engine);
+    testing.add(id);
+    results.delete(id);
+    deps.refresh(id, { form: true, head: true });
+    try {
+      await deps.ensureSaved(id);
+      const status = await ai.testEngine(id);
+      deps.statuses.set(id, status);
+      deps.onStatuses();
+      if (status.ok) {
+        const ms = status.latencyMs !== void 0 ? ` in ${Math.round(status.latencyMs)} ms` : "";
+        const n = status.models.filter((m) => !m.missing).length;
+        const text = `Connected${ms}${n ? `. The server lists ${n} ${n === 1 ? "model" : "models"}.` : "."}`;
+        results.set(id, { level: "ok", text });
+        deps.announce(`${name}: ${text}`);
+      } else {
+        const text = `Failed${status.error ? `: ${status.error}` : ". The server did not answer."}`;
+        results.set(id, { level: "error", text });
+        deps.announce(`${name}: connection ${text.toLowerCase()}`);
+      }
+    } catch (err) {
+      const e = toAiError(err);
+      const copy = aiErrorCopy(e.code);
+      const text = `${copy.title}${e.message && e.message !== copy.title ? `: ${e.message}` : "."}`;
+      results.set(id, { level: "error", text });
+      deps.announce(`${name}: ${text}`);
+    } finally {
+      testing.delete(id);
+      deps.refresh(id, { form: true, head: true, routing: true });
+      deps.focusKey(`eng:${id}:test`);
+    }
+  }
+  async function lookUpKey(id) {
+    const engine = getEngine(id);
+    if (!engine || !ai.listEngines || !ai.discoverModels || deps.hasKey(id) || !deps.savesFirst(id)) {
+      return;
+    }
+    if (!engine.apiKeyEnv?.trim() && !engine.apiKeyFile?.path.trim()) {
+      return;
+    }
+    try {
+      await deps.ensureSaved(id);
+      const status = (await ai.listEngines()).find((s) => s.engineId === id);
+      if (!status?.hasKey || !getEngine(id) || (keyText.get(id) ?? "").trim()) {
+        return;
+      }
+      deps.statuses.set(id, status);
+      deps.onStatuses();
+      deps.refresh(id, { form: true, head: true });
+      trigger(id, "open");
+    } catch {
+    }
+  }
+  function build(id, opts = {}) {
+    const engine = getEngine(id);
+    const wrap = el("div", "ai-form");
+    wrap.id = `ai-engine-editor-${id}`;
+    if (!engine) {
+      return wrap;
+    }
+    const preset = presetOf(engine);
+    const setup = !!opts.setup;
+    const fields = setup ? setupFields(preset, { key: fetchState(id).problem?.kind === "auth" || deps.hasKey(id) }) : expressFields(preset);
+    wrap.dataset.family = preset.family;
+    if (setup) {
+      wrap.classList.add("ai-form--setup");
+    }
+    wrap.setAttribute("role", "group");
+    wrap.setAttribute("aria-label", `${engineDisplayName(engine)} settings`);
+    if ((preset.family === "cloud" || preset.family === "host") && opts.privacy !== false) {
+      wrap.append(privacyCard({ policy: aiProviderPolicy(engine) }, {
+        hostEngine: preset.family === "host",
+        collapsed: "What is sent",
+        open: privacyOpen.has(id),
+        onToggle: (open) => {
+          if (open) {
+            privacyOpen.add(id);
+          } else {
+            privacyOpen.delete(id);
+          }
+        },
+        openLink: deps.openLink,
+        className: "ai-form-privacy"
+      }));
+    }
+    const sheet = el("div", "ai-sheet");
+    for (const field of fields.express) {
+      const keyNote = field === "key" && ai.setSecret ? deps.keyNote?.(engine, preset) ?? null : null;
+      const row = field === "key" ? buildKey(engine, preset, { hint: !keyNote }) : buildExpressField(engine, preset, field, setup);
+      if (!row) {
+        continue;
+      }
+      if (keyNote) {
+        sheet.append(keyNote);
+      }
+      sheet.append(row);
+    }
+    wrap.append(sheet);
+    if (!setup) {
+      wrap.append(buildActions(engine));
+    }
+    wrap.append(...buildAdvanced(engine, preset, fields.advanced));
+    return wrap;
+  }
+  function sheetRow(label, control, opts = {}) {
+    const row = el("div", `ai-sheet-row${opts.className ? ` ${opts.className}` : ""}`);
+    const lbl = el("label", "ai-sheet-label", label);
+    if (opts.forId) {
+      lbl.htmlFor = opts.forId;
+    }
+    const body = el("div", "ai-sheet-body");
+    body.append(control);
+    if (opts.caption) {
+      body.append(typeof opts.caption === "string" ? el("div", "ai-caption", opts.caption) : opts.caption);
+    }
+    row.append(lbl, body);
+    return row;
+  }
+  function buildExpressField(engine, preset, field, setup) {
+    switch (field) {
+      case "name":
+        return buildName(engine);
+      case "key":
+        return buildKey(engine, preset);
+      case "baseUrl":
+        return buildUrl(engine, preset, "express");
+      case "models":
+        return buildModelsPicker(engine, preset, setup);
+      case "defaultModel":
+        return buildDefaultModel(engine);
+      case "enabled":
+        return buildEnabled(engine);
+      default:
+        return null;
+    }
+  }
+  function buildName(engine) {
+    const id = engine.id;
+    const input = el("input", "settings-input ai-sheet-input");
+    input.type = "text";
+    input.id = nextId("ai-name");
+    input.value = engine.name;
+    input.placeholder = "Shown in pickers and the indicator";
+    input.dataset.fk = `eng:${id}:name`;
+    input.addEventListener("input", () => updateEngine(id, { name: input.value }, { head: true, routing: true }));
+    return sheetRow("Name", input, { forId: input.id });
+  }
+  function buildKey(engine, preset, o = {}) {
+    if (!ai.setSecret) {
+      return null;
+    }
+    const id = engine.id;
+    const has = deps.hasKey(id);
+    const line = el("div", "ai-key");
+    const input = el("input", "settings-input settings-input--grow ai-mono");
+    input.type = "password";
+    input.id = nextId("ai-key");
+    input.autocomplete = "off";
+    input.spellcheck = false;
+    input.dataset.fk = `eng:${id}:key`;
+    input.setAttribute("aria-label", `API key for ${engineDisplayName(engine)}`);
+    input.value = keyText.get(id) ?? "";
+    const source = has ? deps.keySource?.(id) : void 0;
+    const fromFile = has && (source ? source === "file" : !keyStored.has(id) && !!engine.apiKeyFile?.path);
+    const fromEnv = has && source === "env";
+    input.placeholder = fromFile || fromEnv ? "Found" : has ? "Stored" : "Paste your key";
+    const problem = fetchState(id).problem;
+    if (problem?.kind === "auth") {
+      input.setAttribute("aria-invalid", "true");
+    }
+    input.addEventListener("input", () => {
+      keyText.set(id, input.value);
+      input.removeAttribute("aria-invalid");
+      window.clearTimeout(keyTimers.get(id));
+      const st = fetchState(id);
+      if (presetOf(getEngine(id) ?? engine).family === "cloud") {
+        trigger(id, "key");
+        if (!st.timer && input.value.trim()) {
+          keyTimers.set(id, window.setTimeout(() => {
+            void settleKey(id);
+          }, 600));
+        }
+      } else if (input.value.trim()) {
+        keyTimers.set(id, window.setTimeout(() => {
+          void settleKey(id);
+        }, 600));
+      }
+    });
+    const flush = () => {
+      const st = fetchState(id);
+      if (st.timer) {
+        window.clearTimeout(st.timer);
+        st.timer = void 0;
+        void runFetch(id, "key");
+      } else if (keyTimers.has(id)) {
+        void settleKey(id);
+      }
+    };
+    input.addEventListener("keydown", (e) => {
+      if (e.key === "Enter") {
+        e.preventDefault();
+        flush();
+      }
+    });
+    input.addEventListener("blur", flush);
+    line.append(input);
+    if (has && source !== "env" && source !== "file") {
+      const clear = button("settings-btn", "Clear", { fk: `eng:${id}:key-clear`, ariaLabel: `Clear the stored API key for ${engineDisplayName(engine)}` });
+      clear.addEventListener("click", () => {
+        void clearKey(id);
+      });
+      line.append(clear);
+    }
+    const caption = el("div", "ai-caption ai-key-caption");
+    const result = keyResults.get(id);
+    if (result) {
+      caption.append(note(result.level, result.text));
+    } else if (fromEnv) {
+      caption.innerHTML = `<span class="ai-key-state">${ICONS.check}<span>Key found</span></span>`;
+      caption.append(" in ", el("code", "ai-key-env", engine.apiKeyEnv ?? "a variable"), ". Paste a key to use another one.");
+    } else if (fromFile) {
+      caption.innerHTML = `<span class="ai-key-state">${ICONS.check}<span>Key found</span></span>`;
+      caption.append(` in ${engine.apiKeyFile?.path ?? "the key file"}${source ? "" : " (or stored here)"}. Paste a key to use another one.`);
+    } else if (has) {
+      caption.innerHTML = `<span class="ai-key-state">${ICONS.check}<span>Stored</span></span>`;
+      caption.append(" in the system\u2019s secure storage. Paste a new key to replace it.");
+    } else if (o.hint === false) {
+    } else if (preset.keyUrl) {
+      caption.append(hostLink(preset.keyHint, preset.keyUrl, deps.openLink, "ai-key-link"));
+    } else {
+      caption.textContent = preset.keyHint;
+    }
+    return sheetRow("API key", line, { forId: input.id, caption: caption.childNodes.length > 0 ? caption : void 0, className: "ai-key-row" });
+  }
+  async function clearKey(id) {
+    const engine = getEngine(id);
+    if (!engine) {
+      return;
+    }
+    keyText.delete(id);
+    keyStored.delete(id);
+    const error = await deps.setKey(id, null);
+    keyResults.set(id, error ? { level: "error", text: error } : { level: "info", text: engine.apiKeyEnv ? `Key cleared. ${engine.apiKeyEnv} is used if it is set.` : engine.apiKeyFile ? "Key cleared. The key file is used if it has a key." : "Key cleared." });
+    deps.refresh(id, { form: true, head: true });
+    deps.focusKey(`eng:${id}:key`);
+  }
+  function buildUrl(engine, preset, where) {
+    const id = engine.id;
+    const input = el("input", "settings-input ai-sheet-input ai-mono");
+    input.type = "url";
+    input.id = nextId("ai-url");
+    input.spellcheck = false;
+    input.autocomplete = "off";
+    input.placeholder = "http://127.0.0.1:8000/v1";
+    input.value = engine.baseUrl;
+    input.dataset.fk = `eng:${id}:url`;
+    const error = el("div", "ai-field-error");
+    error.id = nextId("ai-url-error");
+    error.setAttribute("aria-live", "polite");
+    input.setAttribute("aria-describedby", error.id);
+    const show = () => {
+      const problem = baseUrlProblem(input.value);
+      error.textContent = problem;
+      input.setAttribute("aria-invalid", String(!!problem));
+    };
+    input.addEventListener("input", () => {
+      updateEngine(id, { baseUrl: input.value.trim() }, { head: true });
+      if (error.textContent) {
+        show();
+      }
+    });
+    input.addEventListener("change", () => {
+      show();
+      deps.refresh(id, { routing: true });
+      if (preset.family === "local") {
+        trigger(id, "url");
+      }
+    });
+    if (engine.baseUrl) {
+      show();
+    }
+    const body = el("div", "ai-url");
+    body.append(input, error);
+    const caption = where === "express" ? "The one thing that changes per machine. Usually ends in /v1." : "The server address. Cloud presets fill it in.";
+    return sheetRow("Base URL", body, { forId: input.id, caption });
+  }
+  function sizeTagFor(engineId, preset) {
+    if (preset.family !== "local" || !deps.modelSize) {
+      return null;
+    }
+    const bytes = new Map((deps.statuses.get(engineId)?.models ?? []).map((m) => [m.id, m.sizeBytes]));
+    return (modelId) => deps.modelSize?.(modelId, bytes.get(modelId));
+  }
+  function localPickNote(engine, preset, setup) {
+    const chat = engine.models.filter((m) => !m.missing && m.capabilities.chat);
+    if (chat.length === 0) {
+      return null;
+    }
+    const chosenId = engineDefaultModelId(deps.getDraft(), engine.id);
+    const picked = setup ? chat.some((m) => m.id === chosenId && m.enabled) : chat.some((m) => m.enabled);
+    if (picked) {
+      pickRequired.delete(engine.id);
+      return null;
+    }
+    if (pickRequired.has(engine.id)) {
+      const line2 = note("error", `Pick at least one model before you choose Done. ${engineDisplayName(engine)} needs a default model to answer.`, "ai-pick-note");
+      line2.setAttribute("role", "alert");
+      return line2;
+    }
+    if (preset.family !== "local") {
+      return null;
+    }
+    const sizeOf = sizeTagFor(engine.id, preset);
+    const facts = new Map((deps.statuses.get(engine.id)?.models ?? []).map((m) => [m.id, m]));
+    const tagged = chat.some((m) => sizeOf && sizeOf(m.id) !== void 0 || !!facts.get(m.id)?.sizeBytes || !!modelMoeFastHint(m.id, facts.get(m.id)?.moe, sizeOf?.(m.id)));
+    const text = `Pick a model to start with. No chat model is loaded in ${engineDisplayName(engine)}, so none was chosen for you${tagged ? "; the tags give size and speed hints" : ""}.`;
+    const line = note("info", text, "ai-pick-note");
+    line.setAttribute("role", "status");
+    return line;
+  }
+  function buildModelsPicker(engine, preset, setup = false) {
+    const id = engine.id;
+    const st = fetchState(id);
+    const keyless = preset.family === "cloud" && !deps.hasKey(id) && !(keyText.get(id) ?? "").trim();
+    if (setup && keyless && engine.models.length === 0 && !st.running && !st.problem) {
+      return null;
+    }
+    const box = el("div", "ai-picker");
+    const labelId = nextId("ai-models-label");
+    const listId = nextId("ai-models-list");
+    const head = el("div", "ai-picker-head");
+    const label = el("span", "ai-picker-label", setup ? "Model" : "Models");
+    label.id = labelId;
+    if (st.running) {
+      const spin = el("span", "ai-spinner");
+      spin.setAttribute("aria-hidden", "true");
+      label.append(spin);
+      box.setAttribute("aria-busy", "true");
+    }
+    const countLine = (e) => st.running ? "Fetching\u2026" : setup ? "" : modelCountLine(e);
+    const count = el("span", "ai-models-count", countLine(engine));
+    head.append(label, count);
+    if (ai.discoverModels && !(setup && keyless)) {
+      const fetchBtn = button("ai-link-btn", engine.models.length > 0 ? "Refresh models" : "Fetch models", { html: ICONS.refresh, fk: `eng:${id}:fetch` });
+      const urlBad = !isHostEngineKind(engine.kind) && !!baseUrlProblem(engine.baseUrl);
+      if (st.running) {
+        fetchBtn.setAttribute("aria-disabled", "true");
+      }
+      fetchBtn.disabled = engine.discovery === "manual" || urlBad;
+      if (engine.discovery === "manual") {
+        fetchBtn.title = "The model list is manual for this engine (see Advanced).";
+      }
+      fetchBtn.addEventListener("click", () => {
+        if (!st.running) {
+          trigger(id, "manual");
+        }
+      });
+      head.append(fetchBtn);
+    }
+    box.append(head);
+    const pickNote = localPickNote(engine, preset, setup);
+    if (pickNote && !st.running && !st.problem) {
+      box.append(pickNote);
+    }
+    const listed = engine.models.filter((m) => !m.missing).length;
+    const popularIds = preset.family === "cloud" ? popularModels(preset, engine.models).map((m) => m.id) : [];
+    const chosen = () => setup ? engineDefaultModelId(deps.getDraft(), id) : null;
+    const chosenAtBuild = chosen();
+    const collapsed = setup && popularIds.length > 0 && !showAll.has(id) && (!chosenAtBuild || popularIds.includes(chosenAtBuild));
+    const showInput = setup ? !collapsed && (engine.models.length > 0 ? engine.models.length > FILTER_THRESHOLD || typeOpen.has(id) || !!pickerFilter.get(id) : !keyless && !st.running) : engine.models.length > FILTER_THRESHOLD || engine.models.length === 0 || typeOpen.has(id) || !!pickerFilter.get(id);
+    const sizeOf = sizeTagFor(id, preset);
+    let input = null;
+    if (showInput) {
+      const field = el("div", "ai-combo");
+      const icon = el("span", "ai-combo-icon");
+      icon.innerHTML = ICONS.search;
+      input = el("input", "settings-input ai-combo-input");
+      input.type = "text";
+      input.spellcheck = false;
+      input.autocomplete = "off";
+      input.dataset.fk = `eng:${id}:pick`;
+      input.setAttribute("role", "combobox");
+      input.setAttribute("aria-expanded", "true");
+      input.setAttribute("aria-controls", listId);
+      input.setAttribute("aria-autocomplete", "list");
+      input.setAttribute("aria-label", engine.models.length > 0 ? `Filter models of ${engineDisplayName(engine)}, or type a model id to add it` : `Type a model id for ${engineDisplayName(engine)}`);
+      input.placeholder = engine.models.length > FILTER_THRESHOLD ? `Search ${listed} models, or type an id` : "Type a model id, then Enter";
+      input.value = pickerFilter.get(id) ?? "";
+      field.append(icon, input);
+      box.append(field);
+    }
+    const list = el("ul", "ai-listbox");
+    list.id = listId;
+    list.setAttribute("role", "listbox");
+    list.setAttribute("aria-multiselectable", String(!setup));
+    if (setup) {
+      list.classList.add("ai-listbox--single");
+    }
+    list.setAttribute("aria-labelledby", labelId);
+    if (!input) {
+      list.tabIndex = 0;
+      list.dataset.fk = `eng:${id}:models`;
+    }
+    box.append(list);
+    let active = -1;
+    let options = [];
+    const optionId = (i) => `${listId}-o${i}`;
+    const focusTarget = () => input ?? list;
+    function setActive(i) {
+      active = i >= 0 && i < options.length ? i : -1;
+      list.querySelectorAll(".ai-option.is-active").forEach((n) => n.classList.remove("is-active"));
+      const target = focusTarget();
+      if (active < 0) {
+        target.removeAttribute("aria-activedescendant");
+        return;
+      }
+      const node = Array.from(list.querySelectorAll(".ai-option")).find((n) => n.id === optionId(active));
+      node?.classList.add("is-active");
+      node?.scrollIntoView?.({ block: "nearest" });
+      target.setAttribute("aria-activedescendant", optionId(active));
+    }
+    function renderList() {
+      const filter = collapsed ? "" : pickerFilter.get(id) ?? "";
+      const current = getEngine(id) ?? engine;
+      const all = modelPickerOptions(current, deps.statuses.get(id), filter);
+      const popular = all.filter((o) => popularIds.includes(o.id)).sort((a, b) => popularIds.indexOf(a.id) - popularIds.indexOf(b.id));
+      const rest = collapsed ? [] : all.filter((o) => !popularIds.includes(o.id));
+      const sizes = sizeOf ? new Map(rest.map((o) => [o.id, sizeOf(o.id)])) : null;
+      const sized = !!sizes && [...sizes.values()].some((t) => t !== void 0);
+      const bySize = (tag) => rest.filter((o) => sizes?.get(o.id) === tag);
+      options = sized ? [...SIZE_GROUPS.flatMap((g) => bySize(g.tag))] : [...popular, ...rest];
+      list.replaceChildren();
+      let index = 0;
+      const group = (title, items) => {
+        if (items.length === 0) {
+          return;
+        }
+        const g = el("li", "ai-listbox-group");
+        g.setAttribute("role", "presentation");
+        const heading = el("div", "ai-listbox-heading", title);
+        heading.id = nextId("ai-group");
+        const ul = el("ul", "ai-listbox-items");
+        ul.setAttribute("role", "group");
+        ul.setAttribute("aria-labelledby", heading.id);
+        for (const o of items) {
+          ul.append(optionNode(o, index++));
+        }
+        g.append(heading, ul);
+        list.append(g);
+      };
+      if (sized) {
+        for (const g of SIZE_GROUPS) {
+          group(g.title, bySize(g.tag));
+        }
+      } else if (popular.length > 0) {
+        group("Popular", popular);
+        group("All models", rest);
+      } else {
+        for (const o of rest) {
+          list.append(optionNode(o, index++));
+        }
+      }
+      if (options.length === 0) {
+        const empty = el("li", "ai-listbox-empty");
+        empty.setAttribute("role", "presentation");
+        empty.textContent = filter.trim() ? `No model matches \u201C${filter.trim()}\u201D. Press Enter to add it by id.` : st.running ? "Fetching models\u2026" : keyless ? "Paste your key and the models appear here." : setup ? "No models yet. Fetch them from the server." : "No models yet. Fetch them from the server, or type an id.";
+        list.append(empty);
+      }
+      setActive(Math.min(active, options.length - 1));
+    }
+    function optionNode(o, i) {
+      const li = el("li", "ai-option");
+      li.id = optionId(i);
+      li.setAttribute("role", "option");
+      const on = setup ? o.id === chosen() : o.enabled;
+      li.setAttribute("aria-selected", String(on));
+      li.dataset.modelId = o.id;
+      li.classList.toggle("is-missing", o.missing);
+      li.classList.toggle("is-on", on);
+      const unusable = !(setup ? o.chat : o.usable);
+      if (unusable) {
+        li.classList.add("is-unusable");
+        li.setAttribute("aria-disabled", "true");
+      }
+      const check = el("span", "ai-option-check");
+      check.setAttribute("aria-hidden", "true");
+      check.innerHTML = ICONS.check;
+      const names = el("span", "ai-option-names");
+      names.append(el("span", "ai-option-name", o.name));
+      if (o.hasLabel) {
+        names.append(el("span", "ai-option-id", o.id));
+      }
+      li.append(check, names);
+      const tags = el("span", "ai-option-tags");
+      if (o.loaded) {
+        const t = el("span", "ai-tag ai-tag--loaded", "loaded");
+        t.title = "Loaded in memory on the server right now.";
+        tags.append(t);
+      }
+      if (o.missing) {
+        const t = el("span", "ai-tag ai-tag--missing", "not listed");
+        t.title = "The last fetch did not list this model. It is kept, but never routed.";
+        tags.append(t);
+      }
+      if (o.manual) {
+        tags.append(el("span", "ai-tag", "typed in"));
+      }
+      if (unusable) {
+        const t = el("span", "ai-tag ai-tag--unusable", o.usable ? "not for chat" : "not a chat model");
+        t.title = o.usable ? "An embeddings model: it cannot be the model this engine answers with." : "This model cannot answer (a converter or a draft model for another model), so it cannot be picked.";
+        tags.append(t);
+      }
+      const facts = preset.family === "local" ? deps.statuses.get(id)?.models.find((m) => m.id === o.id) : void 0;
+      const size = sizeOf?.(o.id);
+      const moe = preset.family === "local" ? modelMoeFastHint(o.id, facts?.moe, size) : null;
+      if (moe) {
+        const t = el("span", "ai-tag ai-tag--moe", "MoE \xB7 fast");
+        t.title = moe.activeBillions !== null ? `A mixture of experts: about ${moe.activeBillions}B parameters work per token, so it runs much faster than its size suggests.` : "A mixture of experts: only part of it works per token, so it runs much faster than its size suggests.";
+        tags.append(t);
+      }
+      if (facts?.sizeBytes) {
+        const t = el("span", "ai-tag ai-tag--bytes", formatModelSize(facts.sizeBytes));
+        t.title = "Its size, as the server reports it.";
+        tags.append(t);
+      }
+      if (size) {
+        const t = el("span", `ai-tag ai-tag--size ai-tag--${size.replace(" ", "-")}`, size);
+        t.title = SIZE_TITLES[size];
+        tags.append(t);
+      }
+      if (tags.childElementCount > 0) {
+        li.append(tags);
+      }
+      li.addEventListener("mousedown", (e) => e.preventDefault());
+      li.addEventListener("click", () => {
+        active = i;
+        pick(o.id);
+      });
+      return li;
+    }
+    function pick(modelId) {
+      const o = options.find((x) => x.id === modelId);
+      if (o && !(setup ? o.chat : o.usable)) {
+        deps.announce(`${o.name} is not a chat model, so it cannot be picked.`);
+        return;
+      }
+      if (setup) {
+        choose(modelId);
+      } else {
+        toggle(modelId);
+      }
+    }
+    function choose(modelId) {
+      const model = getEngine(id)?.models.find((m) => m.id === modelId);
+      if (!model || chosen() === modelId) {
+        return;
+      }
+      deps.setDraft(chooseSetupModel(deps.getDraft(), id, modelId, formPicked.get(id)), { head: true, list: true, routing: true });
+      formPicked.set(id, modelId);
+      deps.announce(`${modelDisplayName(model)} chosen.`);
+      refreshAfterPick();
+    }
+    function toggle(modelId) {
+      const current = getEngine(id);
+      const model = current?.models.find((m) => m.id === modelId);
+      if (!current || !model) {
+        return;
+      }
+      const enabled = !model.enabled;
+      deps.setDraft(setModelPicked(deps.getDraft(), id, modelId, enabled), { head: true, routing: true });
+      deps.announce(`${modelDisplayName(model)} ${enabled ? "picked" : "removed"}.`);
+      refreshAfterPick();
+    }
+    function refreshAfterPick() {
+      const scroll = list.scrollTop;
+      const current = getEngine(id) ?? engine;
+      count.textContent = countLine(current);
+      renderList();
+      list.scrollTop = scroll;
+      const pickNote2 = localPickNote(current, preset, setup);
+      const shown = box.querySelector(":scope > .ai-pick-note");
+      if (shown && !pickNote2) {
+        shown.remove();
+      } else if (!shown && pickNote2) {
+        head.after(pickNote2);
+      }
+      const form = box.closest(".ai-form");
+      const def = form?.querySelector(".ai-default-row");
+      const fresh = buildDefaultModel(current);
+      if (def && fresh) {
+        keepFocus(def, () => {
+          def.replaceWith(fresh);
+          return fresh;
+        });
+      }
+      focusTarget().focus({ preventScroll: true });
+    }
+    function addTyped(text) {
+      const current = getEngine(id);
+      if (!current) {
+        return;
+      }
+      const exact = current.models.find((m) => m.id === text);
+      if (exact) {
+        if (setup) {
+          choose(exact.id);
+        } else if (!exact.enabled) {
+          toggle(exact.id);
+        }
+        return;
+      }
+      const r = addManualModel(current, text);
+      if (!r.ok) {
+        deps.announce(r.error);
+        return;
+      }
+      let next = withEngine(deps.getDraft(), r.engine);
+      if (!next.routing.default && r.model.capabilities.chat && r.engine.enabled) {
+        next = setEngineDefaultModel(next, id, r.model.id);
+      }
+      if (setup) {
+        next = chooseSetupModel(next, id, r.model.id, formPicked.get(id));
+        formPicked.set(id, r.model.id);
+      }
+      deps.setDraft(next, { head: true, list: !deps.getDraft().routing.default && !!next.routing.default, routing: true });
+      pickerFilter.delete(id);
+      typeOpen.add(id);
+      deps.announce(`Added ${r.model.id}.`);
+      deps.refresh(id, { form: true });
+      deps.focusKey(`eng:${id}:pick`);
+    }
+    const onKey = (e) => {
+      if (e.key === "ArrowDown" || e.key === "ArrowUp") {
+        e.preventDefault();
+        if (options.length === 0) {
+          return;
+        }
+        const step = e.key === "ArrowDown" ? 1 : -1;
+        setActive(active < 0 ? step > 0 ? 0 : options.length - 1 : (active + step + options.length) % options.length);
+      } else if (e.key === "Home" && !input) {
+        e.preventDefault();
+        setActive(0);
+      } else if (e.key === "End" && !input) {
+        e.preventDefault();
+        setActive(options.length - 1);
+      } else if (e.key === "Enter" || e.key === " " && !input) {
+        e.preventDefault();
+        const typed = input?.value.trim() ?? "";
+        if (active >= 0 && options[active]) {
+          pick(options[active].id);
+        } else if (typed) {
+          addTyped(typed);
+        }
+      } else if (e.key === "Escape") {
+        if (input?.value) {
+          e.preventDefault();
+          e.stopPropagation();
+          input.value = "";
+          pickerFilter.delete(id);
+          active = -1;
+          renderList();
+        } else if (active >= 0) {
+          e.preventDefault();
+          e.stopPropagation();
+          setActive(-1);
+        }
+      }
+    };
+    if (input) {
+      const field = input;
+      field.addEventListener("keydown", onKey);
+      field.addEventListener("input", () => {
+        pickerFilter.set(id, field.value);
+        active = field.value.trim() ? 0 : -1;
+        renderList();
+      });
+    } else {
+      list.addEventListener("keydown", onKey);
+      list.addEventListener("focus", () => {
+        if (active < 0 && options.length > 0) {
+          setActive(0);
+        }
+      });
+    }
+    renderList();
+    if (setup && popularIds.length > 0 && (collapsed || showAll.has(id))) {
+      const more = button("ai-link-btn ai-show-all", collapsed ? `Show all models (${listed})` : "Show popular only", { fk: `eng:${id}:show-all` });
+      more.setAttribute("aria-expanded", String(!collapsed));
+      more.setAttribute("aria-controls", listId);
+      more.addEventListener("click", () => {
+        if (collapsed) {
+          showAll.add(id);
+        } else {
+          showAll.delete(id);
+          pickerFilter.delete(id);
+        }
+        deps.refresh(id, { form: true });
+        deps.focusKey(`eng:${id}:show-all`);
+      });
+      box.append(more);
+    }
+    if (!input && (!setup || !collapsed && engine.models.length > 0)) {
+      const typeBtn = button("ai-link-btn ai-type-btn", "Type a model id\u2026", { fk: `eng:${id}:type-open` });
+      typeBtn.addEventListener("click", () => {
+        typeOpen.add(id);
+        deps.refresh(id, { form: true });
+        deps.focusKey(`eng:${id}:pick`);
+      });
+      box.append(typeBtn);
+    }
+    const problem = st.problem;
+    if (problem && !st.running) {
+      const line = el("div", `ai-fetch-note ai-fetch-note--${problem.kind}`);
+      line.setAttribute("role", "status");
+      line.append(note(problem.kind === "empty" ? "info" : "error", problem.text));
+      if (problem.retry && ai.discoverModels) {
+        const retry = button("ai-link-btn", "Retry", { fk: `eng:${id}:retry` });
+        retry.addEventListener("click", () => {
+          void runFetch(id, st.lastEvent ?? "retry");
+        });
+        line.append(retry);
+      }
+      box.append(line);
+    }
+    const row = el("div", "ai-sheet-row ai-sheet-row--block");
+    row.append(box);
+    return row;
+  }
+  function buildDefaultModel(engine) {
+    const id = engine.id;
+    const draft = deps.getDraft();
+    const enabled = engine.models.filter((m) => m.enabled && !m.missing && m.capabilities.chat);
+    const stored = engineDefaultModelId(draft, id);
+    const current = stored && enabled.some((m) => m.id === stored) ? stored : null;
+    const line = el("div", "ai-default");
+    const select = el("select", "settings-input ai-default-select");
+    select.id = nextId("ai-default");
+    select.dataset.fk = `eng:${id}:default-model`;
+    if (enabled.length === 0) {
+      const o = el("option", "", "Pick a model above");
+      o.value = "";
+      select.append(o);
+      select.disabled = true;
+    } else {
+      for (const m of enabled) {
+        const o = el("option", "", modelDisplayName(m));
+        o.value = m.id;
+        select.append(o);
+      }
+      select.value = current ?? enabled[0].id;
+    }
+    select.addEventListener("change", () => {
+      deps.setDraft(setEngineDefaultModel(deps.getDraft(), id, select.value), { head: true, list: true, routing: true });
+      const model2 = getEngine(id)?.models.find((m) => m.id === select.value);
+      if (model2) {
+        deps.announce(`Default model: ${modelDisplayName(model2)}.`);
+      }
+    });
+    line.append(select);
+    const model = engine.models.find((m) => m.id === (current ?? enabled[0]?.id));
+    const thinking = model ? buildThinkingSelect(engine, model, "express") : null;
+    if (thinking) {
+      const wrap = el("label", "ai-thinking");
+      wrap.append(el("span", "ai-thinking-label", "Thinking"), thinking);
+      line.append(wrap);
+    }
+    const isDefaultEngine = draft.routing.default?.engineId === id;
+    const caption = enabled.length === 0 ? "Pick at least one model to use this engine." : isDefaultEngine ? "Serves every task without its own route." : draft.routing.default ? "Used when this engine is picked for a task, or made the default (the star)." : "Becomes the default route once you pick it.";
+    return sheetRow("Default model", line, { forId: select.id, caption, className: "ai-default-row" });
+  }
+  function buildThinkingSelect(engine, model, where) {
+    const choices = thinkingChoices(engine.kind);
+    if (choices.length === 0) {
+      return null;
+    }
+    const id = engine.id;
+    const select = el("select", `settings-input ${where === "table" ? "settings-input--small " : ""}ai-thinking-select`);
+    select.dataset.fk = where === "express" ? `eng:${id}:thinking` : `model:${id}:${model.id}:thinking`;
+    select.setAttribute("aria-label", `Thinking for ${modelDisplayName(model)}`);
+    select.title = "How hard the model thinks before it answers. Default sends nothing (the model decides).";
+    const dflt = el("option", "", "Default");
+    dflt.value = "";
+    select.append(dflt);
+    for (const c of choices) {
+      const o = el("option", "", c.label);
+      o.value = c.level;
+      select.append(o);
+    }
+    select.value = thinkingLevelFrom(engine.kind, model.requestOverrides) ?? "";
+    select.addEventListener("change", () => {
+      const level = select.value || null;
+      const current = getEngine(id);
+      if (!current) {
+        return;
+      }
+      updateModel(id, model.id, (m) => setModelThinking(m, current.kind, level, isLocal(current)), {});
+      if (advancedOpen.has(id)) {
+        deps.refresh(id, { form: true });
+      }
+    });
+    return select;
+  }
+  function buildEnabled(engine) {
+    const id = engine.id;
+    const toggle = switchInput(engine.enabled, `Enable ${engineDisplayName(engine)}`, `eng:${id}:enabled`);
+    toggle.id = nextId("ai-enabled");
+    toggle.addEventListener("change", () => updateEngine(id, { enabled: toggle.checked }, { list: true, routing: true }));
+    const line = el("div", "ai-enabled-line");
+    line.append(toggle, el("span", "ai-caption", "Engines that are off are never routed."));
+    return sheetRow("Enabled", line, { forId: toggle.id });
+  }
+  function buildActions(engine) {
+    const id = engine.id;
+    const row = el("div", "ai-form-actions");
+    if (ai.testEngine) {
+      const busy = testing.has(id);
+      const test = button("settings-btn settings-btn--secondary", busy ? "Testing\u2026" : "Test connection", { fk: `eng:${id}:test` });
+      if (busy) {
+        test.setAttribute("aria-disabled", "true");
+      }
+      test.disabled = !isHostEngineKind(engine.kind) && !!baseUrlProblem(engine.baseUrl);
+      test.addEventListener("click", () => {
+        void runTest(id);
+      });
+      row.append(test);
+      if (deps.savesFirst(id)) {
+        row.append(el("span", "ai-caption", "Testing saves this engine first, so the app can reach it."));
+      }
+    }
+    const result = results.get(id);
+    if (result) {
+      row.append(note(result.level, result.text, "ai-result"));
+    }
+    return row;
+  }
+  function buildAdvanced(engine, preset, fields) {
+    const id = engine.id;
+    const open = advancedOpen.has(id);
+    const panelId = `ai-advanced-${id}`;
+    const toggle = button("ai-disclosure", "Advanced", { html: ICONS.chevron, fk: `eng:${id}:advanced` });
+    toggle.setAttribute("aria-expanded", String(open));
+    toggle.setAttribute("aria-controls", panelId);
+    toggle.addEventListener("click", () => {
+      if (advancedOpen.has(id)) {
+        advancedOpen.delete(id);
+      } else {
+        advancedOpen.add(id);
+      }
+      deps.refresh(id, { form: true });
+      deps.focusKey(`eng:${id}:advanced`);
+    });
+    const panel = el("div", "ai-advanced");
+    panel.id = panelId;
+    panel.hidden = !open;
+    if (!open) {
+      return [toggle, panel];
+    }
+    const rows = [];
+    for (const field of fields) {
+      if (field === "kind") {
+        rows.push(buildKind(engine));
+      }
+      if (field === "baseUrl") {
+        rows.push(buildUrl(engine, preset, "advanced"));
+      }
+      if (field === "locality") {
+        rows.push(buildLocality(engine));
+      }
+      if (field === "key") {
+        const key = buildKey(engine, preset);
+        if (key) {
+          rows.push(key);
+        }
+      }
+      if (field === "keyEnv") {
+        rows.push(buildKeyEnv(engine));
+      }
+      if (field === "keyFile") {
+        rows.push(buildKeyFile(engine));
+      }
+      if (field === "discovery") {
+        rows.push(buildDiscovery(engine));
+      }
+    }
+    const sheet = el("div", "ai-sheet ai-sheet--advanced");
+    sheet.append(...rows);
+    panel.append(sheet);
+    if (fields.includes("modelsTable")) {
+      panel.append(buildModelsTable(engine));
+    }
+    return [toggle, panel];
+  }
+  function buildKind(engine) {
+    const id = engine.id;
+    const select = el("select", "settings-input");
+    select.id = nextId("ai-kind");
+    select.dataset.fk = `eng:${id}:kind`;
+    for (const kind of AI_ENGINE_KINDS) {
+      if (isHostEngineKind(kind) && kind !== engine.kind) {
+        continue;
+      }
+      const o = el("option", "", AI_ENGINE_KIND_LABELS[kind]);
+      o.value = kind;
+      select.append(o);
+    }
+    if (!isKnownEngineKind(engine.kind)) {
+      const o = el("option", "", engineKindLabel(engine.kind));
+      o.value = engine.kind;
+      select.prepend(o);
+    }
+    select.value = engine.kind;
+    select.addEventListener("change", () => updateEngine(id, { kind: select.value }, { form: true, head: true, routing: true }));
+    return sheetRow("Kind", select, { forId: select.id, caption: "How MikeDown talks to the server." });
+  }
+  function buildLocality(engine) {
+    const id = engine.id;
+    const select = el("select", "settings-input");
+    select.id = nextId("ai-locality");
+    select.dataset.fk = `eng:${id}:locality`;
+    const autoOption = el("option");
+    autoOption.value = "auto";
+    select.append(autoOption);
+    for (const [value, label] of Object.entries(LOCALITY_LABELS)) {
+      const o = el("option", "", label);
+      o.value = value;
+      select.append(o);
+    }
+    select.value = engine.locality;
+    const info = engineLocalityInfo(engine, deps.getDraft().localNetworks);
+    autoOption.textContent = `Auto (detected: ${info.detected})`;
+    const body = el("div", "ai-locality");
+    body.append(select);
+    if (info.mismatch) {
+      body.append(note("warning", info.locality === "cloud" ? "Pinned to cloud, but the address looks local." : "Pinned to local, but the address looks like a cloud server. Text sent to it leaves this network.", "ai-locality-note"));
+    }
+    select.addEventListener("change", () => updateEngine(id, { locality: select.value }, { form: true, head: true, routing: true }));
+    return sheetRow("Locality", body, { forId: select.id, caption: "Auto decides from the address. Cloud engines need Allow cloud." });
+  }
+  function buildKeyEnv(engine) {
+    const id = engine.id;
+    const input = el("input", "settings-input settings-input--medium ai-mono");
+    input.type = "text";
+    input.id = nextId("ai-env");
+    input.spellcheck = false;
+    input.autocomplete = "off";
+    input.placeholder = "NAME_OF_VARIABLE";
+    input.value = engine.apiKeyEnv ?? "";
+    input.dataset.fk = `eng:${id}:env`;
+    input.addEventListener("input", () => {
+      const v = input.value.trim();
+      const current = getEngine(id);
+      if (!current) {
+        return;
+      }
+      const next = { ...current };
+      if (v) {
+        next.apiKeyEnv = v;
+      } else {
+        delete next.apiKeyEnv;
+      }
+      replaceEngine(next, { head: true });
+    });
+    return sheetRow("Key from variable", input, {
+      forId: input.id,
+      // Desktop opened from the Dock has no shell environment (F10).
+      caption: ai.shellEnv === false ? "This app does not read shell variables when opened from the Dock; use the key file or paste the key." : "Used when no key is stored, for example OMLX_API_KEY. Apps opened from the Dock or Start menu may not see variables set in a shell profile."
+    });
+  }
+  function buildKeyFile(engine) {
+    const id = engine.id;
+    const line = el("div", "ai-key");
+    const path = el("input", "settings-input settings-input--grow ai-mono");
+    const json = el("input", "settings-input settings-input--medium ai-mono");
+    for (const input of [path, json]) {
+      input.type = "text";
+      input.spellcheck = false;
+      input.autocomplete = "off";
+    }
+    path.id = nextId("ai-keyfile");
+    path.placeholder = "~/path/to/settings.json";
+    json.placeholder = "auth.api_key";
+    path.value = engine.apiKeyFile?.path ?? "";
+    json.value = engine.apiKeyFile?.jsonPath ?? "";
+    path.dataset.fk = `eng:${id}:keyfile-path`;
+    json.dataset.fk = `eng:${id}:keyfile-json`;
+    path.setAttribute("aria-label", `Key file path for ${engineDisplayName(engine)}`);
+    json.setAttribute("aria-label", `Key file JSON path for ${engineDisplayName(engine)}`);
+    const save = () => {
+      const current = getEngine(id);
+      if (!current) {
+        return;
+      }
+      const p = path.value.trim();
+      const j = json.value.trim();
+      const next = { ...current };
+      if (p && j) {
+        next.apiKeyFile = { ...current.apiKeyFile, path: p, jsonPath: j };
+      } else {
+        delete next.apiKeyFile;
+      }
+      replaceEngine(next, { head: true });
+    };
+    path.addEventListener("input", save);
+    json.addEventListener("input", save);
+    line.append(path, json);
+    return sheetRow("Key file", line, {
+      forId: path.id,
+      caption: "Used when no key is stored and the variable is unset: a JSON file in your home folder and the dotted path to the key inside it. Works for apps opened from the Dock or Start menu."
+    });
+  }
+  function buildDiscovery(engine) {
+    const id = engine.id;
+    const select = el("select", "settings-input");
+    select.id = nextId("ai-discovery");
+    select.dataset.fk = `eng:${id}:discovery`;
+    for (const [value, label] of [["auto", "Ask the server"], ["manual", "Manual only"]]) {
+      const o = el("option", "", label);
+      o.value = value;
+      select.append(o);
+    }
+    select.value = engine.discovery;
+    select.addEventListener("change", () => updateEngine(id, { discovery: select.value }, { form: true }));
+    return sheetRow("Model list", select, { forId: select.id, caption: "Ask the server which models it has (merged with any you add), or keep only the models you add by hand." });
+  }
+  function buildModelsTable(engine) {
+    const id = engine.id;
+    const box = el("div", "ai-models");
+    const head = el("div", "ai-models-head");
+    const missing = engine.models.filter((m) => m.missing).length;
+    head.append(el("span", "settings-label", "All models"));
+    head.append(el("span", "ai-models-count", engine.models.length === 0 ? "none yet" : `${engine.models.length}${missing ? `, ${missing} not listed` : ""}`));
+    box.append(head);
+    if (engine.models.length === 0) {
+      box.append(el("div", "ai-models-empty", engine.discovery === "auto" && ai.discoverModels ? "Fetch models to list what the server offers, or add one by id." : "Add the models this engine serves by id."));
+    } else {
+      const list = el("div", "ai-model-list");
+      list.setAttribute("role", "list");
+      list.setAttribute("aria-label", `Models of ${engineDisplayName(engine)}`);
+      const loaded = new Map((deps.statuses.get(id)?.models ?? []).map((m) => [m.id, m.loaded]));
+      for (const model of engine.models) {
+        list.append(buildModelItem(engine, model, loaded.get(model.id)));
+      }
+      box.append(list);
+    }
+    const add = el("div", "ai-model-add");
+    const addInput = el("input", "settings-input settings-input--small settings-input--grow ai-mono");
+    addInput.type = "text";
+    addInput.placeholder = "Model id, such as qwen3-coder-30b";
+    addInput.spellcheck = false;
+    addInput.setAttribute("aria-label", `Add a model to ${engineDisplayName(engine)} by id`);
+    addInput.dataset.fk = `eng:${id}:add-model`;
+    const addBtn = button("settings-btn", "Add model", { html: ICONS.plus, fk: `eng:${id}:add-model-btn` });
+    const addError = el("div", "ai-field-error");
+    addError.id = nextId("ai-add-model-error");
+    addInput.setAttribute("aria-describedby", addError.id);
+    const doAdd = () => {
+      const current = getEngine(id);
+      if (!current) {
+        return;
+      }
+      const r = addManualModel(current, addInput.value);
+      if (!r.ok) {
+        addError.textContent = r.error;
+        addInput.setAttribute("aria-invalid", "true");
+        addInput.focus();
+        return;
+      }
+      replaceEngine(r.engine, { form: true, routing: true });
+      deps.announce(`Added ${r.model.id}.`);
+      deps.focusKey(`eng:${id}:add-model`);
+    };
+    addBtn.addEventListener("click", doAdd);
+    addInput.addEventListener("keydown", (e) => {
+      if (e.key === "Enter") {
+        e.preventDefault();
+        doAdd();
+      }
+    });
+    addInput.addEventListener("input", () => {
+      addError.textContent = "";
+      addInput.removeAttribute("aria-invalid");
+    });
+    add.append(addInput, addBtn);
+    box.append(add, addError);
+    return box;
+  }
+  function buildModelItem(engine, model, loaded) {
+    const engineId = engine.id;
+    const mfk = (name) => `model:${engineId}:${model.id}:${name}`;
+    const shown = modelDisplayName(model);
+    const item = el("div", "ai-model");
+    item.setAttribute("role", "listitem");
+    item.classList.toggle("is-missing", !!model.missing);
+    item.classList.toggle("is-off", !model.enabled);
+    const top = el("div", "ai-model-top");
+    const enabled = el("input", "ai-model-check");
+    enabled.type = "checkbox";
+    enabled.checked = model.enabled;
+    enabled.dataset.fk = mfk("enabled");
+    enabled.setAttribute("aria-label", `Use ${shown}`);
+    if (!model.capabilities.chat && !model.capabilities.embed && !model.enabled) {
+      enabled.disabled = true;
+      enabled.title = "Not a chat model: it cannot be picked.";
+    }
+    enabled.addEventListener("change", () => {
+      deps.setDraft(setModelPicked(deps.getDraft(), engineId, model.id, enabled.checked), { form: true, head: true, routing: true });
+    });
+    const names = el("div", "ai-model-names");
+    const label = el("input", "ai-model-label");
+    label.type = "text";
+    label.value = model.label ?? "";
+    label.placeholder = model.id;
+    label.spellcheck = false;
+    label.dataset.fk = mfk("label");
+    label.setAttribute("aria-label", `Display name for ${model.id}`);
+    label.addEventListener("input", () => updateModel(engineId, model.id, (m) => {
+      const next = { ...m };
+      if (label.value.trim()) {
+        next.label = label.value;
+      } else {
+        delete next.label;
+      }
+      return next;
+    }, { routing: true }));
+    names.append(label);
+    if (model.label) {
+      names.append(el("span", "ai-model-id", model.id));
+    }
+    const tags = el("div", "ai-model-tags");
+    if (loaded) {
+      const t = el("span", "ai-tag ai-tag--loaded", "loaded");
+      t.title = "Loaded in memory on the server right now.";
+      tags.append(t);
+    }
+    if (model.missing) {
+      const t = el("span", "ai-tag ai-tag--missing", "not listed");
+      t.title = "The last discovery did not list this model. It is kept, but never routed.";
+      tags.append(t);
+    }
+    if (model.manual) {
+      tags.append(el("span", "ai-tag", "added by hand"));
+    }
+    const ctxWrap = el("label", "ai-model-context");
+    const ctxInput = el("input", "settings-input settings-input--small ai-context-input");
+    ctxInput.type = "text";
+    ctxInput.inputMode = "numeric";
+    ctxInput.value = model.capabilities.contextTokens !== null ? String(model.capabilities.contextTokens) : "";
+    ctxInput.placeholder = formatTokens(null);
+    ctxInput.dataset.fk = mfk("context");
+    ctxInput.setAttribute("aria-label", `Context window of ${shown}, in tokens`);
+    ctxInput.title = `Context window in tokens (${formatTokens(model.capabilities.contextTokens)}). Blank means unknown.`;
+    ctxInput.addEventListener("change", () => {
+      const r = parseContextTokens(ctxInput.value);
+      if (!r.ok) {
+        ctxInput.setAttribute("aria-invalid", "true");
+        ctxInput.title = r.error;
+        deps.announce(r.error);
+        return;
+      }
+      ctxInput.removeAttribute("aria-invalid");
+      updateModel(engineId, model.id, (m) => setModelContextTokens(m, r.value), { form: true, routing: true });
+    });
+    ctxWrap.append(ctxInput, el("span", "ai-context-unit", "ctx"));
+    const hasOverrides = !!model.requestOverrides && Object.keys(model.requestOverrides).length > 0;
+    const ovKey = `${engineId}\0${model.id}`;
+    const ovOpen = openOverrides.has(ovKey) || overrideErrors.has(ovKey);
+    const overridesId = nextId("ai-overrides");
+    const ovBtn = button(`ai-icon-btn ai-overrides-btn${hasOverrides ? " has-value" : ""}`, "", {
+      html: '<span aria-hidden="true">{ }</span>',
+      ariaLabel: `Request overrides for ${shown}`,
+      title: hasOverrides ? "Request overrides (set)" : "Request overrides",
+      fk: mfk("overrides")
+    });
+    ovBtn.setAttribute("aria-expanded", String(ovOpen));
+    ovBtn.setAttribute("aria-controls", overridesId);
+    ovBtn.addEventListener("click", () => {
+      if (openOverrides.has(ovKey)) {
+        openOverrides.delete(ovKey);
+      } else {
+        openOverrides.add(ovKey);
+      }
+      deps.refresh(engineId, { form: true });
+      if (openOverrides.has(ovKey)) {
+        deps.focusKey(mfk("overrides-text"));
+      }
+    });
+    const right = el("div", "ai-model-right");
+    const thinking = buildThinkingSelect(engine, model, "table");
+    if (thinking) {
+      right.append(thinking);
+    }
+    right.append(ctxWrap, ovBtn);
+    if (model.manual || model.missing) {
+      const remove = button("ai-icon-btn ai-model-remove", "", { html: ICONS.close, ariaLabel: `Remove ${shown}`, title: "Remove model", fk: mfk("remove") });
+      remove.addEventListener("click", () => {
+        const current = getEngine(engineId);
+        if (!current) {
+          return;
+        }
+        const index = current.models.findIndex((m) => m.id === model.id);
+        const draft = removeRoutesTo(deps.getDraft(), engineId, model.id);
+        deps.setDraft(withEngine(draft, { ...current, models: current.models.filter((m) => m.id !== model.id) }), { form: true, head: true, routing: true });
+        deps.announce(`Removed ${shown}.`);
+        const rest = getEngine(engineId)?.models ?? [];
+        const next = rest[Math.min(index, rest.length - 1)];
+        deps.focusKey(next ? `model:${engineId}:${next.id}:enabled` : `eng:${engineId}:add-model`);
+      });
+      right.append(remove);
+    }
+    top.append(enabled, names, tags, right);
+    const chips = el("div", "ai-chips");
+    chips.setAttribute("role", "group");
+    chips.setAttribute("aria-label", `Capabilities of ${shown}`);
+    for (const chip of AI_CAPABILITY_CHIPS) {
+      const on = model.capabilities[chip.flag];
+      const b = button(`ai-chip${on ? " is-on" : ""}`, chip.label, { title: `${chip.title}. Click to ${on ? "turn off" : "turn on"}.`, fk: mfk(`chip-${chip.flag}`) });
+      b.setAttribute("aria-pressed", String(on));
+      b.setAttribute("aria-label", `${chip.label}: ${chip.title}`);
+      b.addEventListener("click", () => updateModel(engineId, model.id, (m) => toggleModelCapability(m, chip.flag), { form: true, routing: true }));
+      chips.append(b);
+    }
+    const source = el("span", `ai-source ai-source--${model.capabilitiesSource}`, model.capabilitiesSource === "user" ? "edited" : model.capabilitiesSource === "endpoint" ? "from server" : "guessed");
+    source.title = model.capabilitiesSource === "user" ? "You edited these; discovery leaves them alone." : model.capabilitiesSource === "endpoint" ? "Reported by the server; refreshed on discovery." : "Guessed from the model id; refreshed on discovery.";
+    chips.append(source);
+    item.append(top, chips);
+    if (ovOpen) {
+      const ov = el("div", "ai-overrides");
+      ov.id = overridesId;
+      const area = el("textarea", "settings-input ai-mono ai-overrides-text");
+      area.rows = 3;
+      area.spellcheck = false;
+      area.dataset.fk = mfk("overrides-text");
+      area.placeholder = '{ "reasoning_effort": "low" }';
+      const pending = overrideErrors.get(ovKey);
+      area.value = pending ? pending.text : formatRequestOverrides(model.requestOverrides);
+      const help = el("div", "settings-desc", "JSON merged into every request body for this model, last, so it wins. The Thinking menu writes its fields here too.");
+      const err = el("div", "ai-field-error");
+      err.id = nextId("ai-overrides-error");
+      err.setAttribute("aria-live", "polite");
+      area.setAttribute("aria-describedby", err.id);
+      area.setAttribute("aria-label", `Request overrides for ${shown}, as JSON`);
+      if (pending) {
+        err.textContent = pending.error;
+        area.setAttribute("aria-invalid", "true");
+      }
+      area.addEventListener("input", () => {
+        const r = parseRequestOverrides(area.value);
+        if (!r.ok) {
+          overrideErrors.set(ovKey, { text: area.value, error: r.error });
+          err.textContent = r.error;
+          area.setAttribute("aria-invalid", "true");
+          return;
+        }
+        overrideErrors.delete(ovKey);
+        err.textContent = "";
+        area.removeAttribute("aria-invalid");
+        updateModel(engineId, model.id, (m) => {
+          const next = { ...m };
+          if (r.value) {
+            next.requestOverrides = r.value;
+          } else {
+            delete next.requestOverrides;
+          }
+          return next;
+        }, {});
+        ovBtn.classList.toggle("has-value", !!r.value);
+      });
+      ov.append(area, err, help);
+      item.append(ov);
+    }
+    return item;
+  }
+  return {
+    build,
+    opened(id, opts = {}) {
+      const engine = getEngine(id);
+      if (!engine) {
+        return `eng:${id}:name`;
+      }
+      const family = presetOf(engine).family;
+      trigger(id, "open");
+      if (opts.isNew && family === "cloud") {
+        void lookUpKey(id);
+      }
+      if (!opts.isNew) {
+        return `eng:${id}:name`;
+      }
+      if (family === "cloud" && ai.setSecret) {
+        return `eng:${id}:key`;
+      }
+      if (family !== "local") {
+        return `eng:${id}:name`;
+      }
+      return presetOf(engine).id === "custom" ? `eng:${id}:url` : null;
+    },
+    busy(id) {
+      if (testing.has(id)) {
+        return "test";
+      }
+      return fetches.get(id)?.running ? "discover" : void 0;
+    },
+    requirePick(id) {
+      pickRequired.add(id);
+    },
+    forget(id) {
+      pickRequired.delete(id);
+      const st = fetches.get(id);
+      if (st) {
+        window.clearTimeout(st.timer);
+        st.seq++;
+      }
+      window.clearTimeout(keyTimers.get(id));
+      for (const map of [fetches, keyText, keyStored, keyTimers, pickerFilter, results]) {
+        map.delete(id);
+      }
+      advancedOpen.delete(id);
+      typeOpen.delete(id);
+      showAll.delete(id);
+      formPicked.delete(id);
+    },
+    dispose() {
+      for (const st of fetches.values()) {
+        window.clearTimeout(st.timer);
+        st.seq++;
+      }
+      for (const t of keyTimers.values()) {
+        window.clearTimeout(t);
+      }
+      keyTimers.clear();
+      keyText.clear();
+    }
+  };
+}
+
+// src/ai-routing-section.ts
+var FALLBACK_LABELS = {
+  none: "Nothing (the feature is unavailable)",
+  default: "Use the default model",
+  anyLocal: "Default, then any local model",
+  any: "Default, any local, then cloud"
+};
+function createRoutingSection(ctx, deps) {
+  const body = el("div", "ai-routing");
+  function buildRouteSelect(current, req, o) {
+    const draft = deps.getDraft();
+    const select = el("select", "settings-input ai-route-select");
+    select.dataset.fk = o.fk;
+    select.setAttribute("aria-label", o.ariaLabel);
+    const pairs = routePairs(draft, deps.statusList(), req);
+    const first = el("option", "", o.defaultText ?? (pairs.some((p) => p.selectable) ? "Choose a model\u2026" : draft.engines.length === 0 ? "Add an engine first" : "No model can serve this"));
+    first.value = "";
+    select.append(first);
+    const currentKey = routeKey(current);
+    if (current && !pairs.some((p) => routeKey(p) === currentKey)) {
+      const gone = el("option", "", `${routeLabel(draft, current)} (not found)`);
+      gone.value = currentKey;
+      select.append(gone);
+    }
+    const byEngine = /* @__PURE__ */ new Map();
+    for (const p of pairs) {
+      const list = byEngine.get(p.engineId) ?? [];
+      list.push(p);
+      byEngine.set(p.engineId, list);
+    }
+    for (const list of byEngine.values()) {
+      const group = el("optgroup");
+      group.label = `${list[0].engineName} (${list[0].isLocal ? "local" : "cloud"})`;
+      for (const p of list) {
+        const o2 = el("option", "", `${p.engineName} \xB7 ${p.modelName}${p.note ? ` (${p.note})` : ""}`);
+        o2.value = routeKey(p);
+        o2.disabled = !p.selectable && routeKey(p) !== currentKey;
+        group.append(o2);
+      }
+      select.append(group);
+    }
+    select.value = currentKey;
+    if (select.value !== currentKey) {
+      select.value = "";
+    }
+    return select;
+  }
+  function render() {
+    keepFocus(body, () => {
+      body.replaceChildren();
+      const draft = deps.getDraft();
+      const defRow = ctx.makeRow("Default model", "Serves every task without its own route. Needs chat.", "inline");
+      const defSelect = buildRouteSelect(draft.routing.default, DEFAULT_ROUTE_REQUIREMENTS, { fk: "route:default", ariaLabel: "Default model" });
+      defSelect.addEventListener("change", () => {
+        const d = deps.getDraft();
+        deps.setDraft({ ...d, routing: { ...d.routing, default: parseRouteKey(defSelect.value) } }, { defaultChanged: true });
+        render();
+      });
+      defRow.append(defSelect);
+      const defNote = taskRouteNote({ ...draft, routing: { ...draft.routing, tasks: {} } }, deps.statusList(), "chat");
+      if (draft.routing.default && defNote) {
+        defRow.append(note(defNote.level, defNote.text, "ai-row-note"));
+      }
+      const fbField = ctx.makeSelectRow(
+        "When a route is unavailable",
+        "What to try when a task\u2019s model is off, unreachable or lacks what the task needs. Fallback never moves a local route to a cloud engine unless you pick the last option.",
+        draft.routing.fallback,
+        AI_FALLBACK_MODES.map((m) => ({ value: m, label: FALLBACK_LABELS[m] }))
+      );
+      fbField.select.dataset.fk = "route:fallback";
+      fbField.select.addEventListener("change", () => {
+        const d = deps.getDraft();
+        deps.setDraft({ ...d, routing: { ...d.routing, fallback: fbField.select.value } }, { defaultChanged: false });
+        render();
+      });
+      const top = ctx.makeGroup(defRow, fbField.row);
+      const defaultText = draft.routing.default ? `Default: ${routeLabel(draft, draft.routing.default)}` : "Default (none set)";
+      const taskRows = [];
+      const taskRow = (taskId, label, description, req, hostOnly) => {
+        const row = ctx.makeRow(label, description, "inline");
+        row.classList.add("ai-task-row");
+        if (hostOnly) {
+          row.append(el("span", "ai-muted", "Handled by the app"));
+          taskRows.push(row);
+          return;
+        }
+        const select = buildRouteSelect(draft.routing.tasks[taskId], req, { fk: `route:task:${taskId}`, ariaLabel: `Model for ${label}`, defaultText });
+        select.addEventListener("change", () => {
+          const d = deps.getDraft();
+          const tasks = { ...d.routing.tasks };
+          const route = parseRouteKey(select.value);
+          if (route) {
+            tasks[taskId] = { ...tasks[taskId] ?? {}, ...route };
+          } else {
+            delete tasks[taskId];
+          }
+          deps.setDraft({ ...d, routing: { ...d.routing, tasks } }, { defaultChanged: false });
+          render();
+        });
+        row.append(select);
+        const n = taskRouteNote(draft, deps.statusList(), taskId);
+        if (n) {
+          row.append(note(n.level, n.text, "ai-row-note"));
+        }
+        taskRows.push(row);
+      };
+      for (const task of AI_TASKS) {
+        taskRow(task.id, task.label, task.description, taskRequirements(task.id), task.hostMethod === "transcribe");
+      }
+      for (const taskId of unknownRoutedTasks(draft)) {
+        taskRow(taskId, taskId, "Saved by a newer version of MikeDown. Kept as is.", { requires: {} }, false);
+      }
+      const tasksHead = el("div", "ai-subhead", "Model per task");
+      body.append(top, tasksHead, ctx.makeGroup(...taskRows));
+    });
+  }
+  return { element: body, render };
+}
+
+// src/ai-setup-wizard.ts
+var AI_WIZARD_STEPS = 3;
+function wizardStepNumber(step) {
+  return step === "path" ? 1 : step === "done" ? 3 : 2;
+}
+var AI_SUBSCRIPTION_NOTE = "Consumer subscriptions such as ChatGPT Plus or Claude Pro do not include API access. An API key is billed separately by the provider, per use.";
+function subscriptionNote(preset, openLink, policy) {
+  const box = el("div", "ai-wizard-subscription");
+  box.append(el("p", "ai-wizard-subscription-text", AI_SUBSCRIPTION_NOTE));
+  const links = [];
+  if (preset.keyUrl) {
+    links.push([`${preset.name} API keys`, preset.keyUrl]);
+  }
+  if (preset.pricingUrl) {
+    links.push(["Pricing", preset.pricingUrl]);
+  }
+  if (policy?.url) {
+    links.push(["Privacy", policy.url]);
+  }
+  if (links.length > 0) {
+    const line = el("p", "ai-wizard-subscription-links");
+    line.append("Get a key: ");
+    links.forEach(([label, url], i) => {
+      if (i > 0) {
+        line.append(el("span", "ai-wizard-sep", " \xB7 "));
+      }
+      line.append(hostLink(label, url, openLink, "ai-wizard-link"));
+    });
+    box.append(line);
+  }
+  if (policy?.note) {
+    box.append(el("p", "ai-wizard-subscription-links", policy.note));
+  }
+  return box;
+}
+function createSetupWizard(deps) {
+  const { session, form, ctx } = deps;
+  const { ai } = session;
+  const groups = groupPresets(AI_ENGINE_PRESETS);
+  let step = "path";
+  const history = [];
+  let engineId = null;
+  const added = /* @__PURE__ */ new Set();
+  let scan = canScanForSetup(ai) ? lastSetupScan(ai) : plainSetupScan();
+  let scanning = false;
+  let scanAbort = null;
+  let connecting = null;
+  let connectError = null;
+  let advancedOpen = false;
+  let cloudPrivacyOpen = false;
+  let disposed = false;
+  const element = el("div", "ai-wizard");
+  const column = el("div", "ai-wizard-column");
+  element.append(column);
+  function rescan() {
+    if (!canScanForSetup(ai) || disposed) {
+      return;
+    }
+    scanAbort?.abort();
+    const controller = new AbortController();
+    scanAbort = controller;
+    scanning = true;
+    if (step === "local") {
+      deps.announce(AI_DETECT_LOOKING);
+    }
+    redrawScanned();
+    void scanForSetup(ai, controller.signal).then((fresh) => {
+      if (disposed || controller.signal.aborted) {
+        return;
+      }
+      scanAbort = null;
+      scanning = false;
+      scan = fresh;
+      redrawScanned();
+      if (step === "local") {
+        deps.announce(detectionSummary());
+      }
+    });
+  }
+  function redrawScanned() {
+    if (step === "path" || step === "local") {
+      render();
+    }
+  }
+  function localCards() {
+    return scan?.probes ? rankLocalCandidates(scan.probes, session.draft.engines) : null;
+  }
+  function detectionSummary() {
+    const cards = localCards();
+    if (!cards) {
+      return "Could not look for local AI servers.";
+    }
+    const running = cards.filter((c) => c.running);
+    return running.length === 0 ? AI_DETECT_NONE : `Running on this computer: ${running.map((c) => presetName(c.presetId)).join(", ")}.`;
+  }
+  const presetById = (id) => AI_ENGINE_PRESETS.find((p) => p.id === id);
+  const presetName = (id) => presetById(id)?.name ?? id;
+  const machine = () => scan?.hardware?.platform === "darwin" ? "Mac" : "computer";
+  function engineFor(preset) {
+    const card = preset.family === "local" ? localCards()?.find((c) => c.presetId === preset.id && c.alreadyAdded && c.engineId) : void 0;
+    const existing = card?.engineId && session.getEngine(card.engineId) ? session.getEngine(card.engineId) : preset.family !== "local" ? session.draft.engines.find((e) => presetForEngine(e)?.id === preset.id) : void 0;
+    if (existing) {
+      return { id: existing.id, isNew: false };
+    }
+    const engine = engineFromPreset(preset, session.draft.engines.map((e) => e.id));
+    session.addEngine(engine);
+    added.add(engine.id);
+    return { id: engine.id, isNew: true };
+  }
+  function useEngine(id) {
+    if (engineId && engineId !== id && added.has(engineId)) {
+      session.deleteEngine(engineId);
+      form.forget(engineId);
+      added.delete(engineId);
+    }
+    engineId = id;
+    connectError = null;
+  }
+  const currentEngine = () => engineId ? session.getEngine(engineId) : void 0;
+  function readyModel(engine) {
+    if (!engine || !engine.enabled || !isKnownEngineKind(engine.kind)) {
+      return null;
+    }
+    const usable = (m) => !!m && m.enabled && !m.missing && m.capabilities.chat;
+    const id = engineDefaultModelId(session.draft, engine.id);
+    const model = id ? engine.models.find((m) => m.id === id) : void 0;
+    return usable(model) ? model.id : engine.models.find(usable)?.id ?? null;
+  }
+  function cloudBlocked(engine) {
+    return !session.draft.allowCloud && engineLocalityInfo(engine, session.draft.localNetworks).locality === "cloud";
+  }
+  function makeDefault(id, modelId) {
+    const draft = setEngineDefaultModel(session.draft, id, modelId);
+    session.draft = { ...draft, routing: { ...draft.routing, default: { engineId: id, modelId } } };
+  }
+  function allowCloudFor(preset) {
+    if (preset.family !== "local" && !session.draft.allowCloud) {
+      deps.setAllowCloud(true);
+    }
+  }
+  function go(next, o = {}) {
+    if (o.push !== false && next !== step) {
+      history.push(step);
+    }
+    step = next;
+    render({ fresh: true });
+    deps.onStep(step);
+  }
+  async function connect(preset) {
+    if (connecting) {
+      return;
+    }
+    allowCloudFor(preset);
+    const { id } = engineFor(preset);
+    useEngine(id);
+    const fallback = preset.family === "host" ? "copilot" : "local";
+    if (!ai.discoverModels) {
+      go(fallback);
+      return;
+    }
+    connecting = preset.id;
+    render();
+    deps.announce(`Setting up ${preset.name}\u2026`);
+    try {
+      await session.ensureSaved(id);
+      const status = await ai.discoverModels(id);
+      if (disposed || engineId !== id) {
+        return;
+      }
+      if (status && typeof status === "object") {
+        session.statuses.set(id, status);
+        deps.onStatuses();
+      }
+      if (!status || status.ok === false) {
+        throw new Error(status?.error || `Could not fetch the models from ${preset.name}.`);
+      }
+      const engine = session.getEngine(id);
+      if (!engine) {
+        return;
+      }
+      session.draft = withEngine(session.draft, applyDiscoveryForFamily(engine, status, preset.family));
+      const fresh = session.getEngine(id);
+      const modelId = preset.family === "local" ? defaultRouteForEngine(session.draft, session.statusList(), id)?.modelId ?? null : firstChatModelId(fresh.models);
+      if (!modelId && preset.family === "local" && fresh.models.some((m) => !m.missing && m.capabilities.chat)) {
+        connecting = null;
+        go(fallback);
+        form.opened(id);
+        deps.announce(`${preset.name}: pick a model to start with.`);
+        return;
+      }
+      if (!modelId) {
+        throw new Error(preset.family === "host" ? "Copilot lists no chat model for this account yet." : `${preset.name} has no chat model loaded or downloaded yet.`);
+      }
+      makeDefault(id, modelId);
+      connecting = null;
+      go("done");
+    } catch (err) {
+      if (disposed) {
+        return;
+      }
+      connecting = null;
+      connectError = err instanceof Error && err.message ? err.message : `${preset.name} could not be set up.`;
+      deps.announce(connectError);
+      go(fallback);
+      form.opened(id);
+    }
+  }
+  function pick(preset) {
+    allowCloudFor(preset);
+    const { id, isNew } = engineFor(preset);
+    useEngine(id);
+    const target = preset.family === "local" ? "local" : preset.family === "host" ? "copilot" : "cloud";
+    if (step !== target) {
+      go(target);
+    } else {
+      render();
+    }
+    const first = form.opened(id, { isNew: isNew && preset.family === "cloud" });
+    if (isNew && preset.family === "cloud" && first) {
+      deps.focusKey(first);
+    }
+    deps.announce(preset.family === "cloud" ? `${preset.name}: paste your API key.` : `${preset.name}: fetching its models.`);
+  }
+  function continueToDone() {
+    const engine = currentEngine();
+    const modelId = readyModel(engine);
+    if (!engine || !modelId || cloudBlocked(engine)) {
+      return;
+    }
+    makeDefault(engine.id, modelId);
+    go("done");
+  }
+  function render(o = {}) {
+    if (disposed) {
+      return;
+    }
+    keepFocus(column, () => {
+      column.replaceChildren(...buildStep());
+    });
+    element.dataset.step = step;
+    if (o.fresh) {
+      element.scrollTop = 0;
+      column.querySelector(".ai-wizard-title")?.focus({ preventScroll: true });
+    }
+  }
+  function buildStep() {
+    switch (step) {
+      case "path":
+        return buildPath();
+      case "cloud":
+        return buildCloud();
+      case "local":
+        return buildLocal();
+      case "copilot":
+        return buildCopilot();
+      case "done":
+        return buildDone();
+    }
+  }
+  function heading(text, lede) {
+    const head = el("div", "ai-wizard-head");
+    const h = el("h3", "ai-wizard-title", text);
+    h.id = nextId("ai-wizard-title");
+    h.tabIndex = -1;
+    element.setAttribute("aria-labelledby", h.id);
+    head.append(h);
+    if (lede) {
+      head.append(el("p", "ai-wizard-lede", lede));
+    }
+    return head;
+  }
+  function option(o) {
+    const b = button(`ai-wizard-option${o.lead ? " is-lead" : ""}`, "", { fk: o.fk });
+    if (o.state) {
+      b.dataset.state = o.state;
+    }
+    const glyph = el("span", "ai-wizard-option-glyph");
+    glyph.innerHTML = o.glyph;
+    const text = el("span", "ai-wizard-option-text");
+    const name = el("span", "ai-wizard-option-name");
+    if (o.state === "running") {
+      const dot = el("span", "ai-card-dot");
+      dot.setAttribute("aria-hidden", "true");
+      name.append(dot);
+    }
+    name.append(el("span", "", o.name));
+    text.append(name, el("span", "ai-wizard-option-caption", o.caption));
+    const chevron = el("span", "ai-wizard-option-chevron");
+    if (o.state === "busy") {
+      chevron.append(el("span", "ai-spinner"));
+      b.setAttribute("aria-busy", "true");
+    } else {
+      chevron.innerHTML = ICONS.chevron;
+    }
+    chevron.setAttribute("aria-hidden", "true");
+    b.append(glyph, text, chevron);
+    b.addEventListener("click", () => {
+      if (!connecting) {
+        o.onClick();
+      }
+    });
+    return b;
+  }
+  function cloudGlyph() {
+    return `<span class="ai-glyph ai-wizard-glyph-cloud" aria-hidden="true">${ICONS.cloud}</span>`;
+  }
+  function buildPath() {
+    const out = [heading("How should MikeDown reach a model?", "You can change it later in AI Engines.")];
+    if (!scan) {
+      const wait = el("div", "ai-wizard-scanning");
+      wait.setAttribute("role", "status");
+      wait.append(el("span", "ai-spinner"), el("span", "", "Checking this machine\u2026"));
+      out.push(wait);
+      return out;
+    }
+    const rec = scan.recommendation;
+    const copilot = scan.vscodeLm?.available ? groups.host.find((p) => p.kind === "vscode-lm") : void 0;
+    const running = rec.path === "runningLocal" && rec.running ? presetById(rec.running.presetId) : void 0;
+    const options = el("div", "ai-wizard-options");
+    if (running && rec.running) {
+      const models = rec.running.models;
+      options.append(option({
+        fk: `wiz:use:${running.id}`,
+        glyph: kindGlyphHtml(running.kind),
+        name: `${running.name} is running on this ${machine()}${models !== void 0 ? ` \xB7 ${models} ${models === 1 ? "model" : "models"}` : ""}`,
+        caption: connecting === running.id ? `Setting up ${running.name}\u2026` : "Use it. Text stays on this machine.",
+        lead: true,
+        state: connecting === running.id ? "busy" : "running",
+        onClick: () => {
+          void connect(running);
+        }
+      }));
+    }
+    if (copilot) {
+      options.append(option({
+        fk: "wiz:use:copilot",
+        glyph: kindGlyphHtml(copilot.kind),
+        name: "Use GitHub Copilot, no key needed",
+        caption: connecting === copilot.id ? "Fetching Copilot\u2019s models\u2026" : `Through your Copilot plan in VS Code. ${AI_HOST_PRIVACY.permission}`,
+        lead: rec.path === "vscodeLm",
+        ...connecting === copilot.id ? { state: "busy" } : {},
+        onClick: () => {
+          void connect(copilot);
+        }
+      }));
+    }
+    if (options.childElementCount > 0) {
+      options.append(option({
+        fk: "wiz:cloud",
+        glyph: cloudGlyph(),
+        name: "Connect a cloud provider",
+        caption: "Paste an API key from Anthropic, OpenAI or another provider.",
+        onClick: () => go("cloud")
+      }));
+      out.push(options);
+    } else {
+      out.push(buildCloudGroup());
+    }
+    out.push(buildAdvanced());
+    if (scanning) {
+      const line = el("div", "ai-wizard-quiet", "Checking this machine again\u2026");
+      line.setAttribute("role", "status");
+      out.push(line);
+    }
+    return out;
+  }
+  function buildCloudGroup(o = {}) {
+    const section = el("section", "ai-wizard-group");
+    const headingId = nextId("ai-wizard-group");
+    if (o.title !== false) {
+      const h = el("div", "ai-cards-heading");
+      h.id = headingId;
+      h.innerHTML = ICONS.cloud;
+      h.append(el("span", "", "Connect a cloud provider"));
+      section.append(h, el("div", "ai-cards-explainer", "Paste a key from the provider. It bills your account for what you use."));
+      section.setAttribute("aria-labelledby", headingId);
+    }
+    const access = el("div", "ai-cloud-access ai-wizard-cloud-access");
+    access.append(
+      el("p", "ai-wizard-cloud-line", ai.requestCloudConsent ? "Choosing a provider turns on cloud engines; MikeDown still asks before the first request in each workspace." : "Choosing a provider turns on cloud engines."),
+      // No policy links here: the chosen provider's note and the consent dialog carry its own.
+      privacyCard(null, {
+        collapsed: "What this means",
+        open: cloudPrivacyOpen,
+        onToggle: (open) => {
+          cloudPrivacyOpen = open;
+        },
+        openLink: ctx.openLink,
+        // The line above already says the host asks first.
+        ...ai.requestCloudConsent ? {} : { extra: aiConsentStepNote(false) },
+        className: "ai-cloud-access-privacy"
+      })
+    );
+    section.append(access);
+    const grid = el("div", "ai-cards-grid");
+    grid.setAttribute("role", "group");
+    grid.setAttribute("aria-label", "Cloud providers");
+    const picked = currentEngine();
+    const pickedPreset = picked ? presetForEngine(picked)?.id : void 0;
+    for (const preset of groups.cloud) {
+      const card = button("ai-card", "", { fk: `wiz:card:${preset.id}` });
+      card.innerHTML = kindGlyphHtml(preset.kind);
+      const text = el("span", "ai-card-text");
+      text.append(el("span", "ai-card-name", preset.name), el("span", "ai-card-caption", preset.caption));
+      card.append(text);
+      const on = step === "cloud" && pickedPreset === preset.id;
+      card.setAttribute("aria-pressed", String(on));
+      card.classList.toggle("is-selected", on);
+      card.addEventListener("click", () => pick(preset));
+      grid.append(card);
+    }
+    section.append(grid);
+    return section;
+  }
+  function buildAdvanced() {
+    const box = el("div", "ai-wizard-advanced");
+    const panelId = nextId("ai-wizard-advanced");
+    const toggle = button("ai-disclosure", "Advanced: run models on this machine", { html: ICONS.chevron, fk: "wiz:advanced" });
+    toggle.setAttribute("aria-expanded", String(advancedOpen));
+    toggle.setAttribute("aria-controls", panelId);
+    toggle.addEventListener("click", () => {
+      advancedOpen = !advancedOpen;
+      render();
+    });
+    const panel = el("div", "ai-wizard-advanced-panel");
+    panel.id = panelId;
+    panel.hidden = !advancedOpen;
+    const hw = scan?.recommendation.hardwareLine;
+    if (hw) {
+      panel.append(el("p", "ai-wizard-hardware", hw));
+    }
+    panel.append(el("p", "ai-wizard-quiet", "Your own model server, such as LM Studio or Ollama. Text never leaves this machine."));
+    const choose = button("settings-btn", "Choose a local server", { fk: "wiz:local" });
+    choose.addEventListener("click", () => go("local"));
+    panel.append(choose);
+    box.append(toggle, panel);
+    return box;
+  }
+  function formHolder() {
+    const engine = currentEngine();
+    if (!engine) {
+      return null;
+    }
+    const holder = el("div", "ai-wizard-form");
+    if (connectError) {
+      holder.append(note("error", connectError, "ai-wizard-error"));
+    }
+    holder.append(buildForm(engine.id));
+    return holder;
+  }
+  function buildForm(id) {
+    return form.build(id, { privacy: step !== "cloud", setup: true });
+  }
+  function footer(o) {
+    const bar = el("div", "ai-wizard-footer");
+    const hint = el("span", "ai-wizard-hint", o.ready ? "" : o.hint ?? "");
+    hint.id = nextId("ai-wizard-hint");
+    const primary = button("settings-btn settings-btn--primary ai-wizard-next", o.label, { fk: o.fk });
+    if (!o.ready) {
+      primary.setAttribute("aria-disabled", "true");
+      primary.setAttribute("aria-describedby", hint.id);
+    }
+    primary.addEventListener("click", () => {
+      if (o.ready) {
+        o.onClick();
+      } else if (o.hint) {
+        deps.announce(o.hint);
+      }
+    });
+    bar.append(hint, primary);
+    return bar;
+  }
+  function continueFooter() {
+    const engine = currentEngine();
+    const blocked = engine ? cloudBlocked(engine) : false;
+    const ready = !!engine && !!readyModel(engine) && !blocked;
+    const hint = !engine ? step === "local" ? "Pick a server to continue." : "Pick a provider to continue." : blocked ? "Turn on Allow cloud engines to use it." : step === "cloud" && !session.hasKey(engine.id) ? "Paste your API key; the models appear, then Continue." : "Pick a chat model to continue.";
+    return footer({ label: "Continue", fk: "wiz:continue", ready, hint, onClick: continueToDone });
+  }
+  function buildCloud() {
+    const out = [
+      heading("Connect a cloud provider", "Pick a provider and paste an API key. Text you ask about is sent to that provider."),
+      buildCloudGroup({ title: false })
+    ];
+    const holder = formHolder();
+    if (holder) {
+      out.push(holder);
+    }
+    out.push(continueFooter());
+    return out;
+  }
+  function buildLocal() {
+    const lede = scan?.recommendation.hardwareLine || "Your own model server, on this computer or your network. Text never leaves it.";
+    const out = [heading("Run models on this machine", lede)];
+    const list = el("div", "ai-wizard-servers");
+    list.setAttribute("role", "group");
+    list.setAttribute("aria-label", "Local servers");
+    const cards = localCards();
+    const byId = new Map(cards?.map((c) => [c.presetId, c]) ?? []);
+    const ordered = cards ? [...cards.map((c) => presetById(c.presetId)).filter((p) => !!p && p.family === "local"), ...groups.local.filter((p) => !byId.has(p.id))] : groups.local;
+    for (const preset of ordered) {
+      list.append(buildServer(preset, byId.get(preset.id)));
+    }
+    out.push(list);
+    const detect = el("div", "ai-cards-detect");
+    const status = el("span", "ai-cards-detect-text", scanning ? AI_DETECT_LOOKING : cards && !cards.some((c) => c.running) ? AI_DETECT_NONE : "");
+    detect.append(status);
+    if (ai.detectLocalServers) {
+      const again = button("ai-link-btn ai-cards-again", "Look again", { fk: "wiz:look-again" });
+      if (scanning) {
+        again.setAttribute("aria-disabled", "true");
+      }
+      again.addEventListener("click", () => {
+        if (!scanning) {
+          rescan();
+        }
+      });
+      detect.append(again);
+    }
+    out.push(detect);
+    const holder = formHolder();
+    if (holder) {
+      out.push(holder);
+    }
+    out.push(continueFooter());
+    return out;
+  }
+  function buildServer(preset, found) {
+    const row = el("div", "ai-wizard-server");
+    const card = button("ai-card", "", { fk: `wiz:card:${preset.id}` });
+    card.innerHTML = kindGlyphHtml(preset.kind);
+    const text = el("span", "ai-card-text");
+    text.append(el("span", "ai-card-name", preset.name), el("span", "ai-card-caption", preset.caption));
+    const state = !found ? null : found.alreadyAdded && found.engineId && session.getEngine(found.engineId) ? "added" : found.running ? "running" : "stopped";
+    if (state) {
+      card.dataset.state = state;
+      const line = el("span", "ai-card-state");
+      if (state === "running") {
+        const dot = el("span", "ai-card-dot");
+        dot.setAttribute("aria-hidden", "true");
+        line.append(dot);
+      }
+      const count = found?.models !== void 0 ? ` \xB7 ${found.models} ${found.models === 1 ? "model" : "models"}` : "";
+      line.append(el("span", "", state === "added" ? "Added" : state === "running" ? `Running${count}` : "Not running"));
+      text.append(line);
+    }
+    card.append(text);
+    const picked = currentEngine();
+    const on = !!picked && (picked.id === found?.engineId || added.has(picked.id) && presetForEngine(picked)?.id === preset.id);
+    card.setAttribute("aria-pressed", String(on));
+    card.classList.toggle("is-selected", on);
+    card.addEventListener("click", () => pick(preset));
+    row.append(card);
+    if (state === "stopped" && preset.installUrl) {
+      const help = el("div", "ai-wizard-install");
+      help.append(hostLink(`Install ${preset.name}`, preset.installUrl, ctx.openLink, "ai-wizard-link"), el("span", "", ", then come back and choose Look again."));
+      row.append(help);
+    }
+    return row;
+  }
+  function buildCopilot() {
+    const out = [heading("GitHub Copilot", `Copilot\u2019s models through your Copilot plan in VS Code. No key needed. ${AI_HOST_PRIVACY.permission}`)];
+    const holder = formHolder();
+    if (holder) {
+      out.push(holder);
+    }
+    out.push(continueFooter());
+    return out;
+  }
+  function buildDone() {
+    const engine = currentEngine();
+    const modelId = readyModel(engine);
+    if (!engine || !modelId) {
+      return [heading("Set up AI", "Something changed. Go back and choose again.")];
+    }
+    const local = engineLocalityInfo(engine, session.draft.localNetworks).locality === "local";
+    const model = engine.models.find((m) => m.id === modelId);
+    const out = [];
+    const icon = el("span", "ai-wizard-done-icon");
+    icon.innerHTML = ICONS.check;
+    icon.setAttribute("aria-hidden", "true");
+    const head = heading(`Ready: ${engineDisplayName(engine)} \xB7 ${modelDisplayName(model)} \xB7 ${local ? "Local" : "Cloud"}`);
+    head.prepend(icon);
+    out.push(head);
+    const chat = engine.models.filter((m) => m.enabled && !m.missing && m.capabilities.chat);
+    if (chat.length > 1) {
+      const row = el("div", "ai-wizard-model");
+      const select = el("select", "settings-input ai-wizard-model-select");
+      select.id = nextId("ai-wizard-model");
+      select.dataset.fk = "wiz:model";
+      for (const m of chat) {
+        const o = el("option", "", modelDisplayName(m));
+        o.value = m.id;
+        select.append(o);
+      }
+      select.value = modelId;
+      select.addEventListener("change", () => {
+        makeDefault(engine.id, select.value);
+        render();
+        const picked = engine.models.find((m) => m.id === select.value);
+        if (picked) {
+          deps.announce(`Default model: ${modelDisplayName(picked)}.`);
+        }
+      });
+      const label = el("label", "ai-wizard-model-label", "Model");
+      label.htmlFor = select.id;
+      row.append(label, select);
+      out.push(row);
+    }
+    const privacy = el("p", "ai-wizard-privacy");
+    const glyph = el("span", "ai-privacy-glyph");
+    glyph.innerHTML = local ? ICONS.local : ICONS.cloud;
+    privacy.append(glyph, el("span", "", privacyText(engine, local)));
+    out.push(privacy);
+    const more = el("p", "ai-wizard-quiet");
+    if (!deps.turnsOn) {
+      more.append("Choose Done to save. ");
+    }
+    const fine = button("ai-link-btn", "Change settings in AI Engines", { fk: "wiz:open-engine" });
+    fine.addEventListener("click", () => deps.openEngine(engine.id));
+    more.append(fine);
+    out.push(more);
+    out.push(footer({ label: deps.turnsOn ? "Turn on AI" : "Done", fk: "wiz:done", ready: true, onClick: () => deps.finish() }));
+    return out;
+  }
+  function privacyText(engine, local) {
+    if (local) {
+      return AI_CLOUD_PRIVACY.local;
+    }
+    if (presetForEngine(engine)?.family === "host") {
+      return `${AI_HOST_PRIVACY.leaves} ${aiConsentStepNote(!!ai.requestCloudConsent)}`;
+    }
+    const where = aiConsentHost(engine) || hostOfUrl(engine.baseUrl) || "the provider";
+    return `Text you ask about is sent over the internet to ${where}. ${aiConsentStepNote(!!ai.requestCloudConsent)}`;
+  }
+  render();
+  rescan();
+  return {
+    element,
+    step: () => step,
+    engineId: () => engineId,
+    back() {
+      if (connecting) {
+        return;
+      }
+      const previous = history.pop();
+      if (!previous) {
+        deps.leave();
+        return;
+      }
+      step = previous;
+      connectError = null;
+      render({ fresh: true });
+      deps.onStep(step);
+    },
+    refresh(id, refresh) {
+      if (disposed) {
+        return;
+      }
+      if (refresh.form && id && id === engineId) {
+        const current = column.querySelector(".ai-form");
+        if (current) {
+          keepFocus(current, () => {
+            const fresh = buildForm(id);
+            current.replaceWith(fresh);
+            return fresh;
+          });
+        }
+      }
+      const bar = column.querySelector(".ai-wizard-footer");
+      if (bar && step !== "done" && step !== "path") {
+        keepFocus(bar, () => {
+          const next = continueFooter();
+          bar.replaceWith(next);
+          return next;
+        });
+      }
+    },
+    focus() {
+      const target = column.querySelector(".ai-wizard-option.is-lead") ?? column.querySelector(".ai-wizard-option, .ai-card, .ai-wizard-next") ?? column.querySelector(".ai-wizard-title");
+      target?.focus({ preventScroll: true });
+    },
+    dispose() {
+      disposed = true;
+      scanAbort?.abort();
+      element.remove();
+    }
+  };
+}
+
+// src/ai-engines-page.ts
+var NARROW_PX = 720;
+function mountAiEnginesPage(container, ctx, opts) {
+  const session = createAiSettingsSession(opts);
+  const { ai } = session;
+  const getEngine = (id) => session.getEngine(id);
+  let wizard = null;
+  let hardware = knownHardware(ai);
+  let selection = initialSelection();
+  let narrow = false;
+  let view = opts.initial?.engineId || opts.initial?.section === "routing" ? "detail" : "list";
+  let confirmDeleteId = null;
+  let confirmDiscard = false;
+  let finished = false;
+  const headNotes = /* @__PURE__ */ new Map();
+  function initialSelection() {
+    const engines = session.draft.engines;
+    if (opts.initial?.section === "routing") {
+      return { kind: "routing" };
+    }
+    const wanted = opts.initial?.engineId && engines.find((e) => e.id === opts.initial?.engineId);
+    if (wanted) {
+      return { kind: "engine", id: wanted.id };
+    }
+    return engines[0] ? { kind: "engine", id: engines[0].id } : { kind: "add" };
+  }
+  const selectedEngineId = () => selection.kind === "engine" ? selection.id : null;
+  const root = el("div", "ai-page");
+  const titleId = nextId("ai-page-title");
+  const header = el("div", "ai-page-header");
+  const backBtn = button("ai-page-back", "Back", { html: ICONS.back, fk: "page:back" });
+  backBtn.addEventListener("click", () => back());
+  const title = el("h2", "ai-page-title", "AI Engines");
+  title.id = titleId;
+  const doneBtn = button("settings-btn settings-btn--primary ai-page-done", "Done", { fk: "page:done" });
+  doneBtn.addEventListener("click", () => done());
+  const skipBtn = button("settings-btn ai-page-done ai-page-skip", "Skip", { fk: "page:skip", title: "Leave setup; AI stays off" });
+  skipBtn.addEventListener("click", () => leave());
+  skipBtn.hidden = true;
+  const titleLine = el("div", "ai-page-title-line");
+  const titleNote = opts.turnOnWhenDone ? el("span", "ai-page-title-note", "AI turns on when you choose Done") : null;
+  const stepper = el("span", "ai-wizard-steps");
+  stepper.hidden = true;
+  titleLine.append(title, experimentalBadge(), stepper);
+  if (titleNote) {
+    titleLine.append(titleNote);
+  }
+  header.append(backBtn, titleLine, doneBtn, skipBtn);
+  const disclaimer = experimentalDisclaimer("ai-page-disclaimer");
+  const body = el("div", "ai-page-body");
+  const nav = el("nav", "ai-page-nav");
+  nav.setAttribute("aria-label", "Engines and tasks");
+  const detail = el("section", "ai-page-detail");
+  const detailId = nextId("ai-page-detail");
+  detail.id = detailId;
+  body.append(nav, detail);
+  const live = el("div", "ai-live");
+  live.setAttribute("role", "status");
+  live.setAttribute("aria-live", "polite");
+  let liveTimer;
+  function announce(text) {
+    window.clearTimeout(liveTimer);
+    live.textContent = "";
+    liveTimer = window.setTimeout(() => {
+      live.textContent = text;
+    }, 40);
+  }
+  const confirmHost = el("div", "ai-page-confirm-host");
+  root.append(header, disclaimer, body, confirmHost, live);
+  const form = createEngineFormController({
+    ai,
+    getDraft: () => session.draft,
+    setDraft: (next, refresh) => {
+      session.draft = next;
+      applyRefresh(wizard ? wizard.engineId() : selectedEngineId(), refresh);
+    },
+    refresh: (engineId, refresh) => applyRefresh(engineId, refresh),
+    statuses: session.statuses,
+    onStatuses: () => opts.onStatuses(session.statusList()),
+    hasKey: (id) => session.hasKey(id),
+    keySource: (id) => session.keySource(id),
+    setKey,
+    ensureSaved: (id) => session.ensureSaved(id),
+    savesFirst: (id) => session.savesFirst(id),
+    announce,
+    focusKey,
+    openLink: ctx.openLink,
+    // The subscription vs API key note sits over a cloud key field. The wizard always shows it; the full form shows it until a key is stored.
+    keyNote: (engine, preset) => preset.family === "cloud" && (wizard || !session.hasKey(engine.id)) ? subscriptionNote(preset, ctx.openLink, aiProviderPolicy(engine)) : null,
+    modelSize: (modelId, sizeBytes) => hardware ? modelSizeHint(modelId, hardware, sizeBytes) : void 0
+  });
+  const routing = createRoutingSection(ctx, {
+    getDraft: () => session.draft,
+    setDraft: (next, change) => {
+      session.draft = next;
+      if (change.defaultChanged) {
+        renderNav();
+      } else {
+        refreshRoutingEntry();
+      }
+    },
+    statusList: () => session.statusList()
+  });
+  async function setKey(id, value) {
+    const engine = getEngine(id);
+    const error = await session.setKey(id, value);
+    if (engine) {
+      const name = engineDisplayName(engine);
+      announce(error ? `The key for ${name} could not be ${value !== null ? "stored" : "cleared"}.` : value !== null ? `API key stored for ${name}.` : `API key cleared for ${name}.`);
+      refreshHead(id);
+    }
+    return error;
+  }
+  function applyRefresh(engineId, refresh) {
+    if (wizard) {
+      wizard.refresh(engineId, refresh);
+      return;
+    }
+    if (refresh.list) {
+      renderNav();
+      renderDetailHead();
+    } else if (refresh.head) {
+      for (const e of session.draft.engines) {
+        refreshNavItem(e.id);
+      }
+      refreshRoutingEntry();
+      renderDetailHead();
+    }
+    if (refresh.form && engineId) {
+      rerenderForm(engineId);
+    }
+    if (refresh.routing || refresh.list) {
+      scheduleRouting();
+    }
+  }
+  let routingQueued = false;
+  function scheduleRouting() {
+    if (routingQueued) {
+      return;
+    }
+    routingQueued = true;
+    queueMicrotask(() => {
+      routingQueued = false;
+      if (finished || wizard) {
+        return;
+      }
+      refreshRoutingEntry();
+      if (selection.kind === "routing") {
+        routing.render();
+      }
+    });
+  }
+  function refreshHead(engineId) {
+    refreshNavItem(engineId);
+    if (selectedEngineId() === engineId) {
+      renderDetailHead();
+    }
+  }
+  function focusKey(key) {
+    const n = Array.from(root.querySelectorAll("[data-fk]")).find((x) => x.dataset.fk === key);
+    n?.focus({ preventScroll: true });
+  }
+  const navList = el("div", "ai-nav-list");
+  navList.setAttribute("role", "list");
+  navList.setAttribute("aria-label", "Engines");
+  const navEngines = el("div", "ai-nav-group");
+  const routingEntry = el("div", "ai-nav-group ai-nav-group--tools");
+  nav.append(navEngines, routingEntry);
+  nav.addEventListener("keydown", onNavKeydown);
+  function navButton(fk, selected) {
+    const b = button("ai-nav-btn", "", { fk });
+    b.setAttribute("aria-controls", detailId);
+    if (selected) {
+      b.setAttribute("aria-current", "true");
+    }
+    return b;
+  }
+  function renderNav() {
+    if (wizard) {
+      return;
+    }
+    keepFocus(nav, () => {
+      navEngines.replaceChildren();
+      const heading = el("div", "ai-nav-heading", "Engines");
+      heading.setAttribute("aria-hidden", "true");
+      navEngines.append(heading);
+      navList.replaceChildren();
+      if (session.draft.engines.length === 0) {
+        navEngines.append(el("div", "ai-nav-empty", "No engines yet"));
+      } else {
+        for (const engine of session.draft.engines) {
+          navList.append(buildNavItem(engine));
+        }
+        navEngines.append(navList);
+      }
+      routingEntry.replaceChildren(buildRoutingEntry(), buildAddEntry());
+    });
+  }
+  function buildNavItem(engine) {
+    const item = el("div", "ai-nav-item");
+    item.setAttribute("role", "listitem");
+    item.dataset.engineId = engine.id;
+    fillNavItem(item, engine);
+    return item;
+  }
+  function fillNavItem(item, engine) {
+    item.replaceChildren();
+    const selected = selection.kind === "engine" && selection.id === engine.id;
+    const name = engineDisplayName(engine);
+    item.classList.toggle("is-selected", selected);
+    item.classList.toggle("is-disabled", !engine.enabled);
+    const btn = navButton(`nav:eng:${engine.id}`, selected);
+    btn.setAttribute("aria-label", `${name}, ${engineKindLabel(engine.kind)}`);
+    btn.title = name;
+    btn.innerHTML = kindGlyphHtml(engine.kind);
+    const text = el("span", "ai-nav-text");
+    const line = el("span", "ai-nav-name-line");
+    line.append(el("span", "ai-nav-name", name));
+    const isDefault = session.draft.routing.default?.engineId === engine.id;
+    if (isDefault) {
+      const star = el("span", "ai-nav-star");
+      star.innerHTML = ICONS.starOn;
+      star.title = "Default engine";
+      line.append(star);
+    }
+    const subLine = el("span", "ai-nav-sub-line");
+    subLine.append(...localityPills(engine, session.draft).slice(0, 1), el("span", "ai-nav-sub", shortUrl(engine.baseUrl) || "no address"));
+    text.append(line, subLine);
+    btn.append(text, statusBadge(session.statuses.get(engine.id), form.busy(engine.id), { compact: true }));
+    btn.addEventListener("click", () => select({ kind: "engine", id: engine.id }));
+    const enabled = switchInput(engine.enabled, `Enable ${name}`, `nav:eng:${engine.id}:enabled`);
+    enabled.addEventListener("change", () => {
+      session.updateEngine(engine.id, { enabled: enabled.checked });
+      applyRefresh(engine.id, { list: true, form: true, routing: true });
+    });
+    item.append(btn, enabled);
+  }
+  function refreshNavItem(engineId) {
+    if (wizard) {
+      return;
+    }
+    const engine = getEngine(engineId);
+    const item = Array.from(navList.querySelectorAll(".ai-nav-item")).find((n) => n.dataset.engineId === engineId);
+    if (!engine || !item) {
+      return;
+    }
+    keepFocus(item, () => fillNavItem(item, engine));
+  }
+  function routingSubline() {
+    const d = session.draft.routing.default;
+    return d ? routeLabel(session.draft, d) : "No default model";
+  }
+  function buildRoutingEntry() {
+    const btn = navButton("nav:routing", selection.kind === "routing");
+    btn.classList.add("ai-nav-btn--routing");
+    const icon = el("span", "ai-nav-icon");
+    icon.innerHTML = ICONS.routing;
+    const text = el("span", "ai-nav-text");
+    text.append(el("span", "ai-nav-name", "Tasks"), el("span", "ai-nav-sub", routingSubline()));
+    btn.append(icon, text);
+    btn.addEventListener("click", () => select({ kind: "routing" }));
+    return btn;
+  }
+  function refreshRoutingEntry() {
+    const sub = routingEntry.querySelector(".ai-nav-btn--routing .ai-nav-sub");
+    if (sub) {
+      sub.textContent = routingSubline();
+    }
+  }
+  function buildAddEntry() {
+    const btn = navButton("nav:add", selection.kind === "add");
+    btn.classList.add("ai-nav-btn--add");
+    const icon = el("span", "ai-nav-icon");
+    icon.innerHTML = ICONS.plus;
+    btn.append(icon, el("span", "ai-nav-name", "Add engine"));
+    btn.addEventListener("click", () => select({ kind: "add" }));
+    return btn;
+  }
+  function onNavKeydown(e) {
+    if (!["ArrowDown", "ArrowUp", "Home", "End"].includes(e.key)) {
+      return;
+    }
+    const buttons = Array.from(nav.querySelectorAll(".ai-nav-btn"));
+    const at = buttons.indexOf(e.target);
+    if (at < 0) {
+      return;
+    }
+    e.preventDefault();
+    const next = e.key === "Home" ? 0 : e.key === "End" ? buttons.length - 1 : Math.max(0, Math.min(buttons.length - 1, at + (e.key === "ArrowDown" ? 1 : -1)));
+    buttons[next]?.focus();
+  }
+  const detailHead = el("div", "ai-detail-head");
+  const detailBody = el("div", "ai-detail-body");
+  detail.append(detailHead, detailBody);
+  function select(next, o = {}) {
+    const sameEngine = next.kind === "engine" && selection.kind === "engine" && selection.id === next.id;
+    selection = next;
+    confirmDeleteId = null;
+    if (next.kind === "engine") {
+      headNotes.delete(next.id);
+    }
+    if (narrow) {
+      view = "detail";
+    }
+    applyLayout();
+    renderNav();
+    if (!sameEngine || o.isNew) {
+      renderDetail();
+    }
+    let first = null;
+    if (next.kind === "engine" && (!sameEngine || o.isNew)) {
+      first = form.opened(next.id, o);
+    }
+    if (o.isNew && first) {
+      focusKey(first);
+      if (first.endsWith(":url")) {
+        const input = root.querySelector(`[data-fk="${first}"]`);
+        input?.select();
+      }
+    } else if (o.isNew || narrow) {
+      focusDetailTitle();
+    }
+    detail.scrollTop = 0;
+  }
+  function focusDetailTitle() {
+    detailHead.querySelector(".ai-detail-title")?.focus({ preventScroll: true });
+  }
+  function renderDetail() {
+    if (wizard) {
+      return;
+    }
+    renderDetailHead();
+    detailBody.replaceChildren();
+    detail.dataset.kind = selection.kind;
+    if (selection.kind === "engine") {
+      const engine = getEngine(selection.id);
+      if (engine) {
+        detailBody.append(form.build(engine.id));
+      }
+    } else if (selection.kind === "routing") {
+      routing.render();
+      detailBody.append(routing.element);
+    } else {
+      detailBody.append(buildPresetCards());
+      if (canDetect && !detectedOnce) {
+        lookForLocalServers();
+      }
+      if (ai.detectHostEngines && hostAvailable === null) {
+        lookForHostEngines();
+      }
+    }
+  }
+  function detailTitle(text) {
+    const h = el("h3", "ai-detail-title", text);
+    h.id = nextId("ai-detail-title");
+    h.tabIndex = -1;
+    detail.setAttribute("aria-labelledby", h.id);
+    return h;
+  }
+  function renderDetailHead() {
+    if (wizard) {
+      return;
+    }
+    keepFocus(detailHead, () => {
+      detailHead.replaceChildren();
+      if (selection.kind === "routing") {
+        const icon = el("span", "ai-detail-icon");
+        icon.innerHTML = ICONS.routing;
+        const main = el("div", "ai-detail-main");
+        main.append(detailTitle("Tasks"), el("div", "ai-detail-sub", "Which model does what. Tasks on Default use the default model."));
+        detailHead.append(icon, main);
+        return;
+      }
+      if (selection.kind === "add") {
+        const icon = el("span", "ai-detail-icon");
+        icon.innerHTML = ICONS.plus;
+        const main = el("div", "ai-detail-main");
+        const empty = session.draft.engines.length === 0;
+        main.append(
+          detailTitle(empty ? "No engines yet" : "Add an engine"),
+          el("div", "ai-detail-sub", `Two ways to connect: paste a cloud API key, or run models on your own machine.${session.draft.enabled ? "" : " Nothing is sent until AI is on."}`)
+        );
+        detailHead.append(icon, main);
+        return;
+      }
+      const engine = getEngine(selection.id);
+      if (!engine) {
+        return;
+      }
+      fillEngineHead(engine);
+    });
+  }
+  function fillEngineHead(engine) {
+    const name = engineDisplayName(engine);
+    const glyph = el("span", "ai-detail-glyph");
+    glyph.innerHTML = kindGlyphHtml(engine.kind);
+    const main = el("div", "ai-detail-main");
+    const titleLine2 = el("div", "ai-detail-title-line");
+    titleLine2.append(detailTitle(name), ...localityPills(engine, session.draft, { blocked: false }));
+    const models = engine.models.filter((m) => !m.missing).length;
+    const picked = engine.models.filter((m) => !m.missing && m.enabled).length;
+    const subParts = [engineKindLabel(engine.kind), shortUrl(engine.baseUrl) || "no address"];
+    if (engine.models.length > 0) {
+      subParts.push(picked === models ? `${models} ${models === 1 ? "model" : "models"}` : `${picked} of ${models} models`);
+    }
+    main.append(titleLine2, el("div", "ai-detail-sub", subParts.join(" \xB7 ")));
+    const isDefault = session.draft.routing.default?.engineId === engine.id;
+    let star;
+    if (isDefault) {
+      star = el("span", "ai-default-badge");
+      star.innerHTML = ICONS.starOn;
+      star.append(el("span", "ai-btn-text", "Default"));
+      star.title = `Default: ${routeLabel(session.draft, session.draft.routing.default)}. To change it, choose Use by default on another engine, or pick the default model under Tasks.`;
+      star.setAttribute("aria-label", `${name} is the default engine`);
+      star.dataset.fk = `eng:${engine.id}:star`;
+      star.tabIndex = -1;
+    } else {
+      star = button("settings-btn ai-default-btn", "Use by default", {
+        html: ICONS.starOff,
+        title: "Use this engine by default",
+        fk: `eng:${engine.id}:star`
+      });
+      star.addEventListener("click", () => makeDefault(engine.id));
+    }
+    const del = button("ai-icon-btn ai-delete-btn", "", { html: ICONS.trash, ariaLabel: `Delete ${name}`, title: "Delete engine", fk: `eng:${engine.id}:delete` });
+    del.addEventListener("click", () => {
+      confirmDeleteId = engine.id;
+      renderDetailHead();
+      focusKey(`eng:${engine.id}:confirm-cancel`);
+    });
+    const actions = el("div", "ai-detail-actions");
+    actions.append(statusBadge(session.statuses.get(engine.id), form.busy(engine.id)), star, del);
+    const top = el("div", "ai-detail-top");
+    top.append(glyph, main, actions);
+    detailHead.append(top);
+    const issues = engineIssues(engine, session.draft, session.hasKey(engine.id)).filter((i) => !["cloudBlocked", "badUrl", "localityMismatch", "noKey"].includes(i.code));
+    const headNote = headNotes.get(engine.id);
+    if (issues.length > 0 || headNote) {
+      const box = el("div", "ai-engine-issues");
+      for (const i of issues) {
+        box.append(note(i.level, i.text));
+      }
+      if (headNote) {
+        box.append(note(headNote.level, headNote.text, "ai-result"));
+      }
+      detailHead.append(box);
+    }
+    if (cloudBlocked(engine)) {
+      detailHead.append(buildCloudOffNote(engine));
+    }
+    if (confirmDeleteId === engine.id) {
+      detailHead.append(buildDeleteConfirm(engine));
+    }
+  }
+  function cloudBlocked(engine) {
+    return !session.draft.allowCloud && engineLocalityInfo(engine, session.draft.localNetworks).locality === "cloud";
+  }
+  function buildCloudOffNote(engine) {
+    const box = el("div", "ai-cloud-off");
+    box.append(note("info", `Cloud engines are off, so nothing is sent to ${engineDisplayName(engine)} yet.`));
+    const on = button("settings-btn ai-cloud-off-btn", "Turn on cloud engines", { fk: `eng:${engine.id}:allow-cloud` });
+    on.addEventListener("click", () => {
+      setAllowCloud(true);
+      headNotes.set(engine.id, { level: "info", text: "Cloud engines are on. Choose Done to save." });
+      renderDetailHead();
+      focusKey(`eng:${engine.id}:star`);
+    });
+    box.append(on);
+    return box;
+  }
+  function setAllowCloud(on) {
+    if (session.draft.allowCloud === on) {
+      return;
+    }
+    session.draft = { ...session.draft, allowCloud: on };
+    renderNav();
+    const formEngine = wizard ? wizard.engineId() : selectedEngineId();
+    if (formEngine) {
+      rerenderForm(formEngine);
+    }
+    scheduleRouting();
+    announce(on ? "Cloud engines turned on. Choose Done to save." : "Cloud engines turned off. Choose Done to save.");
+  }
+  function rerenderForm(engineId) {
+    if (wizard) {
+      wizard.refresh(engineId, { form: true });
+      return;
+    }
+    if (selectedEngineId() !== engineId) {
+      return;
+    }
+    const current = detailBody.querySelector(".ai-form");
+    if (!current) {
+      return;
+    }
+    keepFocus(current, () => {
+      const fresh = form.build(engineId);
+      current.replaceWith(fresh);
+      return fresh;
+    });
+  }
+  function buildDeleteConfirm(engine) {
+    const box = el("div", "ai-confirm");
+    box.setAttribute("role", "group");
+    const name = engineDisplayName(engine);
+    box.setAttribute("aria-label", `Delete ${name}?`);
+    const msg = el("span", "ai-confirm-text", `Delete ${name}? Routes to it are cleared${ai.setSecret ? " and its stored API key is removed" : ""} when you choose Done.`);
+    const yes = button("settings-btn ai-btn--danger", "Delete", { fk: `eng:${engine.id}:confirm-delete` });
+    const no = button("settings-btn", "Cancel", { fk: `eng:${engine.id}:confirm-cancel` });
+    yes.addEventListener("click", () => deleteEngine(engine.id));
+    no.addEventListener("click", () => {
+      confirmDeleteId = null;
+      renderDetailHead();
+      focusKey(`eng:${engine.id}:delete`);
+    });
+    box.addEventListener("keydown", (e) => {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        e.stopPropagation();
+        no.click();
+      }
+    });
+    box.append(msg, yes, no);
+    return box;
+  }
+  let probes = null;
+  let detectedOnce = false;
+  let detecting = false;
+  let detectAbort = null;
+  const canDetect = typeof ai.detectLocalServers === "function";
+  function lookForLocalServers() {
+    if (!canDetect || finished) {
+      return;
+    }
+    detectAbort?.abort();
+    const controller = new AbortController();
+    detectAbort = controller;
+    detectedOnce = true;
+    detecting = true;
+    refreshLocalCards();
+    announce(AI_DETECT_LOOKING);
+    void detectLocalServers(ai, controller.signal).then((found) => {
+      if (finished || controller.signal.aborted) {
+        return;
+      }
+      detecting = false;
+      detectAbort = null;
+      probes = found;
+      refreshLocalCards();
+      announce(detectionSummary(localCards()));
+    });
+  }
+  function localCards() {
+    return probes ? rankLocalCandidates(probes, session.draft.engines) : null;
+  }
+  function detectionSummary(cards) {
+    if (!cards) {
+      return "Could not look for local AI servers.";
+    }
+    const running = cards.filter((c) => c.running);
+    if (running.length === 0) {
+      return AI_DETECT_NONE;
+    }
+    return `Running on this computer: ${running.map((c) => `${presetName(c.presetId)}${c.models !== void 0 ? `, ${countText(c.models)}` : ""}${c.alreadyAdded ? ", added" : ""}`).join("; ")}.`;
+  }
+  function presetName(id) {
+    return AI_ENGINE_PRESETS.find((p) => p.id === id)?.name ?? id;
+  }
+  function countText(models) {
+    return `${models} ${models === 1 ? "model" : "models"}`;
+  }
+  let hostAvailable = null;
+  function lookForHostEngines() {
+    hostAvailable = false;
+    void hostEngineAvailability(ai).then((found) => {
+      if (finished || !found?.available) {
+        return;
+      }
+      hostAvailable = true;
+      if (selection.kind === "add" && !wizard) {
+        keepFocus(detailBody, () => {
+          detailBody.replaceChildren(buildPresetCards());
+        });
+      }
+    });
+  }
+  function buildPresetCards() {
+    const groups = groupPresets(AI_ENGINE_PRESETS);
+    const box = el("div", "ai-cards");
+    const families = hostAvailable ? [AI_HOST_PRESET_FAMILY, ...AI_PRESET_FAMILIES] : [...AI_PRESET_FAMILIES];
+    for (const family of families) {
+      const presets = groups[family.family];
+      if (presets.length === 0) {
+        continue;
+      }
+      const section = el("section", "ai-cards-group");
+      section.dataset.family = family.family;
+      const headingId = nextId("ai-cards-heading");
+      const heading = el("div", "ai-cards-heading");
+      heading.id = headingId;
+      heading.innerHTML = family.family === "local" ? ICONS.local : ICONS.cloud;
+      heading.append(el("span", "", family.label));
+      section.setAttribute("aria-labelledby", headingId);
+      const grid = el("div", "ai-cards-grid");
+      grid.setAttribute("role", "group");
+      grid.setAttribute("aria-labelledby", headingId);
+      section.append(heading, el("div", "ai-cards-explainer", family.explainer));
+      if (family.family === "local") {
+        section.append(grid);
+        fillLocalGrid(grid, presets);
+        if (canDetect) {
+          section.append(buildDetectLine());
+        }
+      } else if (family.family === "host") {
+        section.append(grid);
+        for (const preset of presets) {
+          grid.append(buildCard(preset));
+        }
+      } else {
+        section.append(buildCloudAccess(presets), grid);
+        for (const preset of presets) {
+          grid.append(buildCard(preset));
+        }
+      }
+      box.append(section);
+    }
+    placeGroups(box);
+    return box;
+  }
+  function placeGroups(box) {
+    const localLeads = !!localCards()?.some((c) => c.running && !c.alreadyAdded);
+    const order = localLeads ? ["host", "local", "cloud"] : ["host", "cloud", "local"];
+    for (const family of order) {
+      const section = box.querySelector(`:scope > .ai-cards-group[data-family="${family}"]`);
+      if (section) {
+        box.append(section);
+      }
+    }
+  }
+  let cloudPrivacyOpen = false;
+  function buildCloudAccess(presets) {
+    return cloudAccessBox({
+      allowed: session.draft.allowCloud,
+      onChange: (on) => setAllowCloud(on),
+      presets,
+      hostAsks: !!ai.requestCloudConsent,
+      open: cloudPrivacyOpen,
+      onToggle: (open) => {
+        cloudPrivacyOpen = open;
+      },
+      openLink: ctx.openLink,
+      fk: "cards:allow-cloud"
+    });
+  }
+  function fillLocalGrid(grid, presets) {
+    grid.replaceChildren();
+    const cards = localCards();
+    const byId = new Map(cards?.map((c) => [c.presetId, c]) ?? []);
+    const ordered = cards ? [...cards.map((c) => presets.find((p) => p.id === c.presetId)).filter((p) => !!p), ...presets.filter((p) => !byId.has(p.id))] : presets;
+    for (const preset of ordered) {
+      grid.append(buildCard(preset, byId.get(preset.id)));
+    }
+  }
+  function buildCard(preset, found) {
+    const card = button("ai-card", "", { fk: `card:${preset.id}`, ariaLabel: `Add ${preset.name}` });
+    card.innerHTML = kindGlyphHtml(preset.kind);
+    const text = el("span", "ai-card-text");
+    text.append(el("span", "ai-card-name", preset.name), el("span", "ai-card-caption", preset.caption));
+    card.append(text);
+    card.title = preset.caption;
+    const cloudEngine = preset.family === "cloud" ? session.draft.engines.find((e) => presetForEngine(e)?.id === preset.id) : void 0;
+    const added = cloudEngine ? cloudEngine.id : found?.alreadyAdded && found.engineId && getEngine(found.engineId) ? found.engineId : null;
+    if (cloudEngine) {
+      card.dataset.state = "added";
+      text.append(el("span", "ai-card-state", "Added"));
+      card.setAttribute("aria-label", `${preset.name}, added. Open it`);
+      card.title = `${preset.name} is already set up. Open it.`;
+    } else if (found) {
+      const state = added ? "added" : found.running ? "running" : "stopped";
+      card.dataset.state = state;
+      const label = state === "added" ? "Added" : state === "running" ? `Running${found.models !== void 0 ? ` \xB7 ${countText(found.models)}` : ""}` : "Not running";
+      const line = el("span", "ai-card-state");
+      if (state === "running") {
+        const dot = el("span", "ai-card-dot");
+        dot.setAttribute("aria-hidden", "true");
+        line.append(dot);
+      }
+      line.append(el("span", "", label));
+      text.append(line);
+      card.setAttribute("aria-label", added ? `${preset.name}, added. Open it` : `Add ${preset.name}, ${label.replace(" \xB7 ", ", ").toLowerCase()}`);
+      if (added) {
+        card.title = `${preset.name} is already set up. Open it.`;
+      }
+    }
+    card.addEventListener("click", () => {
+      if (added && getEngine(added)) {
+        select({ kind: "engine", id: added });
+      } else {
+        addEngine(preset);
+      }
+    });
+    return card;
+  }
+  function buildDetectLine() {
+    const line = el("div", "ai-cards-detect");
+    const status = el("span", "ai-cards-detect-text", detecting ? AI_DETECT_LOOKING : probes && !probes.some((p) => p.ok) ? AI_DETECT_NONE : "");
+    const again = button("ai-link-btn ai-cards-again", "Look again", { fk: "cards:look-again" });
+    if (detecting) {
+      again.setAttribute("aria-disabled", "true");
+    }
+    again.addEventListener("click", () => {
+      if (!detecting) {
+        lookForLocalServers();
+      }
+    });
+    line.append(status, again);
+    return line;
+  }
+  function refreshLocalCards() {
+    const section = detailBody.querySelector('.ai-cards-group[data-family="local"]');
+    if (!section || selection.kind !== "add") {
+      return;
+    }
+    keepFocus(section, () => {
+      const grid = section.querySelector(".ai-cards-grid");
+      if (grid) {
+        fillLocalGrid(grid, groupPresets(AI_ENGINE_PRESETS).local);
+      }
+      const line = section.querySelector(".ai-cards-detect");
+      if (line) {
+        line.replaceWith(buildDetectLine());
+      }
+    });
+    const box = section.parentElement;
+    if (box) {
+      keepFocus(box, () => {
+        placeGroups(box);
+      });
+    }
+  }
+  function addEngine(preset) {
+    const engine = engineFromPreset(preset, session.draft.engines.map((e) => e.id));
+    session.addEngine(engine);
+    select({ kind: "engine", id: engine.id }, { isNew: true });
+    scheduleRouting();
+    announce(preset.family === "cloud" ? `Added ${engine.name}. Paste your API key.` : preset.family === "host" ? `Added ${engine.name}. Fetching its models.` : `Added ${engine.name}. Check the address; models are fetched from it.`);
+  }
+  function deleteEngine(id) {
+    const engine = getEngine(id);
+    if (!engine) {
+      return;
+    }
+    const index = session.draft.engines.findIndex((e) => e.id === id);
+    session.deleteEngine(id);
+    headNotes.delete(id);
+    form.forget(id);
+    confirmDeleteId = null;
+    const next = session.draft.engines[Math.min(index, session.draft.engines.length - 1)];
+    selection = next ? { kind: "engine", id: next.id } : { kind: "add" };
+    renderNav();
+    renderDetail();
+    if (next) {
+      form.opened(next.id);
+    }
+    announce(`Deleted ${engineDisplayName(engine)}. Choose Done to apply.`);
+    focusKey(next ? `nav:eng:${next.id}` : "nav:add");
+  }
+  function makeDefault(engineId) {
+    const engine = getEngine(engineId);
+    if (!engine) {
+      return;
+    }
+    const name = engineDisplayName(engine);
+    const draft = session.draft;
+    if (draft.routing.default?.engineId === engineId) {
+      return;
+    }
+    const route = defaultRouteForEngine(draft, session.statusList(), engineId);
+    if (!route) {
+      headNotes.set(engineId, { level: "info", text: "No model here can be the default yet. Pick or add a chat model first." });
+      announce(`${name} has no chat model to make the default yet.`);
+      renderDetailHead();
+      return;
+    }
+    session.draft = { ...draft, routing: { ...draft.routing, default: route } };
+    announce(`Default model: ${routeLabel(session.draft, route)}.`);
+    headNotes.delete(engineId);
+    renderNav();
+    renderDetailHead();
+    rerenderForm(engineId);
+    focusKey(`eng:${engineId}:star`);
+  }
+  function back() {
+    if (confirmDiscard) {
+      hideDiscard();
+      return;
+    }
+    if (wizard) {
+      wizard.back();
+      return;
+    }
+    if (narrow && view === "detail") {
+      view = "list";
+      applyLayout();
+      focusSelectedEntry();
+      return;
+    }
+    if (session.dirty()) {
+      showDiscard();
+      return;
+    }
+    cancel();
+  }
+  function leave() {
+    if (session.dirty()) {
+      showDiscard();
+    } else {
+      cancel();
+    }
+  }
+  function cancel() {
+    if (finished) {
+      return;
+    }
+    finished = true;
+    session.discard();
+    opts.onCancel();
+  }
+  function done() {
+    if (finished) {
+      return;
+    }
+    const unpicked = firstEngineNeedingPick(session.draft);
+    if (unpicked) {
+      requirePick(unpicked.id);
+      return;
+    }
+    finished = true;
+    const patch = session.collect();
+    const saved = session.commit();
+    if (opts.turnOnWhenDone && !saved.enabled && hasUsableDefaultRoute(saved)) {
+      patch["ai.enabled"] = true;
+      saved.enabled = true;
+    }
+    opts.onDone(patch, saved);
+  }
+  function requirePick(engineId) {
+    const engine = getEngine(engineId);
+    if (!engine) {
+      return;
+    }
+    form.requirePick(engineId);
+    if (wizard) {
+      leaveWizardFor(engineId);
+    } else if (selection.kind !== "engine" || selection.id !== engineId) {
+      selection = { kind: "engine", id: engineId };
+      view = "detail";
+      applyLayout();
+      renderNav();
+      renderDetail();
+    } else {
+      rerenderForm(engineId);
+    }
+    announce(`Pick at least one model for ${engineDisplayName(engine)} before you choose Done.`);
+    const target = Array.from(root.querySelectorAll("[data-fk]")).find((n) => n.dataset.fk === `eng:${engineId}:pick` || n.dataset.fk === `eng:${engineId}:models`);
+    target?.focus({ preventScroll: false });
+  }
+  function showDiscard() {
+    confirmDiscard = true;
+    const scrim = el("div", "ai-page-confirm-scrim");
+    const box = el("div", "ai-page-confirm");
+    box.setAttribute("role", "alertdialog");
+    const headId = nextId("ai-discard-title");
+    const textId = nextId("ai-discard-text");
+    box.setAttribute("aria-labelledby", headId);
+    box.setAttribute("aria-describedby", textId);
+    const head = el("div", "ai-page-confirm-title", "Discard changes?");
+    head.id = headId;
+    const text = el("div", "ai-page-confirm-text", "Your changes to engines and tasks have not been saved. Engines added here and their keys are removed.");
+    text.id = textId;
+    const keep = button("settings-btn", "Keep editing", { fk: "page:keep" });
+    keep.addEventListener("click", () => hideDiscard());
+    const discard = button("settings-btn ai-btn--danger", "Discard", { fk: "page:discard" });
+    discard.addEventListener("click", () => cancel());
+    const actions = el("div", "ai-page-confirm-actions");
+    actions.append(keep, discard);
+    box.append(head, text, actions);
+    scrim.append(box);
+    confirmHost.replaceChildren(scrim);
+    header.inert = true;
+    body.inert = true;
+    if (wizard) {
+      wizard.element.inert = true;
+    }
+    keep.focus();
+  }
+  function hideDiscard() {
+    confirmDiscard = false;
+    confirmHost.replaceChildren();
+    header.inert = false;
+    body.inert = false;
+    if (wizard) {
+      wizard.element.inert = false;
+    }
+    backBtn.focus();
+  }
+  root.addEventListener("keydown", (e) => {
+    if (e.key !== "Escape" || e.defaultPrevented) {
+      return;
+    }
+    e.preventDefault();
+    e.stopPropagation();
+    back();
+  });
+  function applyLayout() {
+    root.classList.toggle("is-narrow", narrow);
+    root.dataset.view = narrow ? view : "both";
+    backBtn.setAttribute("aria-label", narrow && view === "detail" ? "Back to the list" : "Back");
+  }
+  function measure(width) {
+    const next = width > 0 && width < NARROW_PX;
+    if (next === narrow) {
+      return;
+    }
+    narrow = next;
+    applyLayout();
+  }
+  function focusSelectedEntry() {
+    const fk = selection.kind === "engine" ? `nav:eng:${selection.id}` : selection.kind === "routing" ? "nav:routing" : "nav:add";
+    focusKey(fk);
+  }
+  let resizeObserver = null;
+  if (typeof ResizeObserver === "function") {
+    resizeObserver = new ResizeObserver((entries) => {
+      const entry = entries[entries.length - 1];
+      if (entry) {
+        measure(entry.contentRect.width);
+      }
+    });
+    resizeObserver.observe(container);
+  }
+  const unsubscribe = opts.subscribeStatuses?.((list) => {
+    if (finished) {
+      return;
+    }
+    for (const s of list) {
+      if (!form.busy(s.engineId)) {
+        session.statuses.set(s.engineId, s);
+      }
+    }
+    for (const engine of session.draft.engines) {
+      refreshNavItem(engine.id);
+    }
+    renderDetailHead();
+    scheduleRouting();
+    wizard?.refresh(null, {});
+  });
+  function startWizard() {
+    const w = createSetupWizard({
+      session,
+      form,
+      ctx,
+      announce,
+      focusKey,
+      setAllowCloud,
+      onStatuses: () => opts.onStatuses(session.statusList()),
+      onStep: (step) => wizardHeader(step),
+      finish: () => done(),
+      leave,
+      openEngine: (id) => leaveWizardFor(id),
+      turnsOn: !!opts.turnOnWhenDone
+    });
+    wizard = w;
+    root.classList.add("ai-page--wizard");
+    disclaimer.hidden = true;
+    body.hidden = true;
+    root.insertBefore(w.element, body);
+    wizardHeader(w.step());
+  }
+  function wizardHeader(step) {
+    const n = wizardStepNumber(step);
+    title.textContent = "Set up AI";
+    stepper.hidden = false;
+    stepper.replaceChildren();
+    stepper.setAttribute("role", "img");
+    stepper.setAttribute("aria-label", `Step ${n} of ${AI_WIZARD_STEPS}`);
+    for (let i = 1; i <= AI_WIZARD_STEPS; i++) {
+      const dot = el("span", `ai-wizard-dot${i === n ? " is-current" : i < n ? " is-done" : ""}`);
+      stepper.append(dot);
+    }
+    stepper.append(el("span", "ai-wizard-steps-text", `${n} of ${AI_WIZARD_STEPS}`));
+    if (titleNote) {
+      titleNote.hidden = true;
+    }
+    doneBtn.hidden = true;
+    skipBtn.hidden = step === "done";
+    backBtn.setAttribute("aria-label", n === 1 ? "Back" : "Back to the previous step");
+  }
+  function leaveWizardFor(engineId) {
+    const w = wizard;
+    if (!w) {
+      return;
+    }
+    wizard = null;
+    w.dispose();
+    root.classList.remove("ai-page--wizard");
+    disclaimer.hidden = false;
+    body.hidden = false;
+    title.textContent = "AI Engines";
+    stepper.hidden = true;
+    if (titleNote) {
+      titleNote.hidden = false;
+    }
+    doneBtn.hidden = false;
+    skipBtn.hidden = true;
+    selection = getEngine(engineId) ? { kind: "engine", id: engineId } : initialSelection();
+    view = "detail";
+    applyLayout();
+    renderNav();
+    renderDetail();
+    if (selection.kind === "engine") {
+      form.opened(selection.id);
+    }
+    if (narrow) {
+      focusDetailTitle();
+    } else {
+      focusSelectedEntry();
+    }
+  }
+  container.replaceChildren(root);
+  measure(container.getBoundingClientRect().width);
+  applyLayout();
+  if (opts.initial?.section === "wizard" && session.tier === 2) {
+    startWizard();
+  } else {
+    renderNav();
+    renderDetail();
+    if (selection.kind === "engine") {
+      form.opened(selection.id);
+    }
+  }
+  if (ai.hardwareInfo && !hardware) {
+    void setupHardware(ai).then((info) => {
+      if (finished || !info) {
+        return;
+      }
+      hardware = info;
+      const formEngine = wizard ? wizard.engineId() : selectedEngineId();
+      if (formEngine) {
+        rerenderForm(formEngine);
+      }
+    });
+  }
+  if (session.tier === 2) {
+    void session.refreshStatuses().then((ok) => {
+      if (!ok || finished) {
+        return;
+      }
+      for (const engine of session.draft.engines) {
+        refreshNavItem(engine.id);
+      }
+      renderDetailHead();
+      scheduleRouting();
+    });
+  }
+  return {
+    dispose() {
+      if (!finished) {
+        finished = true;
+        session.discard();
+      }
+      finished = true;
+      detectAbort?.abort();
+      wizard?.dispose();
+      window.clearTimeout(liveTimer);
+      unsubscribe?.();
+      resizeObserver?.disconnect();
+      form.dispose();
+      container.replaceChildren();
+    },
+    focus() {
+      if (confirmDiscard) {
+        focusKey("page:keep");
+      } else if (wizard) {
+        wizard.focus();
+      } else if (narrow && view === "detail") {
+        focusDetailTitle();
+      } else if (!narrow && selection.kind === "routing") {
+        focusKey("route:default");
+      } else if (!narrow && selection.kind === "add" && session.draft.engines.length === 0) {
+        detailBody.querySelector(".ai-card")?.focus({ preventScroll: true });
+      } else {
+        focusSelectedEntry();
+      }
+    }
+  };
+}
+
+export {
+  engineKindLabel,
+  engineDisplayName,
+  parseLocalNetworksText,
+  routeLabel,
+  taskRouteNote,
+  aiNextRouteChanged,
+  aiIndicatorState,
+  createAiSettingsSession,
+  withSavedAiKeys,
+  ICONS,
+  kindGlyphHtml,
+  AI_EXPERIMENTAL_DISCLAIMER,
+  experimentalBadge,
+  experimentalDisclaimer,
+  privacyCard,
+  privacyLine,
+  nextId,
+  el,
+  button,
+  switchInput,
+  note,
+  keepFocus,
+  statusBadge,
+  localityPills,
+  AI_DETECT_LOOKING,
+  detectLocalServers,
+  bestLocalServer,
+  setUpLocalEngine,
+  scanForSetup,
+  mountAiEnginesPage
+};
+//# sourceMappingURL=chunk-7A5HEPLK.js.map