@mikedown/core 0.3.0 → 0.4.0

package/dist/{ai-ui-C7ENTWWU.js → ai-ui-QFYFN73D.js}

@@ -13,6 +13,7 @@ import {
   bestLocalServer,
   button,
   createAiSettingsSession,
+  createDocsBasesSection,
   detectLocalServers,
   el,
   engineDisplayName,
@@ -35,8 +36,8 @@ import {
   switchInput,
   taskRouteNote,
   withSavedAiKeys
-} from "./chunk-7A5HEPLK.js";
-import "./chunk-LXZG7IKN.js";
+} from "./chunk-DWXGWVA3.js";
+import "./chunk-N4N54LK2.js";
 import {
   AI_AUDIENCES,
   AI_ENGINE_PRESETS,
@@ -44,8 +45,15 @@ import {
   AI_NO_CONSENTS_TEXT,
   AI_REWRITE_VARIANTS,
   AI_TASKS,
+  ANSWERED_WITHOUT_SOURCES,
   CHARS_PER_TOKEN,
-  DEFAULT_CONTEXT_TOKENS,
+  GHOST_DELAY_MS_DEFAULT,
+  GHOST_DELAY_MS_MAX,
+  GHOST_DELAY_MS_MIN,
+  GHOST_MAX_TOKENS_DEFAULT,
+  GHOST_MAX_TOKENS_MAX,
+  GHOST_MAX_TOKENS_MIN,
+  NO_SOURCES_CITED,
   PROPERTY_VOCABULARY_MAX,
   REWRITE_CONTEXT_CHARS,
   aiConsentHost,
@@ -58,28 +66,46 @@ import {
   aiResultStatsText,
   aiResultStatsTitle,
   budgetDocument,
+  buildContinueMessages,
   buildExplainMessages,
   buildPropertiesMessages,
   buildRewriteMessages,
   buildSummaryMessages,
   buildTitleMessages,
   checkMarkdownStructure,
+  continueMaxTokens,
   coveragePercent,
+  createDocsChat,
+  docsActiveBases,
+  docsCitationLabel,
+  docsDocumentLocation,
+  docsFileHref,
+  docsHeadingAt,
+  docsSectionFile,
+  docsSectionSlug,
   explainMaxTokens,
   finalizeRewriteText,
   finalizeSummary,
   getAiAudience,
+  getAiFeature,
   getAiRewriteVariant,
   getAiTask,
+  ghostAcceptWord,
+  ghostContext,
+  ghostPrefixMatch,
+  ghostTextOptions,
   headingsOutline,
+  insertUrlIsVerbatim,
   isHostEngineKind,
   isRouteUsable,
   jsonRepairMessages,
   makeAiError,
   nearestThinkingLevel,
   parseAiSettings,
+  parseCitations,
   parsePropertySuggestions,
   parseTitles,
+  prepareInsertMarkdown,
   propertiesMaxTokens,
   renderHeadingOutline,
   resolveAiFeature,
@@ -95,12 +121,15 @@ import {
   thinkingMaxTokens,
   titleMaxTokens,
   toAiError,
+  trimGhostSuggestionDetailed,
   whatIsSent,
   withThinkingLevel
-} from "./chunk-JZWKEBCI.js";
+} from "./chunk-IWCXWUWW.js";
 import {
+  DEFAULT_CONTEXT_TOKENS,
   hostOfUrl
-} from "./chunk-QDVY7WW6.js";
+} from "./chunk-APPBNQEY.js";
+import "./chunk-TSP7BAV3.js";
 
 // src/ai-prefs.ts
 var LANGUAGES_KEY = "mikedown.ai.recentLanguages";
@@ -252,6 +281,23 @@ function buildAiSettingsSection(ctx, opts) {
   toolbarField.input.addEventListener("change", () => {
     session.draft = { ...session.draft, showToolbarButton: toolbarField.input.checked };
   });
+  const activityField = ctx.makeCheckboxRow(
+    "AI Activity",
+    "Shows exactly what each AI request sent and received. Kept in memory for this window only; turning it off clears it.",
+    session.draft.activityPanel
+  );
+  activityField.row.classList.add("ai-activity-setting");
+  activityField.input.dataset.fk = "ai-activity-panel";
+  const activityOpen = button("ai-link-btn ai-activity-open", "Open", { fk: "ai-activity:open", ariaLabel: "Open AI Activity" });
+  activityOpen.hidden = !session.draft.activityPanel;
+  activityOpen.addEventListener("click", () => opts.openActivityPanel?.());
+  if (opts.openActivityPanel) {
+    activityField.row.insertBefore(activityOpen, activityField.input);
+  }
+  activityField.input.addEventListener("change", () => {
+    session.draft = { ...session.draft, activityPanel: activityField.input.checked };
+    activityOpen.hidden = !activityField.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.",
@@ -342,6 +388,11 @@ function buildAiSettingsSection(ctx, opts) {
       }
     });
   }
+  const basesRow = ctx.makeRow("Documentation bases", "Folders of markdown the AI can answer from.", "inline");
+  basesRow.classList.add("ai-section");
+  const basesOpen = button("settings-btn settings-btn--secondary", "Manage bases\u2026", { fk: "manage-bases" });
+  basesOpen.addEventListener("click", () => openPage({ section: "bases" }));
+  basesRow.append(basesOpen);
   function renderEngines() {
     keepFocus(enginesBody, () => {
       enginesBody.replaceChildren();
@@ -413,7 +464,7 @@ function buildAiSettingsSection(ctx, opts) {
     }
     return line;
   }
-  const featuresRow = ctx.makeRow("Features", "Turn each feature on or off.");
+  const featuresRow = ctx.makeRow("Features", "Turn each feature on or off. A feature that is off disappears from the menus, and its commands and shortcuts say so instead of running.");
   featuresRow.classList.add("ai-section");
   const featureRows = [];
   const taskRows = [];
@@ -428,6 +479,7 @@ function buildAiSettingsSection(ctx, opts) {
     lbl.id = labelId;
     text.append(lbl, el("span", "settings-desc", def.description));
     const controls = el("div", "ai-feature-controls");
+    let options = null;
     if (planned) {
       controls.append(el("span", "ai-pill ai-pill--soon", "Coming later"));
       row.setAttribute("aria-disabled", "true");
@@ -443,9 +495,15 @@ function buildAiSettingsSection(ctx, opts) {
         session.draft = { ...draft, features: { ...draft.features, [def.id]: { ...draft.features[def.id] ?? {}, enabled: toggle.checked } } };
       });
       controls.append(toggle);
+      if (def.id === "ghostText") {
+        options = buildGhostOptions(toggle, text);
+      }
     }
     row.append(text, controls);
     featureRows.push(row);
+    if (options) {
+      featureRows.push(options);
+    }
   }
   featuresRow.append(ctx.makeGroup(...featureRows));
   if (taskRows.length > 0) {
@@ -491,6 +549,105 @@ function buildAiSettingsSection(ctx, opts) {
     row.append(lbl, select);
     return row;
   }
+  function buildGhostOptions(enabled, rowText) {
+    const saved = ghostTextOptions(session.draft.features);
+    const patch = (change) => {
+      const draft = session.draft;
+      const entry = { ...draft.features.ghostText ?? {} };
+      change(entry);
+      session.draft = { ...draft, features: { ...draft.features, ghostText: entry } };
+    };
+    const numberRow = (label, hint, key, value, range) => {
+      const row = ctx.makeRow(label, hint, "inline");
+      const input = el("input", "settings-input settings-input--small settings-input--short");
+      input.type = "number";
+      input.min = String(range.min);
+      input.max = String(range.max);
+      input.step = String(range.step);
+      input.value = String(value);
+      input.dataset.fk = `feature:ghostText:${key}`;
+      input.setAttribute("aria-label", label);
+      input.addEventListener("change", () => {
+        const typed = Number(input.value);
+        if (input.value.trim() === "" || !Number.isFinite(typed)) {
+          patch((entry) => {
+            delete entry[key];
+          });
+          input.value = String(range.dflt);
+          return;
+        }
+        const next = Math.min(range.max, Math.max(range.min, Math.round(typed)));
+        patch((entry) => {
+          entry[key] = next;
+        });
+        input.value = String(next);
+      });
+      row.append(input);
+      return row;
+    };
+    const delay = numberRow("Delay (ms)", "How long you pause before a suggestion is requested.", "delayMs", saved.delayMs, { min: GHOST_DELAY_MS_MIN, max: GHOST_DELAY_MS_MAX, step: 50, dflt: GHOST_DELAY_MS_DEFAULT });
+    const tokens = numberRow("Max tokens", "The longest suggestion a model may write.", "maxTokens", saved.maxTokens, { min: GHOST_MAX_TOKENS_MIN, max: GHOST_MAX_TOKENS_MAX, step: 1, dflt: GHOST_MAX_TOKENS_DEFAULT });
+    const triggerRow = ctx.makeRow("Trigger", "Automatic suggests as you pause. Manual shortcut suggests only when you press the shortcut.", "inline");
+    const trigger = el("select", "settings-input settings-input--small");
+    trigger.dataset.fk = "feature:ghostText:trigger";
+    trigger.setAttribute("aria-label", "Trigger");
+    for (const [value, label] of [["auto", "Automatic"], ["manual", "Manual shortcut"]]) {
+      const o = el("option", "", label);
+      o.value = value;
+      trigger.append(o);
+    }
+    trigger.value = saved.trigger;
+    trigger.addEventListener("change", () => {
+      patch((entry) => {
+        entry.trigger = trigger.value === "manual" ? "manual" : "auto";
+      });
+    });
+    triggerRow.append(trigger);
+    const panelId = nextId("ai-ghost-options");
+    const toggle = button("ai-disclosure ai-ghost-options-toggle", "Options", { html: ICONS.chevron, fk: "feature:ghostText:options", ariaLabel: "Inline suggestions options" });
+    toggle.setAttribute("aria-expanded", "false");
+    toggle.setAttribute("aria-controls", panelId);
+    const panel = el("div", "ai-advanced ai-ghost-options");
+    panel.id = panelId;
+    panel.hidden = true;
+    toggle.addEventListener("click", () => {
+      panel.hidden = !panel.hidden;
+      toggle.setAttribute("aria-expanded", String(!panel.hidden));
+    });
+    const group = ctx.makeGroup(delay, tokens, triggerRow);
+    panel.append(group);
+    let line = null;
+    let localOnly = null;
+    const syncVisible = () => {
+      box.hidden = !enabled.checked;
+      if (line) {
+        line.hidden = !enabled.checked || !!localOnly?.checked;
+      }
+    };
+    if (tier === 2) {
+      const localRow = ctx.makeRow("Local engines only", "Never sends suggestions to a cloud engine, even when one is set for this task.", "inline");
+      localOnly = switchInput(saved.localOnly, "Local engines only", "feature:ghostText:localOnly");
+      const onlyLocal = localOnly;
+      onlyLocal.addEventListener("change", () => {
+        patch((entry) => {
+          entry.localOnly = onlyLocal.checked;
+        });
+        syncVisible();
+      });
+      localRow.append(onlyLocal);
+      group.append(localRow);
+      line = privacyLine(() => openPage());
+      if (!canManage) {
+        line.querySelector("button")?.remove();
+      }
+      rowText.append(line);
+    }
+    const box = el("div", "settings-row ai-ghost-options-box");
+    box.append(toggle, panel);
+    enabled.addEventListener("change", syncVisible);
+    syncVisible();
+    return box;
+  }
   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" });
@@ -562,6 +719,9 @@ function buildAiSettingsSection(ctx, opts) {
     if (canManage) {
       rows.push(enginesRow);
       renderEngines();
+      if (opts.docsAvailable) {
+        rows.push(basesRow);
+      }
     }
     rows.push(cloudField.row);
     if (listConsents && forgetConsent) {
@@ -569,7 +729,7 @@ function buildAiSettingsSection(ctx, opts) {
       void refreshConsents();
     }
   }
-  rows.push(toolbarField.row, featuresRow);
+  rows.push(toolbarField.row, activityField.row, featuresRow);
   if (tier === 2) {
     rows.push(localNetsRow);
   }
@@ -666,7 +826,7 @@ function aiToolbarMenuEntries(input) {
       entries.push({ type: "separator" });
     }
   };
-  const shared = sharedDisabledReason([input.rewrite, input.explain, input.translate, input.summarize, input.titles, input.properties]);
+  const shared = sharedDisabledReason([input.rewrite, input.explain, input.translate, input.continuation, input.summarize, input.titles, input.properties, input.chat]);
   if (shared) {
     const { label, detail } = aiMenuStatusLine(shared);
     entries.push({ type: "status", id: "ai-status", label, ...detail ? { detail } : {} });
@@ -684,7 +844,7 @@ function aiToolbarMenuEntries(input) {
       id,
       label,
       icon: icon2 ?? input.icons.rewrite,
-      hint: state.enabled || state.hint === shared ? void 0 : state.hint,
+      hint: state.hint === shared ? void 0 : state.hint,
       isDisabled: () => !state.enabled,
       action: run
     });
@@ -692,15 +852,39 @@ function aiToolbarMenuEntries(input) {
   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?.());
+  add("ai-continuation", "Suggest continuation", input.icons.continuation, input.continuation, () => input.onSuggestContinuation?.());
+  if (input.inlineSuggestions) {
+    const { on } = input.inlineSuggestions;
+    entries.push({
+      type: "action",
+      id: "ai-inline-suggestions",
+      label: "Inline suggestions",
+      icon: input.icons.continuation ?? input.icons.rewrite,
+      hint: on ? "On" : "Off",
+      isActive: () => on,
+      action: () => input.onToggleInlineSuggestions?.(!on)
+    });
+  }
   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?.());
+  separate();
+  add("ai-chat", "Chat\u2026", input.icons.chat, input.chat, () => input.onChat?.());
   if (input.thinking && input.thinking.choices.length > 0) {
     separate();
     entries.push(thinkingRowEntry(input.thinking));
   }
   separate();
+  if (input.onActivity) {
+    entries.push({
+      type: "action",
+      id: "ai-activity",
+      label: "AI Activity\u2026",
+      icon: input.icons.activity ?? input.icons.manage,
+      action: () => input.onActivity?.()
+    });
+  }
   entries.push({
     type: "action",
     id: "ai-manage",
@@ -919,6 +1103,87 @@ function position(panel, anchor) {
   panel.style.top = `${Math.max(8, Math.min(top, vh - p.height - 8))}px`;
 }
 
+// src/ai-activity.ts
+var AI_ACTIVITY_LIMIT = 50;
+function aiActivityStatus(entry) {
+  if (entry.error) {
+    return entry.error.code === "cancelled" ? "cancelled" : "error";
+  }
+  if (entry.endedAt === null) {
+    return "streaming";
+  }
+  return entry.route?.viaFallback ? "fallback" : "ok";
+}
+function createAiActivityLog() {
+  let enabled = false;
+  let list = [];
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const fn of [...listeners]) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+  };
+  return {
+    get enabled() {
+      return enabled;
+    },
+    setEnabled(on) {
+      if (enabled === on) {
+        return;
+      }
+      enabled = on;
+      if (!on && list.length > 0) {
+        list = [];
+        notify();
+      }
+    },
+    entries: () => [...list],
+    get: (id) => list.find((e) => e.id === id),
+    record(entry) {
+      if (!enabled) {
+        return;
+      }
+      list = [...list, entry].slice(-AI_ACTIVITY_LIMIT);
+      notify();
+    },
+    update(id, patch) {
+      const i = list.findIndex((e) => e.id === id);
+      if (i < 0) {
+        return;
+      }
+      const current = list[i];
+      const next = { ...current, ...typeof patch === "function" ? patch(current) : patch, id };
+      list = [...list.slice(0, i), next, ...list.slice(i + 1)];
+      notify();
+    },
+    clear() {
+      if (list.length === 0) {
+        return;
+      }
+      list = [];
+      notify();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+function aiActivityResponse(result) {
+  return {
+    text: result.text,
+    ...result.usage ? { usage: result.usage } : {},
+    ...result.finishReason ? { finishReason: result.finishReason } : {},
+    ...result.timing ? { timing: result.timing } : {},
+    served: result.served
+  };
+}
+
 // src/ai-request.ts
 function aiRunThinkingOn(thinking) {
   return !!thinking && (thinking.sent ?? thinking.configured) !== "off";
@@ -983,6 +1248,39 @@ function nextRequestId(feature) {
   requestCounter += 1;
   return `ai-${feature}-${Date.now().toString(36)}-${requestCounter}`;
 }
+var turnCounter = 0;
+function nextTurnId() {
+  turnCounter += 1;
+  return `turn-${Date.now().toString(36)}-${turnCounter}`;
+}
+function askConsent(ai, engineId, about, turnId) {
+  if (turnId && ai.requestTurnConsent) {
+    return ai.requestTurnConsent(engineId, { ...about, turnId });
+  }
+  return ai.requestCloudConsent ? ai.requestCloudConsent(engineId, about) : true;
+}
+function endAiTurn(ctx, turnId) {
+  try {
+    ctx.ai.endTurn?.(turnId);
+  } catch {
+  }
+}
+function activityRoute(settings, route) {
+  const engine = settings.engines.find((e) => e.id === route.engineId);
+  return { engineId: route.engineId, modelId: route.modelId, label: engine?.name ?? route.engineId, isLocal: route.isLocal, viaFallback: route.viaFallback };
+}
+function openActivity(ctx, entry) {
+  try {
+    ctx.activity?.record(entry);
+  } catch {
+  }
+}
+function patchActivity(ctx, id, patch) {
+  try {
+    ctx.activity?.update(id, patch);
+  } catch {
+  }
+}
 function routeUnusableError(r) {
   const map = {
     cloudBlocked: "cloudBlocked",
@@ -1009,11 +1307,83 @@ function withFailures(statuses, failed) {
   }
   return out;
 }
+function pinnedSettings(settings, req, pin) {
+  const task = req.task ?? resolveAiFeature(settings.features, req.feature).task;
+  return {
+    ...settings,
+    routing: {
+      ...settings.routing,
+      fallback: "none",
+      tasks: { ...settings.routing.tasks, [task]: { engineId: pin.engineId, modelId: pin.modelId } }
+    }
+  };
+}
+async function resolveAiTurnRoute(ctx, req, signal) {
+  if (!isTier2(ctx.ai)) {
+    return { blocked: req.allowed ? !req.allowed(null) : false, route: null, pin: null };
+  }
+  const refused = {};
+  const once = {};
+  const turnId = nextTurnId();
+  try {
+    for (let pass = 0; pass < 12; pass++) {
+      if (signal.aborted) {
+        throw makeAiError("cancelled");
+      }
+      const consent = { ...ctx.consent, ...once, ...refused };
+      const resolved = resolveRoute(ctx.settings(), ctx.statuses(), consent, { feature: req.feature, ...req.task ? { task: req.task } : {} });
+      if (!isRouteUsable(resolved)) {
+        throw routeUnusableError(resolved);
+      }
+      if (req.allowed && !req.allowed(resolved)) {
+        endAiTurn(ctx, turnId);
+        return { blocked: true, route: resolved, pin: null };
+      }
+      if (!resolved.needsConsent) {
+        return {
+          blocked: false,
+          route: resolved,
+          pin: {
+            engineId: resolved.engineId,
+            modelId: resolved.modelId,
+            viaFallback: resolved.viaFallback,
+            isLocal: resolved.isLocal,
+            turnId,
+            ...resolved.reason ? { reason: resolved.reason } : {},
+            ...once[resolved.engineId] ? { consented: true } : {}
+          }
+        };
+      }
+      const reply = await askConsent(ctx.ai, resolved.engineId, { feature: req.feature, ...req.sends ? { sends: req.sends } : {}, ...req.baseIds && req.baseIds.length > 0 ? { baseIds: req.baseIds } : {} }, turnId);
+      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;
+        }
+      }
+    }
+    throw makeAiError("unknown", "No engine answered.");
+  } catch (err) {
+    endAiTurn(ctx, turnId);
+    throw err;
+  }
+}
 async function runAiCompletion(ctx, req, events, signal) {
   const tier2 = isTier2(ctx.ai);
   const failed = /* @__PURE__ */ new Map();
   const refused = {};
   const once = {};
+  const pin = tier2 ? req.pin : void 0;
+  if (pin?.consented) {
+    once[pin.engineId] = true;
+  }
   let retried = false;
   for (let pass = 0; pass < 12; pass++) {
     if (signal.aborted) {
@@ -1022,12 +1392,19 @@ async function runAiCompletion(ctx, req, events, signal) {
     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 } : {} });
+      const settings = pin ? pinnedSettings(ctx.settings(), req, pin) : ctx.settings();
+      const resolved = resolveRoute(settings, withFailures(ctx.statuses(), failed), consent, { feature: req.feature, ...req.task ? { task: req.task } : {}, ...req.localOnly ? { localOnly: true } : {} });
       if (!isRouteUsable(resolved)) {
         throw routeUnusableError(resolved);
       }
+      if (pin && pin.isLocal !== void 0 && resolved.isLocal !== pin.isLocal) {
+        const name = ctx.settings().engines.find((e) => e.id === pin.engineId)?.name || pin.engineId;
+        const moved = { ...makeAiError("unknown", `${name} moved between local and cloud during this turn. Ask again.`), engineId: pin.engineId };
+        throw moved;
+      }
       if (resolved.needsConsent) {
-        const reply = ctx.ai.requestCloudConsent ? await ctx.ai.requestCloudConsent(resolved.engineId, { feature: req.feature, ...req.sends ? { sends: req.sends } : {} }) : true;
+        const reply = await askConsent(ctx.ai, resolved.engineId, { feature: req.feature, ...req.sends ? { sends: req.sends } : {}, ...req.baseIds && req.baseIds.length > 0 ? { baseIds: req.baseIds } : {} }, pin?.turnId);
+        events.onConsent?.(reply);
         if (signal.aborted) {
           throw makeAiError("cancelled");
         }
@@ -1035,6 +1412,9 @@ async function runAiCompletion(ctx, req, events, signal) {
           ctx.consent[resolved.engineId] = true;
         } else if (reply === "once") {
           once[resolved.engineId] = true;
+          if (pin) {
+            pin.consented = true;
+          }
         } else {
           refused[resolved.engineId] = false;
           if (reply === "never") {
@@ -1043,36 +1423,62 @@ async function runAiCompletion(ctx, req, events, signal) {
         }
         continue;
       }
-      route = resolved;
+      route = pin ? { ...resolved, viaFallback: pin.viaFallback ?? false, ...pin.reason ? { reason: pin.reason } : {} } : 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;
+    const request = {
+      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 } : {},
+      ...pin?.turnId && route ? { turn: { id: pin.turnId, ...req.sends ? { sends: req.sends } : {}, ...req.baseIds && req.baseIds.length > 0 ? { baseIds: req.baseIds } : {}, isLocal: route.isLocal } } : {}
+    };
+    const entryId = request.requestId;
+    openActivity(ctx, {
+      id: entryId,
+      startedAt: Date.now(),
+      endedAt: null,
+      feature: request.feature,
+      ...req.job ? { job: req.job } : {},
+      ...req.docs ? { docs: req.docs } : {},
+      task: request.task,
+      route: route ? activityRoute(ctx.settings(), route) : null,
+      thinking: thinking?.info ?? null,
+      request,
+      response: { text: "" },
+      error: null,
+      attempt: retried ? 2 : 1
+    });
     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) => {
+      const result = await ctx.ai.complete(request, (delta) => {
         if (signal.aborted) {
           return;
         }
         gotToken = true;
         text += delta;
+        patchActivity(ctx, entryId, { response: { text } });
         events.onToken?.(delta, text);
       }, signal);
-      return { result, route, viaFallback: route?.viaFallback ?? false, thinking: thinking?.info ?? null };
+      patchActivity(ctx, entryId, { endedAt: Date.now(), response: aiActivityResponse(result) });
+      return { result, route, viaFallback: route?.viaFallback ?? false, thinking: thinking?.info ?? null, requestId: entryId };
     } catch (err) {
       const e = signal.aborted ? makeAiError("cancelled") : toAiError(err);
-      if (e.code === "unreachable" && !gotToken && !retried && route) {
+      const retrying = e.code === "unreachable" && !gotToken && !retried && !!route && !pin;
+      patchActivity(ctx, entryId, {
+        endedAt: Date.now(),
+        error: route && !e.engineId && e.code !== "cancelled" ? { ...e, engineId: route.engineId } : e,
+        ...retrying ? { retried: true } : {}
+      });
+      if (retrying && route) {
         retried = true;
         failed.set(route.engineId, e.message);
         continue;
@@ -1082,6 +1488,19 @@ async function runAiCompletion(ctx, req, events, signal) {
   }
   throw makeAiError("unknown", "No engine answered.");
 }
+function aiFeatureOffNotice(ai, settings, feature) {
+  if (!ai) {
+    return null;
+  }
+  if (!settings.enabled) {
+    return "AI is turned off. Turn it on in the AI settings.";
+  }
+  const resolved = resolveAiFeature(settings.features, feature);
+  if (resolved.enabled) {
+    return null;
+  }
+  return `${resolved.definition?.label ?? feature} is turned off in the AI settings.`;
+}
 function aiFeatureAvailability(ai, settings, statuses, consent, feature) {
   if (!ai || !settings.enabled) {
     return { state: "hidden" };
@@ -1102,112 +1521,1725 @@ function aiFeatureAvailability(ai, settings, statuses, consent, 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;
+// src/ai-activity-panel.ts
+var AI_ACTIVITY_BANNER = "This record stays in memory: nothing here is stored or sent anywhere, and turning AI Activity off clears it.";
+var AI_ACTIVITY_EMPTY = {
+  title: "No AI requests yet",
+  text: "Each request an AI feature makes from this window shows up here, with the exact messages sent and the raw response that came back."
+};
+var AI_ACTIVITY_OFF = {
+  title: "AI Activity is off",
+  text: "Requests are not recorded, and earlier ones were cleared. To record them, turn on AI Activity in the AI tab of Settings and save."
+};
+var RENDER_THROTTLE_MS = 100;
+var CONFIRM_MS = 1600;
+var NARROW_PX = 720;
+var STATUS_LABELS = {
+  streaming: "Streaming",
+  ok: "OK",
+  error: "Failed",
+  cancelled: "Cancelled",
+  fallback: "Fallback"
+};
+var pad = (n) => String(n).padStart(2, "0");
+function activityExportFileName(now = /* @__PURE__ */ new Date()) {
+  const day = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`;
+  return `mikedown-ai-activity-${day}-${pad(now.getHours())}${pad(now.getMinutes())}.txt`;
+}
+function clockTime(ms) {
+  const d = new Date(ms);
+  return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${Math.round(ms)} ms`;
   }
-  return node;
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)} s`;
+  }
+  const seconds = Math.round(ms / 1e3);
+  return `${Math.floor(seconds / 60)} min ${seconds % 60} s`;
 }
-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;
+function entryDuration(entry) {
+  return entry.endedAt === null ? null : entry.endedAt - entry.startedAt;
+}
+var JOB_LABELS = { explain: "Explain", translate: "Translate", navigate: "Chat: navigate", answer: "Chat: answer", ghostText: "Inline suggestions" };
+function featureLabel(entry) {
+  return (entry.job ? JOB_LABELS[entry.job] : void 0) ?? getAiFeature(entry.feature)?.label ?? entry.feature;
+}
+function routeOf(entry) {
+  if (entry.route) {
+    return { engine: entry.route.label, model: entry.route.modelId, isLocal: entry.route.isLocal };
   }
-  return -1;
+  const served = entry.response.served;
+  if (served) {
+    return { engine: served.engineName, model: served.modelId, isLocal: served.isLocal };
+  }
+  return { engine: null, model: null, isLocal: null };
 }
-function linkEnd(s, close) {
-  if (s[close + 1] !== "(") {
-    return -1;
+var NO_ROUTE_LABEL = "Chosen by the app";
+function routeLabel2(entry) {
+  const { engine, model } = routeOf(entry);
+  if (!engine) {
+    return NO_ROUTE_LABEL;
   }
-  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 model ? `${engine} \xB7 ${model}` : engine;
+}
+function tokensLabel(entry) {
+  const { promptTokens: promptTokens2, completionTokens } = entry.response.usage ?? {};
+  const parts = [];
+  if (promptTokens2 !== void 0) {
+    parts.push(`${promptTokens2} in`);
   }
-  return -1;
+  if (completionTokens !== void 0) {
+    parts.push(`${completionTokens} out`);
+  }
+  return parts.join(" \xB7 ");
 }
-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;
-    }
+function thinkingLabel(thinking) {
+  if (!thinking) {
+    return null;
   }
-  return -1;
+  const level = thinking.sent ?? thinking.configured;
+  const name = level ? level.charAt(0).toUpperCase() + level.slice(1) : "Model default";
+  return thinking.auto ? `${name} (this task's default)` : name;
 }
-function appendInline(parent, s) {
-  let buf = "";
-  const flush = () => {
-    if (buf) {
-      parent.appendChild(document.createTextNode(buf));
-      buf = "";
-    }
+function messageText(message) {
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  return message.content.map((part) => part.type === "text" ? part.text : `[image: ${part.mime}, ${part.bytes.length} bytes]`).join("\n");
+}
+var plural = (n, word) => `${n.toLocaleString()} ${word}${n === 1 ? "" : "s"}`;
+function docsDetailRows(entry) {
+  const { docs } = entry;
+  if (!docs) {
+    return [];
+  }
+  const ids = (list, count = list.length) => {
+    const more = count - list.length;
+    return more > 0 ? `${list.join(", ")}${list.length > 0 ? ", " : ""}and ${more} more` : list.join(", ");
   };
-  const wrap = (tag, inner, className) => {
-    flush();
-    const node = make(tag, className);
-    appendInline(node, inner);
-    parent.appendChild(node);
+  const rows = [];
+  if (docs.hop !== void 0) {
+    rows.push({ label: "Hop", value: String(docs.hop) });
+  }
+  rows.push({ label: "Pages", value: docs.pages.length > 0 ? ids(docs.pages) : "None", raw: true });
+  if (docs.droppedCount > 0) {
+    rows.push({ label: "Dropped ids", value: ids(docs.droppedIds, docs.droppedCount), raw: true });
+  }
+  if (docs.leftOutIds && docs.leftOutIds.length > 0) {
+    rows.push({ label: "Left out (key)", value: ids(docs.leftOutIds), raw: true });
+  }
+  if (docs.cutIds && docs.cutIds.length > 0) {
+    rows.push({ label: "Did not fit", value: ids(docs.cutIds), raw: true });
+  }
+  return rows;
+}
+function exportEntry(entry, index, total) {
+  const { request, response, error } = entry;
+  const { engine, model, isLocal } = routeOf(entry);
+  const duration = entryDuration(entry);
+  const thinking = thinkingLabel(entry.thinking);
+  const head = [
+    ["Time", new Date(entry.startedAt).toISOString()],
+    ["Feature", entry.feature],
+    ["Job", entry.job && JOB_LABELS[entry.job] ? entry.job : null],
+    ["Task", entry.task],
+    ["Status", aiActivityStatus(entry)],
+    ["Engine", engine ? `${engine}${isLocal === null ? "" : isLocal ? " (local)" : " (cloud)"}` : "chosen by the app"],
+    ["Model", model],
+    ["Via fallback", entry.route?.viaFallback ? "yes" : null],
+    ["Attempt", entry.attempt],
+    ...docsDetailRows(entry).map(({ label, value }) => [label, value]),
+    ["Thinking", thinking],
+    ["Duration", duration === null ? null : `${duration} ms`],
+    ["Format", request.format],
+    ["Max tokens", request.maxTokens],
+    ["Temperature", request.temperature],
+    ["Request overrides", request.requestOverrides ? JSON.stringify(request.requestOverrides) : null]
+  ];
+  const result = [
+    ["Prompt tokens", response.usage?.promptTokens],
+    ["Completion tokens", response.usage?.completionTokens],
+    ["Finish reason", response.finishReason],
+    ["Total time", response.timing ? `${response.timing.totalMs} ms` : null],
+    ["First token", response.timing?.firstTokenMs !== void 0 ? `${response.timing.firstTokenMs} ms` : null],
+    ["Served by", response.served ? `${response.served.engineName} \xB7 ${response.served.modelId} (${response.served.isLocal ? "local" : "cloud"})` : null],
+    ["Error", error ? `${error.code}: ${error.message}` : null],
+    ["Retried", entry.retried ? "yes, on another engine (the next request)" : null]
+  ];
+  const lines = (rows) => rows.filter(([, v]) => v !== null && v !== void 0).map(([k, v]) => `${k}: ${v}`);
+  const metadata = lines(result);
+  const blocks = [
+    [`=== Request ${index + 1} of ${total} ===`, ...lines(head)].join("\n"),
+    "--- Sent ---",
+    ...request.messages.map((m) => `[${m.role}]
+${messageText(m)}`),
+    "--- Received ---",
+    response.text,
+    ...metadata.length > 0 ? [["--- Result ---", ...metadata].join("\n")] : []
+  ];
+  return blocks.join("\n\n");
+}
+function formatActivityExport(entries) {
+  if (entries.length === 0) {
+    return "";
+  }
+  return `${entries.map((entry, i) => exportEntry(entry, i, entries.length)).join("\n\n")}
+`;
+}
+function setText(node, text) {
+  if (node.textContent !== text) {
+    node.textContent = text;
+  }
+}
+function setAttr(node, name, value) {
+  if (node.getAttribute(name) !== value) {
+    node.setAttribute(name, value);
+  }
+}
+function localityPill(isLocal, extraClass = "") {
+  const pill = el("span", `ai-pill ai-pill--${isLocal ? "local" : "cloud"}${extraClass ? ` ${extraClass}` : ""}`);
+  pill.innerHTML = isLocal ? ICONS.local : ICONS.cloud;
+  pill.append(el("span", "", isLocal ? "local" : "cloud"));
+  return pill;
+}
+function actionButton(action, label) {
+  const b = button("settings-btn ai-activity-action", label, { fk: `activity:${action}` });
+  b.dataset.action = action;
+  return b;
+}
+function metaList(rows) {
+  const list = el("dl", "ai-activity-meta");
+  for (const row of rows) {
+    const value = el("dd", row.raw ? "is-raw" : "", row.value);
+    value.dataset.meta = row.label;
+    list.append(el("dt", "", row.label), value);
+  }
+  return list;
+}
+function inlineStatus() {
+  const element = el("span", "ai-activity-inline-status");
+  element.setAttribute("role", "status");
+  let timer;
+  const clear = () => {
+    window.clearTimeout(timer);
+    element.textContent = "";
+    delete element.dataset.level;
   };
-  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;
+  return {
+    element,
+    clear,
+    show(text, level, ms) {
+      clear();
+      element.textContent = text;
+      element.dataset.level = level;
+      if (ms) {
+        timer = window.setTimeout(clear, ms);
+      }
     }
-    if (c === "`") {
-      let n = 1;
-      while (s[i + n] === "`") {
-        n++;
+  };
+}
+function mountAiActivityPanel(container, ctx, opts) {
+  const { log } = opts;
+  const canSave = typeof opts.saveTextFile === "function";
+  let selectedId = opts.selectId !== void 0 && log.get(opts.selectId) ? opts.selectId : null;
+  let detail = null;
+  let mounted = false;
+  let destroyed = false;
+  let narrow = false;
+  let view = selectedId ? "detail" : "list";
+  let renderTimer;
+  let lastRender = 0;
+  let savingAll = false;
+  const collapsed = { sent: false, received: false };
+  const root = el("div", "ai-page ai-activity");
+  root.tabIndex = -1;
+  const header = el("div", "ai-page-header");
+  const backBtn = button("ai-page-back", "Back", { html: ICONS.back, fk: "activity:back" });
+  backBtn.addEventListener("click", () => back());
+  const title = el("h2", "ai-page-title", "AI Activity");
+  title.id = nextId("ai-activity-title");
+  const titleLine = el("div", "ai-page-title-line");
+  titleLine.append(title, experimentalBadge());
+  const headerActions = el("div", "ai-activity-header-actions");
+  const headerStatus = inlineStatus();
+  const saveAllBtn = actionButton("save-all", "Save all");
+  saveAllBtn.hidden = !canSave;
+  saveAllBtn.addEventListener("click", () => {
+    void saveAll();
+  });
+  const clearBtn = actionButton("clear", "Clear all");
+  clearBtn.addEventListener("click", () => log.clear());
+  headerActions.append(headerStatus.element, saveAllBtn, clearBtn);
+  header.append(backBtn, titleLine, headerActions);
+  const banner = el("p", "ai-activity-banner", AI_ACTIVITY_BANNER);
+  const body = el("div", "ai-activity-body");
+  const master = el("div", "ai-activity-master");
+  const listHead = el("div", "ai-activity-list-head");
+  const listId = nextId("ai-activity-list-label");
+  const listLabel = el("span", "ai-activity-list-label", "Requests");
+  listLabel.id = listId;
+  const listCount = el("span", "ai-activity-list-count");
+  listHead.append(listLabel, listCount);
+  const list = el("div", "ai-activity-list");
+  list.setAttribute("role", "listbox");
+  list.setAttribute("aria-labelledby", listId);
+  master.append(listHead, list);
+  const detailPane = el("section", "ai-activity-detail");
+  detailPane.tabIndex = 0;
+  detailPane.setAttribute("aria-label", "Selected request");
+  body.append(master, detailPane);
+  const empty = el("div", "ai-activity-empty");
+  const emptyTitle = el("div", "ai-activity-empty-title");
+  const emptyText = el("p", "ai-activity-empty-text");
+  empty.append(emptyTitle, emptyText);
+  root.append(header, banner, body, empty);
+  const rows = /* @__PURE__ */ new Map();
+  function createRow(entry) {
+    const row = el("div", "ai-activity-row");
+    row.setAttribute("role", "option");
+    row.dataset.entryId = entry.id;
+    row.tabIndex = -1;
+    const dot = el("span", "ai-activity-dot");
+    dot.setAttribute("aria-hidden", "true");
+    const head = el("span", "ai-activity-row-head");
+    const feature = el("span", "ai-activity-row-feature");
+    const statusWord = el("span", "ai-activity-row-status");
+    head.append(feature, statusWord);
+    const when = el("span", "ai-activity-row-when");
+    const duration = el("span", "ai-activity-row-duration");
+    const time = el("span", "ai-activity-row-time");
+    when.append(duration, time);
+    const sub = el("span", "ai-activity-row-sub");
+    const engine = el("span", "ai-activity-row-engine");
+    const locality = el("span", "ai-activity-row-locality");
+    sub.append(engine, locality);
+    const tokens = el("span", "ai-activity-row-tokens");
+    row.append(dot, head, when, sub, tokens);
+    const refs = { row, dot, feature, statusWord, time, engine, locality, duration, tokens, entry: null, shownLocal: null };
+    updateRow(refs, entry);
+    return refs;
+  }
+  function updateRow(refs, entry) {
+    if (refs.entry === entry) {
+      return;
+    }
+    refs.entry = entry;
+    const status = aiActivityStatus(entry);
+    const statusText = entry.retried ? "Failed, retried" : STATUS_LABELS[status];
+    const route = routeLabel2(entry);
+    const { isLocal } = routeOf(entry);
+    const duration = entryDuration(entry);
+    if (refs.row.dataset.status !== status) {
+      refs.row.dataset.status = status;
+    }
+    setText(refs.feature, featureLabel(entry));
+    setText(refs.statusWord, status === "ok" ? "" : statusText);
+    setText(refs.time, clockTime(entry.startedAt));
+    setText(refs.engine, route);
+    setAttr(refs.engine, "title", route);
+    if (refs.shownLocal !== isLocal) {
+      refs.shownLocal = isLocal;
+      refs.locality.replaceChildren(...isLocal === null ? [] : [localityPill(isLocal)]);
+    }
+    setText(refs.duration, duration === null ? "" : formatDuration(duration));
+    setText(refs.tokens, tokensLabel(entry));
+    setAttr(refs.row, "aria-label", `${featureLabel(entry)}, ${statusText}, ${route}, ${clockTime(entry.startedAt)}`);
+  }
+  function renderList(entries) {
+    const live = new Set(entries.map((e) => e.id));
+    for (const [id, refs] of rows) {
+      if (!live.has(id)) {
+        refs.row.remove();
+        rows.delete(id);
       }
-      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;
+    }
+    const before = list.scrollTop;
+    const added = [];
+    let cursor = list.firstElementChild;
+    for (let i = entries.length - 1; i >= 0; i--) {
+      const entry = entries[i];
+      let refs = rows.get(entry.id);
+      if (!refs) {
+        refs = createRow(entry);
+        rows.set(entry.id, refs);
+        list.insertBefore(refs.row, cursor);
+        added.push(refs.row);
         continue;
       }
-      buf += run;
+      updateRow(refs, entry);
+      if (refs.row === cursor) {
+        cursor = cursor.nextElementSibling;
+      } else {
+        list.insertBefore(refs.row, cursor);
+      }
+    }
+    if (before > 0 && added.length > 0) {
+      list.scrollTop = before + added.reduce((sum, row) => sum + row.offsetHeight, 0);
+    }
+    setText(listCount, entries.length === 0 ? "" : `${entries.length} of the last ${AI_ACTIVITY_LIMIT}`);
+  }
+  function markSelected() {
+    for (const [id, refs] of rows) {
+      const on = id === selectedId;
+      setAttr(refs.row, "aria-selected", String(on));
+      refs.row.tabIndex = on ? 0 : -1;
+    }
+  }
+  function selectedRow() {
+    return selectedId ? rows.get(selectedId)?.row ?? null : null;
+  }
+  function select(id, o = {}) {
+    flush();
+    if (!log.get(id)) {
+      return;
+    }
+    selectedId = id;
+    markSelected();
+    renderDetail(log.get(id) ?? null);
+    const row = selectedRow();
+    if (row) {
+      row.scrollIntoView?.({ block: "nearest" });
+      if (o.focus) {
+        row.focus({ preventScroll: true });
+      }
+    }
+  }
+  function openDetail(o) {
+    if (!selectedId) {
+      return;
+    }
+    if (narrow) {
+      view = "detail";
+      applyLayout();
+    }
+    if (o.focus || narrow) {
+      detailPane.focus({ preventScroll: true });
+    }
+  }
+  list.addEventListener("click", (e) => {
+    const row = e.target.closest(".ai-activity-row");
+    const id = row?.dataset.entryId;
+    if (!id) {
+      return;
+    }
+    select(id, { focus: true });
+    openDetail({ focus: false });
+  });
+  list.addEventListener("keydown", (e) => {
+    if (e.altKey || e.ctrlKey || e.metaKey) {
+      return;
+    }
+    const ids = Array.from(list.children, (n) => n.dataset.entryId ?? "");
+    if (ids.length === 0) {
+      return;
+    }
+    const at = selectedId ? ids.indexOf(selectedId) : -1;
+    let next;
+    if (e.key === "ArrowDown") {
+      next = ids[Math.min(at + 1, ids.length - 1)];
+    } else if (e.key === "ArrowUp") {
+      next = ids[Math.max(at - 1, 0)];
+    } else if (e.key === "Home") {
+      next = ids[0];
+    } else if (e.key === "End") {
+      next = ids[ids.length - 1];
+    } else if (e.key === "Enter") {
+      e.preventDefault();
+      openDetail({ focus: true });
+      return;
+    } else {
+      return;
+    }
+    e.preventDefault();
+    if (next) {
+      select(next, { focus: true });
+    }
+  });
+  function buildSection(key, label) {
+    const section = el("section", "ai-activity-section");
+    section.dataset.section = key;
+    const head = el("div", "ai-activity-section-head");
+    const toggle = button("ai-disclosure ai-activity-section-toggle", label, { html: ICONS.chevron, fk: `activity:section:${key}` });
+    const summary = el("span", "ai-activity-section-summary");
+    head.append(toggle, summary);
+    const content = el("div", "ai-activity-section-body");
+    content.id = nextId(`ai-activity-${key}`);
+    toggle.setAttribute("aria-controls", content.id);
+    const apply = () => {
+      content.hidden = collapsed[key];
+      toggle.setAttribute("aria-expanded", String(!collapsed[key]));
+    };
+    apply();
+    toggle.addEventListener("click", () => {
+      collapsed[key] = !collapsed[key];
+      apply();
+    });
+    section.append(head, content);
+    return { section, summary, content };
+  }
+  function renderRoute(node, entry) {
+    const { engine, model, isLocal } = routeOf(entry);
+    const parts = [el("span", "ai-activity-route-engine", engine ?? NO_ROUTE_LABEL)];
+    if (model) {
+      parts.push(el("span", "ai-activity-route-model", model));
+    }
+    if (isLocal !== null) {
+      parts.push(localityPill(isLocal));
+    }
+    node.replaceChildren(...parts);
+  }
+  function detailNotes(entry) {
+    const out = [];
+    if (entry.error) {
+      out.push(note(entry.error.code === "cancelled" ? "info" : "error", entry.error.message));
+    }
+    if (entry.retried) {
+      out.push(note("info", "This engine could not be reached, so the request went to another engine. That attempt is the next request in the list."));
+    }
+    if (!entry.error && entry.route?.viaFallback) {
+      out.push(note("info", "The preferred engine was passed over, so a fallback engine handled this request."));
+    }
+    return out;
+  }
+  function requestRows(entry) {
+    const { format, maxTokens, temperature, requestOverrides } = entry.request;
+    const out = [];
+    if (format) {
+      out.push({ label: "Format", value: format });
+    }
+    if (maxTokens !== void 0) {
+      out.push({ label: "Max tokens", value: maxTokens.toLocaleString() });
+    }
+    if (temperature !== void 0) {
+      out.push({ label: "Temperature", value: String(temperature) });
+    }
+    if (requestOverrides) {
+      out.push({ label: "Overrides", value: JSON.stringify(requestOverrides), raw: true });
+    }
+    return out;
+  }
+  function resultRows(entry) {
+    if (entry.endedAt === null) {
+      return [];
+    }
+    const { usage, finishReason, timing, served } = entry.response;
+    const out = [];
+    const usageParts = [];
+    if (usage?.promptTokens !== void 0) {
+      usageParts.push(`${usage.promptTokens.toLocaleString()} prompt`);
+    }
+    if (usage?.completionTokens !== void 0) {
+      usageParts.push(`${usage.completionTokens.toLocaleString()} completion`);
+    }
+    if (usageParts.length > 0) {
+      out.push({ label: "Usage", value: `${usageParts.join(" \xB7 ")} tokens` });
+    }
+    if (finishReason) {
+      out.push({ label: "Finish reason", value: finishReason });
+    }
+    const total = timing?.totalMs ?? entryDuration(entry);
+    if (total !== null) {
+      const first = timing?.firstTokenMs;
+      out.push({ label: "Timing", value: first === void 0 ? formatDuration(total) : `${formatDuration(total)} total \xB7 first token at ${formatDuration(first)}` });
+    }
+    if (served) {
+      out.push({ label: "Served by", value: `${served.engineName} \xB7 ${served.modelId} (${served.isLocal ? "local" : "cloud"})` });
+    }
+    if (entry.error) {
+      out.push({ label: "Error code", value: entry.error.code });
+    }
+    return out;
+  }
+  function receivedSummaryText(entry) {
+    const size = plural(entry.response.text.length, "character");
+    if (entry.endedAt === null) {
+      return entry.response.text ? `Streaming \xB7 ${size}` : "Waiting for the first token";
+    }
+    return entry.response.text ? size : "Nothing received";
+  }
+  function buildDetail(entry) {
+    const head = el("div", "ai-activity-detail-head");
+    const titleRow = el("div", "ai-activity-detail-title-row");
+    const detailTitle = el("h3", "ai-activity-detail-title", featureLabel(entry));
+    const status = el("span", "ai-activity-status");
+    const dot = el("span", "ai-activity-dot");
+    dot.setAttribute("aria-hidden", "true");
+    const statusWord = el("span", "ai-activity-status-word");
+    status.append(dot, statusWord);
+    const actions = el("div", "ai-activity-detail-actions");
+    const copyStatus = inlineStatus();
+    const copyBtn = actionButton("copy", "Copy");
+    copyBtn.addEventListener("click", () => copySelected(copyStatus));
+    actions.append(copyStatus.element, copyBtn);
+    if (canSave) {
+      const saveBtn = actionButton("save", "Save this request");
+      saveBtn.addEventListener("click", () => {
+        void saveSelected(saveBtn, copyStatus);
+      });
+      actions.append(saveBtn);
+    }
+    titleRow.append(detailTitle, status, actions);
+    const route = el("div", "ai-activity-route");
+    renderRoute(route, entry);
+    const facts = [`Task: ${entry.task}`, `Started ${clockTime(entry.startedAt)}`];
+    const thinking = thinkingLabel(entry.thinking);
+    if (thinking) {
+      facts.unshift(`Thinking: ${thinking}`);
+    }
+    if (entry.attempt === 2) {
+      facts.push("Second attempt");
+    }
+    head.append(titleRow, route, el("div", "ai-activity-thinking", facts.join(" \xB7 ")));
+    const notes = el("div", "ai-activity-notes");
+    const docs = el("div", "ai-activity-docs");
+    const sent = buildSection("sent", "Sent");
+    const totalChars = entry.request.messages.reduce((sum, m) => sum + messageText(m).length, 0);
+    sent.summary.textContent = `${plural(entry.request.messages.length, "message")} \xB7 ${plural(totalChars, "character")}`;
+    for (const message of entry.request.messages) {
+      const text = messageText(message);
+      const block = el("div", "ai-activity-block ai-activity-message");
+      block.dataset.role = message.role;
+      const caption = el("div", "ai-activity-block-caption");
+      caption.append(el("span", "ai-activity-message-role", message.role), el("span", "ai-activity-block-size", plural(text.length, "character")));
+      block.append(caption, el("pre", "ai-activity-text ai-activity-message-text", text));
+      sent.content.append(block);
+    }
+    const requestMeta = requestRows(entry);
+    if (requestMeta.length > 0) {
+      sent.content.append(metaList(requestMeta));
+    }
+    const received = buildSection("received", "Received");
+    const receivedBlock = el("div", "ai-activity-block ai-activity-received");
+    const receivedPre = el("pre", "ai-activity-text ai-activity-received-text");
+    const receivedText = document.createTextNode("");
+    receivedPre.append(receivedText);
+    receivedBlock.append(receivedPre);
+    const receivedMeta = el("div", "ai-activity-received-meta");
+    received.content.append(receivedBlock, receivedMeta);
+    detailPane.replaceChildren();
+    const inner = el("div", "ai-activity-detail-inner");
+    inner.append(head, notes, docs, sent.section, received.section);
+    detailPane.append(inner);
+    detailPane.scrollTop = 0;
+    const refs = {
+      entry,
+      status,
+      statusWord,
+      route,
+      notes,
+      docs,
+      receivedSummary: received.summary,
+      receivedBlock,
+      receivedText,
+      receivedMeta,
+      copyStatus
+    };
+    syncDetail(refs, entry, true);
+    return refs;
+  }
+  function syncDetail(refs, entry, first = false) {
+    const previous = refs.entry;
+    refs.entry = entry;
+    const text = entry.response.text;
+    const current = refs.receivedText.data;
+    if (text !== current) {
+      if (text.startsWith(current)) {
+        refs.receivedText.appendData(text.slice(current.length));
+      } else {
+        refs.receivedText.data = text;
+      }
+    }
+    refs.receivedBlock.hidden = text === "";
+    setText(refs.receivedSummary, receivedSummaryText(entry));
+    if (first || previous.docs !== entry.docs) {
+      const rows2 = docsDetailRows(entry);
+      refs.docs.replaceChildren(...rows2.length > 0 ? [metaList(rows2)] : []);
+    }
+    const ended = first || previous.endedAt !== entry.endedAt || previous.error !== entry.error || previous.retried !== entry.retried || previous.response.served !== entry.response.served;
+    if (!ended) {
+      return;
+    }
+    const status = aiActivityStatus(entry);
+    refs.status.dataset.status = status;
+    setText(refs.statusWord, entry.retried ? "Failed, retried" : STATUS_LABELS[status]);
+    renderRoute(refs.route, entry);
+    refs.notes.replaceChildren(...detailNotes(entry));
+    const meta = resultRows(entry);
+    refs.receivedMeta.replaceChildren(...meta.length > 0 ? [metaList(meta)] : []);
+  }
+  function renderDetail(entry) {
+    if (!entry) {
+      detail?.copyStatus.clear();
+      detail = null;
+      detailPane.replaceChildren();
+      return;
+    }
+    if (detail && detail.entry.id === entry.id) {
+      if (detail.entry !== entry) {
+        syncDetail(detail, entry);
+      }
+      return;
+    }
+    detail?.copyStatus.clear();
+    detail = buildDetail(entry);
+  }
+  function copySelected(status) {
+    const entry = selectedId ? log.get(selectedId) : void 0;
+    if (!entry) {
+      return;
+    }
+    let written;
+    try {
+      written = navigator.clipboard.writeText(formatActivityExport([entry]));
+    } catch {
+      status.show("Could not copy", "error", CONFIRM_MS * 2);
+      return;
+    }
+    written.then(
+      () => {
+        if (!destroyed) {
+          status.show("Copied", "ok", CONFIRM_MS);
+        }
+      },
+      () => {
+        if (!destroyed) {
+          status.show("Could not copy", "error", CONFIRM_MS * 2);
+        }
+      }
+    );
+  }
+  async function saveEntries(entries, status) {
+    status.clear();
+    try {
+      await opts.saveTextFile?.(activityExportFileName(), formatActivityExport(entries));
+    } catch (err) {
+      if (destroyed) {
+        return;
+      }
+      const reason = err instanceof Error && err.message ? `: ${err.message}` : "";
+      status.show(`Could not save${reason}`, "error");
+    }
+  }
+  async function saveSelected(btn, status) {
+    const entry = selectedId ? log.get(selectedId) : void 0;
+    if (!entry) {
+      return;
+    }
+    btn.disabled = true;
+    await saveEntries([entry], status);
+    btn.disabled = false;
+  }
+  async function saveAll() {
+    const entries = log.entries();
+    if (entries.length === 0) {
+      return;
+    }
+    savingAll = true;
+    saveAllBtn.disabled = true;
+    await saveEntries(entries, headerStatus);
+    savingAll = false;
+    if (!destroyed) {
+      saveAllBtn.disabled = log.entries().length === 0;
+    }
+  }
+  function flush() {
+    if (renderTimer !== void 0) {
+      render();
+    }
+  }
+  function render() {
+    window.clearTimeout(renderTimer);
+    renderTimer = void 0;
+    lastRender = Date.now();
+    const entries = log.entries();
+    const isEmpty = entries.length === 0;
+    root.dataset.recording = log.enabled ? "on" : "off";
+    body.hidden = isEmpty;
+    empty.hidden = !isEmpty;
+    if (isEmpty) {
+      const copy = log.enabled ? AI_ACTIVITY_EMPTY : AI_ACTIVITY_OFF;
+      setText(emptyTitle, copy.title);
+      setText(emptyText, copy.text);
+      view = "list";
+      applyLayout();
+    }
+    clearBtn.disabled = isEmpty;
+    if (!savingAll) {
+      saveAllBtn.disabled = isEmpty;
+    }
+    renderList(entries);
+    if (selectedId && !log.get(selectedId)) {
+      selectedId = isEmpty ? null : entries[0].id;
+    } else if (!selectedId && !isEmpty) {
+      selectedId = entries[entries.length - 1].id;
+    }
+    markSelected();
+    renderDetail(selectedId ? log.get(selectedId) ?? null : null);
+    keepFocusInside();
+  }
+  function keepFocusInside() {
+    if (!mounted) {
+      return;
+    }
+    const active = document.activeElement;
+    if (active === document.body || active instanceof HTMLButtonElement && active.disabled && root.contains(active)) {
+      focus();
+    }
+  }
+  function onLogChange() {
+    if (destroyed) {
+      return;
+    }
+    const entries = log.entries();
+    const newest = entries[entries.length - 1];
+    const wait = RENDER_THROTTLE_MS - (Date.now() - lastRender);
+    if (wait <= 0 || !newest || !rows.has(newest.id)) {
+      render();
+    } else if (renderTimer === void 0) {
+      renderTimer = window.setTimeout(render, wait);
+    }
+  }
+  function focus() {
+    (selectedRow() ?? backBtn).focus({ preventScroll: true });
+  }
+  function back() {
+    if (narrow && view === "detail") {
+      view = "list";
+      applyLayout();
+      focus();
+      return;
+    }
+    ctx.close();
+  }
+  root.addEventListener("keydown", (e) => {
+    if (e.key !== "Escape" || e.defaultPrevented) {
+      return;
+    }
+    e.preventDefault();
+    e.stopPropagation();
+    back();
+  });
+  function applyLayout() {
+    root.classList.toggle("is-narrow", narrow);
+    root.dataset.view = narrow ? view : "both";
+    backBtn.setAttribute("aria-label", narrow && view === "detail" ? "Back to the list" : "Back");
+  }
+  function measure(width) {
+    const next = width > 0 && width < NARROW_PX;
+    if (next === narrow) {
+      return;
+    }
+    narrow = next;
+    applyLayout();
+  }
+  let resizeObserver = null;
+  if (typeof ResizeObserver === "function") {
+    resizeObserver = new ResizeObserver((entries) => {
+      measure(entries[0]?.contentRect.width ?? 0);
+    });
+    resizeObserver.observe(root);
+  }
+  container.append(root);
+  applyLayout();
+  render();
+  mounted = true;
+  measure(root.getBoundingClientRect().width);
+  const unsubscribe = log.subscribe(onLogChange);
+  return {
+    destroy() {
+      if (destroyed) {
+        return;
+      }
+      destroyed = true;
+      unsubscribe();
+      window.clearTimeout(renderTimer);
+      renderTimer = void 0;
+      resizeObserver?.disconnect();
+      headerStatus.clear();
+      detail?.copyStatus.clear();
+      root.remove();
+    },
+    focus,
+    refresh() {
+      if (!destroyed) {
+        render();
+      }
+    }
+  };
+}
+
+// src/ai-docs-run.ts
+function withSupportedFormat(ctx, req) {
+  if (req.format !== "json" || !req.pin) {
+    return req;
+  }
+  const { pin } = req;
+  const model = ctx.settings().engines.find((e) => e.id === pin.engineId)?.models.find((m) => m.id === pin.modelId);
+  if (model?.capabilities.json !== false) {
+    return req;
+  }
+  const { format: _format, ...rest } = req;
+  return rest;
+}
+function aiDocsLoopDeps(ctx) {
+  return {
+    resolveRoute: (req, signal) => resolveAiTurnRoute(ctx, req, signal),
+    run: (req, events, signal) => runAiCompletion(ctx, withSupportedFormat(ctx, req), events, signal),
+    contextTokens(route) {
+      if (!route) {
+        return null;
+      }
+      const engine = ctx.settings().engines.find((e) => e.id === route.engineId);
+      return engine?.models.find((m) => m.id === route.modelId)?.capabilities.contextTokens ?? null;
+    },
+    annotate(requestId, detail) {
+      try {
+        ctx.activity?.update(requestId, { docs: detail });
+      } catch {
+      }
+    },
+    endTurn(pin) {
+      if (pin.turnId) {
+        endAiTurn(ctx, pin.turnId);
+      }
+    }
+  };
+}
+function createAiDocsChat(ctx) {
+  return createDocsChat(aiDocsLoopDeps(ctx));
+}
+
+// src/ai-ghost.ts
+var GHOST_BACKOFF_MAX_MS = 5e3;
+var SILENT_REASONS = /* @__PURE__ */ new Set(["cloudBlocked", "consentDenied", "capability", "featureDisabled"]);
+function classifyGhostError(error) {
+  if (error.code !== "unknown") {
+    return error.code;
+  }
+  if (/\bis turned off\.?$/i.test(error.message) || /^No engine and model is chosen/i.test(error.message)) {
+    return "featureDisabled";
+  }
+  if (/\blacks\b/.test(error.message)) {
+    return "capability";
+  }
+  return "unknown";
+}
+var originCounter = 0;
+function createGhostController(deps) {
+  const setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+  const clearTimer = deps.clearTimer ?? ((h) => clearTimeout(h));
+  const now = deps.now ?? (() => Date.now());
+  let destroyed = false;
+  let latest = null;
+  let timer = null;
+  let controller = null;
+  let seq = 0;
+  let busy = false;
+  let visible = null;
+  let origin = null;
+  let backoffMs = 0;
+  const reported = /* @__PURE__ */ new Set();
+  let silenced = false;
+  let idleStopped = false;
+  function setBusy(next) {
+    if (busy === next) {
+      return;
+    }
+    busy = next;
+    try {
+      deps.onBusy?.(next);
+    } catch {
+    }
+  }
+  function show(text) {
+    const next = text === null || text === "" ? null : text;
+    if (next === visible) {
+      return;
+    }
+    visible = next;
+    if (destroyed) {
+      return;
+    }
+    deps.onSuggestion(next);
+  }
+  function cancelTimer() {
+    if (timer !== null) {
+      clearTimer(timer);
+      timer = null;
+    }
+  }
+  function stopStream() {
+    seq += 1;
+    const c = controller;
+    controller = null;
+    if (c && !c.signal.aborted) {
+      c.abort();
+    }
+    setBusy(false);
+  }
+  function clearAll() {
+    cancelTimer();
+    stopStream();
+    origin = null;
+    show(null);
+  }
+  function delay() {
+    return Math.max(deps.options().delayMs, backoffMs);
+  }
+  function bumpBackoff() {
+    backoffMs = Math.min(GHOST_BACKOFF_MAX_MS, Math.max(deps.options().delayMs, backoffMs) * 2);
+  }
+  function activityRoute2(route) {
+    let label = route.engineId;
+    try {
+      label = deps.routeLabel?.(route) ?? label;
+    } catch {
+    }
+    return { engineId: route.engineId, modelId: route.modelId, label, isLocal: route.isLocal, viaFallback: route.viaFallback };
+  }
+  function servedOf(o) {
+    if (o.served) {
+      return o.served;
+    }
+    if (!o.route) {
+      return null;
+    }
+    return { engineId: o.route.engineId, engineName: activityRoute2(o.route).label, modelId: o.route.modelId, isLocal: o.route.isLocal };
+  }
+  function record(entry) {
+    try {
+      deps.record?.(entry);
+    } catch {
+    }
+  }
+  function entryFor(o, response, error) {
+    return {
+      id: o.id,
+      startedAt: o.startedAt,
+      endedAt: o.endedAt ?? now(),
+      feature: "ghostText",
+      job: "ghostText",
+      task: o.request.task,
+      route: o.route ? activityRoute2(o.route) : null,
+      thinking: o.thinking,
+      request: o.request,
+      response: { text: response, ...o.served ? { served: o.served } : {} },
+      error,
+      attempt: 1
+    };
+  }
+  function markAccepted() {
+    const o = origin;
+    if (!o || o.recorded) {
+      return;
+    }
+    o.recorded = true;
+    record(entryFor(o, visible ?? o.raw, null));
+    const served = servedOf(o);
+    if (served) {
+      try {
+        deps.onServed?.(served, o.viaFallback);
+      } catch {
+      }
+    }
+  }
+  function handleError(err, o) {
+    const error = toError(err);
+    if (error.code === "cancelled") {
+      return;
+    }
+    const reason = classifyGhostError(error);
+    const silent = SILENT_REASONS.has(reason);
+    show(null);
+    if (reason === "consentDenied") {
+      silenced = true;
+    }
+    if (silent) {
+      if (!reported.has(reason)) {
+        reported.add(reason);
+        report({ reason, silent: true, error });
+      }
+      return;
+    }
+    bumpBackoff();
+    o.endedAt = now();
+    record(entryFor(o, o.raw, error));
+    report({ reason, silent: false, error });
+  }
+  function report(info) {
+    if (destroyed) {
+      return;
+    }
+    try {
+      deps.onError?.(info);
+    } catch {
+    }
+  }
+  function fire(input) {
+    if (destroyed || silenced || !input.eligible) {
+      return;
+    }
+    cancelTimer();
+    stopStream();
+    show(null);
+    origin = null;
+    const options = deps.options();
+    let snapshot;
+    try {
+      snapshot = input.read();
+    } catch {
+      return;
+    }
+    const maxTokens = continueMaxTokens(options.maxTokens);
+    const ctx = ghostContext(snapshot.markdown, snapshot.caretOffset, deps.contextTokens(), { outputTokens: maxTokens });
+    if (ctx.before.trim() === "") {
+      return;
+    }
+    const messages = buildContinueMessages({ before: ctx.before, after: ctx.after, ...input.blockKind ? { blockKind: input.blockKind } : {} });
+    const req = {
+      feature: "ghostText",
+      task: "continue",
+      sends: "cursor",
+      messages,
+      maxTokens,
+      temperature: 0.3,
+      thinking: "off",
+      job: "ghostText",
+      localOnly: options.localOnly
+    };
+    const ac = new AbortController();
+    controller = ac;
+    const mySeq = ++seq;
+    originCounter += 1;
+    const o = {
+      id: `ai-ghostText-${now().toString(36)}-g${originCounter}`,
+      startedAt: now(),
+      endedAt: null,
+      request: { requestId: "", feature: req.feature, task: req.task ?? "continue", messages, maxTokens, temperature: 0.3 },
+      route: null,
+      thinking: null,
+      served: null,
+      viaFallback: false,
+      raw: "",
+      recorded: false
+    };
+    o.request.requestId = o.id;
+    origin = o;
+    setBusy(true);
+    const events = {
+      onRoute(route, thinking) {
+        if (mySeq !== seq) {
+          return;
+        }
+        o.route = route;
+        o.thinking = thinking;
+        o.viaFallback = route?.viaFallback ?? false;
+      },
+      onToken(_delta, text) {
+        if (mySeq !== seq) {
+          return;
+        }
+        o.raw = text;
+        const r = trimGhostSuggestionDetailed(text, { atBlockEnd: input.atBlockEnd, before: ctx.before });
+        show(r.text);
+        if (r.stopped) {
+          o.endedAt = now();
+          succeeded();
+          stopStream();
+        }
+      },
+      // Not tied to `seq`: an answer given after this request was aborted counts too.
+      onConsent(reply) {
+        if (reply === "once") {
+          idleStopped = true;
+        }
+      }
+    };
+    let pending;
+    try {
+      pending = deps.run(req, events, ac.signal);
+    } catch (err) {
+      stopStream();
+      handleError(err, o);
+      return;
+    }
+    pending.then(
+      (outcome) => {
+        if (mySeq !== seq) {
+          return;
+        }
+        o.endedAt = now();
+        o.served = outcome.result.served ?? null;
+        o.viaFallback = outcome.viaFallback;
+        if (outcome.route) {
+          o.route = outcome.route;
+        }
+        if (outcome.thinking) {
+          o.thinking = outcome.thinking;
+        }
+        if (outcome.requestId) {
+          o.id = outcome.requestId;
+          o.request.requestId = outcome.requestId;
+        }
+        o.raw = outcome.result.text || o.raw;
+        const r = trimGhostSuggestionDetailed(o.raw, { atBlockEnd: input.atBlockEnd, before: ctx.before });
+        show(r.text);
+        succeeded();
+        controller = null;
+        setBusy(false);
+      },
+      (err) => {
+        if (mySeq !== seq) {
+          return;
+        }
+        controller = null;
+        setBusy(false);
+        handleError(err, o);
+      }
+    );
+  }
+  function succeeded() {
+    backoffMs = 0;
+    reported.clear();
+  }
+  function startTimer(input) {
+    timer = setTimer(() => {
+      timer = null;
+      if (!idleStopped) {
+        fire(input);
+      }
+    }, delay());
+  }
+  return {
+    noteChange(input) {
+      if (destroyed) {
+        return;
+      }
+      latest = input;
+      clearAll();
+      if (!input.eligible || silenced || idleStopped) {
+        return;
+      }
+      if (deps.options().trigger === "manual") {
+        return;
+      }
+      startTimer(input);
+    },
+    noteSelectionMove() {
+      if (destroyed) {
+        return;
+      }
+      clearAll();
+    },
+    triggerNow(input) {
+      if (destroyed) {
+        return;
+      }
+      if (input) {
+        latest = input;
+      }
+      const target = latest;
+      clearAll();
+      if (!target || !target.eligible) {
+        return;
+      }
+      fire(target);
+    },
+    accept() {
+      const text = visible;
+      if (text === null) {
+        return null;
+      }
+      markAccepted();
+      cancelTimer();
+      stopStream();
+      origin = null;
+      show(null);
+      return text;
+    },
+    acceptWord() {
+      const text = visible;
+      if (text === null) {
+        return null;
+      }
+      const word = ghostAcceptWord(text);
+      markAccepted();
+      stopStream();
+      show(text.slice(word.length));
+      return word;
+    },
+    dismiss() {
+      if (destroyed) {
+        return;
+      }
+      clearAll();
+    },
+    typed(char) {
+      const text = visible;
+      if (text === null || char === "") {
+        return false;
+      }
+      const rest = ghostPrefixMatch(text, char);
+      if (rest === null) {
+        return false;
+      }
+      stopStream();
+      if (rest === "") {
+        origin = null;
+      }
+      show(rest);
+      return true;
+    },
+    destroy() {
+      if (destroyed) {
+        return;
+      }
+      cancelTimer();
+      stopStream();
+      destroyed = true;
+      latest = null;
+      origin = null;
+      visible = null;
+    }
+  };
+}
+function toError(err) {
+  if (typeof err === "object" && err !== null && typeof err.code === "string" && typeof err.message === "string") {
+    return err;
+  }
+  if (typeof err === "object" && err !== null && err.name === "AbortError") {
+    return makeAiError("cancelled");
+  }
+  return makeAiError("unknown", err instanceof Error ? err.message : void 0);
+}
+
+// src/ai-ghost-plugin.ts
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+import { closeHistory, isHistoryTransaction } from "@tiptap/pm/history";
+var aiGhostKey = new PluginKey("aiGhost");
+var GHOST_KEY_WINDOW_MS = 1e3;
+var CARET_MARK = "\uE000\uF8FF\uE000";
+var ALLOWED_CONTAINERS = /* @__PURE__ */ new Set(["doc", "blockquote", "callout", "bulletList", "orderedList", "listItem", "taskList", "taskItem"]);
+var EMPTY = { text: null, pos: 0, shownAt: 0, change: null, decorations: DecorationSet.empty };
+function classify(tr, meta) {
+  if (meta?.own) {
+    return "own";
+  }
+  if (!tr.docChanged) {
+    return null;
+  }
+  const notTyping = isHistoryTransaction(tr) || !!tr.getMeta("paste") || !!tr.getMeta("uiEvent") || !!tr.getMeta("preventUpdate") || tr.getMeta("addToHistory") === false;
+  return notTyping ? "other" : "typing";
+}
+function ghostWidget(state, text, pos, shownAt) {
+  const toDOM = (view) => {
+    const span = view.dom.ownerDocument.createElement("span");
+    span.className = "mikedown-ghost";
+    span.setAttribute("aria-hidden", "true");
+    span.setAttribute("spellcheck", "false");
+    span.style.animationDelay = `${shownAt - Date.now()}ms`;
+    span.textContent = text;
+    return span;
+  };
+  const marks = state.storedMarks ?? state.selection.$head.marks();
+  return DecorationSet.create(state.doc, [Decoration.widget(pos, toDOM, { side: 1, marks })]);
+}
+function applyGhost(tr, prev, oldState, newState) {
+  const meta = tr.getMeta(aiGhostKey);
+  const root = tr.getMeta("appendedTransaction");
+  const change = (root ? prev.change : null) ?? classify(tr, meta);
+  let text = prev.text;
+  if (meta && "text" in meta) {
+    text = meta.text ?? null;
+  } else if (change !== "own" && (tr.docChanged || !oldState.selection.eq(newState.selection))) {
+    text = null;
+  }
+  if (text === null) {
+    return prev.text === null && prev.change === change ? prev : { ...EMPTY, change };
+  }
+  const pos = newState.selection.head;
+  if (text === prev.text && pos === prev.pos && !tr.docChanged) {
+    return prev.change === change ? prev : { ...prev, change };
+  }
+  const shownAt = prev.text === null ? Date.now() : prev.shownAt;
+  return { text, pos, shownAt, change, decorations: ghostWidget(newState, text, pos, shownAt) };
+}
+function visibleLine(text) {
+  if (!text) {
+    return null;
+  }
+  const newline = text.indexOf("\n");
+  return (newline < 0 ? text : text.slice(0, newline).replace(/[ \t]+$/, "")) || null;
+}
+function readAtCaret(state, serialize) {
+  const marked = serialize(state.tr.insertText(CARET_MARK, state.selection.head).doc);
+  const caretOffset = marked.indexOf(CARET_MARK);
+  if (caretOffset < 0) {
+    return { markdown: "", caretOffset: 0 };
+  }
+  return { markdown: marked.slice(0, caretOffset) + marked.slice(caretOffset + CARET_MARK.length), caretOffset };
+}
+function blockKindAt($head) {
+  const name = $head.parent.type.name;
+  if (name !== "paragraph" && name !== "heading") {
+    return null;
+  }
+  let kind = name === "heading" ? "heading" : "paragraph";
+  let inner = kind !== "paragraph";
+  for (let depth = $head.depth - 1; depth >= 0; depth--) {
+    const container = $head.node(depth).type.name;
+    if (!ALLOWED_CONTAINERS.has(container)) {
+      return null;
+    }
+    if (inner) {
+      continue;
+    }
+    if (container === "listItem" || container === "taskItem") {
+      kind = "listItem";
+      inner = true;
+    } else if (container === "blockquote" || container === "callout") {
+      kind = "blockquote";
+      inner = true;
+    }
+  }
+  return kind;
+}
+function probe(view, options, manual) {
+  const { state } = view;
+  const { selection } = state;
+  const { $head } = selection;
+  const input = { read: () => readAtCaret(state, options.serialize), atBlockEnd: false, eligible: false };
+  if (!selection.empty || !view.editable || view.composing) {
+    return input;
+  }
+  if (options.enabled?.() === false || options.popupOpen?.()) {
+    return input;
+  }
+  const blockKind = blockKindAt($head);
+  if (!blockKind || (state.storedMarks ?? $head.marks()).some((mark) => mark.type.name === "code")) {
+    return input;
+  }
+  const block = $head.parent;
+  if (block.textBetween($head.parentOffset, block.content.size, "\n", "\uFFFC").trim() !== "") {
+    return input;
+  }
+  if (!manual && (block.content.size === 0 || !view.hasFocus())) {
+    return input;
+  }
+  return { ...input, atBlockEnd: $head.parentOffset === block.content.size, eligible: true, blockKind };
+}
+function insertOwn(view, text, keep) {
+  const meta = keep ? { own: true } : { own: true, text: null };
+  view.dispatch(closeHistory(view.state.tr).insertText(text).setMeta(aiGhostKey, meta).scrollIntoView());
+  view.dispatch(closeHistory(view.state.tr).setMeta(aiGhostKey, { own: true }));
+}
+function insertTyped(view, char) {
+  const { from, to } = view.state.selection;
+  const plain = () => view.state.tr.insertText(char).setMeta(aiGhostKey, { own: true }).scrollIntoView();
+  if (!view.someProp("handleTextInput", (handle) => handle(view, from, to, char, plain))) {
+    view.dispatch(plain());
+  }
+}
+function ghostKey(view, event, controller) {
+  const mod = event.metaKey || event.ctrlKey;
+  if (event.key === "Tab" && !mod && !event.shiftKey && !event.altKey) {
+    const text = visibleLine(controller.accept());
+    setGhostSuggestion(view, null);
+    if (!text) {
+      return false;
+    }
+    insertOwn(view, text, false);
+    return true;
+  }
+  if (event.key === "ArrowRight" && mod && !event.shiftKey && !event.altKey) {
+    const word = visibleLine(controller.acceptWord());
+    if (!word) {
+      setGhostSuggestion(view, null);
+      return false;
+    }
+    insertOwn(view, word, true);
+    return true;
+  }
+  if (event.key === "Escape" && !mod && !event.shiftKey && !event.altKey) {
+    controller.dismiss();
+    setGhostSuggestion(view, null);
+    return true;
+  }
+  const printable = [...event.key].length === 1 && !event.metaKey && !(event.ctrlKey && !event.altKey);
+  if (printable && controller.typed(event.key)) {
+    insertTyped(view, event.key);
+    return true;
+  }
+  return false;
+}
+function createGhostPlugin(options) {
+  const { controller } = options;
+  let lastKeyAt = 0;
+  const spec = {
+    key: aiGhostKey,
+    state: {
+      init: () => EMPTY,
+      apply: applyGhost
+    },
+    view: () => ({
+      update(view, prevState) {
+        const { change } = aiGhostKey.getState(view.state) ?? EMPTY;
+        if (change === "own") {
+          return;
+        }
+        if (change === null) {
+          if (!prevState.selection.eq(view.state.selection)) {
+            controller.noteSelectionMove();
+          }
+          return;
+        }
+        const input = probe(view, options, false);
+        const keystroke = change === "typing" && Date.now() - lastKeyAt < GHOST_KEY_WINDOW_MS;
+        controller.noteChange(keystroke ? input : { ...input, eligible: false });
+      }
+    }),
+    props: {
+      decorations: (state) => aiGhostKey.getState(state)?.decorations,
+      handleDOMEvents: {
+        keydown(view, event) {
+          lastKeyAt = Date.now();
+          if (!aiGhostKey.getState(view.state)?.text) {
+            return false;
+          }
+          if (event.isComposing || event.keyCode === 229 || view.composing) {
+            return false;
+          }
+          if (options.popupOpen?.()) {
+            controller.dismiss();
+            setGhostSuggestion(view, null);
+            return false;
+          }
+          if (!ghostKey(view, event, controller)) {
+            return false;
+          }
+          event.preventDefault();
+          return true;
+        },
+        // Do not sit under an IME's own preview.
+        compositionstart() {
+          controller.dismiss();
+          return false;
+        },
+        compositionend() {
+          lastKeyAt = Date.now();
+          return false;
+        },
+        // Tab would go elsewhere, and nobody is waiting for a request once focus has left.
+        blur() {
+          controller.dismiss();
+          return false;
+        }
+      }
+    },
+    triggerNow(view) {
+      controller.triggerNow(probe(view, options, true));
+    }
+  };
+  return new Plugin(spec);
+}
+function setGhostSuggestion(view, text) {
+  if (view.isDestroyed) {
+    return;
+  }
+  const ghost = aiGhostKey.getState(view.state);
+  if (!ghost) {
+    return;
+  }
+  const next = visibleLine(text);
+  if (next === ghost.text) {
+    return;
+  }
+  if (next !== null && (!view.state.selection.empty || view.composing)) {
+    return;
+  }
+  view.dispatch(view.state.tr.setMeta(aiGhostKey, { text: next }).setMeta("addToHistory", false));
+}
+function triggerGhostNow(view) {
+  aiGhostKey.get(view.state)?.spec?.triggerNow(view);
+}
+
+// src/ai-ghost-session.ts
+function ghostFeatureOn(settings) {
+  return settings.enabled && resolveAiFeature(settings.features, "ghostText").enabled;
+}
+function withGhostFeature(settings, enabled) {
+  const features = { ...settings.features, ghostText: { ...settings.features.ghostText ?? {}, enabled } };
+  return {
+    settings: { ...settings, features },
+    patch: { "ai.features": JSON.parse(JSON.stringify(features)) }
+  };
+}
+function ghostAvailability(ai, settings, statuses, consent) {
+  const plain = aiFeatureAvailability(ai, settings, statuses, consent, "ghostText");
+  if (plain.state === "hidden" || typeof ai?.listEngines !== "function" || !ghostTextOptions(settings.features).localOnly) {
+    return plain;
+  }
+  const route = resolveRoute(settings, statuses, consent, { feature: "ghostText", localOnly: true });
+  return isRouteUsable(route) ? { state: "enabled" } : { state: "disabled", reason: route.reason };
+}
+function createGhostSession(deps) {
+  const { editor } = deps;
+  let reason = null;
+  const controller = createGhostController({
+    run: (req, events, signal) => deps.run(req, events, signal),
+    options: () => ghostTextOptions(deps.settings().features),
+    contextTokens() {
+      const settings = deps.settings();
+      const { localOnly } = ghostTextOptions(settings.features);
+      const route = resolveRoute(settings, deps.statuses(), deps.consent, { feature: "ghostText", localOnly });
+      if (!isRouteUsable(route)) {
+        return DEFAULT_CONTEXT_TOKENS;
+      }
+      const model = settings.engines.find((e) => e.id === route.engineId)?.models.find((m) => m.id === route.modelId);
+      return model?.capabilities.contextTokens ?? DEFAULT_CONTEXT_TOKENS;
+    },
+    onSuggestion(text) {
+      if (text) {
+        reason = null;
+      }
+      setGhostSuggestion(editor.view, text);
+    },
+    onBusy: (busy) => deps.onBusy(busy),
+    onServed: (served, viaFallback) => deps.onServed(served, viaFallback),
+    onError(info) {
+      reason = info.error.message;
+    },
+    record: (entry) => deps.record(entry),
+    routeLabel(route) {
+      const engine = deps.settings().engines.find((e) => e.id === route.engineId);
+      return engine ? engineDisplayName(engine) : route.engineId;
+    }
+  });
+  editor.registerPlugin(createGhostPlugin({
+    controller,
+    serialize: (doc) => editor.storage.markdown.serializer.serialize(doc),
+    popupOpen: () => deps.popupOpen(),
+    enabled: () => deps.enabled()
+  }));
+  return {
+    dismiss() {
+      controller.dismiss();
+      setGhostSuggestion(editor.view, null);
+    },
+    trigger() {
+      editor.view.focus();
+      triggerGhostNow(editor.view);
+    },
+    reason: () => reason,
+    destroy() {
+      controller.destroy();
+      editor.unregisterPlugin(aiGhostKey);
+    }
+  };
+}
+
+// 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;
     }
@@ -1368,6 +3400,959 @@ ${lines[i].trim()}`));
   into.replaceChildren(...out);
 }
 
+// src/ai-chat-panel.ts
+var AI_CHAT_SECRET_NOTICE = "Your question looks like it holds a key, so nothing was sent. Take the key out and ask again.";
+var AI_CHAT_BUSY_NOTICE = "The last request is still finishing. Try again in a moment.";
+var AI_CHAT_NO_BASES = "No documentation base is active. Turn one on or add one, or ask about this document instead.";
+var STREAM_THROTTLE_MS = 80;
+var CONFIRM_MS2 = 1600;
+var CHIP_OPEN = "\uE000";
+var CHIP_CLOSE = "\uE001";
+var CHIP_RE = /(\d+)/;
+var ICON_SEND = svgIcon('<path d="M8 13V3M3.5 7.5L8 3l4.5 4.5"/>');
+var ICON_STOP = svgIcon('<rect x="4" y="4" width="8" height="8" rx="1.5"/>');
+var ICON_COPY = svgIcon('<rect x="5.5" y="5.5" width="8" height="8" rx="1.5"/><path d="M10.5 5.5v-2a1 1 0 0 0-1-1h-6a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2"/>');
+var ICON_SAVE = svgIcon('<path d="M8 2.5v8M4.5 7.5L8 11l3.5-3.5M3 13.5h10"/>');
+function svgIcon(body) {
+  return `<svg viewBox="0 0 16 16" width="14" height="14" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${body}</svg>`;
+}
+var plural2 = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+function chatProgressLine(progress, scope) {
+  const hop = progress.hop !== void 0 ? ` hop ${progress.hop} of ${progress.maxHops}` : "";
+  switch (progress.phase) {
+    case "navigate":
+      return progress.pages > 0 ? `Reading ${plural2(progress.pages, "page")}...${hop}` : `Looking through the ${scope === "document" ? "outline" : "index"}...${hop}`;
+    case "keyword":
+      return "Searching for matching sections...";
+    case "answer":
+      return progress.pages > 0 ? `Answering from ${plural2(progress.pages, "section")}...` : "Answering...";
+  }
+}
+function chatLocalOnlyTitle(bases) {
+  const names = bases.map((b) => b.name);
+  if (names.length === 1) {
+    return `Base ${names[0]} is local-only`;
+  }
+  return `Bases ${names.slice(0, -1).join(", ")} and ${names[names.length - 1]} are local-only`;
+}
+var pad2 = (n) => String(n).padStart(2, "0");
+function chatExportFileName(now = /* @__PURE__ */ new Date()) {
+  const day = `${now.getFullYear()}${pad2(now.getMonth() + 1)}${pad2(now.getDate())}`;
+  return `mikedown-ai-chat-${day}-${pad2(now.getHours())}${pad2(now.getMinutes())}.txt`;
+}
+function formatChatExport(turns) {
+  if (turns.length === 0) {
+    return "";
+  }
+  const blocks = turns.map((turn, i) => {
+    const head = [
+      `=== Turn ${i + 1} of ${turns.length} ===`,
+      `Time: ${new Date(turn.startedAt).toISOString()}`,
+      `Scope: ${turn.scope === "bases" ? "Active bases" : "This document"}`,
+      `Status: ${turn.status}`,
+      ...turn.engine ? [`Engine: ${turn.engine}${turn.isLocal === void 0 ? "" : turn.isLocal ? " (local)" : " (cloud)"}`] : []
+    ].join("\n");
+    return [
+      head,
+      "--- Question ---",
+      turn.question ?? "(not kept: it looked like it held a key)",
+      ...turn.answer !== void 0 ? ["--- Answer ---", turn.answer] : [],
+      ...turn.notes && turn.notes.length > 0 ? ["--- Notes ---", turn.notes.join("\n")] : [],
+      ...turn.sources && turn.sources.length > 0 ? ["--- Sources ---", turn.sources.join("\n")] : []
+    ].join("\n\n");
+  });
+  return `${blocks.join("\n\n")}
+`;
+}
+function errorText(error, route, engineName) {
+  if (error.code === "unknown" && error.message) {
+    return error.message;
+  }
+  return aiErrorCopy(error.code, route ? { engine: engineName(route.engineId), model: route.modelId } : {}).message;
+}
+function answerNotes(turn, answer) {
+  const notes = [];
+  if (answer.coverage) {
+    notes.push(answer.coverage);
+  }
+  if (answer.withoutSources && !answer.coverage.includes(ANSWERED_WITHOUT_SOURCES)) {
+    notes.push(ANSWERED_WITHOUT_SOURCES);
+  }
+  if (answer.noSources && turn.scope === "bases") {
+    notes.push(NO_SOURCES_CITED);
+  }
+  return notes;
+}
+function answerParts(turn, answer) {
+  return turn.scope === "bases" ? answer.citations.parts : parseCitations(answer.answer, []).parts;
+}
+function exportTurn(turn, engineName) {
+  const base = { startedAt: turn.startedAt, scope: turn.scope, question: turn.question };
+  const route = turn.route ? { engine: `${engineName(turn.route.engineId)} \xB7 ${turn.route.modelId}`, isLocal: turn.route.isLocal } : {};
+  const outcome = turn.outcome;
+  if (!outcome) {
+    return { ...base, ...route, status: "running", ...turn.partial ? { answer: turn.partial } : {} };
+  }
+  switch (outcome.kind) {
+    case "answered":
+      return {
+        ...base,
+        ...route,
+        status: "answered",
+        answer: answerParts(turn, outcome).map((p) => p.type === "text" ? p.text : `[${p.ns.join(", ")}]`).join(""),
+        notes: answerNotes(turn, outcome),
+        sources: turn.scope === "bases" ? outcome.sent.filter((s) => outcome.citations.cited.includes(s.n)).map((s) => `[${s.n}] ${docsCitationLabel(s.section)}`) : []
+      };
+    case "cancelled":
+      return { ...base, ...route, status: "cancelled", ...turn.partial ? { answer: turn.partial } : {} };
+    case "error":
+      return { ...base, ...route, status: "failed", notes: [errorText(outcome.error, turn.route, engineName)] };
+    case "baseLocalOnly":
+      return { ...base, status: "not sent", notes: [chatLocalOnlyTitle(outcome.bases)] };
+    case "noActiveBases":
+      return { ...base, status: "not sent", notes: [AI_CHAT_NO_BASES] };
+    case "questionHasSecret":
+      return { ...base, status: "not sent", notes: [AI_CHAT_SECRET_NOTICE] };
+    case "busy":
+      return { ...base, status: "not sent", notes: [AI_CHAT_BUSY_NOTICE] };
+  }
+}
+function inlineStatus2() {
+  const element = el("span", "ai-chat-status");
+  element.setAttribute("role", "status");
+  let timer;
+  return {
+    element,
+    show(text, level = "ok") {
+      window.clearTimeout(timer);
+      element.textContent = text;
+      element.dataset.level = level;
+      timer = window.setTimeout(() => {
+        element.textContent = "";
+      }, level === "ok" ? CONFIRM_MS2 : CONFIRM_MS2 * 3);
+    },
+    dispose() {
+      window.clearTimeout(timer);
+    }
+  };
+}
+function mountAiChatPanel(container, opts) {
+  const engineName = (id) => opts.engineName?.(id) ?? id;
+  const turns = [];
+  let statuses = [];
+  let scope = "document";
+  let scopeChosen = false;
+  let current = null;
+  let controller = null;
+  let destroyed = false;
+  let streamTimer;
+  const statusDisposers = /* @__PURE__ */ new Set();
+  const makeStatus = () => {
+    const status = inlineStatus2();
+    statusDisposers.add(() => status.dispose());
+    return status;
+  };
+  const root = el("section", "ai-chat");
+  const titleId = nextId("ai-chat-title");
+  root.setAttribute("aria-labelledby", titleId);
+  const header = el("div", "ai-chat-header");
+  const title = el("h2", "ai-chat-title", "Chat");
+  title.id = titleId;
+  const headerStatus = makeStatus();
+  const copyAllBtn = button("ai-chat-icon", "", { html: ICON_COPY, ariaLabel: "Copy conversation", title: "Copy conversation", fk: "chat:copy-all" });
+  const saveBtn = button("ai-chat-icon", "", { html: ICON_SAVE, ariaLabel: "Save conversation", title: "Save conversation", fk: "chat:save" });
+  const closeBtn = button("ai-chat-icon", "", { html: ICONS.close, ariaLabel: "Close chat (clears this conversation)", title: "Close (clears this conversation)", fk: "chat:close" });
+  header.append(title, experimentalBadge(), el("span", "ai-chat-spacer"), headerStatus.element, copyAllBtn, ...opts.saveTextFile ? [saveBtn] : [], closeBtn);
+  const log = el("div", "ai-chat-log");
+  log.setAttribute("role", "log");
+  log.setAttribute("aria-live", "polite");
+  log.tabIndex = 0;
+  log.setAttribute("aria-label", "Conversation");
+  const empty = el("div", "ai-chat-empty");
+  const emptyTitle = el("div", "ai-chat-empty-title");
+  const emptyText = el("p", "ai-chat-empty-text");
+  empty.append(emptyTitle, emptyText);
+  log.append(empty);
+  const composer = el("div", "ai-chat-composer");
+  const offNote = el("div", "ai-chat-off");
+  const picker = el("div", "ai-chat-scope");
+  picker.setAttribute("role", "radiogroup");
+  picker.setAttribute("aria-label", "What to ask about");
+  const radioName = nextId("ai-chat-scope");
+  const radios = /* @__PURE__ */ new Map();
+  for (const [value, label] of [["document", "This document"], ["bases", "Active bases"]]) {
+    const option = el("label", "ai-chat-seg");
+    const radio = el("input");
+    radio.type = "radio";
+    radio.name = radioName;
+    radio.value = value;
+    radio.addEventListener("change", () => {
+      if (!radio.checked) {
+        return;
+      }
+      scopeChosen = true;
+      setScope(value);
+    });
+    radios.set(value, radio);
+    option.append(radio, el("span", "", label));
+    picker.append(option);
+  }
+  picker.hidden = !opts.docs;
+  const basesLine = el("div", "ai-chat-bases");
+  const box = el("div", "ai-chat-box");
+  const input = el("textarea", "ai-chat-input");
+  input.rows = 1;
+  input.setAttribute("aria-label", "Your question");
+  const sendBtn = button("ai-chat-send", "", { html: ICON_SEND, ariaLabel: "Send", title: "Send (Enter)", fk: "chat:send" });
+  const cancelBtn = button("ai-chat-send ai-chat-send--cancel", "", { html: ICON_STOP, ariaLabel: "Cancel", title: "Cancel (Esc)", fk: "chat:cancel" });
+  cancelBtn.hidden = true;
+  box.append(input, sendBtn, cancelBtn);
+  composer.append(offNote, picker, basesLine, box);
+  root.append(header, log, composer);
+  function activeBases() {
+    return docsActiveBases(statuses);
+  }
+  function setScope(next) {
+    scope = next;
+    const radio = radios.get(next);
+    if (radio) {
+      radio.checked = true;
+    }
+    renderComposerState();
+  }
+  function renderBasesLine() {
+    basesLine.replaceChildren();
+    basesLine.hidden = scope !== "bases";
+    if (scope !== "bases") {
+      return;
+    }
+    const active = activeBases();
+    if (active.length > 0) {
+      basesLine.textContent = active.map((s) => s.base.name).join(", ");
+      basesLine.title = basesLine.textContent;
+      return;
+    }
+    basesLine.title = "";
+    basesLine.append(el("span", "", "No base is active. "));
+    if (opts.openBases) {
+      const manage = button("ai-chat-link", "Manage bases\u2026", { fk: "chat:manage-bases" });
+      manage.addEventListener("click", () => opts.openBases?.());
+      basesLine.append(manage);
+    }
+  }
+  function renderComposerState() {
+    const off = opts.featureOffNotice();
+    offNote.replaceChildren();
+    offNote.hidden = !off;
+    if (off) {
+      offNote.append(note("info", off));
+    }
+    picker.hidden = !opts.docs || !!off;
+    renderBasesLine();
+    if (off) {
+      basesLine.hidden = true;
+    }
+    const busy = current !== null;
+    input.disabled = !!off;
+    input.placeholder = off ? "" : scope === "bases" ? "Ask your documentation\u2026" : "Ask about this document\u2026";
+    sendBtn.hidden = busy;
+    cancelBtn.hidden = !busy;
+    sendBtn.disabled = !!off || input.value.trim() === "";
+    for (const radio of radios.values()) {
+      radio.disabled = busy;
+    }
+    emptyTitle.textContent = scope === "bases" ? "Ask your documentation" : "Ask about this document";
+    emptyText.textContent = scope === "bases" ? "Answers come from the active bases, with citations you can open." : "Answers come from the text in this editor, as it is right now.";
+    empty.hidden = turns.length > 0;
+    copyAllBtn.hidden = turns.length === 0;
+    saveBtn.hidden = turns.length === 0;
+  }
+  async function loadStatuses() {
+    if (!opts.docs) {
+      return;
+    }
+    try {
+      statuses = await opts.docs.listBases();
+    } catch {
+      statuses = [];
+    }
+    if (destroyed) {
+      return;
+    }
+    if (!scopeChosen && current === null) {
+      setScope(activeBases().length > 0 ? "bases" : "document");
+    }
+    for (const turn of turns) {
+      updateChipTitles(turn);
+    }
+    renderComposerState();
+  }
+  function nearBottom() {
+    return log.scrollHeight - log.scrollTop - log.clientHeight < 48;
+  }
+  function scrollDown(was) {
+    if (was) {
+      log.scrollTop = log.scrollHeight;
+    }
+  }
+  function chipTitle(sent) {
+    const file = docsSectionFile(sent.section, sent.baseId, statuses);
+    if (!file) {
+      return sent.section.relPath;
+    }
+    return `${file.baseName}: ${file.root.replace(/[\\/]+$/, "")}/${file.relPath}`;
+  }
+  function updateChipTitles(turn) {
+    for (const { node, sent } of turn.chips) {
+      node.title = chipTitle(sent);
+    }
+  }
+  function makeChip(turn, sent, status) {
+    const label = docsCitationLabel(sent.section);
+    const content = [el("span", "ai-chat-chip-n", String(sent.n)), el("span", "ai-chat-chip-label", label)];
+    let node;
+    if (opts.openFile) {
+      node = button("ai-chat-chip", "", {});
+      node.setAttribute("aria-label", `Open source ${sent.n}: ${label}`);
+      node.addEventListener("click", () => {
+        void openCitation(sent, status);
+      });
+    } else {
+      node = el("span", "ai-chat-chip");
+    }
+    node.append(...content);
+    node.title = chipTitle(sent);
+    turn.chips.push({ node, sent });
+    return node;
+  }
+  async function openCitation(sent, status) {
+    let file = docsSectionFile(sent.section, sent.baseId, statuses);
+    if (!file) {
+      await loadStatuses();
+      if (destroyed) {
+        return;
+      }
+      file = docsSectionFile(sent.section, sent.baseId, statuses);
+    }
+    if (!file || !opts.openFile) {
+      status.show(`Could not open ${sent.section.relPath}: its base is no longer set up.`, "error");
+      return;
+    }
+    const slug = docsSectionSlug(sent.section);
+    opts.openFile(docsFileHref(file.root, file.relPath), slug ? { section: slug } : void 0);
+  }
+  function renderAnswerInto(into, turn, answer, status) {
+    const bySent = new Map(answer.sent.map((s) => [s.n, s]));
+    const marks = [];
+    let markdown = "";
+    for (const part of answerParts(turn, answer)) {
+      if (part.type === "text") {
+        markdown += part.text.replace(/[]/g, "");
+        continue;
+      }
+      part.ns.forEach((n) => {
+        const sent = bySent.get(n);
+        if (!sent) {
+          return;
+        }
+        markdown += `${CHIP_OPEN}${marks.length}${CHIP_CLOSE}`;
+        marks.push(sent);
+      });
+    }
+    renderPreviewMarkdown(into, markdown.trim());
+    const walker = document.createTreeWalker(into, NodeFilter.SHOW_TEXT);
+    const texts = [];
+    for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+      if (CHIP_RE.test(node.data)) {
+        texts.push(node);
+      }
+    }
+    for (const text of texts) {
+      const pieces = text.data.split(CHIP_RE);
+      const out = [];
+      pieces.forEach((piece, i) => {
+        if (i % 2 === 1) {
+          out.push(makeChip(turn, marks[Number(piece)], status));
+        } else if (piece) {
+          out.push(document.createTextNode(piece));
+        }
+      });
+      text.replaceWith(...out);
+    }
+  }
+  function renderNotice(body, level, text, actions = [], titleText) {
+    const card = el("div", "ai-chat-notice");
+    if (titleText) {
+      card.append(el("div", "ai-chat-notice-title", titleText));
+    }
+    card.append(note(level, text));
+    if (actions.length > 0) {
+      const row = el("div", "ai-chat-actions");
+      for (const action of actions) {
+        const b = button("ai-chat-action", action.label, { fk: action.fk });
+        b.addEventListener("click", () => action.run());
+        row.append(b);
+      }
+      card.append(row);
+    }
+    body.append(card);
+  }
+  function renderAnswered(turn, answer) {
+    const { body } = turn;
+    const status = makeStatus();
+    const text = el("div", "ai-chat-answer ai-rw-out");
+    renderAnswerInto(text, turn, answer, status);
+    body.append(text);
+    const notes = answerNotes(turn, answer);
+    if (notes.length > 0) {
+      const box2 = el("div", "ai-chat-notes");
+      for (const line of notes) {
+        box2.append(el("div", "ai-chat-note", line));
+      }
+      body.append(box2);
+    }
+    const row = el("div", "ai-chat-actions");
+    if (opts.canInsert()) {
+      const insert = button("ai-chat-action", "Insert at cursor", { fk: "chat:insert" });
+      insert.addEventListener("click", () => {
+        const sources = turn.scope === "bases" ? answer.sent : [];
+        const location = docsDocumentLocation(opts.documentFolder?.() ?? null, statuses, answer.sent.map((s) => s.baseId));
+        const { markdown, policy } = prepareInsertMarkdown(answer.answer, sources, location);
+        if (opts.insertAtCursor(markdown, policy)) {
+          status.show("Inserted");
+        } else {
+          status.show("Could not insert here.", "error");
+        }
+      });
+      row.append(insert);
+    }
+    const copy = button("ai-chat-action", "Copy", { fk: "chat:copy" });
+    copy.addEventListener("click", () => {
+      const one = exportTurn(turn, engineName);
+      const sources = one.sources && one.sources.length > 0 ? `
+
+${one.sources.join("\n")}` : "";
+      void copyText(`${one.answer ?? ""}${sources}`, status);
+    });
+    row.append(copy);
+    const requestId = answer.run.requestId;
+    if (requestId && opts.openActivity && opts.activityOn?.()) {
+      const activity = button("ai-chat-link", "Activity", { fk: "chat:activity", title: "View this request in AI Activity" });
+      activity.addEventListener("click", () => opts.openActivity?.(requestId));
+      row.append(activity);
+    }
+    row.append(status.element, el("span", "ai-chat-spacer"));
+    if (turn.route) {
+      const pill = el("span", "ai-chat-route");
+      pill.title = `${engineName(turn.route.engineId)} \xB7 ${turn.route.modelId}${turn.route.isLocal ? " (local)" : " (cloud)"}`;
+      const icon2 = el("span", "ai-chat-route-icon");
+      icon2.innerHTML = turn.route.isLocal ? ICONS.local : ICONS.cloud;
+      pill.append(icon2, el("span", "ai-chat-route-name", turn.route.modelId));
+      row.append(pill);
+    }
+    body.append(row);
+  }
+  function renderBody(turn) {
+    const { body } = turn;
+    body.replaceChildren();
+    turn.chips = [];
+    turn.live = null;
+    if (turn.question === null) {
+      turn.node.querySelector(".ai-chat-question")?.remove();
+    }
+    if (turn.running) {
+      if (turn.partial) {
+        turn.live = el("div", "ai-chat-answer ai-rw-out");
+        renderPreviewMarkdown(turn.live, turn.partial);
+        body.append(turn.live);
+      }
+      const line = el("div", "ai-chat-progress");
+      line.append(el("span", "ai-chat-dot"), el("span", "", turn.progress));
+      body.append(line);
+      return;
+    }
+    const outcome = turn.outcome;
+    if (!outcome) {
+      return;
+    }
+    switch (outcome.kind) {
+      case "answered":
+        renderAnswered(turn, outcome);
+        return;
+      case "baseLocalOnly": {
+        const onCloud = outcome.route ? `${engineName(outcome.route.engineId)} is a cloud engine, so` : "This route may not stay on this machine, so";
+        const actions = [
+          ...opts.openRouting ? [{ label: "Pick a local engine", fk: "chat:pick-local", run: () => opts.openRouting?.() }] : [],
+          ...opts.openBases ? [{ label: "Open the base's switch", fk: "chat:base-switch", run: () => opts.openBases?.() }] : []
+        ];
+        renderNotice(body, "warning", `${onCloud} nothing was sent.`, actions, chatLocalOnlyTitle(outcome.bases));
+        return;
+      }
+      case "noActiveBases":
+        renderNotice(body, "info", AI_CHAT_NO_BASES, opts.openBases ? [{ label: "Manage bases\u2026", fk: "chat:manage-bases", run: () => opts.openBases?.() }] : []);
+        return;
+      case "questionHasSecret":
+        renderNotice(body, "warning", AI_CHAT_SECRET_NOTICE);
+        return;
+      case "busy":
+        renderNotice(body, "info", AI_CHAT_BUSY_NOTICE);
+        return;
+      case "cancelled":
+        if (turn.partial) {
+          const text = el("div", "ai-chat-answer ai-rw-out is-cancelled");
+          renderPreviewMarkdown(text, turn.partial);
+          body.append(text);
+        }
+        body.append(el("div", "ai-chat-note", "Cancelled"));
+        return;
+      case "error": {
+        const actions = opts.openRouting ? [{ label: "Open engines", fk: "chat:engines", run: () => opts.openRouting?.() }] : [];
+        renderNotice(body, "error", errorText(outcome.error, turn.route, engineName), actions);
+        return;
+      }
+    }
+  }
+  function addTurn(question) {
+    const node = el("article", "ai-chat-turn");
+    const body = el("div", "ai-chat-reply");
+    node.append(el("div", "ai-chat-question", question), body);
+    const turn = {
+      scope,
+      startedAt: Date.now(),
+      question,
+      running: true,
+      partial: "",
+      progress: "Starting...",
+      route: null,
+      outcome: null,
+      node,
+      body,
+      live: null,
+      chips: []
+    };
+    turns.push(turn);
+    log.append(node);
+    renderBody(turn);
+    return turn;
+  }
+  function flushStream(turn) {
+    window.clearTimeout(streamTimer);
+    streamTimer = void 0;
+    if (!turn.running || turn !== current) {
+      return;
+    }
+    const was = nearBottom();
+    if (turn.live) {
+      renderPreviewMarkdown(turn.live, turn.partial);
+    } else {
+      renderBody(turn);
+    }
+    scrollDown(was);
+  }
+  function finish(turn, outcome) {
+    window.clearTimeout(streamTimer);
+    streamTimer = void 0;
+    const was = nearBottom();
+    turn.running = false;
+    turn.outcome = outcome;
+    if (outcome.kind === "questionHasSecret") {
+      if (input.value === "" && turn.question) {
+        input.value = turn.question;
+      }
+      turn.question = null;
+    }
+    if (outcome.kind === "busy" && input.value === "" && turn.question) {
+      input.value = turn.question;
+    }
+    if (outcome.kind === "answered") {
+      turn.route = outcome.run.route ?? turn.route;
+      turn.node.classList.add("ai-chat-turn--arrived");
+    }
+    renderBody(turn);
+    updateChipTitles(turn);
+    current = null;
+    controller = null;
+    if (outcome.kind === "noActiveBases") {
+      void loadStatuses();
+    }
+    if (document.activeElement === cancelBtn) {
+      input.focus();
+    }
+    renderComposerState();
+    resizeInput();
+    scrollDown(was);
+  }
+  function send() {
+    const question = input.value.trim();
+    if (question === "" || current !== null || opts.featureOffNotice()) {
+      return;
+    }
+    const useBases = scope === "bases" && !!opts.docs;
+    const turn = addTurn(question);
+    current = turn;
+    input.value = "";
+    resizeInput();
+    const abort = new AbortController();
+    controller = abort;
+    renderComposerState();
+    log.scrollTop = log.scrollHeight;
+    if (useBases) {
+      void loadStatuses();
+    }
+    const options = opts.docsOptions?.();
+    const docs = opts.docs;
+    const request = {
+      question,
+      scope: useBases && docs ? { kind: "bases", docs, ...options ? { options } : {} } : { kind: "document", text: opts.documentText(), ...options ? { options } : {} },
+      ...opts.thinking !== void 0 ? { thinking: opts.thinking } : {}
+    };
+    const live = () => !destroyed && current === turn;
+    opts.chat.run(request, {
+      onRoute(route) {
+        if (live()) {
+          turn.route = route;
+        }
+      },
+      onProgress(progress) {
+        if (!live()) {
+          return;
+        }
+        turn.progress = chatProgressLine(progress, turn.scope);
+        const was = nearBottom();
+        renderBody(turn);
+        scrollDown(was);
+      },
+      onToken(_delta, text) {
+        if (!live()) {
+          return;
+        }
+        turn.partial = rewriteVisibleText(text).trimStart();
+        if (streamTimer === void 0) {
+          streamTimer = window.setTimeout(() => flushStream(turn), STREAM_THROTTLE_MS);
+        }
+      }
+    }, abort.signal).then(
+      (outcome) => {
+        if (live()) {
+          finish(turn, outcome);
+        }
+      },
+      (err) => {
+        if (live()) {
+          finish(turn, { kind: "error", error: toAiError(err) });
+        }
+      }
+    );
+  }
+  function cancel() {
+    if (!current) {
+      return;
+    }
+    controller?.abort();
+    finish(current, { kind: "cancelled" });
+  }
+  async function copyText(text, status) {
+    try {
+      await navigator.clipboard.writeText(text);
+      status.show("Copied");
+    } catch {
+      status.show("Could not copy.", "error");
+    }
+  }
+  const exportAll = () => formatChatExport(turns.map((turn) => exportTurn(turn, engineName)));
+  copyAllBtn.addEventListener("click", () => {
+    void copyText(exportAll(), headerStatus);
+  });
+  saveBtn.addEventListener("click", () => {
+    Promise.resolve(opts.saveTextFile?.(chatExportFileName(), exportAll())).catch(() => {
+      if (!destroyed) {
+        headerStatus.show("Could not save.", "error");
+      }
+    });
+  });
+  function resizeInput() {
+    input.style.height = "auto";
+    if (input.scrollHeight > 0) {
+      input.style.height = `${input.scrollHeight}px`;
+    }
+  }
+  input.addEventListener("input", () => {
+    resizeInput();
+    sendBtn.disabled = !!opts.featureOffNotice() || input.value.trim() === "";
+  });
+  input.addEventListener("keydown", (e) => {
+    if (e.key !== "Enter" || e.shiftKey || e.isComposing) {
+      return;
+    }
+    e.preventDefault();
+    send();
+  });
+  sendBtn.addEventListener("click", () => send());
+  cancelBtn.addEventListener("click", () => cancel());
+  closeBtn.addEventListener("click", () => opts.onClose());
+  root.addEventListener("keydown", (e) => {
+    if (e.key !== "Escape") {
+      return;
+    }
+    e.stopPropagation();
+    if (current) {
+      cancel();
+    } else {
+      opts.onEscape?.();
+    }
+  });
+  container.append(root);
+  setScope("document");
+  void loadStatuses();
+  return {
+    destroy() {
+      if (destroyed) {
+        return;
+      }
+      destroyed = true;
+      controller?.abort();
+      controller = null;
+      current = null;
+      window.clearTimeout(streamTimer);
+      for (const dispose of statusDisposers) {
+        dispose();
+      }
+      statusDisposers.clear();
+      turns.length = 0;
+      container.replaceChildren();
+    },
+    focus() {
+      if (input.disabled) {
+        closeBtn.focus();
+      } else {
+        input.focus();
+      }
+    },
+    refresh() {
+      if (destroyed) {
+        return;
+      }
+      void loadStatuses();
+      for (const turn of turns) {
+        if (!turn.running) {
+          renderBody(turn);
+        }
+      }
+      renderComposerState();
+    }
+  };
+}
+
+// src/ai-rewrite.ts
+import { elementFromString, posToDOMRect } from "@tiptap/core";
+import { TextSelection } from "@tiptap/pm/state";
+import { DOMParser as PmDOMParser, Fragment as Fragment2 } from "@tiptap/pm/model";
+import { closeHistory as closeHistory2 } from "@tiptap/pm/history";
+import { EditorView as CmEditorView } from "@codemirror/view";
+import { isolateHistory } from "@codemirror/commands";
+
+// src/ai-insert-guard.ts
+import { Fragment } from "@tiptap/pm/model";
+var INERT_NODES = /* @__PURE__ */ new Set([
+  "blockquote",
+  "bulletList",
+  "callout",
+  "codeBlock",
+  "emoji",
+  "footnoteDef",
+  "footnoteRef",
+  "hardBreak",
+  "heading",
+  "horizontalRule",
+  "listItem",
+  "mathBlock",
+  "mathInline",
+  "orderedList",
+  "paragraph",
+  "table",
+  "tableCell",
+  "tableHeader",
+  "tableRow",
+  "taskItem",
+  "taskList",
+  "text"
+]);
+var INERT_MARKS = /* @__PURE__ */ new Set(["bold", "code", "highlight", "italic", "strike", "underline"]);
+function insertUrlCheck(policy, md) {
+  const citations = new Set(md ? policy.citationHrefs.map((h) => md.normalizeLink(h)) : policy.citationHrefs);
+  const verbatim = (url, kind) => insertUrlIsVerbatim(policy, url, kind) || !!md && insertUrlIsVerbatim(policy, md.normalizeLinkText(url), kind);
+  return {
+    link: (href) => citations.has(href) || verbatim(href, "link"),
+    image: (src) => verbatim(src, "image")
+  };
+}
+function plainText(node) {
+  if (node.type.name === "image") {
+    return [node.attrs.alt, node.attrs.src].filter(Boolean).join(" ");
+  }
+  const attrs = node.attrs;
+  return (node.textContent || String(attrs.alias ?? attrs.target ?? attrs.body ?? "")).replace(/\s+/g, " ").trim();
+}
+var InvalidContent = class extends Error {
+};
+function guardInsertFragment(fragment, check) {
+  const dropped = [];
+  const keepMarks = (marks) => {
+    const kept = marks.filter((mark) => {
+      if (INERT_MARKS.has(mark.type.name)) {
+        return true;
+      }
+      if (mark.type.name === "link") {
+        const href = String(mark.attrs.href ?? "");
+        if (check.link(href)) {
+          return true;
+        }
+        dropped.push(href);
+        return false;
+      }
+      dropped.push(`mark:${mark.type.name}`);
+      return false;
+    });
+    return kept.length === marks.length ? marks : kept;
+  };
+  const asPlain = (node, marks) => {
+    const { schema } = node.type;
+    const text = plainText(node);
+    if (node.isInline) {
+      return text ? [schema.text(text, marks)] : [];
+    }
+    return text ? [schema.nodes.paragraph.create(null, schema.text(text))] : [];
+  };
+  const walkNode = (node) => {
+    const name = node.type.name;
+    const marks = keepMarks(node.marks);
+    if (name === "image") {
+      const src = String(node.attrs.src ?? "");
+      if (check.image(src)) {
+        return [marks === node.marks ? node : node.mark(marks)];
+      }
+      dropped.push(src);
+      return asPlain(node, marks);
+    }
+    if (!INERT_NODES.has(name)) {
+      dropped.push(`node:${name}:${JSON.stringify(node.attrs)}`);
+      return asPlain(node, marks);
+    }
+    if (node.isText) {
+      return [marks === node.marks ? node : node.mark(marks)];
+    }
+    const kids = walkFragment(node.content);
+    if (kids !== node.content && !node.type.validContent(kids)) {
+      throw new InvalidContent();
+    }
+    if (kids === node.content && marks === node.marks) {
+      return [node];
+    }
+    return [node.type.create(node.attrs, kids, marks)];
+  };
+  const walkFragment = (content) => {
+    const out = [];
+    let same = true;
+    content.forEach((child) => {
+      const next = walkNode(child);
+      if (next.length !== 1 || next[0] !== child) {
+        same = false;
+      }
+      out.push(...next);
+    });
+    return same ? content : Fragment.fromArray(out);
+  };
+  try {
+    return { fragment: walkFragment(fragment), dropped };
+  } catch (err) {
+    if (err instanceof InvalidContent) {
+      return null;
+    }
+    throw err;
+  }
+}
+function offenders(markdown, inspector) {
+  const { check, md } = inspector;
+  if (!md) {
+    return null;
+  }
+  const guarded = guardInsertFragment(inspector.fragment(markdown), check);
+  if (!guarded) {
+    return null;
+  }
+  const found = new Set(guarded.dropped);
+  const env = {};
+  const visit = (tokens) => {
+    for (const token of tokens) {
+      if (token.type === "link_open") {
+        const href = token.attrGet("href") ?? "";
+        if (!check.link(href)) {
+          found.add(href);
+        }
+      } else if (token.type === "image") {
+        const src = token.attrGet("src") ?? "";
+        if (!check.image(src)) {
+          found.add(src);
+        }
+      }
+      if (token.children) {
+        visit(token.children);
+      }
+    }
+  };
+  visit(md.parse(markdown, env));
+  for (const def of Object.values(env.references ?? {})) {
+    const href = def.href ?? "";
+    if (!check.link(href) && !check.image(href)) {
+      found.add(href);
+    }
+  }
+  return found;
+}
+function escapeLinkSyntax(text) {
+  return text.replace(/[\\[\]!<`]/g, "\\$&");
+}
+function escapeAllPunctuation(text) {
+  return text.replace(/[!-/:-@[-`{-~]/g, "\\$&");
+}
+function escapeAffectedParts(markdown, clean) {
+  return markdown.split(/(\n[ \t]*\n)/).map((part, i) => i % 2 === 1 || clean(part) ? part : escapeLinkSyntax(part)).join("");
+}
+function guardSourceMarkdown(markdown, inspector, placed) {
+  const cleanAlone = (text) => offenders(text, inspector)?.size === 0;
+  let existing = null;
+  const cleanInPlace = (text) => {
+    if (!placed) {
+      return true;
+    }
+    const { before, after } = placed(text);
+    existing ?? (existing = offenders(before, inspector));
+    const now = offenders(after, inspector);
+    if (!existing || !now) {
+      return false;
+    }
+    for (const url of now) {
+      if (!existing.has(url)) {
+        return false;
+      }
+    }
+    return true;
+  };
+  const candidates = [
+    () => markdown,
+    () => escapeAffectedParts(markdown, cleanAlone),
+    () => escapeLinkSyntax(markdown),
+    () => escapeAllPunctuation(markdown)
+  ];
+  for (const candidate of candidates) {
+    const text = candidate();
+    if (cleanAlone(text) && cleanInPlace(text)) {
+      return text;
+    }
+  }
+  return null;
+}
+
 // src/ai-rewrite.ts
 var nextTargetId = 0;
 function serializeFragment(editor, fragment) {
@@ -1386,7 +4371,7 @@ function serializeRange(editor, doc, from, to) {
   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, Fragment2.from(paragraph.create(null, content)));
   }
   return serializeFragment(editor, content);
 }
@@ -1397,6 +4382,10 @@ function parseBlocks(editor, markdown) {
   const html = markdownStorage(editor)?.parser?.parse(markdown) ?? markdown;
   return PmDOMParser.fromSchema(editor.state.schema).parse(elementFromString(html)).content;
 }
+function sourceInspector(editor, policy) {
+  const md = markdownStorage(editor)?.parser?.md;
+  return { check: insertUrlCheck(policy, md), fragment: (markdown) => parseBlocks(editor, markdown), md };
+}
 function blockquoteMarkdown(text) {
   return text.trim().split("\n").map((line) => line.trim() ? `> ${line}` : ">").join("\n");
 }
@@ -1486,7 +4475,7 @@ function richRewriteTarget(editor) {
         from2 = $a.before();
         to2 = $b.after();
       }
-      const tr = closeHistory(current.tr).replaceRange(from2, to2, slice);
+      const tr = closeHistory2(current.tr).replaceRange(from2, to2, slice);
       tr.setMeta(aiRewriteHighlightKey, { range: null });
       const end = tr.mapping.map(to2, 1);
       try {
@@ -1508,7 +4497,7 @@ function richRewriteTarget(editor) {
       }
       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());
+      editor.view.dispatch(closeHistory2(current.tr).insert(pos, content).scrollIntoView());
       return true;
     },
     release() {
@@ -1643,7 +4632,7 @@ function richDocumentTarget(editor, opts = {}) {
       if (!content.size) {
         return false;
       }
-      const tr = closeHistory(current.tr).replaceWith(0, current.doc.content.size, content);
+      const tr = closeHistory2(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());
@@ -1734,17 +4723,24 @@ function cursorInsertTarget(editor, slash) {
         return null;
       }
     },
-    accept(markdown) {
+    accept(markdown, policy) {
       const r = range();
       if (!r || editor.isDestroyed) {
         return false;
       }
-      const content = parseBlocks(editor, markdown);
+      let content = parseBlocks(editor, markdown);
+      if (policy) {
+        const guarded = guardInsertFragment(content, insertUrlCheck(policy, markdownStorage(editor)?.parser?.md));
+        if (!guarded) {
+          return false;
+        }
+        content = guarded.fragment;
+      }
       if (!content.size) {
         return false;
       }
       const current = editor.state;
-      const tr = closeHistory(current.tr);
+      const tr = closeHistory2(current.tr);
       let at = r.from;
       if (r.to > r.from) {
         const $q = current.doc.resolve(r.from);
@@ -1754,6 +4750,9 @@ function cursorInsertTarget(editor, slash) {
         tr.delete(at, r.to);
       }
       tr.setMeta(aiRewriteHighlightKey, { range: null });
+      if (policy) {
+        tr.setMeta("preventAutolink", true);
+      }
       const $at = tr.doc.resolve(Math.min(at, tr.doc.content.size));
       let from = $at.pos;
       let to = $at.pos;
@@ -1786,7 +4785,7 @@ function cursorInsertTarget(editor, slash) {
     }
   };
 }
-function sourceCursorTarget(view, bodyStart) {
+function sourceCursorTarget(view, bodyStart, parserEditor) {
   const id = ++nextTargetId;
   const head = view.state.selection.main.head;
   view.dispatch({ effects: setCmRewriteRange.of({ from: head, to: head, id, anchor: true }) });
@@ -1811,9 +4810,9 @@ function sourceCursorTarget(view, bodyStart) {
       const c = r ? view.coordsAtPos(r.from) : null;
       return c ? rectUnion(c, c) : null;
     },
-    accept(markdown) {
+    accept(markdown, policy) {
       const r = range();
-      const md = markdown.trim();
+      let md = markdown.trim();
       if (!r || !md) {
         return false;
       }
@@ -1823,18 +4822,31 @@ function sourceCursorTarget(view, bodyStart) {
       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: `
+      const place = (text) => {
+        if (!line.text.trim()) {
+          const lead = prev && prev.text.trim() && line.from >= start ? "\n" : "";
+          return { changes: { from: line.from, to: line.to, insert: `${lead}${text}${textAfter ? "\n" : ""}` }, caret: line.from + lead.length + text.length };
+        }
+        return { changes: { from: line.to, insert: `
 
-${md}${textAfter ? "\n" : ""}` };
-        caret = line.to + 2 + md.length;
+${text}${textAfter ? "\n" : ""}` }, caret: line.to + 2 + text.length };
+      };
+      if (policy) {
+        if (!parserEditor || parserEditor.isDestroyed) {
+          return false;
+        }
+        const before = doc.toString();
+        const guarded = guardSourceMarkdown(md, sourceInspector(parserEditor, policy), (text) => {
+          const { changes: changes2 } = place(text);
+          const after = before.slice(0, changes2.from) + changes2.insert + before.slice(changes2.to ?? changes2.from);
+          return { before: before.slice(start), after: after.slice(bodyStart ? bodyStart(after) : 0) };
+        });
+        if (guarded === null) {
+          return false;
+        }
+        md = guarded;
       }
+      const { changes, caret } = place(md);
       view.dispatch({
         changes,
         selection: { anchor: caret },
@@ -1890,7 +4902,7 @@ function applyRichTitle(editor, effect, title, remove) {
   if (!heading) {
     return false;
   }
-  const tr = closeHistory(editor.state.tr);
+  const tr = closeHistory2(editor.state.tr);
   if (remove && remove.to > remove.from) {
     tr.delete(remove.from, remove.to);
   }
@@ -3305,14 +6317,18 @@ ${untranslated.trimStart()}`) : t.accept(finalText);
   };
 }
 export {
+  AI_ACTIVITY_LIMIT,
   AI_ENGINE_PRESETS,
   AI_TURN_ON_PATCH,
   CHARS_PER_TOKEN,
   DEFAULT_CONTEXT_TOKENS,
   PROPERTY_VOCABULARY_MAX,
+  activityExportFileName,
+  aiActivityStatus,
   aiConsentHost,
   aiErrorCopy,
   aiFeatureAvailability,
+  aiFeatureOffNotice,
   aiIndicatorState,
   aiLengthLimitCopy,
   aiNextRouteChanged,
@@ -3326,11 +6342,19 @@ export {
   budgetDocument,
   buildAiSettingsSection,
   buildPropertiesMessages,
+  createAiActivityLog,
+  createAiDocsChat,
   createAiRewritePopover,
+  createDocsBasesSection,
+  createGhostSession,
   cursorInsertTarget,
   detectLocalServers,
+  docsHeadingAt,
   engineDisplayName,
   experimentalBadge,
+  formatActivityExport,
+  ghostAvailability,
+  ghostFeatureOn,
   headingsOutline,
   hideAiFirstRunPanel,
   hostOfUrl,
@@ -3340,6 +6364,8 @@ export {
   jsonRepairMessages,
   loadThinkingLevel,
   makeAiError,
+  mountAiActivityPanel,
+  mountAiChatPanel,
   mountAiEnginesPage,
   parseAiSettings,
   parsePropertySuggestions,
@@ -3364,7 +6390,8 @@ export {
   thinkingLevelFor,
   toAiError,
   whatIsSent,
+  withGhostFeature,
   withSavedAiKeys,
   yamlHasTitle
 };
-//# sourceMappingURL=ai-ui-C7ENTWWU.js.map
+//# sourceMappingURL=ai-ui-QFYFN73D.js.map