@mikedown/core 0.2.0 → 0.4.0

package/dist/ai/index.d.ts

@@ -0,0 +1,2722 @@
+import { c as AiModelCapabilities, d as AiCapabilityFlag, e as AiSendsScope, f as AiFeatureSettings, g as AiLocality, h as AiEngineConfig, i as AiEngineKind, j as AiModelConfig, k as AiDiscoveredModel, l as AiApiKeyFile, m as AiDocsOptions, A as AiSettings, a as AiEngineStatus, n as AiFinishReason, o as AiUsage, p as AiErrorCode, q as AiCompletionResult, r as AiCompletionRequest, s as AiMessage, t as AiError, u as AiDocsLink, v as AiDocsIndex, w as AiDocsPage, x as AiDocsHome, y as AiDocsSectionRef, z as AiDocsSection, B as AiDocBaseStatus, b as MikeDownDocsHost, C as AiDocsNavigateBy, D as AiConsentRecord, E as AiLocalServerProbe, F as AiHardwareInfo, G as AiHostEngineProbe } from '../types-DO8UBybZ.js';
+export { H as AI_CAPABILITY_FLAGS, I as AI_DOCS_MAX_HOPS_DEFAULT, J as AI_DOCS_MAX_HOPS_MAX, K as AI_DOCS_MAX_HOPS_MIN, L as AI_DOCS_NAVIGATE_BY, N as AI_DOCS_NAVIGATE_BY_DEFAULT, O as AI_DOCS_SOURCE_SHARE_DEFAULT, P as AI_DOCS_SOURCE_SHARE_MAX, Q as AI_DOCS_SOURCE_SHARE_MIN, R as AI_ENGINE_KINDS, S as AI_ERROR_CODES, T as AI_FALLBACK_MODES, U as AI_HOST_ENGINE_KINDS, V as AI_TURN_GRANT_MAX_USES, W as AiCapabilitiesSource, X as AiCompletionTurn, Y as AiConsentAbout, Z as AiConsentReply, _ as AiDocBase, $ as AiDocHomeKind, a0 as AiDocRootStatus, a1 as AiDocsHeading, a2 as AiDocsSettings, a3 as AiEngineStatusModel, a4 as AiFallbackMode, a5 as AiFeatureSetting, a6 as AiGhostTextOptions, a7 as AiGhostTrigger, a8 as AiKeySource, a9 as AiLocalitySetting, aa as AiMessagePart, ab as AiRoute, ac as AiRouting, ad as AiServedBy, ae as AiTiming, af as AiTurnConsentAbout, ag as DEFAULT_CONTEXT_TOKENS, M as MikeDownAiHost, ah as ProviderAdapter } from '../types-DO8UBybZ.js';
+export { a as AI_SETTINGS_KEYS, A as AiSettingsPatch, D as DocRootCheck, G as GHOST_DELAY_MS_DEFAULT, b as GHOST_DELAY_MS_MAX, c as GHOST_DELAY_MS_MIN, d as GHOST_MAX_TOKENS_DEFAULT, e as GHOST_MAX_TOKENS_MAX, f as GHOST_MAX_TOKENS_MIN, P as ParseAiSettingsOptions, g as checkDocRoot, h as docRootKey, i as generateAiId, j as ghostTextOptions, k as isHostEngineKind, l as isKnownEngineKind, n as normalizeDocHomeFile, p as parseAiSettings, m as parseDocBases, o as parseDocsOptions, r as resolveDocsSettings, s as serializeAiSettings } from '../schema-DVfssxQX.js';
+
+/**
+ * Task taxonomy. A feature names a task; the router picks the engine and
+ * model routed to that task and checks the model has what the task needs.
+ * Task ids are the keys of `routing.tasks`; unknown ids saved by a newer
+ * version are kept and route like any other (with no requirements).
+ */
+
+/** A task's needs. Booleans must be true on the model; `contextTokens` is a minimum. */
+type AiCapabilityRequirements = Partial<AiModelCapabilities>;
+interface AiTaskDefinition {
+    id: string;
+    label: string;
+    description: string;
+    requires: AiCapabilityRequirements;
+    /**
+     * Nice to have, never a gate: the router tries candidates that meet these
+     * first and still uses one that does not (a model without JSON mode, a
+     * small context window).
+     */
+    prefers?: AiCapabilityRequirements;
+    /** At least one of these flags must be true (ghost text: a FIM model, or a chat model with a continue prompt). */
+    requiresAny?: AiCapabilityFlag[];
+    /** Served by a host method rather than a model completion. */
+    hostMethod?: 'embed' | 'transcribe';
+}
+/** The "comfortable" context for `summarize`: preferred by the router, and the point below which the UI may warn. Not a gate. */
+declare const SUMMARIZE_MIN_CONTEXT_TOKENS = 32768;
+declare const AI_TASKS: readonly AiTaskDefinition[];
+declare function getAiTask(id: string): AiTaskDefinition | undefined;
+/** Merge two requirement sets: flags OR together, `contextTokens` takes the larger minimum. */
+declare function combineRequirements(a: AiCapabilityRequirements, b: AiCapabilityRequirements): AiCapabilityRequirements;
+/**
+ * The capabilities a model lacks for these requirements, as flag names (and
+ * `contextTokens` when the window is too small). Empty means it qualifies.
+ * An unknown context window counts as `DEFAULT_CONTEXT_TOKENS`.
+ */
+declare function missingCapabilities(caps: AiModelCapabilities, requires: AiCapabilityRequirements, requiresAny?: readonly AiCapabilityFlag[], defaultContextTokens?: number): Array<keyof AiModelCapabilities>;
+
+/**
+ * Feature registry. A feature's defaults (on or off, which task it uses,
+ * what else it needs from a model) live here, so adding a feature is one
+ * entry plus its UI and never a settings migration. `features.<id>` in
+ * settings overrides `enabled` and `task`.
+ */
+
+interface AiFeatureDefinition {
+    id: string;
+    label: string;
+    description: string;
+    defaultEnabled: boolean;
+    defaultTask: string;
+    /** Needs on top of the task's own. */
+    requires: AiCapabilityRequirements;
+    /** `planned` features are listed greyed ("coming later") and never surface. */
+    status: 'available' | 'planned';
+    /** What a request sends, for the consent dialogs and tooltips (`whatIsSent`). Absent: a generic sentence. */
+    sends?: AiSendsScope;
+}
+declare const AI_FEATURES: readonly AiFeatureDefinition[];
+declare function getAiFeature(id: string): AiFeatureDefinition | undefined;
+interface ResolvedAiFeature {
+    id: string;
+    /** Saved value, else the registry default. Unknown features default to off. */
+    enabled: boolean;
+    /** Saved override, else the registry default task, else the feature id. */
+    task: string;
+    requires: AiCapabilityRequirements;
+    definition?: AiFeatureDefinition;
+}
+/** A feature's effective state from saved settings plus the registry. Ignores the master switch. */
+declare function resolveAiFeature(features: AiFeatureSettings, id: string): ResolvedAiFeature;
+
+/**
+ * Local or cloud, from an engine's base URL. Loopback, link-local, IPv6
+ * unique-local, `localhost`, `.local`, `.lan`, `.home.arpa` and `.internal`
+ * are always local; `localNetworks` adds CIDR ranges (RFC 1918 by default, a
+ * WireGuard range such as `10.0.98.0/24`) and `.suffix` host names. Anything
+ * else, including a URL that does not parse, is cloud.
+ */
+
+/** Default `mikedown.ai.localNetworks`: RFC 1918. */
+declare const DEFAULT_LOCAL_NETWORKS: readonly string[];
+/** Lower-cased host of a URL (no port, no brackets), or null. Accepts a bare `host:port`. */
+declare function hostOfUrl(url: string): string | null;
+/**
+ * `local` or `cloud` for a base URL. `localNetworks` entries are IPv4 CIDR
+ * ranges (`10.0.98.0/24`, a bare address counts as /32) or host-name
+ * suffixes (`.ts.net`, `studio.example.com`).
+ */
+declare function detectLocality(baseUrl: string, localNetworks?: readonly string[]): AiLocality;
+/**
+ * The engine's effective locality: its pin, or `detectLocality` for `auto`.
+ * A `vscode-lm` engine is always cloud, whatever its pin: it has no address,
+ * and the text goes to GitHub's Copilot service.
+ */
+declare function engineLocality(engine: Pick<AiEngineConfig, 'baseUrl' | 'locality'> & {
+    kind?: string;
+}, localNetworks?: readonly string[]): AiLocality;
+/**
+ * True when a pinned locality disagrees with the URL (cloud pinned on a
+ * private address, or local pinned on a public one). The indicator shows a
+ * warning glyph for it.
+ */
+declare function localityMismatch(engine: Pick<AiEngineConfig, 'baseUrl' | 'locality'> & {
+    kind?: string;
+}, localNetworks?: readonly string[]): boolean;
+
+/**
+ * Capability detection for models the endpoint does not describe (oMLX and
+ * most OpenAI-compatible servers list bare ids). Order of trust: endpoint
+ * metadata, then these heuristics, then user edits, which always win and
+ * survive re-discovery (`capabilitiesSource: 'user'`).
+ *
+ * Local models: an ordered regex table of families; every matching rule
+ * applies in order, so later, more specific rules override earlier ones.
+ * Cloud models (Anthropic, OpenAI): static tables matched by the longest id
+ * prefix, so a new model in a known line inherits its line's values.
+ */
+
+type CloudTable = Array<{
+    prefix: string;
+    caps: Partial<AiModelCapabilities>;
+}>;
+/** Anthropic models, matched by the longest prefix. Unknown `claude-*` ids get the generic row. */
+declare const ANTHROPIC_MODEL_TABLE: CloudTable;
+/** OpenAI models, matched by the longest prefix. */
+declare const OPENAI_MODEL_TABLE: CloudTable;
+/**
+ * OpenAI's reasoning models, which take only the default sampling: Chat
+ * Completions rejects a `temperature` or `top_p` other than 1 for them. The
+ * native `openai` kind matches on the id; any other kind only on an
+ * `openai/` id (OpenRouter), so a local model that happens to be called
+ * `o3-something` keeps its sampling. `-chat-latest` snapshots match too:
+ * the default sampling costs nothing there.
+ */
+declare function isOpenAiReasoningModel(modelId: string, kind?: AiEngineKind): boolean;
+/**
+ * The `reasoning_effort` that means "Off" for an OpenAI reasoning model, or
+ * null when `modelId` is not one (the caller leaves the request alone). The
+ * Thinking dial stores Off as `none`, which only some families accept:
+ *
+ * - `gpt-5.1` onwards in the 5.x line (5.5 included): `none`.
+ * - `gpt-5`, `gpt-5-mini`, `gpt-5-nano`: `minimal`.
+ * - everything else (o-series, `gpt-6`+, codex and pro variants, ids not
+ *   documented yet): `low`, the one value every reasoning family accepts.
+ *   Newer models reject `none` (and some `minimal`), so unknown means `low`.
+ */
+declare function openAiOffReasoningEffort(modelId: string, kind?: AiEngineKind): 'none' | 'minimal' | 'low' | null;
+interface DetectedCapabilities {
+    capabilities: AiModelCapabilities;
+    /** The family rule or table prefix that matched last, or null for the generic default. */
+    family: string | null;
+}
+/**
+ * Capabilities guessed from a model id. A `vscode-lm` model is a plain chat
+ * model (the endpoint gives its context window). Anthropic and OpenAI engines use
+ * their static tables; any engine whose id (after a `vendor/` prefix, as on
+ * OpenRouter) starts with `claude-` or a known OpenAI line does too. An id
+ * nothing matches is a plain chat model with `DEFAULT_CONTEXT_TOKENS`.
+ */
+declare function detectCapabilities(modelId: string, kind?: AiEngineKind): DetectedCapabilities;
+/** Endpoint values over heuristics: fields the endpoint left out (or null) come from the id. */
+declare function completeCapabilities(partial: Partial<AiModelCapabilities>, modelId: string, kind?: AiEngineKind): AiModelCapabilities;
+/**
+ * Merge one discovery into an engine's saved models, by id:
+ *
+ * - listed and saved: `endpoint`/`heuristic` rows get the fresh values, `user`
+ *   rows keep theirs; `enabled`, `label` and `requestOverrides` are kept, and
+ *   `missing` is cleared;
+ * - saved but not listed: marked `missing: true` (greyed, not deleted), except
+ *   manual entries, which are left alone;
+ * - listed but new: appended in discovery order, enabled unless
+ *   `opts.addEnabled` is false. Cloud engines pass false (OPEN-12): a
+ *   300-model list must not flood the routing pickers, so the user picks.
+ */
+declare function mergeDiscoveredModels(existing: readonly AiModelConfig[], discovered: readonly AiDiscoveredModel[], kind?: AiEngineKind, opts?: {
+    addEnabled?: boolean;
+}): AiModelConfig[];
+
+/**
+ * "Add engine" presets. A preset only fills the new engine's name, kind, base
+ * URL, key variable and key file; everything else is the user's. Presets also
+ * drive the Express engine form: which family a card sits in, the caption
+ * under it, where to get a key, and which fetched models count as Popular.
+ *
+ * No model ids here: they go stale, and the endpoint is the source of truth.
+ * Popular rules are patterns matched against whatever the endpoint lists.
+ */
+
+/**
+ * Where a preset runs: your own server, a cloud API you paste a key for, or
+ * a model API built into the host (`host`: VS Code's GitHub Copilot models,
+ * no address and no key; shown only where the host reports it).
+ */
+type AiPresetFamily = 'local' | 'cloud' | 'host';
+/**
+ * One Popular slot: the newest fetched id that matches `match` (and not
+ * `exclude`). An id `prefer` matches (an alias such as `-latest`) wins;
+ * otherwise "newest" compares the version numbers in the id, then a date
+ * stamp.
+ */
+interface AiPopularRule {
+    /** Short family name, for the picker's tooltip ("Sonnet"). */
+    label: string;
+    match: RegExp;
+    exclude?: RegExp;
+    prefer?: RegExp;
+}
+interface AiEnginePreset {
+    id: string;
+    name: string;
+    kind: AiEngineKind;
+    baseUrl: string;
+    apiKeyEnv?: string;
+    apiKeyFile?: AiApiKeyFile;
+    /** Whether the endpoint expects a key at all (LM Studio accepts any). */
+    needsKey: boolean;
+    family: AiPresetFamily;
+    /** The quick-start card's one-line caption. */
+    caption: string;
+    /** Under the API key field: where to get one, or whether one is needed. A link to `keyUrl` when it has one. */
+    keyHint: string;
+    /** Cloud presets: the provider's page that creates API keys, opened through the host's `openLink`. */
+    keyUrl?: string;
+    /** Cloud presets: the Popular group, in order. The first rule that matches is the auto-picked default. */
+    popular?: readonly AiPopularRule[];
+    /**
+     * Local presets: the path (from the server root, without `/v1`) that local
+     * server detection GETs when it is not `{baseUrl}/models`. The native lists
+     * answer without a key.
+     */
+    detectPath?: string;
+    /** Cloud and host presets: the provider's own page on how API data is used (see `privacy.ts`). */
+    policy?: AiProviderPolicy;
+    /**
+     * Cloud presets: the provider's official API pricing page, linked as
+     * "Pricing" beside the key link. Only the link: prices change, so no
+     * figure is stated in code. URLs checked 2026-10-29.
+     */
+    pricingUrl?: string;
+    /**
+     * Local presets: the official download or install page, for a server that
+     * is not running yet ("Install", then Look again). URLs checked 2026-10-29.
+     */
+    installUrl?: string;
+}
+/**
+ * A provider's official privacy or API data-use page. Only the link: what a
+ * provider does with the text is set by its terms, which change, so no claim
+ * about training or retention is made in code. URLs checked 2026-10-29.
+ */
+interface AiProviderPolicy {
+    /** Link text ("Anthropic privacy and data use"). */
+    label: string;
+    url: string;
+    /** One extra neutral sentence, for a provider that passes requests on (OpenRouter). */
+    note?: string;
+}
+interface AiPresetFamilyInfo {
+    family: AiPresetFamily;
+    /** Group heading over the quick-start cards. */
+    label: string;
+    /** The "two ways to connect" line for this family. */
+    explainer: string;
+}
+/**
+ * The two quick-start groups, in display order, with the "two ways to
+ * connect" copy. The `host` family is not in this list: it shows only on a
+ * host whose `detectHostEngines` reports a model (`AI_HOST_PRESET_FAMILY`).
+ */
+declare const AI_PRESET_FAMILIES: readonly AiPresetFamilyInfo[];
+/** The `host` group (VS Code's built-in models), for the hosts that report one through `detectHostEngines`. */
+declare const AI_HOST_PRESET_FAMILY: AiPresetFamilyInfo;
+declare const AI_ENGINE_PRESETS: readonly AiEnginePreset[];
+/**
+ * The preset a saved engine most likely came from (engines do not store
+ * one): same kind and address, then the same key variable as a tiebreak
+ * (oMLX and vLLM share port 8000); else, for a cloud address, the preset on
+ * the same host; else the one preset of a dedicated kind. Undefined when
+ * nothing fits (a hand-made OpenAI-compatible engine).
+ */
+declare function presetForEngine(engine: {
+    kind: string;
+    baseUrl: string;
+    apiKeyEnv?: string;
+}, presets?: readonly AiEnginePreset[]): AiEnginePreset | undefined;
+/** Local server detection waits this long for each address. */
+declare const AI_LOCAL_DETECT_TIMEOUT_MS = 1500;
+/** What `detectLocalServers` is asked about: every local preset but Custom, at its default address. */
+declare function localDetectCandidates(presets?: readonly AiEnginePreset[]): {
+    presetId: string;
+    baseUrl: string;
+}[];
+
+/**
+ * Pure parsers for discovery responses, one per endpoint shape. Hosts do the
+ * HTTP and hand the parsed JSON here, so the VS Code adapters and the Rust
+ * port read the same fixtures (`test/ai-fixtures/discovery/`). Every parser
+ * tolerates junk: entries without a string id are skipped, never thrown on.
+ */
+
+/** `GET {base}/models` on any OpenAI-compatible server: ids only, capabilities from heuristics. */
+declare function parseOpenAiModelList(body: unknown): AiDiscoveredModel[];
+/**
+ * LM Studio `GET /api/v0/models`: `type` (`llm`, `vlm`, `embeddings`),
+ * `max_context_length`, `state` (`loaded` / `not-loaded`), `arch` (a `moe`
+ * in it marks a mixture of experts; one ending `_mtp` is a speculative-decoding
+ * drafter, not a chat model), and on newer builds `capabilities`
+ * (`tool_use`).
+ */
+declare function parseLmStudioModels(body: unknown): AiDiscoveredModel[];
+/**
+ * oMLX `GET {base}/models/status` (beside its OpenAI `/models`): per model
+ * `loaded` and `model_type` (`llm`, `vlm`, `embedding`, or a non-text type
+ * such as `audio_stt` or `markitdown`, which can neither chat nor embed),
+ * `model_context_length`, `estimated_size` (bytes) and `config_model_type`
+ * (a `moe` in it marks a mixture of experts; one ending `_mtp` is a
+ * speculative-decoding drafter, not a chat model, though it says `llm`).
+ */
+declare function parseOmlxModelStatus(body: unknown): AiDiscoveredModel[];
+/**
+ * Fold a status listing (`parseOmlxModelStatus`) into the models `/models`
+ * listed: the listing decides which models exist, the status adds what it
+ * knows about each (capabilities, loaded state).
+ */
+declare function withModelStatus(listed: readonly AiDiscoveredModel[], status: readonly AiDiscoveredModel[]): AiDiscoveredModel[];
+/**
+ * Sizes in bytes by model id from a listing that has them: LM Studio
+ * `GET /api/v1/models` (`models[].key`, `size_bytes`; its `/api/v0` has
+ * none) and Ollama `GET /api/tags` (`models[].model` or `name`, `size`).
+ */
+declare function parseModelSizes(body: unknown): Map<string, number>;
+/** `models` with the sizes `parseModelSizes` found added; the rest as they were. */
+declare function withModelSizes(models: readonly AiDiscoveredModel[], sizes: ReadonlyMap<string, number>): AiDiscoveredModel[];
+/** Ollama `GET /api/tags`: the model names to ask `/api/show` about. */
+declare function parseOllamaTags(body: unknown): string[];
+/**
+ * Ollama `POST /api/show` for one model: `capabilities` (`completion`,
+ * `vision`, `tools`, `embedding`, `insert`) and the context length under
+ * `model_info["<arch>.context_length"]`.
+ */
+declare function parseOllamaShow(name: string, body: unknown): AiDiscoveredModel;
+/** Which Ollama models are loaded right now, from `GET /api/ps` (optional). */
+declare function parseOllamaRunning(body: unknown): Set<string>;
+/**
+ * Anthropic `GET /v1/models`: `display_name`, `max_input_tokens` (the context
+ * window) and the `capabilities` tree (`image_input.supported`,
+ * `structured_outputs.supported`). Tools are assumed on.
+ */
+declare function parseAnthropicModels(body: unknown): AiDiscoveredModel[];
+/** Anthropic pages its list; the next `after_id`, or null on the last page. */
+declare function anthropicNextPage(body: unknown): string | null;
+/** The URL detection GETs: `detectPath` under the server root (no `/v1`), else `{baseUrl}/models`. */
+declare function localDetectUrl(baseUrl: string, detectPath?: string): string;
+/**
+ * How many models a detection answer lists: `data` (OpenAI-style, LM Studio)
+ * or `models` (Ollama). LM Studio's embedding models are left out. Undefined
+ * for a body of neither shape (the server answered, the count is unknown).
+ */
+declare function countDetectedModels(body: unknown): number | undefined;
+/** What a host needs to probe one detection candidate. */
+interface AiLocalDetectTarget {
+    presetId: string;
+    baseUrl: string;
+    /** The GET. */
+    url: string;
+    /** For the auth header shape. */
+    kind: AiEngineKind;
+    /** Where to read a key, only when `baseUrl` is the preset's own address. */
+    apiKeyEnv?: string;
+    apiKeyFile?: AiApiKeyFile;
+}
+/**
+ * A detection candidate checked against the presets. Null for an unknown or
+ * cloud preset, Custom, or an address that is not http(s). A key source
+ * (oMLX's key file) comes along only when the address is the preset's own,
+ * so a key never goes anywhere the user did not set up.
+ */
+declare function localDetectTarget(candidate: {
+    presetId: string;
+    baseUrl: string;
+}, presets?: readonly AiEnginePreset[]): AiLocalDetectTarget | null;
+
+/**
+ * The settings before the host sends any. Its own module so the editor can
+ * start from them without loading the rest of the AI layer (see `ai-lite.ts`).
+ */
+
+/** The advanced docs options before the user changes any. */
+declare function defaultAiDocsOptions(): AiDocsOptions;
+declare function defaultAiSettings(): AiSettings;
+
+/**
+ * Task routing: which engine and model serve a feature's request. Pure and
+ * cheap, so the editor recomputes it on every request from the settings, the
+ * status cache of the last `listEngines`, and the consent answers so far.
+ *
+ * 1. The master switch and the feature must be on.
+ * 2. Route = `routing.tasks[task]`, else `routing.default`.
+ * 3. A candidate is usable when the engine exists, is enabled and of a known
+ *    kind (a host kind such as `vscode-lm` only when the host lists a status
+ *    for it); the model exists, is enabled and not `missing`; the model has every
+ *    capability the task and feature need; the engine is local, or cloud with
+ *    `allowCloud` on and consent not refused; and its last probe did not fail.
+ * 4. Otherwise `routing.fallback`: `none` stops, `default` tries the default
+ *    route, `anyLocal` then every local engine/model in registry order, `any`
+ *    then cloud engines through the same gate. Fallback never moves a local
+ *    route to a cloud engine unless the mode is `any`.
+ * 5. The result names the pair and whether a fallback served it.
+ *
+ * A task may also `prefers` capabilities (JSON output for `structure`, a big
+ * context for `summarize`). That is never a rejection reason. The chosen
+ * route is honoured as is; when a fallback has several usable candidates in
+ * the same tier (the default route and the local engines, then the cloud
+ * ones), those meeting the preference come first, in registry order.
+ *
+ * Consent: a cloud candidate nobody has asked about yet is usable with
+ * `needsConsent: true`; the caller asks (`host.ai.requestCloudConsent`),
+ * records the answer and resolves again. A refusal (`false`) makes the
+ * engine unusable, which lets the fallback run.
+ */
+
+/** Consent answers by engine id: true granted, false refused ("Not now"), absent never asked. */
+type AiConsentState = Readonly<Record<string, boolean | undefined>>;
+type AiUnusableCode = 'aiDisabled' | 'featureDisabled' | 'noRoute' | 'engineMissing' | 'engineDisabled' | 'engineUnsupported' | 'modelMissing' | 'modelDisabled' | 'modelNotListed' | 'capability' | 'cloudBlocked' | 'consentDenied' | 'probeFailed';
+interface AiRouteOk {
+    engineId: string;
+    modelId: string;
+    viaFallback: boolean;
+    /** Why the preferred route was passed over, when `viaFallback`. */
+    reason?: string;
+    /** The task that was routed. */
+    task: string;
+    isLocal: boolean;
+    /** Cloud engine with no consent answer yet: ask before sending. */
+    needsConsent: boolean;
+}
+interface AiRouteUnusable {
+    unusable: AiUnusableCode;
+    /** Tooltip copy, e.g. "oMLX (Mac Studio) failed its last connection test". */
+    reason: string;
+    task?: string;
+    /** The engine the rejection is about (the routed one), when it is about one engine. */
+    engineId?: string;
+}
+type AiRouteResolution = AiRouteOk | AiRouteUnusable;
+declare function isRouteUsable(r: AiRouteResolution): r is AiRouteOk;
+interface ResolveRouteOptions {
+    feature: string;
+    /** Route this task instead of the feature's. */
+    task?: string;
+    /** Inline suggestions: reject every cloud engine (`cloudBlocked`), whatever Allow cloud and consent say. */
+    localOnly?: boolean;
+}
+declare function resolveRoute(settings: AiSettings, statuses: readonly AiEngineStatus[], consent: AiConsentState, opts: ResolveRouteOptions): AiRouteResolution;
+
+/**
+ * Server-sent events, reassembled from arbitrary network chunks (a line, or
+ * a multi-byte character, may be split across chunks; the host decodes bytes
+ * with a streaming `TextDecoder` before pushing text here), plus readers for
+ * the two completion stream shapes:
+ *
+ * - OpenAI Chat Completions (OpenAI, oMLX, LM Studio, Ollama `/v1`, vLLM,
+ *   llama.cpp): `data: {choices:[{delta:{content}}]}` chunks ending in
+ *   `data: [DONE]`. `reasoning_content` deltas are thinking, not text.
+ * - Anthropic Messages: `message_start`, `content_block_delta` with
+ *   `text_delta`, `message_delta` with `stop_reason` and usage, `message_stop`,
+ *   and an `error` event.
+ *
+ * A stream that ends without its terminator (`[DONE]` or `message_stop`) is
+ * truncated: `finishReason: 'error'`.
+ */
+
+interface SseEvent {
+    /** `event:` field; absent means the default `message`. */
+    event?: string;
+    data: string;
+    id?: string;
+}
+/** Incremental SSE parser (WHATWG event-stream rules: CRLF/CR/LF, `:` comments, multi-line `data`). */
+declare class SseParser {
+    private buffer;
+    private started;
+    private dataLines;
+    private eventName;
+    private lastId;
+    /** Feed decoded text; returns the events it completed. */
+    push(chunk: string): SseEvent[];
+    /** The stream closed: flush a final event that had no trailing blank line. */
+    end(): SseEvent[];
+    private line;
+}
+/** Where a completion stream ended up. */
+interface StreamOutcome {
+    text: string;
+    finishReason: AiFinishReason;
+    usage?: AiUsage;
+    /** The provider's own stop reason (`end_turn`, `length`, `refusal`...). */
+    stopReason?: string;
+    /** A stream-level error event, mapped to a code. */
+    error?: {
+        code: AiErrorCode;
+        message: string;
+    };
+}
+/** One completion stream: push decoded chunks, get text deltas back, then `finish`. */
+interface CompletionStreamReader {
+    push(chunk: string): string[];
+    finish(): StreamOutcome;
+    /**
+     * Output seen so far, answer plus reasoning, in UTF-16 units: above zero
+     * once the model starts generating (the host's first-token time), and the
+     * basis of a token estimate when the engine reports no usage.
+     */
+    outputChars(): number;
+}
+/** Chat Completions stream (`openai-compatible`, `lmstudio`, `ollama`, `openai`). */
+declare function createOpenAiStreamReader(): CompletionStreamReader;
+/** Anthropic Messages stream. */
+declare function createAnthropicStreamReader(): CompletionStreamReader;
+/** The reader for an engine kind. */
+declare function createCompletionStreamReader(kind: AiEngineKind): CompletionStreamReader;
+
+/**
+ * How long a result took and how fast it came: the popover footer's
+ * "2.4 s · 38 tok/s", its tooltip, and the hosts' request log. Hosts measure
+ * (`AiCompletionResult.timing`); this only does the arithmetic and the words.
+ *
+ * Output tokens are the engine's own count when it reports one (OpenAI-style
+ * `usage` with `stream_options.include_usage`, Anthropic `message_delta`),
+ * else about one token per four characters of output, marked approximate
+ * ("~38 tok/s"). Speed is output tokens over the time from the first token to
+ * the end; without a first-token time, over the whole request.
+ *
+ * Desktop's `request_log.rs` ports `aiTimingLogParts`; keep them in step.
+ */
+
+/** Characters per token for the estimate when the engine reports no usage. */
+declare const AI_CHARS_PER_TOKEN = 4;
+interface AiResultStats {
+    totalMs: number;
+    firstTokenMs?: number;
+    outputTokens?: number;
+    inputTokens?: number;
+    /** `outputTokens` (and so the speed) is estimated from the characters. */
+    approximate: boolean;
+    tokensPerSecond?: number;
+}
+/** The numbers behind the footer, or null when the host measured nothing (an older host). */
+declare function aiResultStats(result: Pick<AiCompletionResult, 'text' | 'usage' | 'timing'>): AiResultStats | null;
+/** "0.8 s", "2.4 s", "12 s". */
+declare function formatAiSeconds(ms: number): string;
+/** "38 tok/s", "~38 tok/s", "4.5 tok/s". */
+declare function formatAiTokensPerSecond(tps: number, approximate: boolean): string;
+/** The footer text: "2.4 s · 38 tok/s", or just "2.4 s" with no speed. */
+declare function aiResultStatsText(stats: AiResultStats): string;
+/** The footer tooltip, one fact per line. */
+declare function aiResultStatsTitle(stats: AiResultStats): string;
+/** The request log's additions: `first token N ms` and the speed, when measured. */
+declare function aiTimingLogParts(result: Pick<AiCompletionResult, 'text' | 'usage' | 'timing'>): string[];
+
+/**
+ * Request building per engine kind: endpoint URLs, auth headers and the
+ * completion and embedding bodies. Pure, so the VS Code adapters and the Rust
+ * port produce identical requests (checked against the same fixtures).
+ *
+ * Bodies:
+ * - Chat Completions kinds: `{ model, messages, stream, max_tokens,
+ *   temperature, response_format }`; `openai` uses `max_completion_tokens`
+ *   and asks for usage in the stream. OpenAI reasoning models (o-series,
+ *   GPT-5 onwards) get no `temperature`: they accept only the default.
+ * - `anthropic`: Messages API, system prompts lifted into `system`,
+ *   `max_tokens` always set (required). No sampling parameters: API version
+ *   2026-10-21 rejects `temperature`.
+ *
+ * `model.requestOverrides` merge last, deeply (objects merge, everything else
+ * replaces), so they win (OPEN-6); then the request's own `requestOverrides`
+ * (a per-request thinking level) merge over those the same way.
+ *
+ * A 400 that names a parameter the model does not take
+ * (`unsupportedRequestParam`) is retried once without it
+ * (`withoutRequestParam`); the hosts remember it per engine and model for
+ * the session.
+ */
+
+/** `anthropic-version` sent by the Anthropic adapter. */
+declare const ANTHROPIC_API_VERSION = "2026-10-21";
+/** `max_tokens` for Anthropic when the request sets none (the API requires it). */
+declare const ANTHROPIC_DEFAULT_MAX_TOKENS = 4096;
+/** Appended to the system prompt for `format: 'json'` on kinds with no schema-free JSON mode. */
+declare const JSON_ONLY_INSTRUCTION = "Respond with a single valid JSON value and nothing else.";
+type Json$1 = Record<string, unknown>;
+interface AiEngineEndpoints {
+    /** Streaming completion. */
+    completions: string;
+    /** Model list used for Test connection and bare discovery. */
+    models: string;
+    /** Embeddings, absent for kinds without them. */
+    embeddings?: string;
+    /** Native discovery endpoint (LM Studio `/api/v0/models`, Ollama `/api/tags`). */
+    nativeModels?: string;
+    /** Ollama `POST /api/show` (body `{ model }`). */
+    nativeShow?: string;
+}
+/**
+ * URLs for an engine. OpenAI-style base URLs include `/v1`
+ * (`http://127.0.0.1:8000/v1`); for LM Studio and Ollama a base without it
+ * gets `/v1` added for completions, and their native endpoints hang off the
+ * root. Anthropic's base is the host (`https://api.anthropic.com`), with or
+ * without `/v1`.
+ */
+declare function engineEndpoints(engine: Pick<AiEngineConfig, 'kind' | 'baseUrl'>): AiEngineEndpoints;
+/** Headers for every request to the engine (JSON content type included). */
+declare function buildAuthHeaders(kind: AiEngineKind, apiKey: string | null): Record<string, string>;
+/** Deep merge: nested plain objects merge, anything else in `overrides` replaces. Inputs are not mutated. */
+declare function mergeRequestOverrides(body: Json$1, overrides: Json$1 | undefined): Json$1;
+/** Standard base64 with padding, no line breaks. No `Buffer` or `btoa`, so it runs in every host. */
+declare function bytesToBase64(bytes: Uint8Array): string;
+/** Inverse of `bytesToBase64`; ignores whitespace and accepts URL-safe characters. */
+declare function base64ToBytes(b64: string): Uint8Array;
+interface BuildCompletionOptions {
+    /** Default true. */
+    stream?: boolean;
+}
+/** The JSON body for one completion against `model` on an engine of `kind`. */
+declare function buildCompletionBody(kind: AiEngineKind, model: Pick<AiModelConfig, 'id' | 'requestOverrides'>, req: AiCompletionRequest, opts?: BuildCompletionOptions): Json$1;
+/**
+ * Cloud hosts of the `openai-compatible` kind that take
+ * `stream_options.include_usage` (OpenRouter, Gemini, Groq, DeepSeek).
+ * Mistral and unknown cloud hosts are left out: a strict server may reject
+ * a field it does not know.
+ */
+declare const STREAM_USAGE_HOSTS: readonly string[];
+/**
+ * Whether a streamed completion may ask for usage in the stream. `openai`,
+ * LM Studio and Ollama take it; on `openai-compatible`, a server on this
+ * machine or network (oMLX, vLLM, llama.cpp all take it) or a host in
+ * `STREAM_USAGE_HOSTS`. Anthropic reports usage without being asked.
+ */
+declare function streamUsageSupported(engine: Pick<AiEngineConfig, 'kind' | 'baseUrl'>): boolean;
+/**
+ * `body` asking for usage in the stream (`stream_options.include_usage`)
+ * when the engine takes it, the body streams and the overrides did not set
+ * `stream_options` themselves. Hosts apply it after `buildCompletionBody`.
+ */
+declare function withStreamUsage(body: Json$1, engine: Pick<AiEngineConfig, 'kind' | 'baseUrl'>): Json$1;
+/**
+ * Body fields a server may reject for one model while taking them for
+ * others. Only these are retried: anything else in a 400 is a real error.
+ */
+declare const RETRYABLE_REQUEST_PARAMS: readonly string[];
+/**
+ * The parameter a failed completion was rejected for, or null. Only a 400
+ * whose error says the parameter (or its value) is unsupported counts:
+ * OpenAI's `{ error: { param, code: "unsupported_value" | "unsupported_parameter", message } }`,
+ * or any body whose message quotes one of `RETRYABLE_REQUEST_PARAMS` next to
+ * that wording (the first one quoted, so "Use 'max_completion_tokens'
+ * instead" does not count).
+ */
+declare function unsupportedRequestParam(status: number, bodyText: string): string | null;
+/**
+ * `body` without a parameter the server rejected: `max_tokens` and
+ * `max_completion_tokens` become each other (the documented replacement),
+ * anything else is dropped. Null when the body does not carry it, so there
+ * is nothing to retry.
+ */
+declare function withoutRequestParam(body: Json$1, param: string): Json$1 | null;
+/** Embeddings body (`POST .../embeddings`), or null for kinds without an embeddings endpoint. */
+declare function buildEmbeddingsBody(kind: AiEngineKind, model: Pick<AiModelConfig, 'id' | 'requestOverrides'>, texts: string[]): Json$1 | null;
+/** Vectors from an OpenAI-style embeddings response, in input order. */
+declare function parseEmbeddingsResponse(body: unknown): number[][];
+
+/**
+ * `AiCompletionRequest` over a JSON channel (VS Code `postMessage`, Tauri
+ * `invoke`): image bytes travel as base64, the same way `savePastedImage`
+ * sends pasted images.
+ */
+
+type AiWireMessagePart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    mime: string;
+    dataBase64: string;
+};
+interface AiWireMessage {
+    role: AiMessage['role'];
+    content: string | AiWireMessagePart[];
+}
+type AiWireCompletionRequest = Omit<AiCompletionRequest, 'messages'> & {
+    messages: AiWireMessage[];
+};
+declare function toWireCompletionRequest(req: AiCompletionRequest): AiWireCompletionRequest;
+declare function fromWireCompletionRequest(wire: AiWireCompletionRequest): AiCompletionRequest;
+
+/**
+ * `AiError` helpers and the user-facing copy for each `AiErrorCode`, kept in
+ * one place so the rewrite popover, the AI tab and the indicator say the same
+ * thing. Hosts reject with `{ code, message }`; `message` is the technical
+ * detail, the copy here is what the user reads first.
+ */
+
+interface AiErrorCopy {
+    title: string;
+    message: string;
+    /**
+     * Suggested next step, when there is one. `openEngine`: the failing
+     * engine's own page. `chooseModel`: the same page, to pick another model.
+     */
+    action?: 'openSettings' | 'openEngine' | 'chooseModel' | 'retry' | 'shortenSelection';
+}
+declare const AI_ERROR_COPY: Readonly<Record<AiErrorCode, AiErrorCopy>>;
+/**
+ * A stream that stopped at its token limit (`finishReason: 'length'`). A
+ * thinking model counts its reasoning against that limit, so with thinking
+ * on the advice is to lower Thinking. `empty`: no answer text came back at
+ * all (shown as the error); otherwise the answer is shown with `message` as
+ * a note.
+ */
+declare function aiLengthLimitCopy(opts: {
+    thinking: boolean;
+    empty: boolean;
+}): AiErrorCopy;
+declare function isAiErrorCode(v: unknown): v is AiErrorCode;
+declare function isAiError(v: unknown): v is AiError;
+declare function makeAiError(code: AiErrorCode, message?: string): AiError;
+/** Any rejection value as an `AiError`: an `AiError` as is, an `AbortError` as `cancelled`, the rest `unknown`. */
+declare function toAiError(err: unknown): AiError;
+/**
+ * The copy for `code`. With `engine` (the display name of the engine the
+ * request went to), an engine problem names it and its action is
+ * `openEngine` (`chooseModel` for a model that did not load): the popover's
+ * button opens that engine instead of the AI tab. `model` names the model
+ * where the copy has room for it.
+ */
+declare function aiErrorCopy(code: AiErrorCode, opts?: {
+    engine?: string;
+    model?: string;
+}): AiErrorCopy;
+/**
+ * A local server that could not load the model: LM Studio's `Failed to load
+ * model "x"`, llama.cpp's `error loading model`, Ollama's `llama runner
+ * process has terminated` and its out-of-memory refusal.
+ */
+declare const MODEL_LOAD_FAILED_PHRASES: readonly string[];
+/**
+ * Map an HTTP failure to a code (shared by both hosts): 401/403 auth, 404
+ * modelNotFound, a body that says the model failed to load modelLoadFailed,
+ * 413 or a 400 that mentions the context contextOverflow, 429 and 529
+ * rateLimited, 502/503/504 unreachable, everything else unknown.
+ */
+declare function aiErrorCodeFromHttp(status: number, bodyText?: string): AiErrorCode;
+
+/**
+ * Per-model thinking level (Off / Low / Medium / High) mapped onto each
+ * engine kind's request fields, stored in the model's `requestOverrides`
+ * (OPEN-6) so the adapters need no change: they merge the overrides into
+ * every request body last.
+ *
+ * Mappings:
+ * - `openai` and cloud `openai-compatible` (Gemini, Groq, OpenRouter...):
+ *   `reasoning_effort` `none` / `low` / `medium` / `high`. Off is stored as
+ *   `none`; `buildCompletionBody` swaps it for the lowest value an OpenAI
+ *   reasoning model accepts (`openAiOffReasoningEffort`).
+ * - local `openai-compatible` (oMLX, vLLM, llama.cpp): tiers through
+ *   `reasoning_effort`; Off through `chat_template_kwargs.enable_thinking:
+ *   false`, which the chat template honours (oMLX ignores
+ *   `reasoning_effort: "none"`).
+ * - `lmstudio`: on/off only, `reasoning_effort` `none` or `medium`.
+ * - `ollama`: `reasoning_effort` `none` / `low` / `medium` / `high` (its
+ *   OpenAI-compatible endpoint maps it onto `think`).
+ * - `vscode-lm`: none (VS Code's language model API has no such field).
+ * - `anthropic`: adaptive thinking with `output_config.effort` `low` /
+ *   `medium` / `high`. No Off: current models reject `thinking: disabled`
+ *   (Opus 5.5, Sonnet 5.5, Fable), so Low is the lightest setting.
+ *
+ * "Model default" (no level) removes the kind's thinking fields and leaves
+ * everything else in `requestOverrides` alone.
+ *
+ * Per-task default (Q6): with the dial on Default and no level set on the
+ * model, MikeDown picks the level for the job (`taskThinkingDefault`): Off
+ * for the short edits (every rewrite variant, translate, suggest title,
+ * suggest properties), none for the rest (explain, summarize), so the model
+ * decides there. An explicit dial choice, or a level set on the model, wins
+ * (`resolveThinkingLevel`).
+ */
+type AiThinkingLevel = 'off' | 'low' | 'medium' | 'high';
+interface AiThinkingChoice {
+    level: AiThinkingLevel;
+    label: string;
+}
+interface AiThinkingOptions {
+    /** The engine's locality is local (changes the Off mapping for `openai-compatible`). */
+    local?: boolean;
+}
+type Json = Record<string, unknown>;
+/** The levels a kind can express, in order. Empty means no known mapping: hide the control. */
+declare function thinkingChoices(kind: string): AiThinkingChoice[];
+/**
+ * The level a kind uses for `level`: the level itself when the kind has it,
+ * else the nearest one (Off on Anthropic is Low, any tier on LM Studio is
+ * On). Null for no level or a kind with no mapping.
+ */
+declare function nearestThinkingLevel(kind: string, level: AiThinkingLevel | null): AiThinkingLevel | null;
+/**
+ * What a request is for, as far as its default thinking level goes: a
+ * feature id (`rewrite`, `title`, `frontmatter`, `summary`) or a job that
+ * shares one (`explain` and `translate` run under `rewrite`).
+ */
+type AiThinkingJob = string;
+/**
+ * The level MikeDown picks for a job when the dial is on Default (Q6): Off
+ * for the short edits and the docs chat's `navigate` hops, null (the model's
+ * own) for everything else, the docs chat's `answer` call included.
+ */
+declare function taskThinkingDefault(job: string | undefined): AiThinkingLevel | null;
+interface ResolvedThinkingLevel {
+    /** The level to send (already the kind's nearest), or null to send none. */
+    level: AiThinkingLevel | null;
+    /** True when `level` is the job's default rather than the user's choice. */
+    auto: boolean;
+}
+/**
+ * The level a request sends: the user's explicit choice (the dial) first,
+ * then nothing when the model has its own level set (`configured`), then the
+ * job's default (mapped to the kind's nearest: Off on Anthropic is Low).
+ * The explicit level is sent as given (`thinkingLevelFor` already maps a
+ * remembered one); one the kind cannot express sends nothing.
+ */
+declare function resolveThinkingLevel(kind: string, explicit: AiThinkingLevel | null, configured: AiThinkingLevel | null, job: string | undefined, opts?: {
+    modelId?: string;
+}): ResolvedThinkingLevel;
+/** The request fields for one level, or `{}` when the kind cannot express it. */
+declare function thinkingOverrides(kind: string, level: AiThinkingLevel, opts?: AiThinkingOptions): Json;
+/** The level `overrides` express for this kind, or null for "model default" (or a value the menu has no entry for). */
+declare function thinkingLevelFrom(kind: string, overrides: Json | undefined): AiThinkingLevel | null;
+/**
+ * `requestOverrides` with the thinking level set (null: model default).
+ * Other keys, nested ones included, are kept. Undefined when nothing is left.
+ */
+declare function withThinkingLevel(kind: string, overrides: Json | undefined, level: AiThinkingLevel | null, opts?: AiThinkingOptions): Json | undefined;
+/**
+ * Output tokens a thinking model may spend reasoning before it answers, by
+ * level. A thinking model counts its reasoning against `max_tokens`, so an
+ * answer budget alone can be used up before the first visible word. Sized
+ * for local reasoning models (Qwen3 class), which often think 2,000 to
+ * 4,000 tokens even on a one-paragraph edit. It is a ceiling, not a spend.
+ */
+declare const THINKING_HEADROOM_TOKENS: Readonly<Record<AiThinkingLevel, number>>;
+/** "Model default" (no level set): the model may think, at a level we cannot see. */
+declare const THINKING_DEFAULT_HEADROOM_TOKENS: number;
+/** The most `thinkingMaxTokens` raises a request to (a larger answer budget is kept as is). */
+declare const THINKING_MAX_TOKENS_CAP = 12288;
+interface ThinkingBudgetOptions {
+    /** The model's context window, when known. */
+    contextTokens?: number | null;
+    /** Estimated prompt tokens; with `contextTokens`, the headroom never pushes past the window. */
+    promptTokens?: number;
+}
+/**
+ * The `max_tokens` to send for an answer budget of `answerTokens` on a model
+ * that can think: the answer plus reasoning headroom for the effective level
+ * (null: model default, counted as thinking). Off adds nothing. The raise is
+ * capped at `THINKING_MAX_TOKENS_CAP` and at what is left of the context
+ * window, and never goes below the answer budget.
+ */
+declare function thinkingMaxTokens(answerTokens: number, level: AiThinkingLevel | null, opts?: ThinkingBudgetOptions): number;
+
+/**
+ * Selection rewrite prompt (the `rewrite` feature). Pure: builds the chat
+ * messages from the selected markdown and a little context, and cleans what
+ * the model sends back before it is previewed or parsed into the document.
+ *
+ * Context budget (brainstorm constraint 8): the selection plus the text of
+ * the enclosing block before and after it, and the neighbouring block on each
+ * side, capped at `REWRITE_CONTEXT_CHARS` per side. Never the whole document.
+ */
+
+type AiRewriteVariant = 'shorter' | 'longer' | 'expand' | 'simpler' | 'fixFlow' | 'formal' | 'casual' | 'readingLevel' | 'translate' | 'explain' | 'custom';
+/** Menu group a variant belongs to (the popover's choose phase renders one section per group). */
+type AiRewriteGroup = 'length' | 'tone' | 'audience' | 'translate' | 'explain' | 'custom';
+/** `replace` swaps the selection; `readOnly` only shows text (Explain) and can insert it below. */
+type AiRewriteOutput = 'replace' | 'readOnly';
+type AiAudience = 'general' | 'expert' | 'plain' | 'grade8' | 'esl';
+interface AiAudienceDefinition {
+    id: AiAudience;
+    label: string;
+    /** Instruction line sent to the model for `readingLevel`. */
+    instruction: string;
+}
+declare const AI_AUDIENCES: readonly AiAudienceDefinition[];
+declare function getAiAudience(id: string): AiAudienceDefinition | undefined;
+interface AiRewriteVariantDefinition {
+    id: AiRewriteVariant;
+    /** Menu label. */
+    label: string;
+    /** Tooltip, where the label alone does not tell two variants apart (Longer, Add detail). */
+    title?: string;
+    /**
+     * The instruction line sent to the model. Empty for `custom` (the user's own
+     * words); `{language}` and `{audience}` are filled from `RewritePromptInput.params`.
+     */
+    instruction: string;
+    group: AiRewriteGroup;
+    output: AiRewriteOutput;
+    /** The parameter this variant needs before it can run (a second-level picker supplies it). */
+    param?: 'language' | 'audience';
+}
+/** Order here is the menu order. */
+declare const AI_REWRITE_VARIANTS: readonly AiRewriteVariantDefinition[];
+declare function getAiRewriteVariant(id: string): AiRewriteVariantDefinition | undefined;
+/** Context kept on each side of the selection, in characters (about 400 tokens). */
+declare const REWRITE_CONTEXT_CHARS = 1600;
+/** Longest custom instruction sent as is. */
+declare const REWRITE_INSTRUCTION_MAX_CHARS = 1000;
+interface RewritePromptInput {
+    variant: AiRewriteVariant;
+    /** The user's instruction for `custom` (ignored otherwise). */
+    instruction?: string;
+    /** The selected text as markdown. */
+    selection: string;
+    /** Markdown just before the selection (enclosing block, then the previous one). */
+    before?: string;
+    /** Markdown just after the selection. */
+    after?: string;
+    /** Values for the parameterised variants (`translate` needs `language`, `readingLevel` needs `audience`). */
+    params?: AiRewriteParams;
+    /**
+     * `document` for a whole-document run (`translate`): the passage is the body
+     * without its frontmatter and no context is sent. Default `selection`.
+     */
+    scope?: AiRewriteScope;
+}
+interface AiRewriteParams {
+    language?: string;
+    audience?: AiAudience;
+}
+type AiRewriteScope = 'selection' | 'document';
+/** Longest target language name sent (it is free text from "Other…"). */
+declare const REWRITE_LANGUAGE_MAX_CHARS = 60;
+declare const REWRITE_SYSTEM_PROMPT: string;
+/**
+ * Appended to the system prompt for `translate`. It overrides the "write in the
+ * language of the passage" rule; the target language is named only in the
+ * instruction line.
+ */
+declare const TRANSLATE_SYSTEM_ADDENDUM: string;
+/** Appended to the system prompt when the instruction asks for an explanation (the `explain` variant). */
+declare const EXPLAIN_SYSTEM_ADDENDUM = "The instruction asks for an explanation of the passage, not a version of it: the \"version of the passage\" rules above do not apply. Reply with the explanation only, as Markdown prose, and do not repeat the passage.";
+/** The whole-document variant of the translation note. */
+declare const TRANSLATE_DOCUMENT_NOTE = "The passage is a whole document body (its frontmatter has been removed and is handled elsewhere). Translate all of it, from the first line to the last.";
+/** Neutralise a closing tag inside user text so it cannot end its block early. */
+declare function escapeClosingTag(text: string, tag: string): string;
+/** Context trimmed to the budget at the far end, so the part next to the selection survives. */
+declare function trimRewriteContext(text: string, side: 'before' | 'after', max?: number): string;
+/** Target language as typed, flattened to one short line (it ends up inside a prompt). */
+declare function normalizeRewriteLanguage(language: string | undefined): string;
+/**
+ * The instruction line for a variant. A parameterised variant whose parameter
+ * is missing or unknown falls back to `fixFlow`, like an empty `custom`.
+ */
+declare function rewriteInstruction(input: Pick<RewritePromptInput, 'variant' | 'instruction' | 'params'>): string;
+/** The system prompt for a variant: the shared rules plus the translate or explain addendum. */
+declare function rewriteSystemPrompt(variant: AiRewriteVariant, scope?: AiRewriteScope): string;
+declare function buildRewriteMessages(input: RewritePromptInput): AiMessage[];
+/** Output budget for `explain`: a short note, independent of the passage length. */
+declare const EXPLAIN_MAX_TOKENS = 600;
+/** Output budget: room for "longer" to double the passage, never below a short paragraph. */
+declare function rewriteMaxTokens(selection: string, variant: AiRewriteVariant): number;
+/**
+ * The text to show while it streams: reasoning blocks (`<think>…</think>`,
+ * which some local models put in the content) are hidden, including one that
+ * has not closed yet, and an echoed `<passage>` tag is dropped.
+ */
+declare function rewriteVisibleText(raw: string): string;
+/**
+ * The final replacement: the visible text without a wrapping code fence or
+ * quotes the model added, trimmed, with the selection's own leading and
+ * trailing whitespace put back (a selection of "word " stays one word plus a
+ * space).
+ */
+declare function finalizeRewriteText(raw: string, selection: string): string;
+
+/**
+ * Explain prompt (the `explain` variant of the `rewrite` feature). Pure: builds
+ * the chat messages for a read-only note about the selected passage. The reply
+ * is shown in the popover and can be inserted below the selection; it never
+ * replaces anything.
+ */
+
+declare const EXPLAIN_SYSTEM_PROMPT: string;
+interface ExplainPromptInput {
+    /** The selected text as markdown. */
+    selection: string;
+    /** Markdown just before the selection. */
+    before?: string;
+    /** Markdown just after the selection. */
+    after?: string;
+    /** The document title (frontmatter `title:` or the first heading), if there is one. */
+    title?: string;
+}
+declare function buildExplainMessages(input: ExplainPromptInput): AiMessage[];
+/** Output budget: a short note whatever the passage length. */
+declare function explainMaxTokens(): number;
+
+/**
+ * Markdown structure post-check. Pure: counts the structural pieces of a
+ * passage and compares the original with a model's result, so translate and
+ * tone rewrites can show a warning line before Accept when something was
+ * dropped. A warning only; it never blocks Accept.
+ */
+interface StructureCounts {
+    /** Headings by level, index 0 is level 1. */
+    headings: [number, number, number, number, number, number];
+    fencedCodeBlocks: number;
+    inlineCodeSpans: number;
+    /** URL of every link (inline, reference definition, autolink), in order. */
+    links: string[];
+    /** URL of every image, in order. */
+    images: string[];
+    listItems: number;
+    tableRows: number;
+    wikilinks: number;
+    footnoteReferences: number;
+}
+interface StructureMismatch {
+    kind: 'heading' | 'fencedCodeBlock' | 'inlineCode' | 'link' | 'image' | 'listItem' | 'tableRow' | 'wikilink' | 'footnote';
+    original: number;
+    result: number;
+    /** A human sentence such as "2 links in the original, 1 in the result". */
+    message: string;
+}
+interface StructureDiff {
+    /** True when nothing differs. */
+    ok: boolean;
+    mismatches: StructureMismatch[];
+    /** `mismatches[].message`, ready to show. */
+    messages: string[];
+}
+declare function countMarkdownStructure(markdown: string): StructureCounts;
+/**
+ * Compare the structure of a rewritten passage with the original. Zero
+ * mismatches means every counted piece survived; a mismatch is a sentence for
+ * the warning line, not an error.
+ */
+declare function checkMarkdownStructure(original: string, result: string): StructureDiff;
+
+/**
+ * Lenient JSON for local models (D6). Many local models have no JSON mode, so
+ * a reply can arrive as clean JSON, inside a code fence, after a sentence of
+ * prose, behind a `<think>` block, with a trailing comma or with single
+ * quotes. `parseLenientJson` takes all of those; plain text is `ok: false`
+ * with a message the repair turn can quote. Pure, no DOM.
+ */
+
+type LenientJsonResult<T = unknown> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Strip `<think>`, look inside code fences, take the first balanced `{…}` or
+ * `[…]` that parses (after one repair pass for the common slips) and return
+ * it. A reply with no JSON, or one cut off before it closed, is `ok: false`.
+ * `T` is only the caller's claim about the shape; validate before trusting it.
+ */
+declare function parseLenientJson<T = unknown>(raw: string): LenientJsonResult<T>;
+/**
+ * The one-shot repair turn: append these two messages to the original ones
+ * and ask again. The failed reply goes back as the assistant turn (reasoning
+ * removed, capped), then the parse error.
+ */
+declare function jsonRepairMessages(previousRaw: string, error: string): AiMessage[];
+/**
+ * The prompt line that fixes the reply shape: a one-line example object.
+ * Pass the example as a value (serialised on one line) or as a string.
+ */
+declare function JSON_SHAPE_HINT(example: unknown): string;
+
+/**
+ * Fit a markdown document to a model's context window by whole sections, and
+ * say how much of it fit (never a silent cut). Used by `/summary`, `/title`
+ * and Properties suggestions. Pure, no DOM.
+ *
+ * The kept text is always a prefix of the document: the frontmatter and the
+ * opening sections, ending on a heading boundary. If even the first section
+ * is too big it is cut on a blank line between blocks. A fenced code block is
+ * never split, so a fence that opens inside the kept text also closes in it.
+ */
+/** Characters per token the budget assumes (a little pessimistic for English). */
+declare const CHARS_PER_TOKEN = 3.5;
+interface DocumentBudgetOptions {
+    /** The model's context window in tokens. */
+    contextTokens: number;
+    /** Tokens the answer may use. */
+    outputTokens: number;
+    /** Tokens for the system prompt, instructions and slack. */
+    reserveTokens: number;
+}
+interface BudgetedDocument {
+    /** The markdown to send: frontmatter plus the leading sections that fit. */
+    text: string;
+    /** Share of the document in `text`, 0 to 1 (1 when nothing was cut). */
+    coverage: number;
+    truncated: boolean;
+    /** Sections in `text` (a partly kept first section counts as one). */
+    sectionsIncluded: number;
+    sectionsTotal: number;
+}
+interface HeadingOutlineEntry {
+    /** 1 to 6. */
+    level: number;
+    text: string;
+}
+interface HeadingWithOffsets extends HeadingOutlineEntry {
+    /** Offset of the heading line's first character. */
+    start: number;
+    /** Offset just past the heading line's end of line (the next line's start, or the text length). */
+    end: number;
+}
+/**
+ * Heading levels, texts and line offsets, skipping frontmatter and fenced code.
+ * `limit` stops after that many headings (the documentation index keeps 1000).
+ */
+declare function headingsWithOffsets(markdown: string, limit?: number): HeadingWithOffsets[];
+/** Heading levels and texts, skipping frontmatter and fenced code. `limit` as in `headingsWithOffsets`. */
+declare function headingsOutline(markdown: string, limit?: number): HeadingOutlineEntry[];
+/** Offset just past the leading frontmatter block (0 when there is none). */
+declare function frontmatterEndOffset(markdown: string): number;
+/**
+ * Keep the frontmatter and as many whole leading sections as fit in
+ * `contextTokens - outputTokens - reserveTokens` (at `CHARS_PER_TOKEN`
+ * characters a token). A first section bigger than the budget is cut on a
+ * block boundary instead, and the first block is kept whatever the budget.
+ */
+declare function budgetDocument(markdown: string, opts: DocumentBudgetOptions): BudgetedDocument;
+
+/**
+ * Summary prompts (the `summary` feature: `/summary` and `/outline`). Pure:
+ * builds the chat messages from the budgeted document and tidies the reply
+ * before it is previewed and inserted.
+ *
+ * TL;DR is wrapped in a `[!NOTE]` callout whose first line is **Summary**
+ * (D11: the GFM five are the only kinds that round-trip on GitHub). Outline
+ * stays a plain nested list.
+ */
+
+type AiSummaryKind = 'tldr' | 'outline';
+interface SummaryPromptInput {
+    /** The document as markdown, already through `budgetDocument`. */
+    document: string;
+    kind: AiSummaryKind;
+    /** Share of the document included, 0 to 1 (below 1 means it was cut). */
+    coverage: number;
+}
+/** A document shorter than this gets a one-paragraph TL;DR instead of bullets. */
+declare const SUMMARY_SHORT_DOCUMENT_CHARS = 1200;
+declare const SUMMARY_SYSTEM_PROMPT: string;
+declare const OUTLINE_SYSTEM_PROMPT: string;
+declare function coveragePercent(coverage: number): number;
+declare function buildSummaryMessages(input: SummaryPromptInput): AiMessage[];
+/** Output budget: scales with the input, within a range a small model handles. */
+declare function summaryMaxTokens(kind: AiSummaryKind, inputChars: number): number;
+/** The text to show while it streams (reasoning hidden). */
+declare function summaryVisibleText(raw: string): string;
+/**
+ * The preview once the stream ends: the body `finalizeSummary` will insert,
+ * without the callout wrapper and the coverage line (the popover shows those
+ * apart), so the cut fragment and lead-in are gone before Insert.
+ */
+declare function summaryPreviewText(raw: string, kind: AiSummaryKind, cutOff?: boolean): string;
+/**
+ * The markdown to insert. TL;DR becomes a `[!NOTE]` callout headed
+ * **Summary**; Outline stays the list. When the document was cut
+ * (`coverage` below 1) a "Covers the first N% of the document." line closes
+ * it. An empty reply stays empty so the caller can report a bad output.
+ * `cutOff` (the stream stopped at the length limit) drops a trailing
+ * fragment and ends the text with an ellipsis.
+ */
+declare function finalizeSummary(raw: string, kind: AiSummaryKind, coverage?: number, cutOff?: boolean): string;
+
+/**
+ * Title suggestions (`/title` and "Suggest titles…", the `title` feature).
+ * Pure: the prompt asks for a small JSON object, `parseTitles` validates it.
+ * The document is the budgeted prefix plus the full headings list, so a long
+ * document is still judged as a whole.
+ */
+
+declare const TITLE_MAX_CHARS = 120;
+/** Longest headings list sent, so a huge outline cannot eat the budget. */
+declare const TITLE_OUTLINE_MAX_ITEMS = 60;
+interface TitlePromptInput {
+    /** The document as markdown, already through `budgetDocument`. */
+    document: string;
+    /** All headings of the full document (not only the budgeted part). */
+    outline: readonly HeadingOutlineEntry[];
+    /** The current title, so the model does not hand it back. */
+    existingTitle?: string;
+    count?: number;
+}
+declare const TITLE_SYSTEM_PROMPT: string;
+/** The headings as an indented list, capped. Shared by the title and properties prompts. */
+declare function renderHeadingOutline(outline: readonly HeadingOutlineEntry[], max?: number): string;
+declare function buildTitleMessages(input: TitlePromptInput): AiMessage[];
+/** Output budget: a few short strings. */
+declare function titleMaxTokens(count?: number): number;
+type ParsedTitles = {
+    ok: true;
+    titles: string[];
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * The titles in a reply: `{ "titles": [...] }` (a bare array or a single
+ * `title` string is accepted too), trimmed to 120 characters, de-duplicated
+ * case-insensitively, minus the existing title. No usable title is a failure
+ * so the caller can repair or report `badOutput`.
+ */
+declare function parseTitles(raw: string, existingTitle?: string): ParsedTitles;
+
+interface ParsedEntry {
+    key: string;
+    /** Scalar string, or array of strings (for `tags: [a, b]`-style). */
+    value: string | string[];
+}
+
+/**
+ * Properties suggestions (the `frontmatter` feature: "Suggest" in the
+ * sidebar's Properties header). Pure: the prompt asks for a title, a
+ * description and tags as JSON; `parsePropertySuggestions` validates the
+ * reply and normalises tags through the shared tag syntax, so what reaches the
+ * UI is already safe to apply.
+ */
+
+/** A frontmatter property as the sidebar holds it. */
+type AiFrontmatterEntry = ParsedEntry;
+declare const PROPERTY_MAX_TAGS = 8;
+declare const PROPERTY_DESCRIPTION_MAX_CHARS = 200;
+declare const PROPERTY_TITLE_MAX_CHARS = 120;
+/** Vocabulary tags listed in the prompt at most. */
+declare const PROPERTY_VOCABULARY_MAX = 80;
+interface PropertiesPromptInput {
+    /** The document as markdown, already through `budgetDocument`. */
+    document: string;
+    /** All headings of the full document. */
+    outline: readonly HeadingOutlineEntry[];
+    /** The properties the document already has. */
+    existing: readonly AiFrontmatterEntry[];
+    /** Tags used elsewhere in the workspace, most used first. */
+    vocabulary: readonly string[];
+}
+declare const PROPERTIES_SYSTEM_PROMPT: string;
+/** The tags the entries already carry, normalised (`tags:` or `tag:`, array or comma list). */
+declare function existingTagsOf(existing: readonly AiFrontmatterEntry[]): string[];
+declare function buildPropertiesMessages(input: PropertiesPromptInput): AiMessage[];
+/** Output budget: three short fields. */
+declare function propertiesMaxTokens(): number;
+interface SuggestedTag {
+    /** Normalised: lowercase, no `#`. */
+    tag: string;
+    /** Already used somewhere in the workspace (it is in the vocabulary). */
+    known: boolean;
+}
+interface PropertySuggestions {
+    title?: string;
+    description?: string;
+    tags: SuggestedTag[];
+}
+type ParsedPropertySuggestions = {
+    ok: true;
+    suggestions: PropertySuggestions;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Validate a reply: title and description trimmed to length and dropped when
+ * empty or equal to what the document has, tags normalised, marked `known`
+ * from the vocabulary, minus tags already present, de-duplicated and capped at
+ * 8. A reply with no title, description or tag at all is a failure; one whose
+ * suggestions are all already present succeeds with nothing left in it.
+ */
+declare function parsePropertySuggestions(raw: string, existing: readonly AiFrontmatterEntry[], vocabulary: readonly string[]): ParsedPropertySuggestions;
+
+/**
+ * Inline suggestions ("ghost text", the `ghostText` feature). Pure: a chat
+ * "continue" prompt sent to every model (decision D4; the wire has no FIM
+ * path). The text before the caret is the user turn; the text after it rides
+ * in an `<after>` tag so the model stops where the existing text resumes.
+ */
+
+/** Which kind of text block the caret is in; steers the continuation's shape. */
+type GhostBlockKind = 'paragraph' | 'heading' | 'listItem' | 'blockquote';
+/** Default and bounds for the output budget (tokens). */
+declare const CONTINUE_DEFAULT_MAX_TOKENS = 48;
+declare const CONTINUE_MIN_MAX_TOKENS = 8;
+declare const CONTINUE_MAX_MAX_TOKENS = 256;
+declare const CONTINUE_SYSTEM_PROMPT: string;
+interface ContinuePromptInput {
+    /** The document text before the caret (see `ghostContext`). */
+    before: string;
+    /** The document text after the caret, possibly empty. */
+    after: string;
+    blockKind?: GhostBlockKind;
+}
+declare function buildContinueMessages(input: ContinuePromptInput): AiMessage[];
+/**
+ * Output budget for a request: the `features.ghostText.maxTokens` setting
+ * (default 48), rounded and clamped to 8 to 256. A bad value gets the default.
+ */
+declare function continueMaxTokens(setting?: number | null): number;
+
+/**
+ * The text a ghost-text request sends (decision D3): the text around the
+ * cursor. Pure: given the document's markdown and the caret's offset in it,
+ * return the last `GHOST_BEFORE_CHARS` characters before the caret verbatim
+ * (a few paragraphs), a capped slice of the text after it, and, when the
+ * document runs longer than that tail, a note listing the headings of
+ * everything earlier so the model still knows where in the document it is.
+ * The earlier text itself is never sent, however large the context window.
+ * A small window shrinks the tail (never below 200 characters). Frontmatter
+ * is never part of `before`.
+ */
+/** Characters before the caret that are always sent verbatim. */
+declare const GHOST_BEFORE_CHARS = 2400;
+/** Characters after the caret that are sent as the suffix. */
+declare const GHOST_AFTER_CHARS = 600;
+/** Tokens set aside for the system prompt, the tags and slack. */
+declare const GHOST_RESERVE_TOKENS = 400;
+/** Most headings listed for the sections left out. */
+declare const GHOST_OUTLINE_MAX_ITEMS = 40;
+/** Characters set aside for the list of headings left out. */
+declare const GHOST_OUTLINE_MAX_CHARS = 1000;
+/** Window assumed when a route reports none. */
+declare const GHOST_DEFAULT_CONTEXT_TOKENS = 4096;
+interface GhostContext {
+    before: string;
+    after: string;
+}
+interface GhostContextOptions {
+    /** Tokens the answer may use (the `maxTokens` setting). Default 48. */
+    outputTokens?: number;
+}
+/**
+ * `before` and `after` for a caret at `caretOffset` in `markdown`. A caret
+ * inside the frontmatter yields nothing (both empty), since there is nothing
+ * to continue there. An `after` that is only whitespace is returned empty.
+ */
+declare function ghostContext(markdown: string, caretOffset: number, contextTokens: number, opts?: GhostContextOptions): GhostContext;
+
+/**
+ * Clean up a ghost-text suggestion as it streams in (decisions D5 and D6).
+ * Pure string work, no DOM. The controller calls `trimGhostSuggestion` on
+ * the accumulated raw text after every token, so every rule here must give a
+ * stable answer for a partial string.
+ */
+/** A suggestion longer than this is cut at the end of its next sentence. */
+declare const GHOST_SENTENCE_CUT_CHARS = 120;
+/** How many characters before the caret a suggestion may not repeat. */
+declare const GHOST_REPEAT_CHARS = 20;
+interface GhostTrimOptions {
+    /** The caret is at the end of its text block (nothing after it in the block). */
+    atBlockEnd: boolean;
+    /** The text before the caret (only its tail is used). */
+    before: string;
+}
+interface GhostTrimResult {
+    /** The suggestion to show; empty means show nothing. */
+    text: string;
+    /** A stop rule fired (blank line, newline, sentence cut) or the suggestion was discarded: more tokens cannot change it, so the request can abort. */
+    stopped: boolean;
+}
+/**
+ * Apply the stop rules to `raw`: strip a stray code fence, cut at the first
+ * blank line (and at the first newline when the caret is not at the end of
+ * its block), cut after the first sentence that ends past 120 characters,
+ * drop trailing whitespace, and discard a suggestion that is empty or starts
+ * by repeating the last 20 characters before the caret. A space at the start
+ * is dropped when the text before the caret already ends in whitespace.
+ */
+declare function trimGhostSuggestionDetailed(raw: string, opts: GhostTrimOptions): GhostTrimResult;
+/** The suggestion to show for the raw model output so far. Empty means nothing. */
+declare function trimGhostSuggestion(raw: string, opts: GhostTrimOptions): string;
+/**
+ * The first word of `text` for "accept one word": its leading whitespace,
+ * the word, and the one space or tab after it. The whole text when it has
+ * no second word.
+ */
+declare function ghostAcceptWord(text: string): string;
+/**
+ * The user typed `typed` while `text` was showing: the rest of the
+ * suggestion when `typed` is exactly its start (case-sensitive), else null
+ * (dismiss). An empty result means the whole suggestion was typed.
+ */
+declare function ghostPrefixMatch(text: string, typed: string): string | null;
+
+/**
+ * Every cap and clamp of the documentation-base feature, in one place (S9).
+ * Hosts and the loop import these; nothing else hardcodes a number. The hop
+ * and share limits are M1's (`AI_DOCS_*` in `../types`), re-exported here so a
+ * caller needs one import.
+ */
+
+/** Markdown files indexed per base (decision 13). The walk stops at this many. */
+declare const DOCS_MAX_FILES = 5000;
+/** Bytes per file; a bigger file is skipped and counted in health. */
+declare const DOCS_MAX_FILE_BYTES: number;
+/** Bytes per section sent to a model (the host cuts at this and sets `truncated`). */
+declare const DOCS_MAX_SECTION_BYTES: number;
+/** Links in one hop-1 list. */
+declare const DOCS_MAX_LINKS = 200;
+/** Pages in the in-memory map used when a root has no home document. */
+declare const DOCS_MAX_MAP_ENTRIES = 400;
+/** Sections the keyword fallback returns. */
+declare const DOCS_KEYWORD_TOP = 20;
+/** Terms the keyword fallback uses from one query. */
+declare const DOCS_KEYWORD_MAX_TERMS = 12;
+/** Headings and links kept per page in the index (defence against one huge file). */
+declare const DOCS_MAX_HEADINGS_PER_PAGE = 1000;
+declare const DOCS_MAX_LINKS_PER_PAGE = 1000;
+/** Folders read per base while walking; the walk stops at this many and says so in health (S9). */
+declare const DOCS_MAX_DIRS = 20000;
+/** Heading text is cut to this many code points in the index and in sections (same rule on both hosts). */
+declare const DOCS_MAX_HEADING_CHARS = 200;
+/** A link target is cut to this many code points in the index. */
+declare const DOCS_MAX_LINK_TARGET_CHARS = 500;
+/**
+ * How far (UTF-16 units) the link scanner looks for the end of a `<...>`
+ * destination or a quoted title. A link whose destination or title does not
+ * end within it is not a link. Link text is bounded by the same 300 as before.
+ */
+declare const DOCS_LINK_SCAN_UNITS = 1000;
+/** Link text between the brackets, in UTF-16 units (longer is not a link). */
+declare const DOCS_LINK_TEXT_UNITS = 300;
+/** Milliseconds one base's walk and index may take; past it the build ends and health says so (S9). */
+declare const DOCS_BUILD_BUDGET_MS = 30000;
+/** Candidate pages looked at while counting broken wikilinks, per base; past it the count stops (a lower bound). */
+declare const DOCS_MAX_LINK_WORK = 5000000;
+/** Ids taken from one navigation reply; the rest are dropped and counted. Model output is hostile. */
+declare const DOCS_MAX_READ_IDS_PER_HOP = 20;
+/** Characters of index text in one navigation prompt, whatever the route's context (several roots of 400 map entries add up). */
+declare const DOCS_MAX_NAV_CHARS = 96000;
+/** Longest id the loop looks up; anything longer is dropped unread. */
+declare const DOCS_MAX_ID_CHARS = 2048;
+/** Ids an Activity entry lists per field, each clipped; the count stays exact. */
+declare const DOCS_MAX_ACTIVITY_IDS = 100;
+declare const DOCS_MAX_ACTIVITY_ID_CHARS = 200;
+
+/** Navigation calls before the answer, 1 to 5; anything not a number is the default (3). */
+declare function clampDocsHops(value: unknown): number;
+/** Percent of the route's context the answer's sections may take, 30 to 80; default 60. */
+declare function clampDocsSourceShare(value: unknown): number;
+/**
+ * Cut a section's text to `DOCS_MAX_SECTION_BYTES` UTF-8 bytes on a code point
+ * boundary. Scan (`secrets.ts`) the uncapped text first when you can, so a key
+ * is never cut in half and slips through.
+ */
+declare function capSectionText(text: string, maxBytes?: number): {
+    text: string;
+    truncated: boolean;
+};
+
+/**
+ * Small text helpers the documentation-base modules share. Every rule here is
+ * written to be ported to Rust exactly (Desktop), so none of them leans on
+ * locale behaviour or on a Unicode table.
+ */
+/**
+ * Case folding used by ids, slugs and keyword ranking: ASCII `A` to `Z`
+ * become `a` to `z`, every other code point is left alone. (No Unicode
+ * lowercasing: `É` stays `É`, and `İ` or the Kelvin sign are not touched, so
+ * JavaScript and Rust agree without a table.)
+ */
+declare function foldAscii(text: string): string;
+/**
+ * Compare two strings by Unicode code point (the order UTF-8 bytes give, so
+ * Rust's `str::cmp` agrees). JavaScript's `<` compares UTF-16 units, which
+ * differs for characters above U+FFFF. Returns -1, 0 or 1.
+ */
+declare function cmpCodePoints(a: string, b: string): number;
+/**
+ * The first `max` code points of `text` (the whole text when it has no more).
+ * A surrogate pair counts as one and is never cut. Rust takes `chars().take(max)`.
+ */
+declare function clipCodePoints(text: string, max: number): string;
+
+/**
+ * Documentation-base index: root labels, page ids, heading slugs and the
+ * builder hosts call. Pure, no DOM, no network.
+ *
+ * THE ID CONTRACT (A10). The VS Code host (TypeScript) and Desktop (Rust)
+ * must produce byte-identical labels, ids and slugs; `test/ai-fixtures/docs/`
+ * holds the cases both run. Nothing here uses a regex feature or Unicode table
+ * Rust's standard library lacks.
+ *
+ * ROOT LABEL (`docsRootLabels`). A base has one or more root folders. Each
+ * gets a label, the first segment of every id under it.
+ *   1. Take the root path, split it on `/` and `\`, drop empty segments, take
+ *      the last one (the folder name). A path with no segment gives `root`.
+ *   2. Replace `#` and every control character (below U+0020, and U+007F)
+ *      with `_`. A segment that is `.` or `..` becomes `root`.
+ *   3. Make labels unique within the base, in configured order: the first
+ *      root keeps its label; a later root whose label is already taken gets
+ *      `-2`, `-3`, ... appended (the smallest suffix whose result is unused).
+ *      So `/a/docs` and `/b/docs` are `docs` and `docs-2`; a third `docs`
+ *      folder is `docs-3`. Comparison is exact (case-sensitive).
+ * Labels are only unique inside one base. Ids from two bases can be equal, so
+ * the loop always pairs an id with its base id.
+ *
+ * PAGE ID. `<root label>/<rel path>`, the path relative to the root with `/`
+ * separators and exactly as the file system spells it (case kept), e.g.
+ * `docs/guides/setup.md`. A rel path never starts with `/`, is never empty
+ * and has no `.` or `..` segment (such a page is dropped from the index).
+ *
+ * SECTION ID. `<page id>#<slug>`, one per heading `headingsOutline` reports
+ * (ATX headings outside frontmatter and fenced code, with non-empty text).
+ * A bare page id means the whole page. File names can contain `#`, so
+ * `parseDocsId` looks a full id up as a page first and only then splits at
+ * the LAST `#` (slugs never contain `#`).
+ *
+ * HEADING SLUG (`docsSlug`, `docsSlugs`). From the heading text as
+ * `headingsOutline` returns it (trimmed, closing `#`s removed):
+ *   1. Walk the code points. ASCII `A-Z` become `a-z`. `a-z`, `0-9`, `_` and
+ *      `-` are kept. Whitespace (ASCII space, tab, LF, VT, FF, CR, plus
+ *      U+0085, U+00A0, U+1680, U+2000-U+200A, U+2028, U+2029, U+202F, U+205F,
+ *      U+3000) becomes `-`, one `-` per whitespace code point (not collapsed,
+ *      as GitHub does). Any other ASCII character is dropped. Every non-ASCII
+ *      code point is kept unchanged (no lowercasing), so non-Latin headings
+ *      still get a distinct slug.
+ *   2. An empty result becomes `section`.
+ *   3. Duplicates on one page, in document order: the first keeps its slug;
+ *      a later heading with a taken slug gets `-1`, `-2`, ... appended (the
+ *      smallest suffix whose result is unused, so `Setup`, `Setup`, `Setup 1`
+ *      give `setup`, `setup-1`, `setup-1-1`).
+ * This equals GitHub's anchor for ASCII headings without odd collisions. Link
+ * fragments are also matched against GitHub's anchor (`links.ts`).
+ *
+ * LIMITS (S9, the same on both hosts; `caps.ts`). A page keeps its first 1000
+ * headings, and a heading's text is cut to its first 200 code points BEFORE
+ * the slug is made, in the index and in `splitDocsSections` alike, so ids
+ * agree. A link target is cut to its first 500 code points (`extractDocsLinks`).
+ * Duplicate suffixes are handed out from a counter per base slug (same result
+ * as "smallest unused suffix", in linear time).
+ *
+ * ORDER. `buildDocsIndex` sorts pages by root order, then rel path by code
+ * point, so the same files give the same index on both hosts.
+ */
+
+/** One unique label per root, in the order given (see the header for the rule). */
+declare function docsRootLabels(roots: readonly string[]): string[];
+/** The base slug of one heading text, before duplicate suffixes. */
+declare function docsSlug(text: string): string;
+/** Unique slugs for a page's heading texts, in document order. */
+declare function docsSlugs(texts: readonly string[]): string[];
+/** Heading text as the index and the sections keep it: at most `DOCS_MAX_HEADING_CHARS` code points. */
+declare function clipDocsHeading(text: string): string;
+/** GitHub's anchor for each heading text, with its `-1`, `-2` suffixes (used to match link fragments). */
+declare function githubAnchors(texts: readonly string[]): string[];
+/** `<root label>/<rel path>`. */
+declare function docsPageId(rootLabel: string, relPath: string): string;
+/** `<page id>#<slug>`. */
+declare function docsSectionId(pageId: string, slug: string): string;
+/** The root label of a page or section id: everything before the first `/`. */
+declare function docsIdRoot(id: string): string;
+/**
+ * Split an id the model or host named into its page id and optional slug.
+ * `hasPage` says whether a full string is a page in the host's own index; the
+ * whole id is tried first (a file name may contain `#`), then the part before
+ * the last `#`. Returns null when neither is a known page: never build a path
+ * from an id that is not in the index (S1).
+ */
+declare function parseDocsId(id: string, hasPage: (pageId: string) => boolean): {
+    pageId: string;
+    slug?: string;
+} | null;
+/** True for a rel path a page may have: non-empty, relative, no empty, `.` or `..` segment, no NUL. */
+declare function isSafeRelPath(relPath: string): boolean;
+/** The file name without its `.md` / `.markdown` extension (any case). */
+declare function docsFileStem(relPath: string): string;
+/** A page as the host extracts it: no id, no slugs, no body. */
+interface AiDocsPageInput {
+    /** The root's label (`docsRootLabels`). */
+    root: string;
+    /** Path relative to the root, `/` separators. */
+    relPath: string;
+    /** Frontmatter `title`, when there is one. Else the first heading, else the file name. */
+    title?: string;
+    /** From `headingsOutline(markdown)`. */
+    headings: Array<{
+        level: number;
+        text: string;
+    }>;
+    /** Links as written (`AiDocsLink`). */
+    links?: AiDocsLink[];
+    /** File length in characters. */
+    chars: number;
+}
+interface AiDocsIndexInput {
+    baseId: string;
+    /** Roots that were found, in configured order, each with its label. */
+    roots: Array<{
+        label: string;
+    }>;
+    /** The base's `homeFile` override, a rel path (applied under every root). */
+    homeFile?: string;
+    pages: readonly AiDocsPageInput[];
+    /** The file cap cut the walk short (the builder also sets it past `DOCS_MAX_FILES`). */
+    truncated?: boolean;
+    oversizeSkipped?: number;
+    /** Unix milliseconds; the builder is pure, so the host supplies the clock. */
+    builtAt?: number;
+}
+/**
+ * Build a base's index from host-extracted pages: ids, unique slugs, titles,
+ * deduped and sorted pages (a page with an unknown root label or an unsafe rel
+ * path is dropped; for a repeated id the first in sorted order wins), the file
+ * cap, and each root's home.
+ */
+declare function buildDocsIndex(input: AiDocsIndexInput): AiDocsIndex;
+/** Pages by id, for the lookups the loop and the link resolver do. */
+declare function docsPagesById(index: Pick<AiDocsIndex, 'pages'>): Map<string, AiDocsPage>;
+
+/**
+ * Split a markdown file into the sections the index names. Pure.
+ *
+ * THE SECTION CONTRACT (hosts port this for `readSections` and the keyword
+ * scan; `test/ai-fixtures/docs/sections.json` holds the cases).
+ *   - Headings are the ones `headingsOutline` reports: ATX (`#` to `######`,
+ *     up to three spaces of indent), outside frontmatter and fenced code,
+ *     with non-empty text.
+ *   - A heading's section runs from its line to the line before the NEXT
+ *     heading of any level (sections do not overlap, so a budget never counts
+ *     text twice). The last one runs to the end of the file.
+ *   - Text before the first heading is the preamble, section 0, with no
+ *     heading. It includes the frontmatter. It exists only when there is
+ *     non-whitespace text between the frontmatter and the first heading (or
+ *     the file has no heading at all and is not blank). A file that opens
+ *     with a heading has no preamble, and its frontmatter belongs to no
+ *     section (it is still in a whole-page read).
+ *   - Only the first 1000 headings (`DOCS_MAX_HEADINGS_PER_PAGE`) open a section;
+ *     a heading after that is ordinary text of the 1000th section. A heading's
+ *     text is cut to its first 200 code points (`clipDocsHeading`) before its
+ *     slug is made, as in the index.
+ *   - A section's id is `<page id>#<slug>` (slugs: `docsSlugs`); the preamble
+ *     and a whole-page read are the bare page id.
+ */
+interface DocsMarkdownSection {
+    /** Position in the file; the preamble, when there is one, is 0. */
+    index: number;
+    /** Null for the preamble. */
+    heading: {
+        level: number;
+        text: string;
+        slug: string;
+    } | null;
+    /** Offset of the section's first character, and one past its last. */
+    start: number;
+    end: number;
+    /** The section's markdown (`slice(start, end)`). */
+    text: string;
+}
+declare function splitDocsSections(markdown: string): DocsMarkdownSection[];
+
+/**
+ * Home document per root (decision 3) and the in-memory map used when a root
+ * has none. Pure.
+ *
+ * Precedence, per root: the base's override file (`homeFile`, a rel path),
+ * then `INDEX.md`, then `README.md` at the root's top level, then the map.
+ * Names match with ASCII case folding (`readme.md` counts); when several
+ * pages fold to the same name the exact-case one wins, then the first in
+ * sorted order.
+ */
+
+/** The health text for a root with no home document. */
+declare const DOCS_NO_HOME_TEXT = "No home document";
+/** Pick the home of each root. `pages` must be the index's (sorted) pages. */
+declare function chooseDocsHomes(rootLabels: readonly string[], pages: readonly AiDocsPage[], homeFile?: string): AiDocsHome[];
+/** True when no root of the index has a real home. */
+declare function docsHasNoHome(homes: readonly AiDocsHome[]): boolean;
+/** The health line for one root's home: `null` when it has one, else "No home document". */
+declare function docsHomeHealth(home: AiDocsHome): string | null;
+interface DocsMapEntry {
+    pageId: string;
+    title: string;
+    /** Texts of the page's level 1 to 3 headings, at most `DOCS_MAP_HEADINGS_PER_PAGE`. */
+    headings: string[];
+}
+interface DocsMap {
+    root: string;
+    entries: DocsMapEntry[];
+    /** Pages of the root that did not fit the cap. */
+    omitted: number;
+}
+declare const DOCS_MAP_HEADINGS_PER_PAGE = 8;
+/**
+ * The in-memory map of one root: titles and headings of its pages, at most
+ * `cap` pages (400). When the root has more, the shallowest pages are kept
+ * (fewest folders, then path order) and the entries are listed in path order.
+ * Nothing is written to disk.
+ */
+declare function buildDocsMap(index: Pick<AiDocsIndex, 'pages'>, root: string, cap?: number): DocsMap;
+/** One line per page: `- <page id> | <title> | <heading>; <heading>`; a final line counts what was left out. */
+declare function renderDocsMap(map: DocsMap): string;
+
+/**
+ * Resolve the links of a base's pages inside its index (decision 14), mark the
+ * broken ones and produce the hop-1 link list. Pure; the host only extracts
+ * links as written (`AiDocsLink`).
+ *
+ * Rules.
+ *   - A link with a scheme (`https:`, `mailto:`, anything `name:` with two or
+ *     more letters before the colon) or starting `//` is `external`: not
+ *     followable, not counted as broken.
+ *   - A relative link resolves from the linking page's folder. `?query` is
+ *     dropped, `%XX` decoded (kept raw when malformed), `.` and `..`
+ *     normalised. A link that climbs above its own root, or starts with `/`
+ *     or a drive letter, is broken (`outside-root`) and never followable.
+ *     The index does not know where roots sit on disk, so a link into a
+ *     sibling root is broken too, even when that folder is another root of the
+ *     base.
+ *   - The target must be a page of the index (exact id; if the path has no
+ *     `.md` / `.markdown` extension, `.md` is tried). Else broken `not-found`.
+ *   - `#fragment` is matched against the page's heading slugs, then GitHub's
+ *     anchors. A fragment that matches nothing still resolves to the page
+ *     (`fragmentMissing`): the page is real.
+ *   - Wikilinks (`[[Name]]`, `[[Name#Heading]]`, `[[folder/Name|alias]]`)
+ *     match pages by file stem, ASCII case-folded, anywhere in the base. With
+ *     several matches the nearest to the linking page wins (same folder, then
+ *     fewest folder hops, then the shorter id, then code point order) and
+ *     `ambiguous` carries the count. This is `pickBestWikilinkTarget`
+ *     (`src/wikilinkResolve.ts`) reimplemented over page ids: core cannot
+ *     import from `src/` and the original uses Node's `path`. Matching other
+ *     active bases is the loop's job; `candidates` says how many matched here.
+ */
+
+type AiDocsLinkStatus = 'ok' | 'broken' | 'external';
+type AiDocsBrokenReason = 'outside-root' | 'not-found';
+interface AiDocsResolvedLink {
+    text: string;
+    target: string;
+    kind: AiDocsLink['kind'];
+    status: AiDocsLinkStatus;
+    reason?: AiDocsBrokenReason;
+    /** The page the link lands on (status `ok`). */
+    pageId?: string;
+    /** The section it lands on, when the fragment matched a heading. */
+    sectionId?: string;
+    /** The page is real but the `#fragment` matched no heading. */
+    fragmentMissing?: boolean;
+    /** Wikilink only: how many pages matched the name in this base. */
+    candidates?: number;
+}
+interface DocsLinkResolver {
+    resolve(fromPageId: string, link: AiDocsLink): AiDocsResolvedLink;
+    /**
+     * Links that are `broken`, over every page of the index. The work on
+     * wikilinks is bounded (`DOCS_MAX_LINK_WORK` candidate pages); past it the
+     * count stops, so it is a lower bound for a hostile base.
+     */
+    countBroken(): number;
+    /** Broken links on one page, for a host that counts a page at a time and yields between pages. Shares the work bound. */
+    countBrokenOn(pageId: string): number;
+    /** The wikilink work bound was hit, so `countBroken` is a lower bound. */
+    workExceeded(): boolean;
+}
+/** Order wikilink candidates nearest first (see the header). Pure and total. */
+declare function rankDocsWikilinkCandidates(fromPageId: string, candidateIds: readonly string[]): string[];
+declare function createDocsLinkResolver(index: Pick<AiDocsIndex, 'pages'>): DocsLinkResolver;
+interface DocsLinkList {
+    /** Followable links, in page order, one per landing (page or section). */
+    links: AiDocsResolvedLink[];
+    /** Followable links beyond the cap. */
+    omitted: number;
+    /** Links on the page that are broken (not listed). */
+    broken: number;
+}
+/**
+ * The hop-1 link list of a page (usually a home): its followable links,
+ * deduplicated by landing, at most `cap` (200). Broken and external links are
+ * left out; broken ones are counted.
+ */
+declare function docsLinkList(index: Pick<AiDocsIndex, 'pages'>, pageId: string, cap?: number, resolver?: DocsLinkResolver): DocsLinkList;
+
+/**
+ * Keyword fallback ranking (decision 11): when a root's home is the map, or
+ * navigation read nothing, hosts scan their files and rank sections with this,
+ * so both hosts return the same order for the same input. Pure.
+ *
+ * THE RANKING CONTRACT (A10; `test/ai-fixtures/docs/keyword.json`). All
+ * arithmetic is integer, all comparison is by code point; nothing depends on
+ * locale.
+ *
+ * Case folding. ASCII `A-Z` become `a-z`; every other code point is left
+ * unchanged (`foldAscii`). `É` does not match `é`.
+ *
+ * Terms. Fold the query, then split it into tokens: a token is a maximal run
+ * of ASCII letters and digits, `_`, and any non-ASCII code point that is not
+ * in the fixed whitespace list (`isDocsSpace`). Everything else separates
+ * tokens (so `key-rotation` is `key`, `rotation`). Drop tokens in `STOP_WORDS`
+ * unless that leaves none (then keep every token). Remove repeats (first
+ * occurrence stays), keep the first `DOCS_KEYWORD_MAX_TERMS` (12). No terms,
+ * no results.
+ *
+ * Fields of a section: its heading text (none for a preamble), its page title,
+ * its page rel path, and its text. A term "occurs" in a field when the folded
+ * field contains it as a substring (so `rotat` finds `rotation`); occurrences
+ * are counted left to right without overlap.
+ *
+ * Score, per section, over all terms:
+ *   10 x (terms occurring in the heading)
+ *    + 3 x (terms occurring in the page title)
+ *    + 2 x (terms occurring in the rel path)
+ *    + sum over terms of min(occurrences in the text, 5)
+ *    + 6 x (terms occurring in any of the four fields)
+ * A score of 0 means no match and the section is left out.
+ *
+ * Order. Score descending; ties broken by section id ascending by code point
+ * (ids are unique). The first `DOCS_KEYWORD_TOP` (20) are returned.
+ */
+
+/** Words that carry no meaning in a question. Fixed list; the same on every host. */
+declare const DOCS_STOP_WORDS: readonly string[];
+/** Fold and split a query into ranking terms (see the header). */
+declare function keywordTerms(query: string): string[];
+/** Non-overlapping occurrences of `term` in `text`, left to right. */
+declare function countOccurrences(text: string, term: string): number;
+/** A section as the host scans it. */
+interface DocsKeywordSection {
+    /** `<page id>#<slug>`, or the page id for a preamble. */
+    id: string;
+    pageId: string;
+    /** The page's title. */
+    title: string;
+    relPath: string;
+    /** The heading text; absent for a preamble. */
+    heading?: string;
+    text: string;
+}
+/** Score one section against folded terms (0 is no match). */
+declare function scoreKeywordSection(terms: readonly string[], section: DocsKeywordSection): number;
+/** Rank sections for a query: scored, ordered, top `limit` (20). */
+declare function rankKeywordSections(query: string, sections: readonly DocsKeywordSection[], limit?: number): AiDocsSectionRef[];
+
+/**
+ * Secrets scan (S7, A6): strict patterns, run on every string that leaves the
+ * machine for a model, on every engine. A matching section or entry is left
+ * out and counted in the coverage note. No lookbehind (older WebKit rejects
+ * the whole module). Pure, linear-time (each pattern is
+ * anchored on a literal prefix and uses bounded or possessive-by-construction
+ * runs; `test/…` runs 1 MiB adversarial inputs).
+ *
+ * Patterns (a match anywhere in the text):
+ *   - aws-access-key: `AKIA` or `ASIA` + 16 of `[0-9A-Z]`, not inside a longer
+ *     alphanumeric run.
+ *   - api-token: `sk-` (optionally `sk-ant-`, `sk-proj-` ...) followed by a run
+ *     of at least 20 of `[A-Za-z0-9_-]` that contains a digit, and only where
+ *     `sk-` does not continue a word, so `task-based`, `risk-free` and
+ *     `desk-mounted` never match; or Stripe style `sk_live_` / `sk_test_` /
+ *     `rk_live_` / `rk_test_` + 16 or more alphanumerics.
+ *   - private-key: any `-----BEGIN ... PRIVATE KEY-----` header (RSA, EC,
+ *     DSA, OPENSSH, ENCRYPTED, bare, `PGP PRIVATE KEY BLOCK`). The header is
+ *     enough; the body need not be present. Whitespace between the words of
+ *     the header may include a line break (a header re-wrapped by a tool).
+ *   - jwt: `eyJ...` `.` `eyJ...` `.` signature (each part base64url; header
+ *     and payload at least 8 characters after `eyJ`; the signature may be
+ *     empty, for unsecured tokens).
+ *
+ * A section the host cut at the byte cap (`truncated`) may have lost the end
+ * of a key. Hosts scan the uncapped text when they can (`capSectionText`
+ * says so); for what arrives already cut, `scanDocsSections` also applies the
+ * tail rule (`findSecretAtCutoff`): a key that starts in the last stretch of
+ * the text and runs to its end counts.
+ */
+
+type DocsSecretKind = 'aws-access-key' | 'api-token' | 'private-key' | 'jwt';
+/** What kind of secret `text` contains, or null. The string-level check (A6). */
+declare function findSecret(text: string): DocsSecretKind | null;
+declare function containsSecret(text: string): boolean;
+/**
+ * For text that was cut at the cap: a secret that begins near the end and runs
+ * off it (half a key is still a key). Looks only at the last 256 characters.
+ */
+declare function findSecretAtCutoff(text: string): DocsSecretKind | null;
+interface SecretScan<T> {
+    /** Items with no secret, in the order given. */
+    kept: T[];
+    /** Ids of the items left out. Ids only: never the text (S13). */
+    leftOut: string[];
+    /** Why each was left out, by id. */
+    kinds: Record<string, DocsSecretKind>;
+}
+/** Scan any list of items. `textOf` returns every string of the item that would be sent. */
+declare function scanForSecrets<T extends {
+    id: string;
+}>(items: readonly T[], textOf: (item: T) => string | readonly string[], truncatedOf?: (item: T) => boolean): SecretScan<T>;
+/** Scan the sections `readSections` returned. */
+declare function scanDocsSections(sections: readonly AiDocsSection[]): SecretScan<AiDocsSection>;
+/**
+ * This-document scope: scan the live text per section, drop the sections that
+ * hold a key and keep the rest, so one key does not drop the whole document.
+ * `text` is the kept sections joined as they were (in file order).
+ */
+declare function dropSecretSections(markdown: string): {
+    text: string;
+    total: number;
+    leftOut: number;
+};
+/**
+ * The coverage phrase: "1 section left out: looks like it contains a key".
+ * `noun` is what was left out (`section`, or `entry` for navigation lists).
+ */
+declare function secretsLeftOutPhrase(count: number, noun?: 'section' | 'entry'): string;
+
+/**
+ * The answer call's source budget: keep whole sections in the order asked
+ * until the share of the route's context is used, then number what was kept
+ * and write the coverage note. Pure. Built on `documentBudget.ts`
+ * (`CHARS_PER_TOKEN`).
+ *
+ * Rules.
+ *   - Sections are deduplicated by id (first stays) and taken in the order
+ *     given: the loop puts the most relevant first.
+ *   - The budget is `floor(contextTokens x sourceShare / 100 x
+ *     CHARS_PER_TOKEN)` characters. A section that fits the room left is kept;
+ *     one that does not is left out and the next is tried, so a huge section
+ *     cannot starve smaller ones.
+ *   - If nothing fits whole, the first section is kept cut to the budget (on a
+ *     code point boundary, `truncated` set), so an answer always has something.
+ *   - NUMBERING HAPPENS AFTER THE CUT: `n` runs 1..k over the sections that
+ *     are actually sent, in the order kept. A model never sees a gap.
+ *   - Callers scan for secrets first (`scanDocsSections`) and pass how many
+ *     sections that left out, so the note can say so.
+ */
+
+interface DocsBudgetOptions {
+    /** The route's context window, in tokens. */
+    contextTokens: number;
+    /** Percent of it the sections may take. Clamped 30 to 80 (default 60). */
+    sourceShare?: number;
+    /** Sections the secrets scan already left out. */
+    secretsLeftOut?: number;
+}
+interface AiDocsNumberedSection {
+    /** 1-based, contiguous over what is sent. */
+    n: number;
+    section: AiDocsSection;
+}
+interface DocsBudgetResult {
+    /** What goes to the model, numbered. */
+    sent: AiDocsNumberedSection[];
+    /** Ids left out because they did not fit. */
+    cutIds: string[];
+    /** Sections asked for, after dedupe and without the secret ones. */
+    requested: number;
+    /** Sections sent that the host or the budget cut short. */
+    cutShort: number;
+    /** Characters the budget allowed. */
+    budgetChars: number;
+    /** "answered from 4 of 7 sections, 3 left out", or null when no section was sent or asked for. */
+    note: string | null;
+}
+/** Characters of source text a route allows. */
+declare function docsBudgetChars(contextTokens: number, sourceShare?: number): number;
+/** The coverage note (without the secrets part when `secretsLeftOut` is 0). */
+declare function docsCoverageNote(total: number, used: number, cutShort: number, secretsLeftOut: number): string | null;
+declare function budgetDocsSections(sections: readonly AiDocsSection[], opts: DocsBudgetOptions): DocsBudgetResult;
+
+/**
+ * Citations in an answer, and what Insert at cursor does with it. Pure.
+ *
+ * Parsing (`parseCitations`). The model cites sources as `[n]` or `[n, m]`
+ * (the numbers the final call gave its sections). A marker is NOT a citation
+ * when it sits in a fenced code block or code span, is followed by `(` or `:`
+ * (a link or a definition), follows `!` or a non-citation `]` (an image or
+ * `[text][1]` reference). Unknown numbers are dropped from the text (and from
+ * a list); none valid means `NO_SOURCES_CITED`.
+ *
+ * Insert (`prepareInsertMarkdown`, A8/S8). THE SECURITY BOUNDARY IS NOT HERE. It
+ * is the parsed walk in `ai-insert-guard.ts`, which runs on the editor's own
+ * parser output and enforces `InsertUrlPolicy`. A string-level pass approximates
+ * CommonMark, and wherever it disagrees with markdown-it, markup gets through.
+ * Treat what follows as a first pass that keeps the common cases readable (in
+ * source mode above all), and never rely on it to stop anything.
+ * Two steps, in this order:
+ *   1. `sanitizeInsertMarkdown`: every link, image, reference-style link and
+ *      bare or `<...>` autolink the MODEL wrote becomes plain text unless its
+ *      URL appears verbatim in a cited section's text (and is `https:`,
+ *      `http:` or, for links, `mailto:`). A link around an image is handled
+ *      innermost first, so nesting cannot carry an image through. Raw HTML
+ *      tags are escaped. Code spans and fenced blocks are left alone.
+ *   2. `rewriteCitationsForInsert`: each citation becomes a CommonMark
+ *      relative link to the cited file, such as
+ *      `[Key rotation](security.md#key-rotation)` (spaces and brackets in
+ *      the path percent-encoded), when the current document sits under the
+ *      same root as the source; otherwise plain `file › heading` text. The
+ *      fragment is the heading slug (`docsSlug`), which is GitHub's anchor
+ *      for ASCII headings.
+ * Those relative links are the only links Insert adds.
+ */
+
+declare const NO_SOURCES_CITED = "No sources cited";
+declare const ANSWERED_WITHOUT_SOURCES = "answered without sources";
+type DocsCitationPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'cite';
+    ns: number[];
+};
+interface ParsedCitations {
+    /** Valid numbers in order of first appearance. */
+    cited: number[];
+    /** Numbers the model wrote that match no source, in order, once each. */
+    dropped: number[];
+    /** The answer with unknown numbers removed. */
+    text: string;
+    /** The same answer cut into plain text and citation parts, for rendering `[1]` chips. */
+    parts: DocsCitationPart[];
+    /** True when no valid citation is left. Show `NO_SOURCES_CITED`. */
+    noSources: boolean;
+}
+/** Find `[n]` markers and keep the valid ones. `validNs` are the numbers of the sections sent. */
+declare function parseCitations(answer: string, validNs: Iterable<number>): ParsedCitations;
+/** The slug part of a section id (`undefined` for a whole page). */
+declare function docsSectionSlug(section: Pick<AiDocsSection, 'id' | 'pageId'>): string | undefined;
+/** The chip text: `file › heading`, or the file alone for a whole page. */
+declare function docsCitationLabel(section: Pick<AiDocsSection, 'relPath' | 'heading'>): string;
+/**
+ * Percent-encode what would end a CommonMark link destination or change what
+ * it points at: space, `%`, `#` (a file named `a#b.md` is not `a` plus a
+ * fragment), `?`, brackets, parentheses, angle brackets, backslash, control
+ * characters.
+ */
+declare function encodeLinkPath(path: string): string;
+/** Where the document being edited sits: the label of the root that contains it and its folder relative to that root (`''` for the root itself). */
+interface DocsDocumentLocation {
+    root: string;
+    folder: string;
+    /** The base of that root. Labels are unique per base only, so a source from another base is not linked. */
+    baseId?: string;
+}
+/** Relative path from a folder (relative to a root) to a file (relative to the same root). */
+declare function relativeDocsPath(fromFolder: string, toRelPath: string): string;
+/**
+ * The CommonMark relative link for one cited section, or null when the
+ * document is not under the section's root (then the caller writes plain text).
+ */
+declare function citationLink(section: AiDocsSection, location: DocsDocumentLocation | null | undefined): string | null;
+/**
+ * Replace each valid `[n]` with its link (or `file › heading` text). Unknown
+ * numbers are removed. Run `sanitizeInsertMarkdown` first.
+ */
+declare function rewriteCitationsForInsert(answer: string, sources: ReadonlyArray<AiDocsNumberedSection & {
+    baseId?: string;
+}>, location?: DocsDocumentLocation | null): string;
+/**
+ * What may stay live in inserted content (S8), enforced on the parsed result by
+ * `ai-insert-guard.ts`: citation links built from the sections sent, and URLs
+ * that appear verbatim in a cited section.
+ */
+interface InsertUrlPolicy {
+    /** Destinations of the citation links, as written in the markdown (before the parser normalizes them). */
+    citationHrefs: readonly string[];
+    citedTexts: readonly string[];
+}
+/** The verbatim half of `InsertUrlPolicy`: a link (`https:`, `http:`, `mailto:`) or image (`https:`) URL found in a cited section. */
+declare function insertUrlIsVerbatim(policy: InsertUrlPolicy, url: string, kind: 'link' | 'image'): boolean;
+interface SanitizedMarkdown {
+    markdown: string;
+    /** Links, autolinks and definitions turned into text. */
+    linksRemoved: number;
+    imagesRemoved: number;
+}
+/** See the header. `citedTexts` are the texts of the sections the answer cited. */
+declare function sanitizeInsertMarkdown(markdown: string, citedTexts: readonly string[]): SanitizedMarkdown;
+/**
+ * The text Insert at cursor puts in the document: sanitize what the model
+ * wrote, then turn citations into relative links (or `file › heading`). Also
+ * returns the `policy` the caller must hand to the insert, whose parsed walk is
+ * what actually keeps anything else out.
+ */
+declare function prepareInsertMarkdown(answer: string, sources: ReadonlyArray<AiDocsNumberedSection & {
+    baseId?: string;
+}>, location?: DocsDocumentLocation | null): SanitizedMarkdown & {
+    policy: InsertUrlPolicy;
+};
+
+/**
+ * Getting from a cited section back to its file, and from the document being
+ * edited to a base. Pure, for the chat panel and the editor's reveal.
+ *
+ * A chip's target comes from `host.docs.listBases()` (the root) and the section
+ * the host read (`relPath`), never from model text. The href is a `file:` URL
+ * because both hosts need an absolute path outside the current folder, and a
+ * Windows path would read as a URL scheme. Hosts open it after their own checks.
+ *
+ * A heading is found again by M2's slug rule (`docs/index.ts`), not GitHub's:
+ * the two differ on non-ASCII text and on some duplicates.
+ */
+
+/** `file:` URL for `relPath` under an absolute root: POSIX, drive letter or UNC. */
+declare function docsFileHref(root: string, relPath: string): string;
+/** The absolute path a section's file has, for display. Null when its base or root is no longer configured. */
+declare function docsSectionFile(section: Pick<AiDocsSection, 'pageId' | 'relPath'>, baseId: string, statuses: readonly AiDocBaseStatus[]): {
+    root: string;
+    relPath: string;
+    baseName: string;
+} | null;
+/**
+ * Where a folder sits among the bases, for Insert's relative links. Null for a
+ * folder that is not absolute (an untitled document) or under no root. A base
+ * in `prefer` wins, so a folder under two bases links to the one the answer used.
+ */
+declare function docsDocumentLocation(folder: string | null | undefined, statuses: readonly AiDocBaseStatus[], prefer?: readonly string[]): DocsDocumentLocation | null;
+interface DocsHeadingHit {
+    /** Which heading, 0-based, counting the headings `headingsOutline` reports. */
+    index: number;
+    /** Where its line starts in `markdown`. */
+    offset: number;
+}
+/** The heading whose M2 slug is `slug`, or null. */
+declare function docsHeadingAt(markdown: string, slug: string): DocsHeadingHit | null;
+
+/**
+ * The documentation chat's turn: choose one route, navigate by outlines, read
+ * sections, answer with citations. The security model rests here, so the rules
+ * are stated once and enforced in code, not in a prompt.
+ *
+ *   - One route per turn (decision 7, A4). The route is resolved once, the
+ *     per-base cloud switch is checked on it (one reached `viaFallback` too),
+ *     and only then may a consent dialog or a request happen. Every hop and the
+ *     answer carry the pin, so an engine going down mid-turn fails the turn; it
+ *     never moves pages to another engine. The next turn resolves afresh.
+ *   - Fail closed (S6). No route (a tier-1 host routes by itself) counts as not
+ *     local. `allowCloud` comes from `listBases()` for this turn, never a copy.
+ *   - The model names ids and nothing else (S1). Its reply is hostile: `read`
+ *     may be missing, not a list, full of non-strings or thousands long. Only
+ *     ids found in an active base's index reach `readSections`, and what is
+ *     passed on is the index's own string, not the model's.
+ *   - Ids are unique per base only, so a read is always `(baseId, id)`. With
+ *     more than one base the ids offered carry a `b1:` token.
+ *   - Secrets (S7, A6, A7). Every string is scanned before any message is
+ *     built: section text and labels, titles, headings, link text, keyword
+ *     labels, the question. The Activity log records messages verbatim, so what
+ *     the scan leaves out can reach neither a request nor an entry.
+ *   - Nothing from a page changes the control flow (S10). Only the model's JSON,
+ *     filtered through the index, picks what is read. The answer call's output
+ *     is never parsed for further reads, and the hop cap holds regardless.
+ *   - Read-only (S12). No writes, no shell, no URLs: the loop's only effects are
+ *     `deps` and the read calls of `host.docs`.
+ *
+ * Pure: `ai/` has no DOM and no network, and `ai-request.ts` sits outside it,
+ * so the completion runner and route resolution are parameters
+ * (`ai-docs-run.ts` is the wiring).
+ */
+
+declare const DOCS_CHAT_FEATURE = "chat";
+/** The This document scope's synthetic page. */
+declare const DOCS_DOCUMENT_BASE_ID = "document";
+/**
+ * A route held for a whole turn (A4): the pair `runAiCompletion` must use, with
+ * no re-routing and no retry elsewhere.
+ */
+interface AiRoutePin {
+    engineId: string;
+    modelId: string;
+    /** How the turn's route was reached, for the badge and the Activity entry. */
+    viaFallback?: boolean;
+    reason?: string;
+    /** "Allow once" answered for this turn: it covers every call of this turn, and nothing after it. */
+    consented?: boolean;
+    /** The engine's locality when the turn was routed. A pinned call fails if it has changed. */
+    isLocal?: boolean;
+    /** The turn, on the wire with every request (`AiCompletionTurn`), so a host can hold "Allow once" for exactly this turn. */
+    turnId?: string;
+}
+/** What a chat request's Activity entry adds to the usual fields (A7). Ids only, never text. */
+interface AiDocsActivityDetail {
+    /** Which navigation step, 1-based. Absent on the answer. */
+    hop?: number;
+    /** Navigate: the sections this hop's reply read. Answer: the sections sent. */
+    pages: string[];
+    /** Ids the model named that were not used, clipped and at most `DOCS_MAX_ACTIVITY_IDS`. */
+    droppedIds: string[];
+    /** Everything dropped, non-strings and overflow included. */
+    droppedCount: number;
+    /** Sections the secrets scan left out. */
+    leftOutIds?: string[];
+    /** Sections that did not fit the budget. */
+    cutIds?: string[];
+}
+interface DocsRunRequest {
+    feature: string;
+    task: string;
+    sends: AiSendsScope;
+    baseIds?: string[];
+    messages: AiMessage[];
+    maxTokens: number;
+    temperature: number;
+    format?: 'json';
+    job: 'navigate' | 'answer';
+    thinking?: AiThinkingLevel | null | ((kind: string) => AiThinkingLevel | null);
+    pin?: AiRoutePin;
+    docs: AiDocsActivityDetail;
+}
+/** The thinking state of the request, as the runner reports it. */
+interface DocsRunThinking {
+    kind: string;
+    configured: AiThinkingLevel | null;
+    sent: AiThinkingLevel | null;
+    auto?: boolean;
+}
+interface DocsRunOutcome {
+    result: AiCompletionResult;
+    route: AiRouteOk | null;
+    viaFallback: boolean;
+    thinking: DocsRunThinking | null;
+    /** The Activity entry's id, for `annotate`. */
+    requestId?: string;
+}
+interface DocsRunEvents {
+    onRoute?(route: AiRouteOk | null, thinking: DocsRunThinking | null): void;
+    onToken?(delta: string, text: string): void;
+}
+interface DocsRouteRequest {
+    feature: string;
+    task: string;
+    sends: AiSendsScope;
+    baseIds?: string[];
+    /** Asked about every route considered, before any consent dialog. False stops the turn with `blocked`. */
+    allowed(route: AiRouteOk | null): boolean;
+}
+interface DocsTurnRoute {
+    /** `allowed` said no; nothing was asked and nothing was sent. */
+    blocked: boolean;
+    /** Null for a tier-1 host. */
+    route: AiRouteOk | null;
+    /** Null when there is no route to hold. */
+    pin: AiRoutePin | null;
+}
+/** What the loop needs from the editor's request layer (`aiDocsLoopDeps`). */
+interface DocsLoopDeps {
+    resolveRoute(req: DocsRouteRequest, signal: AbortSignal): Promise<DocsTurnRoute>;
+    run(req: DocsRunRequest, events: DocsRunEvents, signal: AbortSignal): Promise<DocsRunOutcome>;
+    /** The route's context window, null when unknown. */
+    contextTokens(route: AiRouteOk | null): number | null;
+    /** Update a request's Activity entry once the hop's reply was acted on. */
+    annotate?(requestId: string, detail: AiDocsActivityDetail): void;
+    /** The turn holding `pin` is over, however it ended. */
+    endTurn?(pin: AiRoutePin): void;
+}
+/** The read side of `host.docs`; the loop never touches `saveBases` or a folder picker. */
+type DocsReadHost = Pick<MikeDownDocsHost, 'listBases' | 'index' | 'readSections' | 'keywordSearch'>;
+type DocsTurnScope = {
+    kind: 'bases';
+    docs: DocsReadHost;
+    options?: Partial<AiDocsOptions>;
+}
+/** Live editor text: a single synthetic page, no host calls, task `chat`. */
+ | {
+    kind: 'document';
+    text: string;
+    title?: string;
+    options?: Partial<AiDocsOptions>;
+};
+interface DocsTurnInput {
+    question: string;
+    scope: DocsTurnScope;
+    /** The user's dial, for the answer only: navigation stays on its job default (Off). */
+    thinking?: DocsRunRequest['thinking'];
+}
+interface DocsTurnProgress {
+    phase: 'navigate' | 'keyword' | 'answer';
+    /** Navigation step, 1-based. */
+    hop?: number;
+    maxHops: number;
+    /** Sections read so far. */
+    pages: number;
+}
+interface DocsTurnEvents extends DocsRunEvents {
+    onProgress?(progress: DocsTurnProgress): void;
+}
+/** A numbered section as sent, with the base it came from: ids are unique per base only. */
+interface DocsSentSection extends AiDocsNumberedSection {
+    baseId: string;
+}
+interface DocsTurnAnswer {
+    kind: 'answered';
+    /** The answer with unknown citation numbers removed and reasoning stripped. */
+    answer: string;
+    citations: ParsedCitations;
+    sent: DocsSentSection[];
+    /** The note under the answer: coverage, secrets left out, or "answered without sources". */
+    coverage: string;
+    /** Nothing was read: label the answer. */
+    withoutSources: boolean;
+    /** Sections were sent and the answer cites none: "No sources cited". */
+    noSources: boolean;
+    /** Navigation calls made (a repair turn is not a hop). */
+    hops: number;
+    droppedCount: number;
+    secretsLeftOut: number;
+    /** Nav entries the scan left out of the prompts. */
+    entriesLeftOut: number;
+    run: DocsRunOutcome;
+}
+type DocsTurnOutcome = DocsTurnAnswer
+/** S6: a cloud route (or none) and a base that may not leave the machine. Nothing was asked or sent. */
+ | {
+    kind: 'baseLocalOnly';
+    bases: Array<{
+        id: string;
+        name: string;
+    }>;
+    route: AiRouteOk | null;
+} | {
+    kind: 'noActiveBases';
+}
+/** The question itself looks like it holds a key. Nothing was sent. */
+ | {
+    kind: 'questionHasSecret';
+}
+/** Another request of this editor is in flight. */
+ | {
+    kind: 'busy';
+} | {
+    kind: 'cancelled';
+} | {
+    kind: 'error';
+    error: AiError;
+};
+/** "Active" (A1): enabled and with a root found. Host-reported state, re-checked rather than assumed. */
+declare function docsActiveBases(statuses: readonly AiDocBaseStatus[]): AiDocBaseStatus[];
+/** S6: the active bases `route` may not carry. A null route counts as not local (fail closed). */
+declare function docsBlockingBases(active: readonly AiDocBaseStatus[], route: AiRouteOk | null): AiDocBaseStatus[];
+/**
+ * The bases of this turn that may not go on to the answer call, by what the
+ * host says now (F6): one that was disabled or removed mid-turn on any route,
+ * one whose cloud switch went off on a route that is not local.
+ */
+declare function docsBasesOffMidTurn(active: readonly AiDocBaseStatus[], now: readonly AiDocBaseStatus[], route: AiRouteOk | null): Array<{
+    id: string;
+    name: string;
+}>;
+/**
+ * One turn, start to finish. Never rejects: a cancelled or failed hop ends the
+ * turn with an outcome, and what Activity recorded stays there.
+ */
+declare function runDocsTurn(deps: DocsLoopDeps, input: DocsTurnInput, events: DocsTurnEvents, signal: AbortSignal): Promise<DocsTurnOutcome>;
+interface DocsChat {
+    /** A turn is in flight. */
+    readonly busy: boolean;
+    /** Start a turn; `{ kind: 'busy' }`, with nothing touched, while another is running. Abort `signal` to cancel the hops and the answer. */
+    run(input: DocsTurnInput, events: DocsTurnEvents, signal: AbortSignal): Promise<DocsTurnOutcome>;
+}
+/** One per editor: one chat request in flight at a time (decision 13). */
+declare function createDocsChat(deps: DocsLoopDeps): DocsChat;
+
+/**
+ * The navigation hop's prompt: outlines and links only, never a body (A5),
+ * and the parser for what comes back. Pure.
+ *
+ * Everything between `<index>` and `</index>` came from someone's files, so
+ * the prompt says it is data (S10). The loop scans every string for secrets
+ * (S7, A6) before it gets here. Nothing in a reply is trusted: `read` is
+ * returned as it arrived and the loop filters it through the index (S1).
+ */
+
+/** Output budget for one hop: a short list of ids (`runAiCompletion` adds reasoning headroom when thinking is on). */
+declare const DOCS_NAV_MAX_TOKENS = 768;
+/** One thing the model can ask for. `id` null: a label over `children`. */
+interface DocsNavEntry {
+    id: string | null;
+    text: string;
+    children?: DocsNavEntry[];
+}
+/** A page's or a root's part of the index. */
+interface DocsNavBlock {
+    /** "Root docs, home page: Handbook". */
+    label: string;
+    outline: DocsNavEntry[];
+    links: DocsNavEntry[];
+    /** Entries a cap already kept out of this block. */
+    omitted: number;
+}
+interface DocsNavigatePromptInput {
+    question: string;
+    blocks: readonly DocsNavBlock[];
+    /** Offered ids already asked for, so the model moves on. */
+    alreadyRead: readonly string[];
+    hop: number;
+    maxHops: number;
+    navigateBy: AiDocsNavigateBy;
+    /** Characters of index text allowed. */
+    maxChars: number;
+}
+interface DocsNavigatePrompt {
+    messages: AiMessage[];
+    /** Ids the index text offers. Zero means there is nothing to ask for: send nothing. */
+    offered: number;
+    /** Entries that did not fit, or that a cap kept out. */
+    omitted: number;
+}
+declare function docsNavigateSystemPrompt(navigateBy: AiDocsNavigateBy): string;
+/** One line of index text: no way to start a new line or run on. Call it after the secrets scan, never before. */
+declare function docsNavText(text: string, max?: number): string;
+declare function buildDocsNavigateMessages(input: DocsNavigatePromptInput): DocsNavigatePrompt;
+type DocsNavReply = {
+    ok: true;
+    read: unknown[];
+    done: boolean;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * A navigation reply's shape, and nothing more: `read` comes back as it
+ * arrived (ids, numbers, whatever) for the loop to filter. `done` counts only
+ * when it is exactly `true`. A bare array is taken as `read`. Missing `read`
+ * is fine with `done: true`; otherwise it is a parse failure and gets the one
+ * repair turn, as does a `read` that is not an array.
+ */
+declare function parseDocsNavReply(raw: string): DocsNavReply;
+
+/**
+ * The answer call's prompt: the question, the coverage note and the numbered
+ * sections, delimited and declared to be data. Pure. Only the sections that
+ * passed the secrets scan and the budget ever reach this builder, so the
+ * Activity log, which records messages verbatim, cannot see the others (A7).
+ *
+ * The answer is text for a person. It is never parsed for further reads.
+ */
+
+/** The longest answer asked for; a small context gets less (`docsAnswerMaxTokens`). */
+declare const DOCS_ANSWER_MAX_TOKENS = 2048;
+interface DocsAnswerPromptInput {
+    question: string;
+    sent: readonly AiDocsNumberedSection[];
+    /** "answered from 4 of 7 sections, 3 left out". Counts only, no page text. */
+    coverage: string | null;
+    scope: 'bases' | 'document';
+}
+declare function docsAnswerSystemPrompt(scope: DocsAnswerPromptInput['scope'], withSources: boolean): string;
+declare function buildDocsAnswerMessages(input: DocsAnswerPromptInput): AiMessage[];
+/** Answer budget: what the context has left after the prompt, within a range (`runAiCompletion` adds reasoning headroom when thinking is on). */
+declare function docsAnswerMaxTokens(contextTokens: number, messages: readonly AiMessage[]): number;
+/** The answer without reasoning blocks: what the panel streams and stores. */
+declare function finalizeDocsAnswer(raw: string): string;
+
+/**
+ * Privacy copy for cloud engines: the four lines every surface shows (the
+ * privacy card, the disclaimer, the consent dialogs), what each feature
+ * sends, each provider's policy link, and the consent dialog text both hosts
+ * render (VS Code's modal, Desktop's native dialog; Desktop has a Rust port
+ * checked against `test/ai-fixtures/consent/`).
+ *
+ * No claims about any provider's training or retention: those are set by the
+ * provider's terms and change. The copy says "may" and points at the policy.
+ */
+
+/** The four lines of the privacy card, in display order. */
+declare const AI_CLOUD_PRIVACY: {
+    readonly leaves: "Text you ask about is sent over the internet to the provider and processed on their servers.";
+    readonly terms: string;
+    readonly local: "A local engine keeps everything on this machine or your network.";
+    readonly keys: "Your API key stays in this app's secure storage on this machine.";
+};
+/**
+ * The privacy card's lines for an engine built into the host (VS Code's
+ * Copilot models, `vscode-lm`): no API key, and the text goes through the
+ * host to GitHub's Copilot service under the user's Copilot plan. No claim
+ * about how a plan handles it; the policy link says.
+ */
+declare const AI_HOST_PRIVACY: {
+    readonly leaves: "Text you ask about goes through VS Code to GitHub’s Copilot service and is processed on GitHub’s servers, under your Copilot plan.";
+    readonly terms: "Whether it is retained or used for training is set by your plan’s terms, which differ between individual and business plans and may change; read them before you decide.";
+    readonly local: "A local engine keeps everything on this machine or your network.";
+    readonly permission: "VS Code also asks for its own permission the first time MikeDown uses Copilot.";
+};
+/**
+ * The sentence about the consent step, for the cloud privacy card: whether
+ * the host asks before a cloud engine's first request (`hostAsks`: it has
+ * `requestCloudConsent`) or sends without asking.
+ */
+declare function aiConsentStepNote(hostAsks: boolean): string;
+/** What a request of each scope sends, as the object of "sends …". */
+declare const AI_SENDS_TEXT: Readonly<Record<AiSendsScope, string>>;
+/** For a request whose feature is unknown. */
+declare const AI_SENDS_FALLBACK = "the text you ask the AI about";
+/** Most base names a consent sentence lists before it says "and N more". */
+declare const AI_SENDS_MAX_BASE_NAMES = 5;
+/**
+ * What a request sends, as the object of a sentence ("MikeDown sends …").
+ * `sends` wins (whole-document Translate runs as the `rewrite` feature);
+ * else the feature's own scope; else a generic phrase. For `docsBase`,
+ * `baseNames` (the host's names for the bases the request would read from)
+ * are spelled out: "pages from the documentation bases you turned on:
+ * “Handbook” and “Notes”". Without names it is the bare phrase.
+ */
+declare function whatIsSent(feature?: string, sends?: AiSendsScope, baseNames?: readonly string[]): string;
+/** The policy of the cloud preset on `host` (an engine's base URL host), if one matches. */
+declare function aiProviderPolicyForHost(host: string | null | undefined, presets?: readonly AiEnginePreset[]): AiProviderPolicy | undefined;
+/**
+ * The policy for an engine, matched by its base URL's host (engines do not
+ * store a preset); a host kind with no address (`vscode-lm`) by its kind.
+ */
+declare function aiProviderPolicy(engine: {
+    baseUrl: string;
+    kind?: string;
+}, presets?: readonly AiEnginePreset[]): AiProviderPolicy | undefined;
+/**
+ * Where an engine sends text, as the consent dialog's `host`: the base URL's
+ * host ("api.anthropic.com"), the URL itself when it has none, or the
+ * service's name for a host kind ("GitHub Copilot" for `vscode-lm`).
+ */
+declare function aiConsentHost(engine: {
+    baseUrl: string;
+    kind?: string;
+}): string;
+/** Where a consent answer is remembered: VS Code says workspace, Desktop folder (or session without one). */
+type AiConsentScopeWord = 'workspace' | 'folder' | 'session';
+interface AiConsentTextInput {
+    engineName: string;
+    /** The engine's kind; a host kind (`vscode-lm`) reads as a service built into VS Code, not an address. */
+    kind?: string;
+    /** The engine's host ("api.anthropic.com"), or its base URL when it has none. */
+    host: string;
+    feature?: string;
+    sends?: AiSendsScope;
+    /** Names of the bases a `docsBase` request reads from, as the host knows them (never from the webview). */
+    baseNames?: readonly string[];
+    scopeWord: AiConsentScopeWord;
+    /** The provider's policy (see `aiProviderPolicyForHost`). */
+    policy?: AiProviderPolicy | null;
+    /**
+     * Spell the policy link out in the body, for a dialog that can neither
+     * link nor spare a button for it (Desktop's native dialog). VS Code's modal
+     * has a "Read the provider's policy" button instead.
+     */
+    policyLine?: boolean;
+}
+interface AiConsentText {
+    title: string;
+    /** Paragraphs separated by a blank line. */
+    body: string;
+    /** Remembered for the workspace or folder (for the session without one). */
+    allow: string;
+    /** This request only; nothing is remembered and the next request asks again. */
+    allowOnce: string;
+    /** Declines; the host does not ask about this engine again until it restarts. */
+    deny: string;
+    /** The policy button's label, when there is a policy and the body does not spell it out. */
+    readPolicy?: string;
+}
+/** The consent dialog's words, the single source for both hosts. */
+declare function aiConsentText(input: AiConsentTextInput): AiConsentText;
+/** Shown in the Cloud consents list when there is nothing stored. */
+declare const AI_NO_CONSENTS_TEXT = "No cloud engine has been allowed here.";
+/**
+ * One line of the Cloud consents list, without the Forget button:
+ * "Anthropic · this workspace · Allowed". A stored "never" (older versions)
+ * reads "Not allowed"; this session's "Don't allow", "Not allowed until restart".
+ */
+declare function aiConsentSummary(record: Pick<AiConsentRecord, 'answer' | 'scope'>, engineName: string): string;
+
+/**
+ * The setup wizard's first decision, as plain data: which path to offer
+ * first (a running local server, VS Code's Copilot models, or a cloud
+ * provider), whether this machine can run models locally, and how big a
+ * model fits (OQ11, OQ13). No DOM, no network: the host reports the
+ * hardware (`hardwareInfo`), the running servers (`detectLocalServers`) and
+ * its built-in models (`detectHostEngines`).
+ *
+ * Every size here is a hint for a 4-bit quantised model, never a gate: the
+ * user can pick any model.
+ */
+
+/** OQ11: Apple Silicon with this much unified memory can run local models. */
+declare const AI_LOCAL_MIN_UNIFIED_GB = 16;
+/** OQ11: any machine with this much memory can. */
+declare const AI_LOCAL_MIN_MEMORY_GB = 32;
+/** OQ11: or an NVIDIA GPU with this much video memory (Desktop only, where it can be read). */
+declare const AI_LOCAL_MIN_VRAM_GB = 8;
+type AiSetupPath = 'runningLocal' | 'vscodeLm' | 'cloud';
+interface AiSetupInput {
+    /** `detectLocalServers` results (every candidate, running or not). */
+    running: readonly AiLocalServerProbe[];
+    /** `hardwareInfo()`, or null when the host cannot tell. */
+    hardware: AiHardwareInfo | null;
+    /** VS Code only: whether `vscode.lm` offers a Copilot model (see `vscodeLmAvailability`). */
+    vscodeLm?: {
+        available: boolean;
+        models: number;
+    };
+}
+interface AiSetupRecommendation {
+    /** What the wizard offers first. */
+    path: AiSetupPath;
+    /** OQ11: this machine is above the threshold, so local is shown as an option (still under Advanced unless a server runs). */
+    localCapable: boolean;
+    /** The model-size sentence for this machine (OQ11); empty without hardware info. */
+    localHint: string;
+    /**
+     * Step 1's hardware line: "Local is an option on this machine: Apple
+     * Silicon, 32 GB. Models up to about 30B parameters run well." when
+     * capable, the small-machine sentence when not, empty without hardware
+     * info.
+     */
+    hardwareLine: string;
+    /** `runningLocal`: the server to offer (most models first, then preset order). */
+    running?: AiLocalServerProbe;
+    /** Why, one short sentence per signal checked, in order (for tooltips, logs and tests). */
+    reasons: string[];
+}
+/** Bytes to gigabytes, for display ("32 GB"). */
+declare function formatMemoryGb(bytes: number): string;
+/** OQ11's threshold: Apple Silicon with 16 GB or more, any machine with 32 GB or more, or an NVIDIA GPU with 8 GB of VRAM or more. */
+declare function isLocalCapable(hw: AiHardwareInfo | null): boolean;
+/**
+ * The memory a local model runs in: unified memory on Apple Silicon, an
+ * NVIDIA card's VRAM when the host read it, else system memory (CPU
+ * inference: slower, but it runs).
+ */
+declare function modelMemoryBytes(hw: AiHardwareInfo): number;
+/** OQ11's model-size sentence for a machine ("Models up to about 30B parameters run well."); empty for null. */
+declare function localSizeHint(hw: AiHardwareInfo | null): string;
+/** "Apple Silicon, 32 GB", "64 GB of memory, NVIDIA GeForce RTX 4090 (24 GB)", "16 GB of memory". */
+declare function describeHardware(hw: AiHardwareInfo): string;
+/** Shown on a machine below the OQ11 threshold. */
+declare const AI_LOCAL_SMALL_MACHINE = "This machine is on the small side for local models; cloud is the easier path.";
+/** Added when the host read no GPU (VS Code reads none): the hint comes from memory alone. */
+declare const AI_LOCAL_ROUGH_GUESS = "A rough guess from memory alone; the graphics card was not checked.";
+/**
+ * The wizard's path, checked in order (OQ13):
+ *
+ * a. a local server is running and lists models → offer it first;
+ * b. VS Code offers a Copilot model (`vscode-lm`, OQ12) → offer it first;
+ * c. this machine is above the OQ11 threshold → cloud first, with "Local is
+ *    an option on this machine" shown;
+ * d. otherwise cloud, with local under Advanced and no hint.
+ *
+ * `localCapable`, `localHint` and `hardwareLine` are filled whatever the path.
+ */
+declare function recommendSetupPath(input: AiSetupInput): AiSetupRecommendation;
+/** The recommendation's `vscodeLm` input from `detectHostEngines` results. */
+declare function vscodeLmAvailability(probes: readonly AiHostEngineProbe[] | null | undefined): {
+    available: boolean;
+    models: number;
+};
+/**
+ * A model's parameter count in billions, from its id: `7b`, `30b`, `1.5b`,
+ * `270m`, a mixture `8x7b` (total). The first count wins, so `30b-a3b`
+ * (active parameters) reads 30. Null when the id names none.
+ */
+declare function modelParamsBillions(id: string): number | null;
+type AiModelSizeTag = 'fits' | 'tight' | 'too large';
+/**
+ * "fits", "tight" or "too large" for a model on this machine: from the size
+ * the server reported when there is one (`modelSizeHintFromBytes`), else the
+ * parameter count in its id (OQ11's bands, 4-bit). Undefined when neither is
+ * known or the hardware is unknown: no tag. A hint only; nothing is blocked.
+ */
+declare function modelSizeHint(id: string, hardware: AiHardwareInfo | null, sizeBytes?: number): AiModelSizeTag | undefined;
+/**
+ * "fits", "tight" or "too large" from a size the server reported (bytes on
+ * disk or its load estimate), against this machine's model memory.
+ */
+declare function modelSizeHintFromBytes(sizeBytes: number, hardware: AiHardwareInfo): AiModelSizeTag;
+/** A model size for a picker row: "16 GB", "2.6 GB", "0.2 GB". */
+declare function formatModelSize(bytes: number): string;
+/**
+ * The active parameters (billions) an id names, as mixture-of-experts models
+ * do: `Qwen3.6-35B-A3B`, `qwen3.5-122b-a10b`, `Nemotron-3-Super-120B-A12B`.
+ * Null when the id names none.
+ */
+declare function modelActiveParamsBillions(id: string): number | null;
+/**
+ * Whether a model is a mixture of experts, from its id's active parameters or
+ * the server's word for it (`moe`: LM Studio's `arch`, oMLX's
+ * `config_model_type`). Only a few billion parameters run per token, so it is
+ * much faster than its size suggests. A row hint only, never a reason to pick it.
+ */
+declare function modelMoeHint(id: string, moe?: boolean): {
+    activeBillions: number | null;
+} | null;
+/**
+ * The picker's "MoE · fast" hint: a mixture of experts that also fits this
+ * machine (`fits`). A tight fit (a 409 GB model on a 512 GB Mac) or one too
+ * large runs slowly however few parameters work per token, and an unknown fit
+ * proves nothing, so neither gets the speed hint (Q5).
+ */
+declare function modelMoeFastHint(id: string, moe: boolean | undefined, size: AiModelSizeTag | undefined): {
+    activeBillions: number | null;
+} | null;
+/** One model as `localDefaultModel` weighs it. */
+interface AiLocalModelChoice {
+    id: string;
+    /** Can chat (an `llm` or `vlm`; not embeddings, speech or a converter). */
+    chat: boolean;
+    missing?: boolean;
+    /** Loaded on the server right now. */
+    loaded?: boolean;
+}
+/**
+ * The model a new local engine starts with: a chat model the server has
+ * loaded, else null and the user picks. Size is a poor guide to speed (a
+ * mixture of experts runs far faster than a dense model its size), so no
+ * guess is made from it.
+ */
+declare function localDefaultModel(models: readonly AiLocalModelChoice[]): string | null;
+
+export { AI_AUDIENCES, AI_CHARS_PER_TOKEN, AI_CLOUD_PRIVACY, AI_ENGINE_PRESETS, AI_ERROR_COPY, AI_FEATURES, AI_HOST_PRESET_FAMILY, AI_HOST_PRIVACY, AI_LOCAL_DETECT_TIMEOUT_MS, AI_LOCAL_MIN_MEMORY_GB, AI_LOCAL_MIN_UNIFIED_GB, AI_LOCAL_MIN_VRAM_GB, AI_LOCAL_ROUGH_GUESS, AI_LOCAL_SMALL_MACHINE, AI_NO_CONSENTS_TEXT, AI_PRESET_FAMILIES, AI_REWRITE_VARIANTS, AI_SENDS_FALLBACK, AI_SENDS_MAX_BASE_NAMES, AI_SENDS_TEXT, AI_TASKS, ANSWERED_WITHOUT_SOURCES, ANTHROPIC_API_VERSION, ANTHROPIC_DEFAULT_MAX_TOKENS, ANTHROPIC_MODEL_TABLE, AiApiKeyFile, AiCapabilityFlag, AiCompletionRequest, AiCompletionResult, AiConsentRecord, AiDiscoveredModel, AiDocBaseStatus, AiDocsHome, AiDocsIndex, AiDocsLink, AiDocsNavigateBy, AiDocsOptions, AiDocsPage, AiDocsSection, AiDocsSectionRef, AiEngineConfig, AiEngineKind, AiEngineStatus, AiError, AiErrorCode, AiFeatureSettings, AiFinishReason, AiHardwareInfo, AiHostEngineProbe, AiLocalServerProbe, AiLocality, AiMessage, AiModelCapabilities, AiModelConfig, AiSendsScope, AiSettings, AiUsage, CHARS_PER_TOKEN, CONTINUE_DEFAULT_MAX_TOKENS, CONTINUE_MAX_MAX_TOKENS, CONTINUE_MIN_MAX_TOKENS, CONTINUE_SYSTEM_PROMPT, DEFAULT_LOCAL_NETWORKS, DOCS_ANSWER_MAX_TOKENS, DOCS_BUILD_BUDGET_MS, DOCS_CHAT_FEATURE, DOCS_DOCUMENT_BASE_ID, DOCS_KEYWORD_MAX_TERMS, DOCS_KEYWORD_TOP, DOCS_LINK_SCAN_UNITS, DOCS_LINK_TEXT_UNITS, DOCS_MAP_HEADINGS_PER_PAGE, DOCS_MAX_ACTIVITY_IDS, DOCS_MAX_ACTIVITY_ID_CHARS, DOCS_MAX_DIRS, DOCS_MAX_FILES, DOCS_MAX_FILE_BYTES, DOCS_MAX_HEADINGS_PER_PAGE, DOCS_MAX_HEADING_CHARS, DOCS_MAX_ID_CHARS, DOCS_MAX_LINKS, DOCS_MAX_LINKS_PER_PAGE, DOCS_MAX_LINK_TARGET_CHARS, DOCS_MAX_LINK_WORK, DOCS_MAX_MAP_ENTRIES, DOCS_MAX_NAV_CHARS, DOCS_MAX_READ_IDS_PER_HOP, DOCS_MAX_SECTION_BYTES, DOCS_NAV_MAX_TOKENS, DOCS_NO_HOME_TEXT, DOCS_STOP_WORDS, EXPLAIN_MAX_TOKENS, EXPLAIN_SYSTEM_ADDENDUM, EXPLAIN_SYSTEM_PROMPT, GHOST_AFTER_CHARS, GHOST_BEFORE_CHARS, GHOST_DEFAULT_CONTEXT_TOKENS, GHOST_OUTLINE_MAX_CHARS, GHOST_OUTLINE_MAX_ITEMS, GHOST_REPEAT_CHARS, GHOST_RESERVE_TOKENS, GHOST_SENTENCE_CUT_CHARS, JSON_ONLY_INSTRUCTION, JSON_SHAPE_HINT, MODEL_LOAD_FAILED_PHRASES, MikeDownDocsHost, NO_SOURCES_CITED, OPENAI_MODEL_TABLE, OUTLINE_SYSTEM_PROMPT, PROPERTIES_SYSTEM_PROMPT, PROPERTY_DESCRIPTION_MAX_CHARS, PROPERTY_MAX_TAGS, PROPERTY_TITLE_MAX_CHARS, PROPERTY_VOCABULARY_MAX, RETRYABLE_REQUEST_PARAMS, REWRITE_CONTEXT_CHARS, REWRITE_INSTRUCTION_MAX_CHARS, REWRITE_LANGUAGE_MAX_CHARS, REWRITE_SYSTEM_PROMPT, STREAM_USAGE_HOSTS, SUMMARIZE_MIN_CONTEXT_TOKENS, SUMMARY_SHORT_DOCUMENT_CHARS, SUMMARY_SYSTEM_PROMPT, SseParser, THINKING_DEFAULT_HEADROOM_TOKENS, THINKING_HEADROOM_TOKENS, THINKING_MAX_TOKENS_CAP, TITLE_MAX_CHARS, TITLE_OUTLINE_MAX_ITEMS, TITLE_SYSTEM_PROMPT, TRANSLATE_DOCUMENT_NOTE, TRANSLATE_SYSTEM_ADDENDUM, aiConsentHost, aiConsentStepNote, aiConsentSummary, aiConsentText, aiErrorCodeFromHttp, aiErrorCopy, aiLengthLimitCopy, aiProviderPolicy, aiProviderPolicyForHost, aiResultStats, aiResultStatsText, aiResultStatsTitle, aiTimingLogParts, anthropicNextPage, base64ToBytes, budgetDocsSections, budgetDocument, buildAuthHeaders, buildCompletionBody, buildContinueMessages, buildDocsAnswerMessages, buildDocsIndex, buildDocsMap, buildDocsNavigateMessages, buildEmbeddingsBody, buildExplainMessages, buildPropertiesMessages, buildRewriteMessages, buildSummaryMessages, buildTitleMessages, bytesToBase64, capSectionText, checkMarkdownStructure, chooseDocsHomes, citationLink, clampDocsHops, clampDocsSourceShare, clipCodePoints, clipDocsHeading, cmpCodePoints, combineRequirements, completeCapabilities, containsSecret, continueMaxTokens, countDetectedModels, countMarkdownStructure, countOccurrences, coveragePercent, createAnthropicStreamReader, createCompletionStreamReader, createDocsChat, createDocsLinkResolver, createOpenAiStreamReader, defaultAiDocsOptions, defaultAiSettings, describeHardware, detectCapabilities, detectLocality, docsActiveBases, docsAnswerMaxTokens, docsAnswerSystemPrompt, docsBasesOffMidTurn, docsBlockingBases, docsBudgetChars, docsCitationLabel, docsCoverageNote, docsDocumentLocation, docsFileHref, docsFileStem, docsHasNoHome, docsHeadingAt, docsHomeHealth, docsIdRoot, docsLinkList, docsNavText, docsNavigateSystemPrompt, docsPageId, docsPagesById, docsRootLabels, docsSectionFile, docsSectionId, docsSectionSlug, docsSlug, docsSlugs, dropSecretSections, encodeLinkPath, engineEndpoints, engineLocality, escapeClosingTag, existingTagsOf, explainMaxTokens, finalizeDocsAnswer, finalizeRewriteText, finalizeSummary, findSecret, findSecretAtCutoff, foldAscii, formatAiSeconds, formatAiTokensPerSecond, formatMemoryGb, formatModelSize, fromWireCompletionRequest, frontmatterEndOffset, getAiAudience, getAiFeature, getAiRewriteVariant, getAiTask, ghostAcceptWord, ghostContext, ghostPrefixMatch, githubAnchors, headingsOutline, headingsWithOffsets, hostOfUrl, insertUrlIsVerbatim, isAiError, isAiErrorCode, isLocalCapable, isOpenAiReasoningModel, isRouteUsable, isSafeRelPath, jsonRepairMessages, keywordTerms, localDefaultModel, localDetectCandidates, localDetectTarget, localDetectUrl, localSizeHint, localityMismatch, makeAiError, mergeDiscoveredModels, mergeRequestOverrides, missingCapabilities, modelActiveParamsBillions, modelMemoryBytes, modelMoeFastHint, modelMoeHint, modelParamsBillions, modelSizeHint, modelSizeHintFromBytes, nearestThinkingLevel, normalizeRewriteLanguage, openAiOffReasoningEffort, parseAnthropicModels, parseCitations, parseDocsId, parseDocsNavReply, parseEmbeddingsResponse, parseLenientJson, parseLmStudioModels, parseModelSizes, parseOllamaRunning, parseOllamaShow, parseOllamaTags, parseOmlxModelStatus, parseOpenAiModelList, parsePropertySuggestions, parseTitles, prepareInsertMarkdown, presetForEngine, propertiesMaxTokens, rankDocsWikilinkCandidates, rankKeywordSections, recommendSetupPath, relativeDocsPath, renderDocsMap, renderHeadingOutline, resolveAiFeature, resolveRoute, resolveThinkingLevel, rewriteCitationsForInsert, rewriteInstruction, rewriteMaxTokens, rewriteSystemPrompt, rewriteVisibleText, runDocsTurn, sanitizeInsertMarkdown, scanDocsSections, scanForSecrets, scoreKeywordSection, secretsLeftOutPhrase, splitDocsSections, streamUsageSupported, summaryMaxTokens, summaryPreviewText, summaryVisibleText, taskThinkingDefault, thinkingChoices, thinkingLevelFrom, thinkingMaxTokens, thinkingOverrides, titleMaxTokens, toAiError, toWireCompletionRequest, trimGhostSuggestion, trimGhostSuggestionDetailed, trimRewriteContext, unsupportedRequestParam, vscodeLmAvailability, whatIsSent, withModelSizes, withModelStatus, withStreamUsage, withThinkingLevel, withoutRequestParam };
+export type { AiAudience, AiAudienceDefinition, AiCapabilityRequirements, AiConsentScopeWord, AiConsentState, AiConsentText, AiConsentTextInput, AiDocsActivityDetail, AiDocsBrokenReason, AiDocsIndexInput, AiDocsLinkStatus, AiDocsNumberedSection, AiDocsPageInput, AiDocsResolvedLink, AiEngineEndpoints, AiEnginePreset, AiErrorCopy, AiFeatureDefinition, AiFrontmatterEntry, AiLocalDetectTarget, AiLocalModelChoice, AiModelSizeTag, AiPopularRule, AiPresetFamily, AiPresetFamilyInfo, AiProviderPolicy, AiResultStats, AiRewriteGroup, AiRewriteOutput, AiRewriteParams, AiRewriteScope, AiRewriteVariant, AiRewriteVariantDefinition, AiRouteOk, AiRoutePin, AiRouteResolution, AiRouteUnusable, AiSetupInput, AiSetupPath, AiSetupRecommendation, AiSummaryKind, AiTaskDefinition, AiThinkingChoice, AiThinkingJob, AiThinkingLevel, AiThinkingOptions, AiUnusableCode, AiWireCompletionRequest, AiWireMessage, AiWireMessagePart, BudgetedDocument, BuildCompletionOptions, CompletionStreamReader, ContinuePromptInput, DetectedCapabilities, DocsAnswerPromptInput, DocsBudgetOptions, DocsBudgetResult, DocsChat, DocsCitationPart, DocsDocumentLocation, DocsHeadingHit, DocsKeywordSection, DocsLinkList, DocsLinkResolver, DocsLoopDeps, DocsMap, DocsMapEntry, DocsMarkdownSection, DocsNavBlock, DocsNavEntry, DocsNavReply, DocsNavigatePrompt, DocsNavigatePromptInput, DocsReadHost, DocsRouteRequest, DocsRunEvents, DocsRunOutcome, DocsRunRequest, DocsRunThinking, DocsSecretKind, DocsSentSection, DocsTurnAnswer, DocsTurnEvents, DocsTurnInput, DocsTurnOutcome, DocsTurnProgress, DocsTurnRoute, DocsTurnScope, DocumentBudgetOptions, ExplainPromptInput, GhostBlockKind, GhostContext, GhostContextOptions, GhostTrimOptions, GhostTrimResult, HeadingOutlineEntry, HeadingWithOffsets, InsertUrlPolicy, LenientJsonResult, ParsedCitations, ParsedPropertySuggestions, ParsedTitles, PropertiesPromptInput, PropertySuggestions, ResolveRouteOptions, ResolvedAiFeature, ResolvedThinkingLevel, RewritePromptInput, SanitizedMarkdown, SecretScan, SseEvent, StreamOutcome, StructureCounts, StructureDiff, StructureMismatch, SuggestedTag, SummaryPromptInput, ThinkingBudgetOptions, TitlePromptInput };