@mikedown/core 0.1.0 → 0.3.0

package/dist/ai-ui-C7ENTWWU.js

@@ -0,0 +1,3370 @@
+import {
+  aiRewriteHighlightKey,
+  cmRewriteRange,
+  getPortal,
+  setCmRewriteRange
+} from "./chunk-L4FO63DF.js";
+import {
+  AI_DETECT_LOOKING,
+  AI_EXPERIMENTAL_DISCLAIMER,
+  ICONS,
+  aiIndicatorState,
+  aiNextRouteChanged,
+  bestLocalServer,
+  button,
+  createAiSettingsSession,
+  detectLocalServers,
+  el,
+  engineDisplayName,
+  engineKindLabel,
+  experimentalBadge,
+  experimentalDisclaimer,
+  keepFocus,
+  kindGlyphHtml,
+  localityPills,
+  mountAiEnginesPage,
+  nextId,
+  note,
+  parseLocalNetworksText,
+  privacyCard,
+  privacyLine,
+  routeLabel,
+  scanForSetup,
+  setUpLocalEngine,
+  statusBadge,
+  switchInput,
+  taskRouteNote,
+  withSavedAiKeys
+} from "./chunk-7A5HEPLK.js";
+import "./chunk-LXZG7IKN.js";
+import {
+  AI_AUDIENCES,
+  AI_ENGINE_PRESETS,
+  AI_FEATURES,
+  AI_NO_CONSENTS_TEXT,
+  AI_REWRITE_VARIANTS,
+  AI_TASKS,
+  CHARS_PER_TOKEN,
+  DEFAULT_CONTEXT_TOKENS,
+  PROPERTY_VOCABULARY_MAX,
+  REWRITE_CONTEXT_CHARS,
+  aiConsentHost,
+  aiConsentStepNote,
+  aiConsentSummary,
+  aiErrorCopy,
+  aiLengthLimitCopy,
+  aiProviderPolicy,
+  aiResultStats,
+  aiResultStatsText,
+  aiResultStatsTitle,
+  budgetDocument,
+  buildExplainMessages,
+  buildPropertiesMessages,
+  buildRewriteMessages,
+  buildSummaryMessages,
+  buildTitleMessages,
+  checkMarkdownStructure,
+  coveragePercent,
+  explainMaxTokens,
+  finalizeRewriteText,
+  finalizeSummary,
+  getAiAudience,
+  getAiRewriteVariant,
+  getAiTask,
+  headingsOutline,
+  isHostEngineKind,
+  isRouteUsable,
+  jsonRepairMessages,
+  makeAiError,
+  nearestThinkingLevel,
+  parseAiSettings,
+  parsePropertySuggestions,
+  parseTitles,
+  propertiesMaxTokens,
+  renderHeadingOutline,
+  resolveAiFeature,
+  resolveRoute,
+  resolveThinkingLevel,
+  rewriteMaxTokens,
+  rewriteVisibleText,
+  summaryMaxTokens,
+  summaryPreviewText,
+  summaryVisibleText,
+  thinkingChoices,
+  thinkingLevelFrom,
+  thinkingMaxTokens,
+  titleMaxTokens,
+  toAiError,
+  whatIsSent,
+  withThinkingLevel
+} from "./chunk-JZWKEBCI.js";
+import {
+  hostOfUrl
+} from "./chunk-QDVY7WW6.js";
+
+// src/ai-prefs.ts
+var LANGUAGES_KEY = "mikedown.ai.recentLanguages";
+var AUDIENCE_KEY = "mikedown.ai.audience";
+var THINKING_KEY = "mikedown.ai.thinking";
+var MAX_RECENT_LANGUAGES = 3;
+var LANGUAGE_MAX_CHARS = 60;
+var AI_TRANSLATE_LANGUAGES = [
+  "English",
+  "Spanish",
+  "French",
+  "German",
+  "Portuguese",
+  "Italian",
+  "Dutch",
+  "Japanese",
+  "Chinese (Simplified)",
+  "Korean",
+  "Arabic",
+  "Hindi"
+];
+var sameLanguage = (a, b) => a.toLocaleLowerCase() === b.toLocaleLowerCase();
+function cleanLanguage(language) {
+  return language.replace(/\s+/g, " ").trim().slice(0, LANGUAGE_MAX_CHARS);
+}
+function loadRecentLanguages() {
+  try {
+    const raw = localStorage.getItem(LANGUAGES_KEY);
+    if (!raw) {
+      return [];
+    }
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    const out = [];
+    for (const item of parsed) {
+      if (typeof item !== "string") {
+        continue;
+      }
+      const lang = cleanLanguage(item);
+      if (lang && !out.some((l) => sameLanguage(l, lang))) {
+        out.push(lang);
+      }
+      if (out.length >= MAX_RECENT_LANGUAGES) {
+        break;
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function rememberLanguage(language) {
+  const lang = cleanLanguage(language);
+  if (!lang) {
+    return;
+  }
+  try {
+    const next = [lang, ...loadRecentLanguages().filter((l) => !sameLanguage(l, lang))].slice(0, MAX_RECENT_LANGUAGES);
+    localStorage.setItem(LANGUAGES_KEY, JSON.stringify(next));
+  } catch {
+  }
+}
+function translateLanguageChoices(recents = loadRecentLanguages()) {
+  return {
+    recents,
+    languages: AI_TRANSLATE_LANGUAGES.filter((l) => !recents.some((r) => sameLanguage(r, l)))
+  };
+}
+function loadAudience() {
+  try {
+    const raw = localStorage.getItem(AUDIENCE_KEY);
+    return raw && getAiAudience(raw) ? raw : null;
+  } catch {
+    return null;
+  }
+}
+function rememberAudience(audience) {
+  if (!getAiAudience(audience)) {
+    return;
+  }
+  try {
+    localStorage.setItem(AUDIENCE_KEY, audience);
+  } catch {
+  }
+}
+var THINKING_LEVELS = ["off", "low", "medium", "high"];
+function loadThinkingLevel() {
+  try {
+    const raw = localStorage.getItem(THINKING_KEY);
+    return raw && THINKING_LEVELS.includes(raw) ? raw : null;
+  } catch {
+    return null;
+  }
+}
+function rememberThinkingLevel(level) {
+  try {
+    if (level) {
+      localStorage.setItem(THINKING_KEY, level);
+    } else {
+      localStorage.removeItem(THINKING_KEY);
+    }
+  } catch {
+  }
+}
+function thinkingLevelFor(kind) {
+  return nearestThinkingLevel(kind, loadThinkingLevel());
+}
+
+// src/ai-settings.ts
+function buildAiSettingsSection(ctx, opts) {
+  const session = createAiSettingsSession(opts);
+  const { tier } = session;
+  const canManage = tier === 2 && !!opts.openEnginesPage;
+  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 rows = [];
+  const intro = el("div", "ai-experimental-intro");
+  const introHead = el("div", "ai-experimental-head");
+  introHead.append(el("span", "ai-experimental-title", "AI features"), experimentalBadge());
+  intro.append(introHead, experimentalDisclaimer());
+  rows.push(intro);
+  const masterField = ctx.makeCheckboxRow(
+    "Enable AI features",
+    tier === 2 ? "Writing help from engines you choose. While this is off, nothing is sent anywhere." : "Writing help from the AI service this app provides. While this is off, nothing is sent anywhere.",
+    session.draft.enabled
+  );
+  masterField.row.classList.add("ai-master");
+  masterField.input.dataset.fk = "ai-enabled";
+  masterField.input.addEventListener("change", () => {
+    session.draft = { ...session.draft, enabled: masterField.input.checked };
+  });
+  const toolbarField = ctx.makeCheckboxRow(
+    "Show AI button on the toolbar",
+    "Opens the AI actions. While AI is off, it offers to turn AI on and set it up.",
+    session.draft.showToolbarButton
+  );
+  toolbarField.input.dataset.fk = "ai-toolbar-button";
+  toolbarField.input.addEventListener("change", () => {
+    session.draft = { ...session.draft, showToolbarButton: toolbarField.input.checked };
+  });
+  const cloudField = ctx.makeCheckboxRow(
+    "Allow cloud engines",
+    "Lets tasks use engines outside this network, such as Anthropic or OpenAI. Local engines never need it.",
+    session.draft.allowCloud
+  );
+  cloudField.input.dataset.fk = "ai-allow-cloud";
+  cloudField.row.append(privacyCard(session.draft.engines.map((e) => ({ policy: aiProviderPolicy(e) })), {
+    openLink: ctx.openLink,
+    extra: aiConsentStepNote(!!session.ai.requestCloudConsent),
+    className: "ai-row-note"
+  }));
+  cloudField.input.addEventListener("change", () => {
+    session.draft = { ...session.draft, allowCloud: cloudField.input.checked };
+    renderEngines();
+  });
+  const listConsents = session.ai.listConsents?.bind(session.ai);
+  const forgetConsent = session.ai.forgetConsent?.bind(session.ai);
+  const consentsRow = ctx.makeRow("Cloud consents", "Cloud engines you have allowed or refused here. Forget an answer to be asked again.");
+  consentsRow.classList.add("ai-section");
+  const consentsBody = el("div", "ai-consents");
+  consentsRow.append(consentsBody);
+  function engineNameFor(engineId) {
+    const engine = session.draft.engines.find((e) => e.id === engineId);
+    return engine ? engineDisplayName(engine) : engineId;
+  }
+  function renderConsents(records, problem) {
+    keepFocus(consentsBody, () => {
+      consentsBody.replaceChildren();
+      if (problem) {
+        consentsBody.append(note("error", problem));
+      }
+      if (records.length === 0) {
+        if (!problem) {
+          consentsBody.append(el("div", "ai-consents-empty", AI_NO_CONSENTS_TEXT));
+        }
+        return;
+      }
+      const list = el("ul", "ai-consents-list");
+      list.setAttribute("aria-label", "Cloud consents");
+      for (const record of records) {
+        const name = engineNameFor(record.engineId);
+        const item = el("li", "ai-consent");
+        const forget = button("settings-btn settings-btn--secondary ai-consent-forget", "Forget", { ariaLabel: `Forget the answer for ${name}`, fk: `consent-forget:${record.engineId}` });
+        forget.addEventListener("click", () => {
+          forget.disabled = true;
+          void forgetConsent?.(record.engineId).then(
+            () => {
+              opts.onConsentForgotten?.(record.engineId);
+              announce(`Forgot the answer for ${name}.`);
+              return refreshConsents();
+            },
+            (err) => refreshConsents(toAiError(err).message)
+          );
+        });
+        item.append(el("span", "ai-consent-text", aiConsentSummary(record, name)), forget);
+        list.append(item);
+      }
+      consentsBody.append(list);
+    });
+  }
+  async function refreshConsents(problem) {
+    if (!listConsents) {
+      return;
+    }
+    try {
+      renderConsents(await listConsents(), problem);
+    } catch (err) {
+      renderConsents([], toAiError(err).message);
+    }
+  }
+  const enginesRow = ctx.makeRow("Engines", "Servers that run the models. Local engines keep your text on this network.");
+  enginesRow.classList.add("ai-section");
+  const enginesBody = el("div", "ai-engines-body");
+  enginesRow.append(enginesBody);
+  function openPage(initial) {
+    const pendingEnable = session.draft.enabled && !session.original.enabled;
+    opts.openEnginesPage?.({
+      initial,
+      session: { ...session.fork(), pendingEnable },
+      onDone: (patch, saved) => {
+        session.absorb(saved, patch);
+        cloudField.input.checked = session.draft.allowCloud;
+        masterField.input.checked = session.draft.enabled;
+        renderEngines();
+        if (Object.keys(patch).length > 0) {
+          announce("Engines and tasks saved.");
+        }
+      }
+    });
+  }
+  function renderEngines() {
+    keepFocus(enginesBody, () => {
+      enginesBody.replaceChildren();
+      const draft = session.draft;
+      if (draft.engines.length === 0) {
+        const empty = el("div", "ai-summary-empty");
+        empty.append(
+          el("div", "ai-empty-title", "No engines yet"),
+          el("div", "ai-empty-text", `Two ways to connect: paste a cloud API key, or run models on your own machine.${draft.enabled ? "" : " Nothing is sent until AI is on."}`)
+        );
+        enginesBody.append(empty);
+      } else {
+        const list = el("div", "ai-engines ai-engines--compact");
+        list.setAttribute("role", "list");
+        list.setAttribute("aria-label", "Engines");
+        for (const engine of draft.engines) {
+          list.append(buildEngineItem(engine));
+        }
+        enginesBody.append(list, buildRouteLine());
+      }
+      const manage = button("settings-btn settings-btn--secondary ai-manage-btn", draft.engines.length === 0 ? "Add engine\u2026" : "Manage engines\u2026", { fk: "manage-engines" });
+      manage.addEventListener("click", () => openPage());
+      const actions = el("div", "ai-summary-actions");
+      actions.append(manage);
+      enginesBody.append(actions);
+    });
+  }
+  function buildEngineItem(engine) {
+    const item = el("div", "ai-engine ai-engine--compact");
+    item.setAttribute("role", "listitem");
+    item.dataset.engineId = engine.id;
+    item.classList.toggle("is-disabled", !engine.enabled);
+    const name = engineDisplayName(engine);
+    const head = el("div", "ai-engine-head");
+    const glyph = el("span", "ai-engine-glyph");
+    glyph.innerHTML = kindGlyphHtml(engine.kind, "ai-glyph--sm");
+    const open = button("ai-engine-main ai-engine-open", "", { ariaLabel: `${name}: open in AI Engines`, fk: `eng:${engine.id}:open` });
+    const titleLine = el("span", "ai-engine-title");
+    titleLine.append(el("span", "ai-engine-name", name), ...localityPills(engine, session.draft));
+    open.title = engineKindLabel(engine.kind);
+    open.append(titleLine);
+    open.addEventListener("click", () => openPage({ engineId: engine.id }));
+    const enabled = switchInput(engine.enabled, `Enable ${name}`, `eng:${engine.id}:enabled-row`);
+    enabled.addEventListener("change", () => {
+      session.updateEngine(engine.id, { enabled: enabled.checked });
+      renderEngines();
+    });
+    const actions = el("div", "ai-engine-actions");
+    actions.append(statusBadge(session.statuses.get(engine.id), void 0, { compact: true }), enabled);
+    head.append(glyph, open, actions);
+    item.append(head);
+    return item;
+  }
+  function buildRouteLine() {
+    const draft = session.draft;
+    const line = el("div", "ai-route-line");
+    const labelId = nextId("ai-route-line");
+    const label = el("span", "ai-route-line-label", "Default model");
+    label.id = labelId;
+    const value = el("span", "ai-route-line-value", draft.routing.default ? routeLabel(draft, draft.routing.default) : "None set");
+    value.classList.toggle("is-none", !draft.routing.default);
+    const change = button("ai-link-btn", "Change\u2026", { fk: "route:change", ariaLabel: "Change the default model" });
+    change.setAttribute("aria-describedby", labelId);
+    change.addEventListener("click", () => openPage({ section: "routing" }));
+    line.append(label, value, change);
+    const n = draft.routing.default ? taskRouteNote({ ...draft, routing: { ...draft.routing, tasks: {} } }, session.statusList(), "chat") : { level: "info", text: "Tasks have nowhere to go until a default model is set." };
+    if (n) {
+      line.append(note(n.level, n.text, "ai-row-note"));
+    }
+    return line;
+  }
+  const featuresRow = ctx.makeRow("Features", "Turn each feature on or off.");
+  featuresRow.classList.add("ai-section");
+  const featureRows = [];
+  const taskRows = [];
+  for (const def of AI_FEATURES) {
+    const planned = def.status === "planned";
+    const resolved = resolveAiFeature(session.draft.features, def.id);
+    const row = el("div", "settings-row settings-row--inline ai-feature");
+    row.classList.toggle("is-planned", planned);
+    const text = el("div", "settings-row-text");
+    const labelId = nextId("ai-feature");
+    const lbl = el("span", "settings-label", def.label);
+    lbl.id = labelId;
+    text.append(lbl, el("span", "settings-desc", def.description));
+    const controls = el("div", "ai-feature-controls");
+    if (planned) {
+      controls.append(el("span", "ai-pill ai-pill--soon", "Coming later"));
+      row.setAttribute("aria-disabled", "true");
+    } else {
+      if (tier === 2) {
+        taskRows.push(buildTaskRow(def));
+      }
+      const toggle = switchInput(resolved.enabled, def.label, `feature:${def.id}:enabled`);
+      toggle.setAttribute("aria-labelledby", labelId);
+      toggle.removeAttribute("aria-label");
+      toggle.addEventListener("change", () => {
+        const draft = session.draft;
+        session.draft = { ...draft, features: { ...draft.features, [def.id]: { ...draft.features[def.id] ?? {}, enabled: toggle.checked } } };
+      });
+      controls.append(toggle);
+    }
+    row.append(text, controls);
+    featureRows.push(row);
+  }
+  featuresRow.append(ctx.makeGroup(...featureRows));
+  if (taskRows.length > 0) {
+    featuresRow.append(...buildTaskDisclosure(taskRows));
+  }
+  function buildTaskRow(def) {
+    const defaultTask = getAiTask(def.defaultTask);
+    const row = el("div", "settings-row settings-row--inline ai-feature-task");
+    const labelId = nextId("ai-feature-task");
+    const lbl = el("span", "settings-label", def.label);
+    lbl.id = labelId;
+    const select = el("select", "settings-input settings-input--small");
+    select.dataset.fk = `feature:${def.id}:task`;
+    select.setAttribute("aria-label", `Task route for ${def.label}`);
+    const dflt = el("option", "", `Default task (${defaultTask?.label ?? def.defaultTask})`);
+    dflt.value = "";
+    select.append(dflt);
+    for (const task of AI_TASKS) {
+      if (task.hostMethod) {
+        continue;
+      }
+      const o = el("option", "", task.label);
+      o.value = task.id;
+      select.append(o);
+    }
+    const saved = session.draft.features[def.id]?.task;
+    if (saved && !AI_TASKS.some((t) => t.id === saved)) {
+      const o = el("option", "", saved);
+      o.value = saved;
+      select.append(o);
+    }
+    select.value = saved ?? "";
+    select.addEventListener("change", () => {
+      const draft = session.draft;
+      const entry = { ...draft.features[def.id] ?? {} };
+      if (select.value) {
+        entry.task = select.value;
+      } else {
+        delete entry.task;
+      }
+      session.draft = { ...draft, features: { ...draft.features, [def.id]: entry } };
+    });
+    row.append(lbl, select);
+    return row;
+  }
+  function buildTaskDisclosure(taskRowsIn) {
+    const panelId = nextId("ai-feature-tasks");
+    const toggle = button("ai-disclosure ai-feature-tasks-toggle", "Advanced: task per feature", { html: ICONS.chevron, fk: "features:advanced" });
+    toggle.setAttribute("aria-expanded", "false");
+    toggle.setAttribute("aria-controls", panelId);
+    const panel = el("div", "ai-advanced ai-feature-tasks");
+    panel.id = panelId;
+    panel.hidden = true;
+    panel.append(el("div", "settings-desc", "Each feature uses its own task\u2019s model (see Tasks on the AI Engines page). Pick another task to borrow its model."), ctx.makeGroup(...taskRowsIn));
+    toggle.addEventListener("click", () => {
+      panel.hidden = !panel.hidden;
+      toggle.setAttribute("aria-expanded", String(!panel.hidden));
+    });
+    return [toggle, panel];
+  }
+  const localNetsRow = ctx.makeRow("Local networks", "Networks and host names that count as local, so an engine there never needs Allow cloud.");
+  localNetsRow.classList.add("ai-section");
+  {
+    const panelId = nextId("ai-local-networks");
+    const toggle = button("ai-disclosure ai-local-networks-toggle", "Advanced: local networks", { html: ICONS.chevron, fk: "local-networks:advanced" });
+    toggle.setAttribute("aria-expanded", "false");
+    toggle.setAttribute("aria-controls", panelId);
+    const panel = el("div", "ai-advanced ai-local-networks");
+    panel.id = panelId;
+    panel.hidden = true;
+    const area = el("textarea", "settings-input ai-mono ai-overrides-text");
+    area.rows = 4;
+    area.spellcheck = false;
+    area.dataset.fk = "ai-local-networks";
+    area.placeholder = "10.0.98.0/24\n.ts.net";
+    area.value = session.draft.localNetworks.join("\n");
+    area.setAttribute("aria-label", "Local networks, one per line");
+    const err = el("div", "ai-field-error");
+    err.id = nextId("ai-local-networks-error");
+    err.setAttribute("aria-live", "polite");
+    area.setAttribute("aria-describedby", err.id);
+    area.addEventListener("input", () => {
+      const parsed = parseLocalNetworksText(area.value);
+      if (!parsed.ok) {
+        err.textContent = parsed.error;
+        area.setAttribute("aria-invalid", "true");
+        return;
+      }
+      err.textContent = "";
+      area.removeAttribute("aria-invalid");
+      session.draft = { ...session.draft, localNetworks: parsed.value };
+      if (canManage) {
+        renderEngines();
+      }
+    });
+    area.addEventListener("blur", () => {
+      if (area.getAttribute("aria-invalid") !== "true") {
+        area.value = session.draft.localNetworks.join("\n");
+      }
+    });
+    panel.append(
+      el("div", "settings-desc", "One per line. An IPv4 range such as 10.0.98.0/24 (a WireGuard network, say) or a host-name suffix such as .ts.net. Loopback, link-local, .local, .lan and .home.arpa always count. Leave it blank for the defaults (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16). Saved to your user settings only, never to a folder."),
+      area,
+      err
+    );
+    toggle.addEventListener("click", () => {
+      panel.hidden = !panel.hidden;
+      toggle.setAttribute("aria-expanded", String(!panel.hidden));
+    });
+    localNetsRow.append(toggle, panel);
+  }
+  rows.push(masterField.row);
+  if (tier === 2) {
+    if (canManage) {
+      rows.push(enginesRow);
+      renderEngines();
+    }
+    rows.push(cloudField.row);
+    if (listConsents && forgetConsent) {
+      rows.push(consentsRow);
+      void refreshConsents();
+    }
+  }
+  rows.push(toolbarField.row, featuresRow);
+  if (tier === 2) {
+    rows.push(localNetsRow);
+  }
+  rows.push(live);
+  const unsubscribe = canManage ? opts.subscribeStatuses?.((list) => {
+    if (!enginesRow.isConnected) {
+      return;
+    }
+    for (const s of list) {
+      session.statuses.set(s.engineId, s);
+    }
+    renderEngines();
+  }) : void 0;
+  if (canManage) {
+    void session.refreshStatuses().then((ok) => {
+      if (ok && enginesRow.isConnected) {
+        renderEngines();
+      }
+    });
+  }
+  const close = () => {
+    window.clearTimeout(liveTimer);
+    unsubscribe?.();
+  };
+  return {
+    rows,
+    collect: () => session.collect(),
+    onDiscarded: () => {
+      close();
+      session.discard();
+    },
+    onSaved: () => {
+      close();
+      opts.onSaved(session.commit());
+    }
+  };
+}
+
+// src/ai-toolbar.ts
+var AI_TURN_ON_PATCH = { "ai.enabled": true };
+function aiSetupTarget(tier, settings) {
+  if (tier !== 2) {
+    return { kind: "tab" };
+  }
+  const byRoute = settings.routing.default?.engineId;
+  const engineId = byRoute && settings.engines.some((e) => e.id === byRoute) ? byRoute : settings.engines[0]?.id;
+  return engineId ? { kind: "page", engineId } : { kind: "wizard" };
+}
+var THINKING_DEFAULT = "default";
+function thinkingRowEntry(row) {
+  const short = (label) => label === "Medium" ? "Med" : label;
+  return {
+    type: "segmented",
+    id: "ai-thinking",
+    label: "Thinking",
+    title: "Thinking level for the next AI requests",
+    options: [
+      { value: THINKING_DEFAULT, label: "Default", title: "Thinking: the model's default", spoken: "Default" },
+      ...row.choices.map((c) => ({ value: c.level, label: short(c.label), title: `Thinking: ${c.label}`, spoken: c.label }))
+    ],
+    value: () => row.value() ?? THINKING_DEFAULT,
+    onChange: (v) => row.onChange(v === THINKING_DEFAULT ? null : v),
+    classes: { group: "ai-rw-think", label: "ai-rw-think-label", segment: "ai-rw-think-seg" }
+  };
+}
+var SELECT_TEXT_HINT = "Select text first";
+var UNREACHABLE_REASON = /could not reach|no answer|timed out|ECONNREFUSED|ENOTFOUND|EHOSTUNREACH|fetch failed|connection refused/i;
+function aiMenuStatusLine(reason) {
+  const failed = /^(.+?) failed its last connection test/.exec(reason);
+  if (!failed) {
+    return { label: reason };
+  }
+  return UNREACHABLE_REASON.test(reason) ? { label: `${failed[1]} isn't reachable`, detail: reason } : { label: `${failed[1]} failed its last connection test`, detail: reason.slice(failed[0].length).replace(/^[:.\s]+/, "") || void 0 };
+}
+function sharedDisabledReason(states) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const state of states) {
+    if (state && !state.enabled && state.hint !== SELECT_TEXT_HINT) {
+      counts.set(state.hint, (counts.get(state.hint) ?? 0) + 1);
+    }
+  }
+  let best = null;
+  for (const [hint, n] of counts) {
+    if (n >= 2 && (best === null || n > counts.get(best))) {
+      best = hint;
+    }
+  }
+  return best;
+}
+function aiToolbarMenuEntries(input) {
+  const entries = [];
+  const separate = () => {
+    if (entries.length > 0 && entries[entries.length - 1].type !== "separator") {
+      entries.push({ type: "separator" });
+    }
+  };
+  const shared = sharedDisabledReason([input.rewrite, input.explain, input.translate, input.summarize, input.titles, input.properties]);
+  if (shared) {
+    const { label, detail } = aiMenuStatusLine(shared);
+    entries.push({ type: "status", id: "ai-status", label, ...detail ? { detail } : {} });
+    if (input.onRetest) {
+      entries.push({ type: "action", id: "ai-retest", label: "Look again", action: () => input.onRetest?.() });
+    }
+    entries.push({ type: "separator" });
+  }
+  const add = (id, label, icon2, state, run) => {
+    if (!state) {
+      return;
+    }
+    entries.push({
+      type: "action",
+      id,
+      label,
+      icon: icon2 ?? input.icons.rewrite,
+      hint: state.enabled || state.hint === shared ? void 0 : state.hint,
+      isDisabled: () => !state.enabled,
+      action: run
+    });
+  };
+  add("ai-rewrite", "Rewrite selection", input.icons.rewrite, input.rewrite, () => input.onRewrite());
+  add("ai-explain", "Explain selection", input.icons.explain, input.explain, () => input.onExplain?.());
+  add("ai-translate", "Translate\u2026", input.icons.translate, input.translate, () => input.onTranslate?.());
+  separate();
+  add("ai-summarize", "Summarize document\u2026", input.icons.summarize, input.summarize, () => input.onSummarize?.());
+  add("ai-titles", "Suggest titles\u2026", input.icons.titles, input.titles, () => input.onSuggestTitles?.());
+  add("ai-properties", "Suggest properties", input.icons.properties, input.properties, () => input.onSuggestProperties?.());
+  if (input.thinking && input.thinking.choices.length > 0) {
+    separate();
+    entries.push(thinkingRowEntry(input.thinking));
+  }
+  separate();
+  entries.push({
+    type: "action",
+    id: "ai-manage",
+    label: input.canManageEngines ? "Manage engines\u2026" : "AI settings\u2026",
+    icon: input.icons.manage,
+    action: () => input.onManage()
+  });
+  return entries;
+}
+var AI_FIRST_RUN_VERBS = "Rewrite, translate, explain, summarize, suggest titles and tags.";
+var AI_FIRST_RUN_NOTICE = "AI features are experimental, and AI output can be wrong, so review it.";
+var AI_FIRST_RUN_NONE = "Connect a provider you already use. Running models on this machine is under Advanced.";
+function aiDetectFoundText(name, models) {
+  const count = models === void 0 ? "" : `, ${models} ${models === 1 ? "model" : "models"}`;
+  return `${name} is running on this computer${count}.`;
+}
+var openPanel = null;
+function isAiFirstRunPanelOpen() {
+  return openPanel !== null;
+}
+function hideAiFirstRunPanel() {
+  openPanel?.close(false);
+}
+function showAiFirstRunPanel(opts) {
+  hideAiFirstRunPanel();
+  const { anchor } = opts;
+  const tier1 = opts.tier === 1;
+  const setUpLabel = tier1 ? "Turn on" : "Set up";
+  const panel = el("div", "ai-first-run");
+  panel.setAttribute("role", "dialog");
+  const titleId = nextId("ai-first-run-title");
+  const textId = nextId("ai-first-run-text");
+  panel.setAttribute("aria-labelledby", titleId);
+  panel.setAttribute("aria-describedby", textId);
+  const head = el("div", "ai-experimental-head");
+  const title = el("span", "ai-experimental-title", "AI features");
+  title.id = titleId;
+  head.append(title, experimentalBadge());
+  const verbs = el("p", "ai-first-run-verbs", AI_FIRST_RUN_VERBS);
+  const text = el("p", "ai-disclaimer ai-first-run-notice", `${AI_FIRST_RUN_NOTICE} `);
+  text.id = textId;
+  const notice = button("ai-link-btn ai-first-run-notice-toggle", "Read the full notice", { fk: "ai-first-run:notice" });
+  notice.setAttribute("aria-expanded", "false");
+  text.append(notice);
+  const fullNotice = el("p", "ai-disclaimer ai-first-run-notice-full", AI_EXPERIMENTAL_DISCLAIMER);
+  fullNotice.id = nextId("ai-first-run-notice-full");
+  fullNotice.hidden = true;
+  notice.setAttribute("aria-controls", fullNotice.id);
+  const status = el("div", "ai-first-run-status");
+  status.setAttribute("role", "status");
+  status.setAttribute("aria-live", "polite");
+  status.hidden = true;
+  const actions = el("div", "ai-first-run-actions");
+  const other = button("ai-link-btn ai-first-run-other", "Set up another way\u2026", { fk: "ai-first-run:other" });
+  other.hidden = true;
+  const cancel = button("settings-btn settings-btn--secondary", "Cancel", { fk: "ai-first-run:cancel" });
+  const primary = button("settings-btn settings-btn--primary", setUpLabel, { fk: "ai-first-run:turn-on" });
+  actions.append(other, cancel, primary);
+  const privacy = privacyLine(() => setUp());
+  privacy.hidden = true;
+  const learnMore = privacy.querySelector("button");
+  panel.append(head, verbs, text, fullNotice, status, privacy, actions);
+  let found = null;
+  let busy = false;
+  const detectAbort = new AbortController();
+  function setStatus(state, line = "") {
+    status.hidden = state === "hidden";
+    status.dataset.state = state;
+    status.replaceChildren();
+    if (state === "hidden") {
+      return;
+    }
+    if (state === "found") {
+      const dot = el("span", "ai-first-run-dot");
+      dot.setAttribute("aria-hidden", "true");
+      status.append(dot);
+    }
+    status.append(el("span", "", line));
+  }
+  let closed = false;
+  function close(restore) {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    detectAbort.abort();
+    document.removeEventListener("mousedown", onOutside, true);
+    panel.removeEventListener("keydown", onKeydown);
+    panel.remove();
+    if (openPanel?.element === panel) {
+      openPanel = null;
+    }
+    if (restore && anchor.isConnected) {
+      anchor.focus({ preventScroll: true });
+    }
+  }
+  function onOutside(e) {
+    const target = e.target;
+    if (!busy && !panel.contains(target) && !anchor.contains(target)) {
+      close(false);
+    }
+  }
+  function onKeydown(e) {
+    if (e.key === "Escape") {
+      e.preventDefault();
+      e.stopPropagation();
+      if (!busy) {
+        close(true);
+      }
+    } else if (e.key === "Tab") {
+      const order = [notice, learnMore, other, cancel, primary].filter((b) => !b.hidden && !b.closest("[hidden]") && !b.disabled);
+      if (order.length === 0) {
+        return;
+      }
+      e.preventDefault();
+      const at = order.indexOf(document.activeElement);
+      const next = at < 0 ? 0 : (at + (e.shiftKey ? order.length - 1 : 1)) % order.length;
+      order[next].focus();
+    }
+  }
+  function setUp() {
+    close(false);
+    opts.onTurnOn();
+  }
+  async function useLocal(server) {
+    if (!opts.onUseLocal) {
+      return;
+    }
+    busy = true;
+    for (const b of [notice, learnMore, other, cancel, primary]) {
+      b.disabled = true;
+    }
+    setStatus("working", `Setting up ${server.name}\u2026`);
+    try {
+      await opts.onUseLocal(server.presetId);
+      busy = false;
+      close(true);
+    } catch (err) {
+      busy = false;
+      if (closed) {
+        return;
+      }
+      found = null;
+      for (const b of [notice, learnMore, other, cancel, primary]) {
+        b.disabled = false;
+      }
+      other.hidden = true;
+      privacy.hidden = true;
+      primary.textContent = setUpLabel;
+      setStatus("error", err instanceof Error && err.message ? err.message : `${server.name} could not be set up.`);
+      primary.focus({ preventScroll: true });
+    }
+  }
+  notice.addEventListener("click", () => {
+    fullNotice.hidden = !fullNotice.hidden;
+    notice.setAttribute("aria-expanded", String(!fullNotice.hidden));
+    notice.textContent = fullNotice.hidden ? "Read the full notice" : "Hide the full notice";
+    position(panel, anchor);
+  });
+  cancel.addEventListener("click", () => close(true));
+  other.addEventListener("click", () => setUp());
+  primary.addEventListener("click", () => {
+    if (found) {
+      void useLocal(found);
+    } else {
+      setUp();
+    }
+  });
+  panel.addEventListener("keydown", onKeydown);
+  document.addEventListener("mousedown", onOutside, true);
+  if (opts.detect && !tier1) {
+    setStatus("looking", AI_DETECT_LOOKING);
+    void opts.detect(detectAbort.signal).then(
+      (result) => {
+        if (closed || busy) {
+          return;
+        }
+        if (result.kind === "found" && opts.onUseLocal) {
+          found = result;
+          primary.textContent = `Use ${result.name}`;
+          other.hidden = false;
+          privacy.hidden = false;
+          setStatus("found", aiDetectFoundText(result.name, result.models));
+        } else if (result.kind === "none") {
+          setStatus("none", AI_FIRST_RUN_NONE);
+        } else {
+          setStatus("hidden");
+        }
+        position(panel, anchor);
+      },
+      () => {
+        if (!closed && !busy) {
+          setStatus("hidden");
+        }
+      }
+    );
+  }
+  getPortal().appendChild(panel);
+  position(panel, anchor);
+  openPanel = { element: panel, close };
+  primary.focus({ preventScroll: true });
+  return { element: panel, close: () => close(true) };
+}
+function position(panel, anchor) {
+  const a = anchor.getBoundingClientRect();
+  const p = panel.getBoundingClientRect();
+  const vw = window.innerWidth;
+  const vh = window.innerHeight;
+  const bounds = anchor.closest(".mikedown-root")?.getBoundingClientRect();
+  const minLeft = Math.max(8, (bounds?.left ?? 0) + 8);
+  const maxLeft = Math.min(vw, bounds?.right ?? vw) - p.width - 8;
+  const left = Math.max(minLeft, Math.min(a.left + a.width / 2 - p.width / 2, maxLeft));
+  const below = vh - a.bottom >= p.height + 6 || vh - a.bottom >= a.top;
+  const top = below ? a.bottom + 6 : a.top - p.height - 6;
+  panel.style.left = `${left}px`;
+  panel.style.top = `${Math.max(8, Math.min(top, vh - p.height - 8))}px`;
+}
+
+// src/ai-request.ts
+function aiRunThinkingOn(thinking) {
+  return !!thinking && (thinking.sent ?? thinking.configured) !== "off";
+}
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function thinkingRequestOverrides(kind, modelOverrides, level, opts = {}) {
+  const out = withThinkingLevel(kind, void 0, level, opts);
+  if (!out || kind === "anthropic" || !modelOverrides) {
+    return out;
+  }
+  if (modelOverrides.reasoning_effort !== void 0 && out.reasoning_effort === void 0) {
+    out.reasoning_effort = "none";
+  }
+  const modelKwargs = modelOverrides.chat_template_kwargs;
+  const kwargs = isObject(out.chat_template_kwargs) ? out.chat_template_kwargs : {};
+  if (isObject(modelKwargs) && modelKwargs.enable_thinking !== void 0 && kwargs.enable_thinking === void 0) {
+    out.chat_template_kwargs = { ...kwargs, enable_thinking: true };
+  }
+  return out;
+}
+function routeThinking(settings, route, req) {
+  const engine = settings.engines.find((e) => e.id === route.engineId);
+  if (!engine || thinkingChoices(engine.kind).length === 0) {
+    return null;
+  }
+  const model = engine.models.find((m) => m.id === route.modelId);
+  const configured = thinkingLevelFrom(engine.kind, model?.requestOverrides);
+  const wanted = req.thinking;
+  const explicit = typeof wanted === "function" ? wanted(engine.kind) : wanted ?? null;
+  const { level, auto } = resolveThinkingLevel(engine.kind, explicit, configured, req.job ?? req.feature, { modelId: route.modelId });
+  const overrides = level ? thinkingRequestOverrides(engine.kind, model?.requestOverrides, level, { local: route.isLocal }) : void 0;
+  return {
+    info: { kind: engine.kind, configured, sent: overrides ? level : null, ...overrides && auto ? { auto: true } : {} },
+    ...overrides ? { overrides } : {},
+    contextTokens: model?.capabilities.contextTokens ?? null
+  };
+}
+function promptTokens(messages) {
+  let chars = 0;
+  for (const m of messages) {
+    if (typeof m.content === "string") {
+      chars += m.content.length;
+    } else {
+      for (const part of m.content) {
+        if (part.type === "text") {
+          chars += part.text.length;
+        }
+      }
+    }
+  }
+  return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function requestMaxTokens(req, thinking) {
+  if (req.maxTokens === void 0 || !thinking) {
+    return req.maxTokens;
+  }
+  const level = thinking.info.sent ?? thinking.info.configured;
+  return thinkingMaxTokens(req.maxTokens, level, { contextTokens: thinking.contextTokens, promptTokens: promptTokens(req.messages) });
+}
+var requestCounter = 0;
+function nextRequestId(feature) {
+  requestCounter += 1;
+  return `ai-${feature}-${Date.now().toString(36)}-${requestCounter}`;
+}
+function routeUnusableError(r) {
+  const map = {
+    cloudBlocked: "cloudBlocked",
+    consentDenied: "consentDenied",
+    probeFailed: "unreachable",
+    modelMissing: "modelNotFound",
+    modelNotListed: "modelNotFound"
+  };
+  const e = makeAiError(map[r.unusable] ?? "unknown", r.reason);
+  return r.engineId ? { ...e, engineId: r.engineId } : e;
+}
+function isTier2(ai) {
+  return typeof ai.listEngines === "function";
+}
+function withFailures(statuses, failed) {
+  if (failed.size === 0) {
+    return [...statuses];
+  }
+  const out = statuses.map((s) => failed.has(s.engineId) ? { ...s, ok: false, error: failed.get(s.engineId) } : s);
+  for (const [engineId, error] of failed) {
+    if (!out.some((s) => s.engineId === engineId)) {
+      out.push({ engineId, ok: false, isLocal: true, hasKey: false, error, models: [] });
+    }
+  }
+  return out;
+}
+async function runAiCompletion(ctx, req, events, signal) {
+  const tier2 = isTier2(ctx.ai);
+  const failed = /* @__PURE__ */ new Map();
+  const refused = {};
+  const once = {};
+  let retried = false;
+  for (let pass = 0; pass < 12; pass++) {
+    if (signal.aborted) {
+      throw makeAiError("cancelled");
+    }
+    let route = null;
+    if (tier2) {
+      const consent = { ...ctx.consent, ...once, ...refused };
+      const resolved = resolveRoute(ctx.settings(), withFailures(ctx.statuses(), failed), consent, { feature: req.feature, ...req.task ? { task: req.task } : {} });
+      if (!isRouteUsable(resolved)) {
+        throw routeUnusableError(resolved);
+      }
+      if (resolved.needsConsent) {
+        const reply = ctx.ai.requestCloudConsent ? await ctx.ai.requestCloudConsent(resolved.engineId, { feature: req.feature, ...req.sends ? { sends: req.sends } : {} }) : true;
+        if (signal.aborted) {
+          throw makeAiError("cancelled");
+        }
+        if (reply === true) {
+          ctx.consent[resolved.engineId] = true;
+        } else if (reply === "once") {
+          once[resolved.engineId] = true;
+        } else {
+          refused[resolved.engineId] = false;
+          if (reply === "never") {
+            ctx.consent[resolved.engineId] = false;
+          }
+        }
+        continue;
+      }
+      route = resolved;
+    }
+    const thinking = route ? routeThinking(ctx.settings(), route, req) : null;
+    const maxTokens = requestMaxTokens(req, thinking);
+    events.onRoute?.(route, thinking?.info ?? null);
+    let text = "";
+    let gotToken = false;
+    try {
+      const result = await ctx.ai.complete({
+        requestId: nextRequestId(req.feature),
+        feature: req.feature,
+        task: route?.task ?? req.task ?? resolveAiFeature(ctx.settings().features, req.feature).task,
+        ...route ? { route: { engineId: route.engineId, modelId: route.modelId } } : {},
+        messages: req.messages,
+        ...req.format ? { format: req.format } : {},
+        ...maxTokens !== void 0 ? { maxTokens } : {},
+        ...req.temperature !== void 0 ? { temperature: req.temperature } : {},
+        ...thinking?.overrides ? { requestOverrides: thinking.overrides } : {}
+      }, (delta) => {
+        if (signal.aborted) {
+          return;
+        }
+        gotToken = true;
+        text += delta;
+        events.onToken?.(delta, text);
+      }, signal);
+      return { result, route, viaFallback: route?.viaFallback ?? false, thinking: thinking?.info ?? null };
+    } catch (err) {
+      const e = signal.aborted ? makeAiError("cancelled") : toAiError(err);
+      if (e.code === "unreachable" && !gotToken && !retried && route) {
+        retried = true;
+        failed.set(route.engineId, e.message);
+        continue;
+      }
+      throw route && !e.engineId && e.code !== "cancelled" ? { ...e, engineId: route.engineId } : e;
+    }
+  }
+  throw makeAiError("unknown", "No engine answered.");
+}
+function aiFeatureAvailability(ai, settings, statuses, consent, feature) {
+  if (!ai || !settings.enabled) {
+    return { state: "hidden" };
+  }
+  if (!resolveAiFeature(settings.features, feature).enabled) {
+    return { state: "hidden" };
+  }
+  if (!isTier2(ai)) {
+    return { state: "enabled" };
+  }
+  const answers = {};
+  for (const [id, v] of Object.entries(consent)) {
+    if (typeof v === "boolean") {
+      answers[id] = v;
+    }
+  }
+  const r = resolveRoute(settings, statuses, answers, { feature });
+  return isRouteUsable(r) ? { state: "enabled" } : { state: "disabled", reason: r.reason };
+}
+
+// src/ai-rewrite.ts
+import { elementFromString, posToDOMRect } from "@tiptap/core";
+import { TextSelection } from "@tiptap/pm/state";
+import { DOMParser as PmDOMParser, Fragment } from "@tiptap/pm/model";
+import { closeHistory } from "@tiptap/pm/history";
+import { EditorView as CmEditorView } from "@codemirror/view";
+import { isolateHistory } from "@codemirror/commands";
+
+// src/ai-markdown-preview.ts
+var FENCE = /^ {0,3}(`{3,}|~{3,})/;
+var HEADING = /^ {0,3}(#{1,6})[ \t]+(.*?)(?:[ \t]+#+)?[ \t]*$/;
+var ITEM = /^([ \t]*)([-*+]|\d{1,9}[.)])[ \t]+(.*)$/;
+var QUOTE = /^ {0,3}>[ \t]?(.*)$/;
+var RULE = /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/;
+var isSpace = (c) => c === void 0 || /\s/.test(c);
+var isWord = (c) => c !== void 0 && /[\p{L}\p{N}]/u.test(c);
+function make(tag, className) {
+  const node = document.createElement(tag);
+  if (className) {
+    node.className = className;
+  }
+  return node;
+}
+function findCloser(s, delim, from) {
+  for (let j = s.indexOf(delim, from); j !== -1; j = s.indexOf(delim, j + 1)) {
+    if (s[j - 1] === "\\" || isSpace(s[j - 1])) {
+      continue;
+    }
+    if (delim.length === 1 && (s[j + 1] === delim || s[j - 1] === delim)) {
+      continue;
+    }
+    if (delim === "_" && isWord(s[j + 1])) {
+      continue;
+    }
+    return j;
+  }
+  return -1;
+}
+function linkEnd(s, close) {
+  if (s[close + 1] !== "(") {
+    return -1;
+  }
+  let depth = 0;
+  for (let k = close + 1; k < s.length; k++) {
+    if (s[k] === "\n") {
+      return -1;
+    }
+    if (s[k] === "(") {
+      depth++;
+    } else if (s[k] === ")" && --depth === 0) {
+      return k + 1;
+    }
+  }
+  return -1;
+}
+function matchingBracket(s, open) {
+  let depth = 0;
+  for (let k = open; k < s.length; k++) {
+    if (s[k] === "\\") {
+      k++;
+    } else if (s[k] === "[") {
+      depth++;
+    } else if (s[k] === "]" && --depth === 0) {
+      return k;
+    }
+  }
+  return -1;
+}
+function appendInline(parent, s) {
+  let buf = "";
+  const flush = () => {
+    if (buf) {
+      parent.appendChild(document.createTextNode(buf));
+      buf = "";
+    }
+  };
+  const wrap = (tag, inner, className) => {
+    flush();
+    const node = make(tag, className);
+    appendInline(node, inner);
+    parent.appendChild(node);
+  };
+  let i = 0;
+  while (i < s.length) {
+    const c = s[i];
+    if (c === "\\" && i + 1 < s.length && /[\\`*_{}[\]()#+\-.!~>|]/.test(s[i + 1])) {
+      buf += s[i + 1];
+      i += 2;
+      continue;
+    }
+    if (c === "`") {
+      let n = 1;
+      while (s[i + n] === "`") {
+        n++;
+      }
+      const run = "`".repeat(n);
+      const end = s.indexOf(run, i + n);
+      if (end !== -1 && s[end + n] !== "`") {
+        flush();
+        const code = make("code");
+        code.textContent = s.slice(i + n, end).replace(/^ (.*) $/, "$1");
+        parent.appendChild(code);
+        i = end + n;
+        continue;
+      }
+      buf += run;
+      i += n;
+      continue;
+    }
+    if (c === "*" || c === "_") {
+      const doubled = s[i + 1] === c;
+      const delim = doubled ? c + c : c;
+      const after = s[i + delim.length];
+      const leftOk = c === "*" || !isWord(s[i - 1]);
+      if (leftOk && !isSpace(after) && after !== c) {
+        const end = findCloser(s, delim, i + delim.length);
+        if (end > i + delim.length) {
+          wrap(doubled ? "strong" : "em", s.slice(i + delim.length, end));
+          i = end + delim.length;
+          continue;
+        }
+      }
+      buf += delim;
+      i += delim.length;
+      continue;
+    }
+    if (c === "~" && s[i + 1] === "~" && !isSpace(s[i + 2])) {
+      const end = findCloser(s, "~~", i + 2);
+      if (end > i + 2) {
+        wrap("del", s.slice(i + 2, end));
+        i = end + 2;
+        continue;
+      }
+    }
+    if (c === "[" || c === "!" && s[i + 1] === "[") {
+      const open = c === "!" ? i + 1 : i;
+      const close = matchingBracket(s, open);
+      const end = close === -1 ? -1 : linkEnd(s, close);
+      if (end !== -1) {
+        wrap("span", s.slice(open + 1, close), c === "!" ? "ai-rw-md-image" : "ai-rw-md-link");
+        i = end;
+        continue;
+      }
+    }
+    buf += c;
+    i++;
+  }
+  flush();
+}
+var indentOf = (ws) => ws.replace(/\t/g, "    ").length;
+function renderPreviewMarkdown(into, markdown) {
+  const out = [];
+  const lines = markdown.replace(/\r\n?/g, "\n").split("\n");
+  let i = 0;
+  const startsBlock = (line) => FENCE.test(line) || HEADING.test(line) || ITEM.test(line) || QUOTE.test(line) || RULE.test(line);
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line.trim()) {
+      i++;
+      continue;
+    }
+    const fence = FENCE.exec(line);
+    if (fence) {
+      const marker = fence[1];
+      const body = [];
+      i++;
+      while (i < lines.length && !new RegExp(`^ {0,3}${marker[0]}{${marker.length},}[ \\t]*$`).test(lines[i])) {
+        body.push(lines[i++]);
+      }
+      i++;
+      const pre = make("pre", "ai-rw-md-pre");
+      const code = make("code");
+      code.textContent = body.join("\n");
+      pre.appendChild(code);
+      out.push(pre);
+      continue;
+    }
+    const heading = HEADING.exec(line);
+    if (heading) {
+      const node = make("div", "ai-rw-md-h");
+      node.dataset.level = String(heading[1].length);
+      appendInline(node, heading[2]);
+      out.push(node);
+      i++;
+      continue;
+    }
+    if (RULE.test(line)) {
+      out.push(make("hr", "ai-rw-md-hr"));
+      i++;
+      continue;
+    }
+    if (QUOTE.test(line)) {
+      const inner = [];
+      while (i < lines.length && QUOTE.test(lines[i])) {
+        inner.push(QUOTE.exec(lines[i++])[1]);
+      }
+      const quote = make("blockquote", "ai-rw-md-quote");
+      renderPreviewMarkdown(quote, inner.join("\n"));
+      out.push(quote);
+      continue;
+    }
+    if (ITEM.test(line)) {
+      const stack = [];
+      const roots = [];
+      while (i < lines.length) {
+        const m = ITEM.exec(lines[i]);
+        if (!m) {
+          if (lines[i].trim() && /^[ \t]+\S/.test(lines[i]) && !startsBlock(lines[i]) && stack.length) {
+            const item = stack[stack.length - 1].item;
+            item.appendChild(document.createTextNode(`
+${lines[i].trim()}`));
+            i++;
+            continue;
+          }
+          if (!lines[i].trim() && ITEM.test(lines[i + 1] ?? "")) {
+            i++;
+            continue;
+          }
+          break;
+        }
+        const indent = indentOf(m[1]);
+        const ordered = /\d/.test(m[2]);
+        while (stack.length && indent < stack[stack.length - 1].indent) {
+          stack.pop();
+        }
+        let top = stack[stack.length - 1];
+        if (top && indent === top.indent && ordered !== top.ordered) {
+          stack.pop();
+          top = stack[stack.length - 1];
+        }
+        if (!top || indent > top.indent) {
+          const list = make(ordered ? "ol" : "ul", "ai-rw-md-list");
+          if (ordered) {
+            const start = parseInt(m[2], 10);
+            if (start !== 1) {
+              list.setAttribute("start", String(start));
+            }
+          }
+          if (top?.item) {
+            top.item.appendChild(list);
+          } else {
+            roots.push(list);
+          }
+          top = { indent, ordered, list, item: null };
+          stack.push(top);
+        }
+        const li = make("li");
+        appendInline(li, m[3]);
+        top.list.appendChild(li);
+        top.item = li;
+        i++;
+      }
+      out.push(...roots);
+      continue;
+    }
+    const para = [];
+    while (i < lines.length && lines[i].trim() && (para.length === 0 || !startsBlock(lines[i]))) {
+      para.push(lines[i++]);
+    }
+    const p = make("p", "ai-rw-md-p");
+    appendInline(p, para.join("\n"));
+    out.push(p);
+  }
+  into.replaceChildren(...out);
+}
+
+// src/ai-rewrite.ts
+var nextTargetId = 0;
+function serializeFragment(editor, fragment) {
+  const storage = editor.storage.markdown;
+  try {
+    const md = storage?.serializer?.serialize(fragment);
+    if (typeof md === "string") {
+      return md;
+    }
+  } catch {
+  }
+  return fragment.textBetween(0, fragment.size, "\n\n");
+}
+function serializeRange(editor, doc, from, to) {
+  const content = doc.slice(from, to).content;
+  const parent = doc.resolve(from).parent;
+  const paragraph = editor.state.schema.nodes.paragraph;
+  if (content.firstChild?.isInline && !parent.type.spec.code && paragraph) {
+    return serializeFragment(editor, Fragment.from(paragraph.create(null, content)));
+  }
+  return serializeFragment(editor, content);
+}
+function markdownStorage(editor) {
+  return editor.storage.markdown;
+}
+function parseBlocks(editor, markdown) {
+  const html = markdownStorage(editor)?.parser?.parse(markdown) ?? markdown;
+  return PmDOMParser.fromSchema(editor.state.schema).parse(elementFromString(html)).content;
+}
+function blockquoteMarkdown(text) {
+  return text.trim().split("\n").map((line) => line.trim() ? `> ${line}` : ">").join("\n");
+}
+function visibleTopRect(el3) {
+  const r = el3.getBoundingClientRect();
+  const top = Math.max(r.top, 8);
+  return new DOMRect(r.left, top, Math.max(1, r.width), 1);
+}
+function rectUnion(a, b) {
+  const left = Math.min(a.left, b.left);
+  const top = Math.min(a.top, b.top);
+  return new DOMRect(left, top, Math.max(a.right, b.right) - left, Math.max(a.bottom, b.bottom) - top);
+}
+function richRewriteTarget(editor) {
+  const { state } = editor;
+  const sel = state.selection;
+  if ("$anchorCell" in sel) {
+    return null;
+  }
+  let from = sel.from;
+  let to = sel.to;
+  if (sel.empty) {
+    const $f = sel.$from;
+    if (!$f.parent.isTextblock || $f.parent.type.spec.code || !$f.parent.textContent.trim()) {
+      return null;
+    }
+    from = $f.start();
+    to = $f.end();
+  }
+  const doc = state.doc;
+  if (!doc.textBetween(from, to, " ").trim()) {
+    return null;
+  }
+  const text = serializeRange(editor, doc, from, to);
+  if (!text.trim()) {
+    return null;
+  }
+  const $from = doc.resolve(from);
+  const $to = doc.resolve(to);
+  const beforeStart = $from.depth > 0 ? $from.posAtIndex(Math.max(0, $from.index(0) - 1), 0) : 0;
+  const afterEnd = $to.depth > 0 ? $to.posAtIndex(Math.min(doc.childCount, $to.index(0) + 2), 0) : doc.content.size;
+  const before = beforeStart < from ? serializeRange(editor, doc, beforeStart, from) : "";
+  const after = afterEnd > to ? serializeRange(editor, doc, to, afterEnd) : "";
+  const id = ++nextTargetId;
+  editor.view.dispatch(state.tr.setMeta(aiRewriteHighlightKey, { range: { from, to, id } }).setMeta("addToHistory", false));
+  const range = () => {
+    if (editor.isDestroyed) {
+      return null;
+    }
+    const r = aiRewriteHighlightKey.getState(editor.state);
+    return r && r.id === id ? r : null;
+  };
+  return {
+    mode: "rich",
+    scope: "selection",
+    text,
+    before,
+    after,
+    multiline: text.trim().includes("\n"),
+    alive: () => !!range(),
+    rect() {
+      const r = range();
+      if (!r) {
+        return null;
+      }
+      try {
+        return posToDOMRect(editor.view, r.from, r.to);
+      } catch {
+        return null;
+      }
+    },
+    accept(markdown) {
+      const r = range();
+      if (!r || editor.isDestroyed) {
+        return false;
+      }
+      const current = editor.state;
+      const html = markdownStorage(editor)?.parser?.parse(markdown, { inline: true }) ?? markdown;
+      const slice = PmDOMParser.fromSchema(current.schema).parseSlice(elementFromString(html), {
+        preserveWhitespace: true,
+        context: current.doc.resolve(r.from)
+      });
+      let { from: from2, to: to2 } = r;
+      const $a = current.doc.resolve(from2);
+      const $b = current.doc.resolve(to2);
+      if (slice.content.firstChild?.isBlock && $a.parent.isTextblock && $b.parent.isTextblock && $a.parentOffset === 0 && $b.parentOffset === $b.parent.content.size && $a.depth === $b.depth && $a.node($a.depth - 1) === $b.node($b.depth - 1)) {
+        from2 = $a.before();
+        to2 = $b.after();
+      }
+      const tr = closeHistory(current.tr).replaceRange(from2, to2, slice);
+      tr.setMeta(aiRewriteHighlightKey, { range: null });
+      const end = tr.mapping.map(to2, 1);
+      try {
+        tr.setSelection(TextSelection.between(tr.doc.resolve(Math.min(from2, tr.doc.content.size)), tr.doc.resolve(Math.min(end, tr.doc.content.size))));
+      } catch {
+      }
+      editor.view.dispatch(tr.scrollIntoView());
+      return true;
+    },
+    insertBelow(markdown) {
+      const r = range();
+      if (!r || editor.isDestroyed) {
+        return false;
+      }
+      const current = editor.state;
+      const content = parseBlocks(editor, blockquoteMarkdown(markdown));
+      if (!content.size) {
+        return false;
+      }
+      const $to2 = current.doc.resolve(r.to);
+      const pos = $to2.depth > 0 ? $to2.after(1) : r.to;
+      editor.view.dispatch(closeHistory(current.tr).insert(pos, content).scrollIntoView());
+      return true;
+    },
+    release() {
+      if (!range()) {
+        return;
+      }
+      editor.view.dispatch(editor.state.tr.setMeta(aiRewriteHighlightKey, { range: null }).setMeta("addToHistory", false));
+    },
+    focus() {
+      if (!editor.isDestroyed) {
+        editor.view.focus();
+      }
+    }
+  };
+}
+function sourceRewriteTarget(view) {
+  const { state } = view;
+  const sel = state.selection.main;
+  let { from, to } = sel;
+  if (sel.empty) {
+    const line = state.doc.lineAt(from);
+    if (!line.text.trim()) {
+      return null;
+    }
+    from = line.from;
+    to = line.to;
+  }
+  const text = state.sliceDoc(from, to);
+  if (!text.trim()) {
+    return null;
+  }
+  const before = state.sliceDoc(Math.max(0, from - REWRITE_CONTEXT_CHARS * 2), from);
+  const after = state.sliceDoc(to, Math.min(state.doc.length, to + REWRITE_CONTEXT_CHARS * 2));
+  const id = ++nextTargetId;
+  view.dispatch({ effects: setCmRewriteRange.of({ from, to, id }) });
+  const range = () => {
+    const r = view.state.field(cmRewriteRange, false);
+    return r && r.id === id ? r : null;
+  };
+  return {
+    mode: "source",
+    scope: "selection",
+    text,
+    before,
+    after,
+    multiline: text.trim().includes("\n"),
+    alive: () => !!range(),
+    rect() {
+      const r = range();
+      if (!r) {
+        return null;
+      }
+      const a = view.coordsAtPos(r.from);
+      const b = view.coordsAtPos(r.to, -1);
+      if (!a || !b) {
+        return a ? rectUnion(a, a) : b ? rectUnion(b, b) : null;
+      }
+      if (b.top > a.top + 1) {
+        const content = view.contentDOM.getBoundingClientRect();
+        return rectUnion(a, { ...b, left: content.left, right: Math.max(a.right, b.right) });
+      }
+      return rectUnion(a, b);
+    },
+    accept(markdown) {
+      const r = range();
+      if (!r) {
+        return false;
+      }
+      view.dispatch({
+        changes: { from: r.from, to: r.to, insert: markdown },
+        selection: { anchor: r.from, head: r.from + markdown.length },
+        effects: setCmRewriteRange.of(null),
+        annotations: isolateHistory.of("full"),
+        userEvent: "input.ai",
+        scrollIntoView: true
+      });
+      return true;
+    },
+    insertBelow(markdown) {
+      const r = range();
+      if (!r) {
+        return false;
+      }
+      const doc = view.state.doc;
+      const endLine = doc.lineAt(r.to);
+      const line = r.to > r.from && endLine.from === r.to ? doc.lineAt(r.to - 1) : endLine;
+      const next = line.number < doc.lines ? doc.line(line.number + 1) : null;
+      const insert = `
+
+${blockquoteMarkdown(markdown)}${next && next.text.trim() ? "\n" : ""}`;
+      view.dispatch({
+        changes: { from: line.to, insert },
+        annotations: isolateHistory.of("full"),
+        userEvent: "input.ai",
+        scrollIntoView: true
+      });
+      return true;
+    },
+    release() {
+      if (range()) {
+        view.dispatch({ effects: setCmRewriteRange.of(null) });
+      }
+    },
+    focus() {
+      view.focus();
+    }
+  };
+}
+function richDocumentTarget(editor, opts = {}) {
+  if (editor.isDestroyed) {
+    return null;
+  }
+  const text = markdownStorage(editor)?.getMarkdown?.() ?? editor.state.doc.textBetween(0, editor.state.doc.content.size, "\n\n");
+  if (!text.trim()) {
+    return null;
+  }
+  return {
+    mode: "rich",
+    scope: "document",
+    text,
+    before: "",
+    after: "",
+    multiline: false,
+    alive: () => !editor.isDestroyed,
+    rect: () => editor.isDestroyed ? null : visibleTopRect(editor.view.dom),
+    accept(markdown) {
+      if (editor.isDestroyed) {
+        return false;
+      }
+      const current = editor.state;
+      const content = parseBlocks(editor, markdown);
+      if (!content.size) {
+        return false;
+      }
+      const tr = closeHistory(current.tr).replaceWith(0, current.doc.content.size, content);
+      tr.setMeta(aiRewriteHighlightKey, { range: null });
+      tr.setSelection(TextSelection.atStart(tr.doc));
+      editor.view.dispatch(tr.scrollIntoView());
+      opts.scrollToTop?.();
+      return true;
+    },
+    insertBelow: () => false,
+    release() {
+    },
+    focus() {
+      if (!editor.isDestroyed) {
+        editor.view.focus();
+      }
+    }
+  };
+}
+function sourceDocumentTarget(view, bodyStart) {
+  const full = view.state.doc.toString();
+  const text = full.slice(bodyStart(full));
+  if (!text.trim()) {
+    return null;
+  }
+  return {
+    mode: "source",
+    scope: "document",
+    text,
+    before: "",
+    after: "",
+    multiline: false,
+    alive: () => view.dom.isConnected,
+    rect: () => visibleTopRect(view.scrollDOM),
+    accept(markdown) {
+      const current = view.state.doc.toString();
+      const from = bodyStart(current);
+      view.dispatch({
+        changes: { from, to: current.length, insert: markdown },
+        selection: { anchor: from },
+        effects: [setCmRewriteRange.of(null), CmEditorView.scrollIntoView(0, { y: "start" })],
+        annotations: isolateHistory.of("full"),
+        userEvent: "input.ai"
+      });
+      return true;
+    },
+    insertBelow: () => false,
+    release() {
+    },
+    focus() {
+      view.focus();
+    }
+  };
+}
+function cursorInsertTarget(editor, slash) {
+  if (editor.isDestroyed) {
+    return null;
+  }
+  const { state } = editor;
+  const id = ++nextTargetId;
+  const head = state.selection.head;
+  const initial = slash && slash.to > slash.from ? { from: slash.from, to: slash.to, id } : { from: head, to: head, id, anchor: true };
+  editor.view.dispatch(state.tr.setMeta(aiRewriteHighlightKey, { range: initial }).setMeta("addToHistory", false));
+  const range = () => {
+    if (editor.isDestroyed) {
+      return null;
+    }
+    const r = aiRewriteHighlightKey.getState(editor.state);
+    return r && r.id === id ? r : null;
+  };
+  return {
+    mode: "rich",
+    scope: "cursor",
+    text: "",
+    before: "",
+    after: "",
+    multiline: false,
+    alive: () => !!range(),
+    range() {
+      const r = range();
+      return r ? { from: r.from, to: r.to } : null;
+    },
+    rect() {
+      const r = range();
+      if (!r) {
+        return null;
+      }
+      try {
+        return posToDOMRect(editor.view, r.from, r.to);
+      } catch {
+        return null;
+      }
+    },
+    accept(markdown) {
+      const r = range();
+      if (!r || editor.isDestroyed) {
+        return false;
+      }
+      const content = parseBlocks(editor, markdown);
+      if (!content.size) {
+        return false;
+      }
+      const current = editor.state;
+      const tr = closeHistory(current.tr);
+      let at = r.from;
+      if (r.to > r.from) {
+        const $q = current.doc.resolve(r.from);
+        if ($q.parentOffset > 0 && current.doc.textBetween(r.from - 1, r.from) === " ") {
+          at = r.from - 1;
+        }
+        tr.delete(at, r.to);
+      }
+      tr.setMeta(aiRewriteHighlightKey, { range: null });
+      const $at = tr.doc.resolve(Math.min(at, tr.doc.content.size));
+      let from = $at.pos;
+      let to = $at.pos;
+      if ($at.depth > 0) {
+        const block = $at.node(1);
+        const empty = block.type.name === "paragraph" && block.content.size === 0;
+        from = empty ? $at.before(1) : $at.after(1);
+        to = empty ? $at.after(1) : from;
+      }
+      tr.replaceWith(from, to, content);
+      const end = Math.min(from + content.size, tr.doc.content.size);
+      try {
+        tr.setSelection(TextSelection.near(tr.doc.resolve(end), -1));
+      } catch {
+      }
+      editor.view.dispatch(tr.scrollIntoView());
+      return true;
+    },
+    insertBelow: () => false,
+    release() {
+      if (!range()) {
+        return;
+      }
+      editor.view.dispatch(editor.state.tr.setMeta(aiRewriteHighlightKey, { range: null }).setMeta("addToHistory", false));
+    },
+    focus() {
+      if (!editor.isDestroyed) {
+        editor.view.focus();
+      }
+    }
+  };
+}
+function sourceCursorTarget(view, bodyStart) {
+  const id = ++nextTargetId;
+  const head = view.state.selection.main.head;
+  view.dispatch({ effects: setCmRewriteRange.of({ from: head, to: head, id, anchor: true }) });
+  const range = () => {
+    const r = view.state.field(cmRewriteRange, false);
+    return r && r.id === id ? r : null;
+  };
+  return {
+    mode: "source",
+    scope: "cursor",
+    text: "",
+    before: "",
+    after: "",
+    multiline: false,
+    alive: () => !!range() && view.dom.isConnected,
+    range() {
+      const r = range();
+      return r ? { from: r.from, to: r.to } : null;
+    },
+    rect() {
+      const r = range();
+      const c = r ? view.coordsAtPos(r.from) : null;
+      return c ? rectUnion(c, c) : null;
+    },
+    accept(markdown) {
+      const r = range();
+      const md = markdown.trim();
+      if (!r || !md) {
+        return false;
+      }
+      const doc = view.state.doc;
+      const start = bodyStart ? bodyStart(doc.toString()) : 0;
+      const line = doc.lineAt(Math.max(r.from, Math.min(start, doc.length)));
+      const prev = line.number > 1 ? doc.line(line.number - 1) : null;
+      const next = line.number < doc.lines ? doc.line(line.number + 1) : null;
+      const textAfter = !!next && !!next.text.trim();
+      let changes;
+      let caret;
+      if (!line.text.trim()) {
+        const lead = prev && prev.text.trim() && line.from >= start ? "\n" : "";
+        changes = { from: line.from, to: line.to, insert: `${lead}${md}${textAfter ? "\n" : ""}` };
+        caret = line.from + lead.length + md.length;
+      } else {
+        changes = { from: line.to, insert: `
+
+${md}${textAfter ? "\n" : ""}` };
+        caret = line.to + 2 + md.length;
+      }
+      view.dispatch({
+        changes,
+        selection: { anchor: caret },
+        effects: setCmRewriteRange.of(null),
+        annotations: isolateHistory.of("full"),
+        userEvent: "input.ai",
+        scrollIntoView: true
+      });
+      return true;
+    },
+    insertBelow: () => false,
+    release() {
+      if (range()) {
+        view.dispatch({ effects: setCmRewriteRange.of(null) });
+      }
+    },
+    focus() {
+      view.focus();
+    }
+  };
+}
+var AI_TITLE_EFFECT_HINTS = {
+  frontmatter: "Sets title: in Properties",
+  h1: "Replaces the H1",
+  insertH1: "Inserts an H1"
+};
+function yamlHasTitle(yaml) {
+  return /^title[ \t]*:/m.test(yaml ?? "");
+}
+function setYamlTitle(yaml, title) {
+  const lines = yaml.split("\n");
+  const i = lines.findIndex((l) => /^title[ \t]*:/.test(l));
+  if (i < 0) {
+    return yaml;
+  }
+  let end = i + 1;
+  while (end < lines.length && /^[ \t]+\S/.test(lines[end])) {
+    end++;
+  }
+  lines.splice(i, end - i, `title: ${yamlScalar(title)}`);
+  return lines.join("\n");
+}
+function yamlScalar(s) {
+  const plain = !/[:#[\]{},&*!|>'"%@`]/.test(s) && !/^\s|\s$/.test(s) && !/^(-?\d+(\.\d+)?|true|false|null|yes|no|on|off|~|-.*)$/i.test(s);
+  return plain && s ? s : `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function applyRichTitle(editor, effect, title, remove) {
+  if (editor.isDestroyed || !title.trim()) {
+    return false;
+  }
+  const { schema } = editor.state;
+  const heading = schema.nodes.heading;
+  if (!heading) {
+    return false;
+  }
+  const tr = closeHistory(editor.state.tr);
+  if (remove && remove.to > remove.from) {
+    tr.delete(remove.from, remove.to);
+  }
+  tr.setMeta(aiRewriteHighlightKey, { range: null });
+  let h1 = null;
+  if (effect === "h1") {
+    tr.doc.descendants((node, pos) => {
+      if (h1) {
+        return false;
+      }
+      if (node.type === heading && node.attrs.level === 1) {
+        h1 = { pos, size: node.content.size };
+        return false;
+      }
+      return !node.isTextblock;
+    });
+  }
+  const found = h1;
+  if (found) {
+    tr.replaceWith(found.pos + 1, found.pos + 1 + found.size, schema.text(title));
+  } else {
+    tr.insert(0, heading.create({ level: 1 }, schema.text(title)));
+  }
+  editor.view.dispatch(tr.scrollIntoView());
+  return true;
+}
+function sourceH1Line(markdown, from) {
+  let pos = from;
+  let fence = null;
+  while (pos <= markdown.length) {
+    const nl = markdown.indexOf("\n", pos);
+    const end = nl < 0 ? markdown.length : nl;
+    const line = markdown.slice(pos, end);
+    const f = /^ {0,3}(`{3,}|~{3,})/.exec(line);
+    if (fence) {
+      if (f && f[1][0] === fence[0] && f[1].length >= fence.length && !line.trim().slice(f[1].length).trim()) {
+        fence = null;
+      }
+    } else if (f) {
+      fence = f[1];
+    } else {
+      const m = /^( {0,3}#[ \t]+)/.exec(line);
+      if (m) {
+        return { from: pos, to: end, prefix: m[1] };
+      }
+    }
+    if (nl < 0) {
+      break;
+    }
+    pos = nl + 1;
+  }
+  return null;
+}
+function applySourceTitle(view, effect, title, frontmatter) {
+  if (!title.trim()) {
+    return false;
+  }
+  const full = view.state.doc.toString();
+  let change;
+  if (effect === "frontmatter" && frontmatter.yaml !== null && yamlHasTitle(frontmatter.yaml)) {
+    const yamlFrom = full.indexOf("\n") + 1;
+    change = { from: yamlFrom, to: yamlFrom + frontmatter.yaml.length, insert: setYamlTitle(frontmatter.yaml, title) };
+  } else {
+    const h1 = effect === "insertH1" ? null : sourceH1Line(full, frontmatter.bodyStart);
+    change = h1 ? { from: h1.from + h1.prefix.length, to: h1.to, insert: title } : { from: frontmatter.bodyStart, to: frontmatter.bodyStart, insert: `# ${title}
+
+` };
+  }
+  view.dispatch({
+    changes: change,
+    effects: setCmRewriteRange.of(null),
+    annotations: isolateHistory.of("full"),
+    userEvent: "input.ai"
+  });
+  return true;
+}
+var icon = (body, size = 14) => `<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">${body}</svg>`;
+var SPARK = icon('<path d="M8 2.2l1.25 3.3 3.3 1.25-3.3 1.25L8 11.3 6.75 8 3.45 6.75 6.75 5.5z"/><path d="M12.6 10.6l.5 1.3 1.3.5-1.3.5-.5 1.3-.5-1.3-1.3-.5 1.3-.5z"/>');
+var CLOSE = icon('<path d="M4.5 4.5l7 7M11.5 4.5l-7 7"/>', 12);
+var LOCAL = icon('<path d="M2.5 7.5L8 3l5.5 4.5M4 6.5V13h8V6.5"/>', 11);
+var CLOUD = icon('<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);
+var ALERT = icon('<path d="M8 2.5l6 10.5H2z"/><path d="M8 6.5v3M8 11.4v.1"/>', 16);
+var WARN = icon('<path d="M8 2.5l6 10.5H2z"/><path d="M8 6.5v3M8 11.4v.1"/>', 12);
+var BACK = icon('<path d="M9.5 4L5.5 8l4 4"/>', 14);
+var CHECK = icon('<path d="M3.5 8.5l3 3 6-7"/>', 12);
+function el2(tag, className, text) {
+  const node = document.createElement(tag);
+  if (className) {
+    node.className = className;
+  }
+  if (text !== void 0) {
+    node.textContent = text;
+  }
+  return node;
+}
+function button2(className, label, onClick) {
+  const b = el2("button", className, label);
+  b.type = "button";
+  b.addEventListener("mousedown", (e) => e.preventDefault());
+  b.addEventListener("click", () => {
+    if (b.getAttribute("aria-disabled") !== "true") {
+      onClick();
+    }
+  });
+  return b;
+}
+var GROUP_LABELS = {
+  length: "Length",
+  tone: "Tone",
+  audience: "Audience",
+  translate: "Translate",
+  explain: "Explain",
+  custom: "Custom"
+};
+function aiRewriteMenuGroups() {
+  const groups = [];
+  for (const v of AI_REWRITE_VARIANTS) {
+    let g = groups.find((x) => x.group === v.group);
+    if (!g) {
+      g = { group: v.group, label: GROUP_LABELS[v.group], variants: [] };
+      groups.push(g);
+    }
+    g.variants.push(v);
+  }
+  return groups;
+}
+var STRUCTURE_CHECKED = /* @__PURE__ */ new Set(["translate", "simpler", "formal", "casual", "expand"]);
+var STRUCTURE_NOUNS = {
+  heading: ["heading", "headings"],
+  fencedCodeBlock: ["code block", "code blocks"],
+  inlineCode: ["inline code span", "inline code spans"],
+  link: ["link", "links"],
+  image: ["image", "images"],
+  listItem: ["list item", "list items"],
+  tableRow: ["table row", "table rows"],
+  wikilink: ["wikilink", "wikilinks"],
+  footnote: ["footnote reference", "footnote references"]
+};
+function structureWarningText(diff) {
+  if (diff.ok) {
+    return "";
+  }
+  const byKind = /* @__PURE__ */ new Map();
+  for (const m of diff.mismatches) {
+    const seen = byKind.get(m.kind);
+    if (seen) {
+      seen.original += m.original;
+      seen.result += m.result;
+    } else {
+      byKind.set(m.kind, { original: m.original, result: m.result, message: m.message });
+    }
+  }
+  const parts = [];
+  for (const [kind, m] of byKind) {
+    const [one, many] = STRUCTURE_NOUNS[kind];
+    const d = m.original - m.result;
+    const noun = Math.abs(d) === 1 ? one : many;
+    if (d > 0) {
+      parts.push(`${d} ${noun} missing in the result`);
+    } else if (d < 0) {
+      parts.push(`${-d} extra ${noun} in the result`);
+    } else if (kind === "link" || kind === "image") {
+      parts.push(`${many} point somewhere else in the result`);
+    } else {
+      parts.push(`${many} differ in the result`);
+    }
+  }
+  return `Check: ${parts.join("; ")}`;
+}
+function documentMaxTokens(text) {
+  return Math.max(1024, Math.min(16384, Math.ceil(text.length / CHARS_PER_TOKEN * 1.6) + 256));
+}
+var DOCUMENT_RESERVE_TOKENS = 768;
+function budgetTranslation(body, contextTokens) {
+  let maxTokens = documentMaxTokens(body);
+  let b = budgetDocument(body, { contextTokens, outputTokens: maxTokens, reserveTokens: DOCUMENT_RESERVE_TOKENS });
+  if (b.truncated) {
+    const room = Math.max(0, contextTokens - DOCUMENT_RESERVE_TOKENS);
+    maxTokens = Math.max(1024, Math.min(16384, Math.floor(room * 1.6 / 2.6)));
+    b = budgetDocument(body, { contextTokens, outputTokens: maxTokens, reserveTokens: DOCUMENT_RESERVE_TOKENS });
+    if (b.truncated) {
+      maxTokens = Math.min(maxTokens, documentMaxTokens(b.text));
+    }
+  }
+  return b.truncated ? { text: b.text, rest: body.slice(b.text.length), coverage: b.coverage, maxTokens } : { text: body, rest: "", coverage: 1, maxTokens };
+}
+function coverageNoteText(job, coverage) {
+  if (coverage >= 1) {
+    return "";
+  }
+  const pct = coveragePercent(coverage);
+  if (job === "translate") {
+    return `Translates the first ${pct}% of the document; the rest did not fit the model's context and stays as it is.`;
+  }
+  if (job === "titles") {
+    return `Based on the first ${pct}% of the document and all of its headings; the rest did not fit the model's context.`;
+  }
+  return `Covers the first ${pct}% of the document; the rest did not fit the model's context.`;
+}
+var SUMMARY_KIND_LABELS = { tldr: "TL;DR", outline: "Outline" };
+var REPAIR_NOTE = "Fixing the answer format\u2026";
+function hasParam(def, params) {
+  if (def?.param === "language") {
+    return !!params.language?.trim();
+  }
+  if (def?.param === "audience") {
+    return !!params.audience && !!getAiAudience(params.audience);
+  }
+  return true;
+}
+var plainLabel = (label) => label.replace(/…$/, "");
+var thinkingSegmentLabel = (label) => label === "Medium" ? "Med" : label;
+function thinkingInEffect(t) {
+  return t ? t.sent ?? t.configured : null;
+}
+var THINKING_DEFAULT2 = "default";
+var thinkingSelected = (t) => (t && !t.auto ? t.sent : null) ?? THINKING_DEFAULT2;
+var capitalizeFirst = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+function createAiRewritePopover(deps) {
+  let target = null;
+  let root = null;
+  let phase = "choose";
+  let variant = "shorter";
+  let instruction = "";
+  let params = {};
+  let picker = null;
+  let wholeDocument = false;
+  let docOnly = false;
+  let controller = null;
+  let runSeq = 0;
+  let raw = "";
+  let finalText = "";
+  let summaryCutOff = false;
+  let route = null;
+  let served = null;
+  let stats = null;
+  let viaFallback = false;
+  let thinking = null;
+  let error = null;
+  let errorCopy = null;
+  let unavailable = false;
+  let note2 = "";
+  let warning = null;
+  let job = "rewrite";
+  let summaryJob = null;
+  let titleJob = null;
+  let titles = [];
+  let coverage = 1;
+  let sentText = "";
+  let untranslated = "";
+  let repairing = false;
+  let side = null;
+  let frame = 0;
+  let copiedTimer;
+  let detach = [];
+  let titleEl;
+  let badgeEl;
+  let statsEl;
+  let thinkEl;
+  let chooseEl;
+  let menuEl;
+  let formEl;
+  let pickerEl;
+  let inputEl;
+  let bodyEl;
+  let oldTextEl;
+  let outEl;
+  let caretEl;
+  let newLabelEl;
+  let newPaneEl;
+  let errorEl;
+  let warnEl;
+  let footEl;
+  let acceptBtn;
+  let retryBtn;
+  let copyBtn;
+  let noteEl;
+  let closeBtn;
+  let liveEl;
+  let kindEl;
+  let coverageEl;
+  let titlesBoxEl;
+  let titlesEl;
+  let titleHintEl;
+  function abort() {
+    runSeq += 1;
+    controller?.abort();
+    controller = null;
+  }
+  function close(opts = {}) {
+    if (!target) {
+      return;
+    }
+    abort();
+    cancelAnimationFrame(frame);
+    window.clearTimeout(copiedTimer);
+    for (const off of detach) {
+      off();
+    }
+    detach = [];
+    root?.remove();
+    root = null;
+    syncBusy();
+    const t = target;
+    target = null;
+    picker = null;
+    t.release();
+    if (opts.refocus !== false) {
+      t.focus();
+    }
+  }
+  function outputMode() {
+    if (job === "summary") {
+      return "insert";
+    }
+    if (job === "titles") {
+      return "choose";
+    }
+    if (getAiRewriteVariant(variant)?.output === "readOnly") {
+      return "readOnly";
+    }
+    return target?.scope === "document" ? "replaceDocument" : "replace";
+  }
+  function build() {
+    const box = el2("div", "mikedown-ai-rewrite");
+    box.setAttribute("role", "dialog");
+    box.setAttribute("aria-label", "Rewrite with AI");
+    box.tabIndex = -1;
+    const head = el2("div", "ai-rw-head");
+    const spark = el2("span", "ai-rw-spark");
+    spark.innerHTML = SPARK;
+    titleEl = el2("span", "ai-rw-title", "Rewrite");
+    thinkEl = el2("div", "ai-rw-think");
+    thinkEl.setAttribute("role", "radiogroup");
+    thinkEl.setAttribute("aria-label", "Thinking");
+    thinkEl.hidden = true;
+    thinkEl.addEventListener("keydown", onThinkingKey);
+    badgeEl = el2("span", "ai-rw-badge");
+    badgeEl.hidden = true;
+    closeBtn = button2("ai-rw-icon-btn", "", () => close());
+    closeBtn.innerHTML = CLOSE;
+    kindEl = el2("div", "ai-rw-kind");
+    kindEl.setAttribute("role", "group");
+    kindEl.setAttribute("aria-label", "Summary kind");
+    kindEl.hidden = true;
+    for (const k of ["tldr", "outline"]) {
+      const seg = button2("ai-rw-kind-seg", SUMMARY_KIND_LABELS[k], () => pickKind(k));
+      seg.dataset.kind = k;
+      seg.title = k === "tldr" ? "A short TL;DR of the document (runs again)" : "An outline of the document (runs again)";
+      kindEl.append(seg);
+    }
+    head.append(spark, titleEl, kindEl, thinkEl, closeBtn);
+    chooseEl = el2("div", "ai-rw-choose");
+    menuEl = el2("div", "ai-rw-menu");
+    menuEl.setAttribute("role", "menu");
+    menuEl.setAttribute("aria-label", "Rewrite options");
+    for (const g of aiRewriteMenuGroups()) {
+      if (g.group === "custom") {
+        continue;
+      }
+      const section = el2("div", "ai-rw-group");
+      section.dataset.group = g.group;
+      section.setAttribute("role", "group");
+      section.setAttribute("aria-label", g.label);
+      const heading = el2("div", "ai-rw-group-label", g.label);
+      heading.setAttribute("aria-hidden", "true");
+      const chips = el2("div", "ai-rw-chips");
+      for (const v of g.variants) {
+        const chip = button2("ai-rw-chip", v.label, () => choose(v));
+        chip.setAttribute("role", "menuitem");
+        if (v.title) {
+          chip.title = v.title;
+        }
+        chip.dataset.variant = v.id;
+        if (v.param) {
+          chip.setAttribute("aria-haspopup", "menu");
+        }
+        chips.append(chip);
+      }
+      section.append(heading, chips);
+      menuEl.append(section);
+    }
+    formEl = el2("form", "ai-rw-form");
+    inputEl = el2("input", "ai-rw-input");
+    inputEl.type = "text";
+    inputEl.placeholder = 'Describe a change, e.g. "make it friendlier"';
+    inputEl.setAttribute("aria-label", "Custom rewrite instruction");
+    inputEl.maxLength = 1e3;
+    const go = button2("ai-rw-btn ai-rw-btn--primary", "Rewrite", () => submitCustom());
+    formEl.append(inputEl, go);
+    formEl.addEventListener("submit", (e) => {
+      e.preventDefault();
+      submitCustom();
+    });
+    pickerEl = el2("div", "ai-rw-picker");
+    chooseEl.append(menuEl, formEl, pickerEl);
+    bodyEl = el2("div", "ai-rw-body");
+    const oldPane = el2("div", "ai-rw-pane ai-rw-pane--old");
+    oldTextEl = el2("div", "ai-rw-text");
+    oldPane.append(el2("div", "ai-rw-label", "Original"), oldTextEl);
+    newPaneEl = el2("div", "ai-rw-pane ai-rw-pane--new");
+    const newText = el2("div", "ai-rw-text");
+    outEl = el2("div", "ai-rw-out");
+    caretEl = el2("span", "ai-rw-caret");
+    newText.append(outEl);
+    newLabelEl = el2("div", "ai-rw-label", "Rewrite");
+    newPaneEl.append(newLabelEl, newText);
+    bodyEl.append(oldPane, newPaneEl);
+    titlesBoxEl = el2("div", "ai-rw-titles-box");
+    titlesEl = el2("div", "ai-rw-titles");
+    titlesEl.setAttribute("role", "menu");
+    titlesEl.setAttribute("aria-label", "Suggested titles");
+    titleHintEl = el2("div", "ai-rw-titles-hint");
+    titlesBoxEl.append(titlesEl, titleHintEl);
+    errorEl = el2("div", "ai-rw-error");
+    errorEl.setAttribute("role", "alert");
+    coverageEl = el2("div", "ai-rw-coverage");
+    warnEl = el2("div", "ai-rw-warn");
+    footEl = el2("div", "ai-rw-foot");
+    acceptBtn = button2("ai-rw-btn ai-rw-btn--primary", "Accept", () => accept());
+    retryBtn = button2("ai-rw-btn", "Retry", () => rerun());
+    copyBtn = button2("ai-rw-btn", "Copy", () => copy());
+    noteEl = el2("span", "ai-rw-note");
+    statsEl = el2("span", "ai-rw-stats");
+    statsEl.hidden = true;
+    footEl.append(acceptBtn, retryBtn, copyBtn, noteEl, statsEl, badgeEl);
+    liveEl = el2("div", "ai-rw-sr");
+    liveEl.setAttribute("aria-live", "polite");
+    box.append(head, chooseEl, bodyEl, titlesBoxEl, errorEl, coverageEl, warnEl, footEl, liveEl);
+    return box;
+  }
+  function submitCustom() {
+    const text = inputEl.value.trim();
+    if (!text) {
+      inputEl.focus();
+      return;
+    }
+    start("custom", text);
+  }
+  function choose(def) {
+    if (def.param) {
+      openPicker(def.param === "language" ? "language" : "audience");
+      return;
+    }
+    start(def.id);
+  }
+  function pickerOption(label, checked, onPick) {
+    const b = button2("ai-rw-option", "", onPick);
+    b.setAttribute("role", "menuitemradio");
+    b.setAttribute("aria-checked", checked ? "true" : "false");
+    const mark = el2("span", "ai-rw-option-check");
+    mark.innerHTML = CHECK;
+    b.append(mark, el2("span", "ai-rw-option-label", label));
+    return b;
+  }
+  function pickerSeparator() {
+    const sep = el2("div", "ai-rw-option-sep");
+    sep.setAttribute("role", "separator");
+    return sep;
+  }
+  function renderPicker() {
+    if (!picker) {
+      pickerEl.replaceChildren();
+      return;
+    }
+    const head = el2("div", "ai-rw-picker-head");
+    const back = button2("ai-rw-icon-btn ai-rw-back", "", () => closePicker());
+    back.innerHTML = BACK;
+    back.setAttribute("aria-label", "Back (Esc)");
+    back.title = "Back (Esc)";
+    back.hidden = docOnly;
+    head.append(back, el2("span", "ai-rw-picker-title", picker === "language" ? "Translate to" : "Reading level"));
+    const list = el2("div", "ai-rw-picker-list");
+    list.setAttribute("role", "menu");
+    list.setAttribute("aria-label", picker === "language" ? "Language" : "Audience");
+    const parts = [head, list];
+    if (picker === "language") {
+      const { recents, languages } = translateLanguageChoices();
+      recents.forEach((lang, i) => list.append(pickerOption(lang, i === 0, () => pickLanguage(lang))));
+      if (recents.length) {
+        list.append(pickerSeparator());
+      }
+      for (const lang of languages) {
+        list.append(pickerOption(lang, false, () => pickLanguage(lang)));
+      }
+      list.append(pickerSeparator());
+      const otherForm = el2("form", "ai-rw-form ai-rw-other");
+      otherForm.hidden = true;
+      const otherInput = el2("input", "ai-rw-input");
+      otherInput.type = "text";
+      otherInput.placeholder = "Language, e.g. Swahili";
+      otherInput.setAttribute("aria-label", "Other language");
+      otherInput.maxLength = 60;
+      otherForm.append(otherInput, button2("ai-rw-btn ai-rw-btn--primary", "Translate", () => pickLanguage(otherInput.value)));
+      otherForm.addEventListener("submit", (e) => {
+        e.preventDefault();
+        pickLanguage(otherInput.value);
+      });
+      const other = button2("ai-rw-option ai-rw-option--other", "", () => {
+        otherForm.hidden = false;
+        other.setAttribute("aria-expanded", "true");
+        otherInput.focus();
+        position2();
+      });
+      other.setAttribute("role", "menuitem");
+      other.setAttribute("aria-expanded", "false");
+      other.append(el2("span", "ai-rw-option-check"), el2("span", "ai-rw-option-label", "Other\u2026"));
+      list.append(other);
+      parts.push(otherForm);
+      if (docOnly || deps.documentTarget) {
+        const toggle = el2("label", "ai-rw-toggle");
+        const box = el2("input");
+        box.type = "checkbox";
+        box.checked = wholeDocument;
+        box.disabled = docOnly;
+        box.addEventListener("change", () => {
+          wholeDocument = box.checked;
+        });
+        toggle.append(box, el2("span", "", "Whole document"));
+        toggle.title = docOnly ? "Nothing is selected, so the whole document is translated." : "Translate the whole document instead of the selection (frontmatter is kept).";
+        const foot = el2("div", "ai-rw-picker-foot");
+        foot.append(toggle);
+        parts.push(foot);
+      }
+    } else {
+      const remembered = loadAudience();
+      for (const a of AI_AUDIENCES) {
+        list.append(pickerOption(a.label, a.id === remembered, () => pickAudience(a.id)));
+      }
+    }
+    pickerEl.replaceChildren(...parts);
+  }
+  function openPicker(kind) {
+    picker = kind;
+    variant = kind === "language" ? "translate" : "readingLevel";
+    phase = "choose";
+    renderPicker();
+    render();
+    position2();
+    const items = [...pickerEl.querySelectorAll(".ai-rw-picker-list > button")];
+    (items.find((b) => b.getAttribute("aria-checked") === "true") ?? items[0])?.focus({ preventScroll: true });
+  }
+  function closePicker() {
+    if (docOnly) {
+      close();
+      return;
+    }
+    const was = variant;
+    picker = null;
+    renderPicker();
+    render();
+    position2();
+    menuEl.querySelector(`.ai-rw-chip[data-variant="${was}"]`)?.focus({ preventScroll: true });
+  }
+  function pickLanguage(language) {
+    const lang = language.replace(/\s+/g, " ").trim();
+    if (!lang) {
+      pickerEl.querySelector(".ai-rw-other .ai-rw-input")?.focus();
+      return;
+    }
+    params = { language: lang };
+    if (wholeDocument && !useDocumentTarget()) {
+      return;
+    }
+    start("translate");
+  }
+  function pickAudience(audience) {
+    params = { audience };
+    start("readingLevel");
+  }
+  function useDocumentTarget() {
+    if (!target) {
+      return false;
+    }
+    if (target.scope === "document") {
+      return true;
+    }
+    const doc = deps.documentTarget?.() ?? null;
+    if (!doc) {
+      return false;
+    }
+    target.release();
+    target = doc;
+    side = null;
+    return true;
+  }
+  function headTitle() {
+    if (job === "summary") {
+      return summaryJob?.kind === "outline" ? "Outline" : "Summary";
+    }
+    if (job === "titles") {
+      return "Suggest titles";
+    }
+    if (unavailable) {
+      return "Rewrite";
+    }
+    if (phase === "choose") {
+      return picker === "language" ? "Translate" : picker === "audience" ? "Reading level" : "Rewrite";
+    }
+    if (variant === "explain") {
+      return "Explain";
+    }
+    if (variant === "custom") {
+      return "Rewrite \xB7 Custom";
+    }
+    if (variant === "translate") {
+      return `Translate \xB7 ${params.language ?? ""}${target?.scope === "document" ? " \xB7 Whole document" : ""}`;
+    }
+    if (variant === "readingLevel") {
+      return `Reading level \xB7 ${(params.audience && getAiAudience(params.audience)?.label) ?? ""}`;
+    }
+    return `Rewrite \xB7 ${plainLabel(getAiRewriteVariant(variant)?.label ?? "")}`;
+  }
+  function renderThinking() {
+    const choices = thinking && phase !== "choose" ? thinkingChoices(thinking.kind) : [];
+    thinkEl.hidden = choices.length === 0;
+    if (choices.length === 0) {
+      return;
+    }
+    const current = thinkingSelected(thinking);
+    const focused = thinkEl.contains(document.activeElement) ? document.activeElement.dataset.level : void 0;
+    const label = el2("span", "ai-rw-think-label", "Thinking");
+    label.setAttribute("aria-hidden", "true");
+    const options = [
+      { level: THINKING_DEFAULT2, label: "Default", title: "Thinking: picked for the task" },
+      ...choices.map((c) => ({ level: c.level, label: thinkingSegmentLabel(c.label), title: `Thinking: ${c.label}` }))
+    ];
+    const stop = focused && options.some((o) => o.level === focused) ? focused : current;
+    const segments = options.map((o) => {
+      const seg = button2("ai-rw-think-seg", o.label, () => pickThinking(o.level === THINKING_DEFAULT2 ? null : o.level));
+      seg.dataset.level = o.level;
+      seg.setAttribute("role", "radio");
+      seg.setAttribute("aria-checked", o.level === current ? "true" : "false");
+      seg.setAttribute("aria-label", o.level === THINKING_DEFAULT2 ? "Default" : choices.find((c) => c.level === o.level)?.label ?? o.label);
+      seg.tabIndex = o.level === stop ? 0 : -1;
+      seg.title = `${o.title} (runs again)`;
+      return seg;
+    });
+    const effective = thinkingInEffect(thinking);
+    thinkEl.title = thinking?.sent && thinking.auto ? `Thinking: Default, ${choices.find((c) => c.level === thinking?.sent)?.label ?? thinking.sent} for this task` : thinking?.sent ? `Thinking: ${choices.find((c) => c.level === thinking?.sent)?.label ?? thinking.sent}` : effective ? `Thinking: the model's setting (${choices.find((c) => c.level === effective)?.label ?? effective})` : "Thinking: the model's default";
+    thinkEl.replaceChildren(label, ...segments);
+    if (focused) {
+      segments.find((b) => b.dataset.level === focused)?.focus({ preventScroll: true });
+    }
+  }
+  function onThinkingKey(e) {
+    if (!/^(Arrow(Left|Right|Up|Down)|Home|End)$/.test(e.key)) {
+      return;
+    }
+    const segs = [...thinkEl.querySelectorAll(".ai-rw-think-seg")];
+    const at = segs.indexOf(document.activeElement);
+    if (at < 0) {
+      return;
+    }
+    e.preventDefault();
+    e.stopPropagation();
+    const forward = e.key === "ArrowRight" || e.key === "ArrowDown";
+    const next = e.key === "Home" ? 0 : e.key === "End" ? segs.length - 1 : (at + (forward ? 1 : -1) + segs.length) % segs.length;
+    for (const [i, b] of segs.entries()) {
+      b.tabIndex = i === next ? 0 : -1;
+    }
+    segs[next].focus({ preventScroll: true });
+  }
+  function renderBadge() {
+    renderThinking();
+    const b = deps.badge(route, served, served ? viaFallback : route?.viaFallback ?? false, jobSends());
+    badgeEl.hidden = !b;
+    if (!b) {
+      return;
+    }
+    badgeEl.dataset.where = b.where ?? "";
+    badgeEl.classList.toggle("is-pending", !served);
+    const level = served ? thinkingInEffect(thinking) : null;
+    const levelLabel = level && thinking ? thinkingChoices(thinking.kind).find((c) => c.level === level)?.label : void 0;
+    let title = b.title;
+    if (b.where === "cloud") {
+      const j = jobSends();
+      const what = whatIsSent(j.feature, j.sends);
+      if (!title.includes(what)) {
+        title = `${title} ${served ? "Sent" : "Sends"} ${what}.`;
+      }
+    }
+    badgeEl.title = levelLabel ? `${title} Thinking: ${levelLabel.toLowerCase()}.` : title;
+    const glyph = el2("span", "ai-rw-badge-glyph");
+    glyph.innerHTML = b.where === "cloud" ? CLOUD : LOCAL;
+    const text = el2("span", "ai-rw-badge-text");
+    const cut = capitalizeFirst(b.text).split(" \xB7 ");
+    if (cut.length >= 3) {
+      text.append(el2("span", "ai-rw-badge-engine", `${cut.slice(0, 2).join(" \xB7 ")} \xB7 `), el2("span", "ai-rw-badge-model", cut.slice(2).join(" \xB7 ")));
+    } else {
+      text.append(el2("span", "ai-rw-badge-engine", capitalizeFirst(b.text)));
+    }
+    const parts = [glyph, text];
+    if (b.fallback) {
+      parts.push(el2("span", "ai-rw-badge-fallback", "(fallback)"));
+    }
+    badgeEl.replaceChildren(...parts);
+  }
+  function placeCaret() {
+    let host = outEl;
+    for (let last = host.lastElementChild; last && /^(UL|OL|LI|BLOCKQUOTE|P|DIV)$/.test(last.tagName); last = host.lastElementChild) {
+      host = last;
+    }
+    host.append(caretEl);
+  }
+  function renderOut() {
+    const shown = job === "titles" ? "" : job === "summary" ? (phase === "done" && summaryJob ? summaryPreviewText(raw, summaryJob.kind, summaryCutOff) : summaryVisibleText(raw)).trim() : phase === "done" ? finalText.trim() : rewriteVisibleText(raw).trimStart();
+    renderPreviewMarkdown(outEl, shown);
+    placeCaret();
+    newPaneEl.classList.toggle("is-waiting", phase === "running" && !shown);
+    if (phase === "running" && !shown) {
+      const name = deps.badge(route, null, false)?.text.split(" \xB7 ")[1];
+      outEl.replaceChildren();
+      placeCaret();
+      outEl.dataset.placeholder = repairing ? REPAIR_NOTE : job === "titles" && raw ? "Suggesting titles\u2026" : name ? `Waiting for ${name}\u2026` : "Waiting for the engine\u2026";
+    } else {
+      delete outEl.dataset.placeholder;
+    }
+    const scroller = outEl.parentElement;
+    if (scroller && phase === "running" && scroller.scrollHeight - scroller.scrollTop - scroller.clientHeight < 40) {
+      scroller.scrollTop = scroller.scrollHeight;
+    }
+  }
+  function scheduleOut() {
+    if (frame) {
+      return;
+    }
+    frame = requestAnimationFrame(() => {
+      frame = 0;
+      if (root) {
+        renderOut();
+      }
+    });
+  }
+  let busyReported = false;
+  function syncBusy() {
+    const running = !!root && phase === "running";
+    if (running === busyReported) {
+      return;
+    }
+    busyReported = running;
+    deps.onBusy?.(running);
+  }
+  function render() {
+    syncBusy();
+    if (!root || !target) {
+      return;
+    }
+    const mode = outputMode();
+    root.dataset.phase = phase;
+    root.dataset.output = mode;
+    root.dataset.layout = mode === "replace" && target.multiline ? "split" : "single";
+    root.setAttribute("aria-busy", phase === "running" ? "true" : "false");
+    root.setAttribute("aria-label", job === "summary" ? "Summarize with AI" : job === "titles" ? "Suggest titles with AI" : variant === "explain" && phase !== "choose" ? "Explain with AI" : "Rewrite with AI");
+    titleEl.textContent = headTitle();
+    if (variant === "custom" && instruction && phase !== "choose") {
+      titleEl.title = instruction;
+    } else {
+      titleEl.title = titleEl.textContent;
+    }
+    chooseEl.hidden = phase !== "choose";
+    menuEl.hidden = !!picker;
+    formEl.hidden = !!picker;
+    pickerEl.hidden = !picker;
+    bodyEl.hidden = phase === "choose" || phase === "error" || mode === "choose" && phase === "done";
+    titlesBoxEl.hidden = !(mode === "choose" && phase === "done");
+    kindEl.hidden = job !== "summary";
+    for (const seg of kindEl.querySelectorAll(".ai-rw-kind-seg")) {
+      seg.setAttribute("aria-pressed", seg.dataset.kind === summaryJob?.kind ? "true" : "false");
+    }
+    errorEl.hidden = phase !== "error";
+    footEl.hidden = phase === "choose" || phase === "error";
+    newLabelEl.textContent = mode === "readOnly" ? "Explanation" : variant === "translate" ? "Translation" : "Rewrite";
+    renderBadge();
+    renderOut();
+    const ready = phase === "done" && !!finalText.trim();
+    acceptBtn.hidden = phase === "error" || mode === "choose";
+    acceptBtn.setAttribute("aria-disabled", ready ? "false" : "true");
+    acceptBtn.textContent = mode === "readOnly" ? "Insert below" : mode === "insert" ? "Insert" : mode === "replaceDocument" ? "Replace document" : "Accept";
+    acceptBtn.title = mode === "readOnly" ? "Insert the explanation as a quote below the selection" : mode === "insert" ? "Insert at the cursor (Enter)" : mode === "replaceDocument" ? "Replace the document body; frontmatter is kept (Enter)" : "Replace the selection (Enter)";
+    copyBtn.hidden = phase === "error" || mode === "choose";
+    copyBtn.setAttribute("aria-disabled", (phase === "done" ? finalText : rewriteVisibleText(raw)).trim() ? "false" : "true");
+    retryBtn.hidden = phase === "error";
+    noteEl.textContent = repairing ? REPAIR_NOTE : note2;
+    statsEl.hidden = !(phase === "done" && stats);
+    if (phase === "done" && stats) {
+      statsEl.textContent = aiResultStatsText(stats);
+      statsEl.title = aiResultStatsTitle(stats);
+    }
+    const covered = job === "rewrite" ? target.scope === "document" ? "translate" : null : job;
+    const covText = covered && (phase === "running" || phase === "done") ? coverageNoteText(covered, coverage) : "";
+    coverageEl.hidden = !covText;
+    coverageEl.textContent = covText;
+    const closeLabel = mode === "readOnly" ? "Close (Esc)" : "Cancel (Esc)";
+    closeBtn.setAttribute("aria-label", closeLabel);
+    closeBtn.title = closeLabel;
+    warnEl.hidden = !(phase === "done" && warning);
+    if (phase === "done" && warning) {
+      const glyph = el2("span", "ai-rw-warn-icon");
+      glyph.innerHTML = WARN;
+      warnEl.replaceChildren(glyph, el2("span", "ai-rw-warn-text", warning.text));
+      warnEl.title = warning.title;
+    }
+    if (phase === "error" && error) {
+      renderError(error);
+    }
+  }
+  function errorEngine(e) {
+    return e.engineId ? deps.engineName?.(e.engineId) ?? null : null;
+  }
+  function copyFor(e) {
+    if (unavailable) {
+      return { title: "No engine can rewrite right now", message: e.message, action: "openSettings" };
+    }
+    const engine = errorEngine(e);
+    const model = route && (!e.engineId || route.engineId === e.engineId) ? route.modelId : void 0;
+    return errorCopy ?? aiErrorCopy(e.code, { ...engine ? { engine } : {}, ...model ? { model } : {} });
+  }
+  function renderError(e) {
+    const copyText = copyFor(e);
+    const iconEl = el2("span", "ai-rw-error-icon");
+    iconEl.innerHTML = ALERT;
+    const textBox = el2("div", "ai-rw-error-text");
+    textBox.append(el2("div", "ai-rw-error-title", copyText.title));
+    const detail = e.message && e.message !== copyText.message ? e.message : "";
+    textBox.append(el2("div", "ai-rw-error-message", e.code === "unknown" && detail ? detail : copyText.message));
+    if (detail && e.code === "modelLoadFailed") {
+      const more = el2("details", "ai-rw-error-more");
+      more.append(el2("summary", void 0, "Details"), el2("div", "ai-rw-error-detail", detail));
+      textBox.append(more);
+    } else if (detail && e.code !== "unknown") {
+      textBox.append(el2("div", "ai-rw-error-detail", detail));
+    }
+    if (e.code === "contextOverflow" && target) {
+      const what = target.scope === "selection" ? "The selection" : "The document";
+      const size = job === "summary" ? summaryJob?.markdown.length ?? 0 : job === "titles" ? titleJob?.markdown.length ?? 0 : target.text.length;
+      textBox.append(el2("div", "ai-rw-error-detail", `${what} is ${size.toLocaleString()} characters.`));
+    }
+    const actions = el2("div", "ai-rw-error-actions");
+    const onEngine = (copyText.action === "openEngine" || copyText.action === "chooseModel") && !!e.engineId;
+    const settingsLabel = copyText.action === "chooseModel" ? "Choose model" : onEngine ? `Open ${errorEngine(e) ?? "engine"}` : "Open AI settings";
+    const primary = copyText.action === "openSettings" || copyText.action === "chooseModel" || onEngine;
+    const settingsBtn = button2(`ai-rw-btn${primary ? " ai-rw-btn--primary" : ""}`, settingsLabel, () => {
+      close({ refocus: false });
+      if (onEngine) {
+        deps.openSettings(e.engineId);
+      } else {
+        deps.openSettings();
+      }
+    });
+    actions.append(settingsBtn);
+    if (!unavailable && copyText.action !== "shortenSelection" && e.code !== "cloudBlocked") {
+      actions.append(button2(`ai-rw-btn${copyText.action === "retry" ? " ai-rw-btn--primary" : ""}`, e.code === "badOutput" ? "Try again" : "Retry", () => rerun()));
+    }
+    actions.append(button2("ai-rw-btn", "Close", () => close()));
+    errorEl.replaceChildren(iconEl, textBox, actions);
+  }
+  function position2() {
+    if (!root || !target) {
+      return;
+    }
+    if (!target.alive()) {
+      close({ refocus: false });
+      return;
+    }
+    const rect = target.rect();
+    if (!rect) {
+      return;
+    }
+    const vw = window.innerWidth;
+    const vh = window.innerHeight;
+    const gap = 8;
+    const w = root.offsetWidth || 440;
+    const h = root.offsetHeight || 200;
+    if (!side) {
+      const reserve = Math.min(vh * 0.55, 380);
+      side = rect.bottom + gap + reserve <= vh - gap || rect.top - gap - reserve < gap ? "below" : "above";
+    }
+    let top = side === "below" ? rect.bottom + gap : rect.top - gap - h;
+    top = Math.max(gap, Math.min(top, vh - h - gap));
+    const left = Math.max(gap, Math.min(rect.left, vw - w - gap));
+    root.style.top = `${Math.round(top)}px`;
+    root.style.left = `${Math.round(left)}px`;
+  }
+  function moveFocus(e) {
+    const inTitles = outputMode() === "choose" && phase === "done";
+    if (!root || phase !== "choose" && !inTitles || !/^(Arrow(Up|Down|Left|Right)|Home|End)$/.test(e.key)) {
+      return false;
+    }
+    const selector = inTitles ? ".ai-rw-titles > button" : picker ? ".ai-rw-picker-list > button" : ".ai-rw-menu .ai-rw-chip";
+    const items = [...root.querySelectorAll(selector)];
+    const i = items.indexOf(e.target);
+    if (i < 0) {
+      return false;
+    }
+    const forward = e.key === "ArrowDown" || e.key === "ArrowRight";
+    const next = e.key === "Home" ? 0 : e.key === "End" ? items.length - 1 : (i + (forward ? 1 : -1) + items.length) % items.length;
+    items[next].focus({ preventScroll: true });
+    return true;
+  }
+  function mount(t) {
+    close({ refocus: false });
+    target = t;
+    side = null;
+    raw = "";
+    finalText = "";
+    summaryCutOff = false;
+    route = null;
+    served = null;
+    stats = null;
+    viaFallback = false;
+    thinking = null;
+    error = null;
+    unavailable = false;
+    note2 = "";
+    warning = null;
+    picker = null;
+    params = {};
+    variant = "shorter";
+    instruction = "";
+    docOnly = t.scope === "document";
+    wholeDocument = docOnly;
+    job = "rewrite";
+    summaryJob = null;
+    titleJob = null;
+    titles = [];
+    coverage = 1;
+    sentText = "";
+    untranslated = "";
+    repairing = false;
+    root = build();
+    getPortal().appendChild(root);
+    const onKey = (e) => {
+      if (!root) {
+        return;
+      }
+      if (e.key === "Escape") {
+        e.preventDefault();
+        e.stopPropagation();
+        if (phase === "choose" && picker) {
+          closePicker();
+        } else {
+          close();
+        }
+        return;
+      }
+      if (root.contains(e.target) && moveFocus(e)) {
+        e.preventDefault();
+        return;
+      }
+      const mode = outputMode();
+      if (e.key === "Enter" && phase === "done" && mode !== "readOnly" && mode !== "choose" && !e.shiftKey && !e.altKey) {
+        const t2 = e.target;
+        const inField = !!t2 && (t2.tagName === "INPUT" || t2.tagName === "TEXTAREA");
+        const onOtherButton = !!t2 && t2.tagName === "BUTTON" && t2 !== acceptBtn && root.contains(t2);
+        if (!inField && !onOtherButton || e.metaKey || e.ctrlKey) {
+          e.preventDefault();
+          e.stopPropagation();
+          accept();
+        }
+      }
+    };
+    const onDown = (e) => {
+      if (root && !root.contains(e.target)) {
+        close({ refocus: false });
+      }
+    };
+    const onMove = () => position2();
+    document.addEventListener("keydown", onKey, true);
+    document.addEventListener("mousedown", onDown, true);
+    window.addEventListener("resize", onMove);
+    document.addEventListener("scroll", onMove, true);
+    detach.push(
+      () => document.removeEventListener("keydown", onKey, true),
+      () => document.removeEventListener("mousedown", onDown, true),
+      () => window.removeEventListener("resize", onMove),
+      () => document.removeEventListener("scroll", onMove, true)
+    );
+  }
+  function pickThinking(level) {
+    if (!thinking || phase === "choose") {
+      return;
+    }
+    if ((level ?? THINKING_DEFAULT2) === thinkingSelected(thinking)) {
+      return;
+    }
+    rememberThinkingLevel(level);
+    thinking = { ...thinking, sent: level, auto: false };
+    const label = level ? thinkingChoices(thinking.kind).find((c) => c.level === level)?.label ?? level : "Default";
+    rerun();
+    liveEl.textContent = `Thinking: ${label}`;
+  }
+  function rerun() {
+    if (job === "summary") {
+      startSummary();
+    } else if (job === "titles") {
+      startTitles();
+    } else {
+      start(variant, instruction);
+    }
+  }
+  function contextTokensFor(feature) {
+    return deps.routeInfo?.(feature).contextTokens ?? DEFAULT_CONTEXT_TOKENS;
+  }
+  function beginRun() {
+    abort();
+    const ac = new AbortController();
+    controller = ac;
+    phase = "running";
+    raw = "";
+    finalText = "";
+    summaryCutOff = false;
+    served = null;
+    stats = null;
+    error = null;
+    errorCopy = null;
+    note2 = "";
+    warning = null;
+    repairing = false;
+    return { seq: runSeq, signal: ac.signal };
+  }
+  function runEvents(seq) {
+    return {
+      onRoute: (r, th) => {
+        if (seq !== runSeq) {
+          return;
+        }
+        route = r;
+        thinking = th;
+        raw = "";
+        renderBadge();
+        renderOut();
+      },
+      onToken: (_delta, text) => {
+        if (seq !== runSeq) {
+          return;
+        }
+        raw = text;
+        scheduleOut();
+      }
+    };
+  }
+  function jobSends() {
+    if (job === "summary") {
+      return { feature: "summary", sends: "document" };
+    }
+    if (job === "titles") {
+      return { feature: "title", sends: "document" };
+    }
+    return { feature: "rewrite", sends: target?.scope === "document" ? "document" : "selection" };
+  }
+  function noteServed(outcome) {
+    const by = { ...outcome.result.served, ...jobSends() };
+    served = by;
+    stats = aiResultStats(outcome.result);
+    viaFallback = outcome.viaFallback;
+    thinking = outcome.thinking;
+    deps.onServed(by, outcome.viaFallback);
+  }
+  function finishNote(outcome) {
+    const reason = outcome.result.finishReason;
+    if (reason === "length") {
+      return aiLengthLimitCopy({ thinking: aiRunThinkingOn(outcome.thinking), empty: false }).message;
+    }
+    return reason === "error" ? "The stream ended early." : "";
+  }
+  function showLengthError(outcome) {
+    const copy2 = aiLengthLimitCopy({ thinking: aiRunThinkingOn(outcome.thinking), empty: true });
+    errorCopy = copy2;
+    showError(makeAiError("badOutput", copy2.message));
+  }
+  function showError(e) {
+    phase = "error";
+    error = e;
+    repairing = false;
+    render();
+    position2();
+    liveEl.textContent = `${copyFor(e).title}.`;
+    errorEl.querySelector(".ai-rw-btn--primary, .ai-rw-btn")?.focus({ preventScroll: true });
+  }
+  function runFailed(seq) {
+    return (err) => {
+      if (seq !== runSeq || !root) {
+        return;
+      }
+      controller = null;
+      const e = toAiError(err);
+      if (e.code === "cancelled") {
+        return;
+      }
+      showError(e);
+    };
+  }
+  function pickKind(kind) {
+    if (!summaryJob || summaryJob.kind === kind) {
+      return;
+    }
+    summaryJob.kind = kind;
+    startSummary();
+  }
+  function startSummary() {
+    const t = target;
+    const sj = summaryJob;
+    if (!t || !root || !sj) {
+      return;
+    }
+    const { seq, signal } = beginRun();
+    const kind = sj.kind;
+    const b = budgetDocument(sj.markdown, {
+      contextTokens: contextTokensFor("summary"),
+      outputTokens: summaryMaxTokens(kind, sj.markdown.length),
+      reserveTokens: DOCUMENT_RESERVE_TOKENS
+    });
+    coverage = b.coverage;
+    render();
+    position2();
+    root.focus({ preventScroll: true });
+    deps.run({
+      feature: "summary",
+      messages: buildSummaryMessages({ document: b.text, kind, coverage: b.coverage }),
+      maxTokens: summaryMaxTokens(kind, b.text.length),
+      temperature: 0.3,
+      thinking: thinkingLevelFor,
+      job: "summary"
+    }, runEvents(seq), signal).then((outcome) => {
+      if (seq !== runSeq || !root) {
+        return;
+      }
+      controller = null;
+      noteServed(outcome);
+      raw = outcome.result.text || raw;
+      const cutOff = outcome.result.finishReason === "length";
+      summaryCutOff = cutOff;
+      finalText = finalizeSummary(raw, kind, coverage, cutOff);
+      if (!finalText.trim()) {
+        if (cutOff) {
+          showLengthError(outcome);
+        } else {
+          showError(makeAiError("badOutput"));
+        }
+        return;
+      }
+      phase = "done";
+      note2 = finishNote(outcome);
+      render();
+      position2();
+      liveEl.textContent = `${kind === "outline" ? "Outline" : "Summary"} ready. Press Enter to insert or Escape to cancel.`;
+      acceptBtn.focus({ preventScroll: true });
+    }, runFailed(seq));
+  }
+  function startTitles() {
+    const t = target;
+    const tj = titleJob;
+    if (!t || !root || !tj) {
+      return;
+    }
+    const { seq, signal } = beginRun();
+    titles = [];
+    const info = deps.routeInfo?.("title");
+    const outline = headingsOutline(tj.markdown);
+    const b = budgetDocument(tj.markdown, {
+      contextTokens: info?.contextTokens ?? DEFAULT_CONTEXT_TOKENS,
+      outputTokens: titleMaxTokens(3),
+      reserveTokens: DOCUMENT_RESERVE_TOKENS + Math.ceil(renderHeadingOutline(outline).length / CHARS_PER_TOKEN)
+    });
+    coverage = b.coverage;
+    render();
+    position2();
+    root.focus({ preventScroll: true });
+    const messages = buildTitleMessages({ document: b.text, outline, existingTitle: tj.existingTitle, count: 3 });
+    const request = (msgs) => deps.run({
+      feature: "title",
+      messages: msgs,
+      maxTokens: titleMaxTokens(3),
+      temperature: 0.7,
+      thinking: thinkingLevelFor,
+      job: "title",
+      ...info?.json ? { format: "json" } : {}
+    }, runEvents(seq), signal);
+    request(messages).then(async (first) => {
+      if (seq !== runSeq || !root) {
+        return;
+      }
+      noteServed(first);
+      const firstText = first.result.text || raw;
+      if (!rewriteVisibleText(firstText).trim() && first.result.finishReason === "length") {
+        controller = null;
+        showLengthError(first);
+        return;
+      }
+      let last = first;
+      let parsed = parseTitles(firstText, tj.existingTitle);
+      if (!parsed.ok) {
+        repairing = true;
+        render();
+        const second = await request([...messages, ...jsonRepairMessages(firstText, parsed.error)]);
+        if (seq !== runSeq || !root) {
+          return;
+        }
+        noteServed(second);
+        repairing = false;
+        last = second;
+        parsed = parseTitles(second.result.text || raw, tj.existingTitle);
+        if (!parsed.ok) {
+          if (second.result.finishReason === "length") {
+            controller = null;
+            showLengthError(second);
+            return;
+          }
+          throw makeAiError("badOutput", parsed.error);
+        }
+      }
+      controller = null;
+      titles = parsed.titles.slice(0, 3);
+      phase = "done";
+      note2 = finishNote(last);
+      renderTitles();
+      render();
+      position2();
+      liveEl.textContent = `${titles.length} ${titles.length === 1 ? "title" : "titles"} ready. ${AI_TITLE_EFFECT_HINTS[tj.effect]}. Escape cancels.`;
+      titlesEl.querySelector("button")?.focus({ preventScroll: true });
+    }).catch(runFailed(seq));
+  }
+  function renderTitles() {
+    titlesEl.replaceChildren(...titles.map((title) => {
+      const b = button2("ai-rw-option ai-rw-title-option", "", () => pickTitle(title));
+      b.setAttribute("role", "menuitem");
+      b.append(el2("span", "ai-rw-option-label", title));
+      return b;
+    }));
+    titleHintEl.textContent = titleJob ? AI_TITLE_EFFECT_HINTS[titleJob.effect] : "";
+  }
+  function pickTitle(title) {
+    const t = target;
+    const tj = titleJob;
+    if (!t || !tj || phase !== "done") {
+      return;
+    }
+    const ok = tj.apply(title);
+    close({ refocus: true });
+    if (!ok) {
+      t.focus();
+    }
+  }
+  function start(v, custom) {
+    const t = target;
+    if (!t || !root) {
+      return;
+    }
+    const { seq, signal } = beginRun();
+    variant = v;
+    instruction = v === "custom" ? custom ?? instruction : "";
+    picker = null;
+    oldTextEl.textContent = t.scope === "document" ? "" : t.text.trim();
+    const def = getAiRewriteVariant(v);
+    if (def?.param === "language" && params.language) {
+      rememberLanguage(params.language);
+    }
+    if (def?.param === "audience" && params.audience) {
+      rememberAudience(params.audience);
+    }
+    const readOnly = def?.output === "readOnly";
+    sentText = t.text;
+    untranslated = "";
+    coverage = 1;
+    let maxTokens = readOnly ? explainMaxTokens() : rewriteMaxTokens(t.text, v);
+    if (t.scope === "document" && !readOnly) {
+      const b = budgetTranslation(t.text, contextTokensFor("rewrite"));
+      sentText = b.text;
+      untranslated = b.rest;
+      coverage = b.coverage;
+      maxTokens = b.maxTokens;
+    }
+    render();
+    position2();
+    root.focus({ preventScroll: true });
+    const messages = readOnly ? buildExplainMessages({ selection: t.text, before: t.before, after: t.after, title: t.title }) : buildRewriteMessages({
+      variant: v,
+      instruction,
+      selection: sentText,
+      before: t.before,
+      after: t.after,
+      params: def?.param ? params : void 0,
+      scope: t.scope === "document" ? "document" : "selection"
+    });
+    deps.run({
+      feature: "rewrite",
+      ...t.scope === "document" ? { sends: "document" } : {},
+      messages,
+      maxTokens,
+      temperature: v === "fixFlow" || v === "translate" ? 0.2 : 0.5,
+      thinking: thinkingLevelFor,
+      // Explain keeps the model's own thinking; every other variant is a short edit (Off).
+      job: readOnly ? "explain" : v === "translate" ? "translate" : "rewrite"
+    }, runEvents(seq), signal).then((outcome) => {
+      if (seq !== runSeq || !root) {
+        return;
+      }
+      controller = null;
+      noteServed(outcome);
+      finalText = finalizeRewriteText(outcome.result.text || raw, readOnly ? "" : sentText);
+      if (!finalText.trim()) {
+        phase = "error";
+        if (outcome.result.finishReason === "length") {
+          errorCopy = aiLengthLimitCopy({ thinking: aiRunThinkingOn(outcome.thinking), empty: true });
+          error = makeAiError("badOutput", errorCopy.message);
+        } else {
+          error = { code: "unknown", message: "The engine sent back no text." };
+        }
+      } else {
+        phase = "done";
+        note2 = finishNote(outcome);
+        if (STRUCTURE_CHECKED.has(v)) {
+          const diff = checkMarkdownStructure(sentText, finalText);
+          const text = structureWarningText(diff);
+          warning = text ? { text, title: diff.messages.join("\n") } : null;
+        }
+      }
+      render();
+      position2();
+      liveEl.textContent = phase !== "done" ? "Rewrite failed." : readOnly ? "Explanation ready. Insert below adds it to the document; Escape closes." : `${variant === "translate" ? "Translation" : "Rewrite"} ready. Press Enter to accept or Escape to cancel.${warning ? ` ${warning.text}.` : ""}`;
+      if (phase === "done") {
+        (readOnly ? root : acceptBtn).focus({ preventScroll: true });
+      }
+    }, runFailed(seq));
+  }
+  function accept() {
+    const t = target;
+    const mode = outputMode();
+    if (!t || phase !== "done" || !finalText.trim() || mode === "choose") {
+      return;
+    }
+    const ok = mode === "readOnly" ? t.insertBelow(finalText) : mode === "replaceDocument" && untranslated.trim() ? t.accept(`${finalText.trimEnd()}
+
+${untranslated.trimStart()}`) : t.accept(finalText);
+    close({ refocus: true });
+    if (!ok) {
+      t.focus();
+    }
+  }
+  function copy() {
+    const text = (phase === "done" ? finalText : rewriteVisibleText(raw)).trim();
+    if (!text) {
+      return;
+    }
+    void navigator.clipboard?.writeText(text).then(() => {
+      if (!root) {
+        return;
+      }
+      copyBtn.textContent = "Copied";
+      window.clearTimeout(copiedTimer);
+      copiedTimer = window.setTimeout(() => {
+        copyBtn.textContent = "Copy";
+      }, 1200);
+    }, () => {
+    });
+  }
+  return {
+    open(t, choice) {
+      mount(t);
+      params = { ...choice?.params };
+      wholeDocument = docOnly || !!choice?.wholeDocument;
+      const def = choice ? getAiRewriteVariant(choice.variant) : void 0;
+      if (docOnly && (!def || def.id !== "translate" || !hasParam(def, params))) {
+        openPicker("language");
+        return;
+      }
+      if (def && def.param && !hasParam(def, params)) {
+        openPicker(def.param === "language" ? "language" : "audience");
+        return;
+      }
+      if (def && (def.id !== "custom" || choice?.instruction?.trim())) {
+        if (def.id === "translate" && wholeDocument && !useDocumentTarget()) {
+          wholeDocument = false;
+          openPicker("language");
+          return;
+        }
+        start(def.id, choice?.instruction);
+        return;
+      }
+      phase = "choose";
+      render();
+      position2();
+      inputEl.focus({ preventScroll: true });
+    },
+    openSummary(t, sj) {
+      mount(t);
+      job = "summary";
+      summaryJob = { ...sj };
+      startSummary();
+    },
+    openTitles(t, tj) {
+      mount(t);
+      job = "titles";
+      titleJob = tj;
+      startTitles();
+    },
+    openUnavailable(t, reason) {
+      mount(t);
+      phase = "error";
+      error = { code: "unknown", message: reason };
+      unavailable = true;
+      render();
+      position2();
+      errorEl.querySelector(".ai-rw-btn")?.focus({ preventScroll: true });
+    },
+    close: () => close(),
+    isOpen: () => !!target,
+    destroy() {
+      close({ refocus: false });
+    }
+  };
+}
+export {
+  AI_ENGINE_PRESETS,
+  AI_TURN_ON_PATCH,
+  CHARS_PER_TOKEN,
+  DEFAULT_CONTEXT_TOKENS,
+  PROPERTY_VOCABULARY_MAX,
+  aiConsentHost,
+  aiErrorCopy,
+  aiFeatureAvailability,
+  aiIndicatorState,
+  aiLengthLimitCopy,
+  aiNextRouteChanged,
+  aiRewriteMenuGroups,
+  aiRunThinkingOn,
+  aiSetupTarget,
+  aiToolbarMenuEntries,
+  applyRichTitle,
+  applySourceTitle,
+  bestLocalServer,
+  budgetDocument,
+  buildAiSettingsSection,
+  buildPropertiesMessages,
+  createAiRewritePopover,
+  cursorInsertTarget,
+  detectLocalServers,
+  engineDisplayName,
+  experimentalBadge,
+  headingsOutline,
+  hideAiFirstRunPanel,
+  hostOfUrl,
+  isAiFirstRunPanelOpen,
+  isHostEngineKind,
+  isRouteUsable,
+  jsonRepairMessages,
+  loadThinkingLevel,
+  makeAiError,
+  mountAiEnginesPage,
+  parseAiSettings,
+  parsePropertySuggestions,
+  privacyCard,
+  privacyLine,
+  propertiesMaxTokens,
+  rememberThinkingLevel,
+  renderHeadingOutline,
+  resolveRoute,
+  rewriteVisibleText,
+  richDocumentTarget,
+  richRewriteTarget,
+  runAiCompletion,
+  scanForSetup,
+  setUpLocalEngine,
+  setYamlTitle,
+  showAiFirstRunPanel,
+  sourceCursorTarget,
+  sourceDocumentTarget,
+  sourceRewriteTarget,
+  thinkingChoices,
+  thinkingLevelFor,
+  toAiError,
+  whatIsSent,
+  withSavedAiKeys,
+  yamlHasTitle
+};
+//# sourceMappingURL=ai-ui-C7ENTWWU.js.map