@mikedown/core 0.3.0 → 0.4.0

package/dist/ai/index.d.ts

@@ -1,6 +1,6 @@
-import { b as AiModelCapabilities, c as AiCapabilityFlag, d as AiSendsScope, e as AiFeatureSettings, f as AiLocality, g as AiEngineConfig, h as AiEngineKind, i as AiModelConfig, j as AiDiscoveredModel, k as AiApiKeyFile, A as AiSettings, a as AiEngineStatus, l as AiFinishReason, m as AiUsage, n as AiErrorCode, o as AiCompletionResult, p as AiCompletionRequest, q as AiMessage, r as AiError, s as AiConsentRecord, t as AiLocalServerProbe, u as AiHardwareInfo, v as AiHostEngineProbe } from '../types-CgEeIUhi.js';
-export { w as AI_CAPABILITY_FLAGS, x as AI_ENGINE_KINDS, y as AI_ERROR_CODES, z as AI_FALLBACK_MODES, B as AI_HOST_ENGINE_KINDS, C as AiCapabilitiesSource, D as AiConsentAbout, E as AiConsentReply, F as AiEngineStatusModel, G as AiFallbackMode, H as AiFeatureSetting, I as AiKeySource, J as AiLocalitySetting, K as AiMessagePart, L as AiRoute, N as AiRouting, O as AiServedBy, P as AiTiming, Q as DEFAULT_CONTEXT_TOKENS, M as MikeDownAiHost, R as ProviderAdapter } from '../types-CgEeIUhi.js';
-export { a as AI_SETTINGS_KEYS, A as AiSettingsPatch, P as ParseAiSettingsOptions, g as generateAiId, i as isHostEngineKind, b as isKnownEngineKind, p as parseAiSettings, s as serializeAiSettings } from '../schema-DYzxkuSb.js';
+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
@@ -390,6 +390,8 @@ declare function localDetectTarget(candidate: {
  * 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;
 
 /**
@@ -451,6 +453,8 @@ 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;
 
@@ -811,7 +815,8 @@ declare function nearestThinkingLevel(kind: string, level: AiThinkingLevel | nul
 type AiThinkingJob = string;
 /**
  * The level MikeDown picks for a job when the dial is on Default (Q6): Off
- * for the short edits, null (the model's own) for everything else.
+ * 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 {
@@ -1114,8 +1119,21 @@ interface HeadingOutlineEntry {
     level: number;
     text: string;
 }
-/** Heading levels and texts, skipping frontmatter and fenced code. */
-declare function headingsOutline(markdown: string): HeadingOutlineEntry[];
+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`
@@ -1272,6 +1290,1172 @@ type ParsedPropertySuggestions = {
  */
 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
@@ -1312,12 +2496,17 @@ declare function aiConsentStepNote(hostAsks: boolean): string;
 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.
+ * 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): string;
+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;
 /**
@@ -1347,6 +2536,8 @@ interface AiConsentTextInput {
     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;
@@ -1527,5 +2718,5 @@ interface AiLocalModelChoice {
  */
 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_TEXT, AI_TASKS, ANTHROPIC_API_VERSION, ANTHROPIC_DEFAULT_MAX_TOKENS, ANTHROPIC_MODEL_TABLE, AiApiKeyFile, AiCapabilityFlag, AiCompletionRequest, AiCompletionResult, AiConsentRecord, AiDiscoveredModel, AiEngineConfig, AiEngineKind, AiEngineStatus, AiError, AiErrorCode, AiFeatureSettings, AiFinishReason, AiHardwareInfo, AiHostEngineProbe, AiLocalServerProbe, AiLocality, AiMessage, AiModelCapabilities, AiModelConfig, AiSendsScope, AiSettings, AiUsage, CHARS_PER_TOKEN, DEFAULT_LOCAL_NETWORKS, EXPLAIN_MAX_TOKENS, EXPLAIN_SYSTEM_ADDENDUM, EXPLAIN_SYSTEM_PROMPT, JSON_ONLY_INSTRUCTION, JSON_SHAPE_HINT, MODEL_LOAD_FAILED_PHRASES, 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, budgetDocument, buildAuthHeaders, buildCompletionBody, buildEmbeddingsBody, buildExplainMessages, buildPropertiesMessages, buildRewriteMessages, buildSummaryMessages, buildTitleMessages, bytesToBase64, checkMarkdownStructure, combineRequirements, completeCapabilities, countDetectedModels, countMarkdownStructure, coveragePercent, createAnthropicStreamReader, createCompletionStreamReader, createOpenAiStreamReader, defaultAiSettings, describeHardware, detectCapabilities, detectLocality, engineEndpoints, engineLocality, escapeClosingTag, existingTagsOf, explainMaxTokens, finalizeRewriteText, finalizeSummary, formatAiSeconds, formatAiTokensPerSecond, formatMemoryGb, formatModelSize, fromWireCompletionRequest, getAiAudience, getAiFeature, getAiRewriteVariant, getAiTask, headingsOutline, hostOfUrl, isAiError, isAiErrorCode, isLocalCapable, isOpenAiReasoningModel, isRouteUsable, jsonRepairMessages, localDefaultModel, localDetectCandidates, localDetectTarget, localDetectUrl, localSizeHint, localityMismatch, makeAiError, mergeDiscoveredModels, mergeRequestOverrides, missingCapabilities, modelActiveParamsBillions, modelMemoryBytes, modelMoeFastHint, modelMoeHint, modelParamsBillions, modelSizeHint, modelSizeHintFromBytes, nearestThinkingLevel, normalizeRewriteLanguage, openAiOffReasoningEffort, parseAnthropicModels, parseEmbeddingsResponse, parseLenientJson, parseLmStudioModels, parseModelSizes, parseOllamaRunning, parseOllamaShow, parseOllamaTags, parseOmlxModelStatus, parseOpenAiModelList, parsePropertySuggestions, parseTitles, presetForEngine, propertiesMaxTokens, recommendSetupPath, renderHeadingOutline, resolveAiFeature, resolveRoute, resolveThinkingLevel, rewriteInstruction, rewriteMaxTokens, rewriteSystemPrompt, rewriteVisibleText, streamUsageSupported, summaryMaxTokens, summaryPreviewText, summaryVisibleText, taskThinkingDefault, thinkingChoices, thinkingLevelFrom, thinkingMaxTokens, thinkingOverrides, titleMaxTokens, toAiError, toWireCompletionRequest, trimRewriteContext, unsupportedRequestParam, vscodeLmAvailability, whatIsSent, withModelSizes, withModelStatus, withStreamUsage, withThinkingLevel, withoutRequestParam };
-export type { AiAudience, AiAudienceDefinition, AiCapabilityRequirements, AiConsentScopeWord, AiConsentState, AiConsentText, AiConsentTextInput, AiEngineEndpoints, AiEnginePreset, AiErrorCopy, AiFeatureDefinition, AiFrontmatterEntry, AiLocalDetectTarget, AiLocalModelChoice, AiModelSizeTag, AiPopularRule, AiPresetFamily, AiPresetFamilyInfo, AiProviderPolicy, AiResultStats, AiRewriteGroup, AiRewriteOutput, AiRewriteParams, AiRewriteScope, AiRewriteVariant, AiRewriteVariantDefinition, AiRouteOk, AiRouteResolution, AiRouteUnusable, AiSetupInput, AiSetupPath, AiSetupRecommendation, AiSummaryKind, AiTaskDefinition, AiThinkingChoice, AiThinkingJob, AiThinkingLevel, AiThinkingOptions, AiUnusableCode, AiWireCompletionRequest, AiWireMessage, AiWireMessagePart, BudgetedDocument, BuildCompletionOptions, CompletionStreamReader, DetectedCapabilities, DocumentBudgetOptions, ExplainPromptInput, HeadingOutlineEntry, LenientJsonResult, ParsedPropertySuggestions, ParsedTitles, PropertiesPromptInput, PropertySuggestions, ResolveRouteOptions, ResolvedAiFeature, ResolvedThinkingLevel, RewritePromptInput, SseEvent, StreamOutcome, StructureCounts, StructureDiff, StructureMismatch, SuggestedTag, SummaryPromptInput, ThinkingBudgetOptions, TitlePromptInput };
+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 };