@mikedown/core 0.3.0 → 0.4.0

package/dist/{types-CsVNVSNY.d.ts → types-2TZErbJr.d.ts}

@@ -1,5 +1,5 @@
 import { Editor } from '@tiptap/core';
-import { M as MikeDownAiHost, A as AiSettings, O as AiServedBy, a as AiEngineStatus } from './types-CgEeIUhi.js';
+import { M as MikeDownAiHost, b as MikeDownDocsHost, A as AiSettings, ad as AiServedBy, a as AiEngineStatus } from './types-DO8UBybZ.js';
 
 /**
  * Toolbar layout model: schema, parse, normalize, migrate and edit helpers.
@@ -187,12 +187,21 @@ interface MikeDownHost {
     /**
      * Open a link. Absent means external links open in a new browser tab and
      * relative links are ignored. `reveal` asks the target document to scroll
-     * to a link back to this one (sidebar backlinks).
+     * to a link back to this one (sidebar backlinks), or, with `section`, to the
+     * heading with that documentation-base slug (chat citations). A chat citation's
+     * href is a `file:` URL under a documentation base root.
      */
     openLink?(href: string, behavior?: LinkOpenBehavior, reveal?: {
         href?: string;
         occurrence?: number;
+        section?: string;
     }): void;
+    /**
+     * The absolute folder of the current document, null while it has none
+     * (untitled). Insert from the chat uses it for relative links; absent, it
+     * writes plain `file › heading` text.
+     */
+    documentFolder?(): string | null;
     /**
      * Persist settings. Absent means changes made in the Settings modal last
      * for the session only. `source: 'slashMenu'` marks the slash menu's
@@ -249,6 +258,8 @@ interface MikeDownHost {
     exportHtml?(html: string): void;
     printDocument?(html: string): void;
     viewInBrowser?(html: string): void;
+    /** Offer a save dialog with this suggested name and write the text there (the AI Activity panel). Without it, the panel's Save buttons are hidden. */
+    saveTextFile?(name: string, text: string): Promise<void>;
     sidebarPrefs?: MikeDownSidebarPrefs;
     /**
      * Inference through the host. `complete` alone (tier 1) turns the features
@@ -256,6 +267,11 @@ interface MikeDownHost {
      * Types and helpers live in `@mikedown/core/ai`.
      */
     ai?: MikeDownAiHost;
+    /**
+     * User-level folders of markdown the AI chat can navigate and answer from.
+     * Needs `ai` as well. Types live in `@mikedown/core/ai`.
+     */
+    docs?: MikeDownDocsHost;
 }
 /** A host with every optional method absent. `onChange` does nothing. */
 declare class NoopHost implements MikeDownHost {
@@ -483,7 +499,11 @@ type MikeDownCommand = 'toggleBold' | 'toggleItalic' | 'toggleStrike' | 'toggleH
 /** Suggest titles with AI: three candidates; a pick sets `title:`, the H1, or a new H1 (no-op without `host.ai`). */
  | 'aiSuggestTitle'
 /** Suggest properties with AI: the sidebar's Suggest (Properties shown and expanded); chips apply a title, description or tag (no-op without `host.ai`). */
- | 'aiSuggestProperties' | 'copyAsRichText' | 'heading1' | 'heading2' | 'heading3' | 'heading4' | 'heading5' | 'heading6' | 'paragraph' | 'openFind' | 'openFindReplace' | 'insertTable' | 'insertLink' | 'insertImage' | 'zoomIn' | 'zoomOut' | 'zoomReset';
+ | 'aiSuggestProperties'
+/** Open the AI chat panel: questions about this document or the documentation bases (no-op without `host.ai`). */
+ | 'aiChat'
+/** Ask for an inline suggestion at the caret now, whatever the trigger setting (no-op without `host.ai`). */
+ | 'aiSuggestContinuation' | 'copyAsRichText' | 'heading1' | 'heading2' | 'heading3' | 'heading4' | 'heading5' | 'heading6' | 'paragraph' | 'openFind' | 'openFindReplace' | 'insertTable' | 'insertLink' | 'insertImage' | 'zoomIn' | 'zoomOut' | 'zoomReset';
 type MikeDownEvent = 'change' | 'focus' | 'blur' | 'ready';
 /**
  * Where the user is in the document: which view is showing, the caret and
@@ -536,6 +556,8 @@ interface MikeDownEditorHandle {
     scrollToAnchor(slug: string): void;
     /** Scroll to and flash the Nth link with this href. */
     revealLink(href: string, occurrence?: number): void;
+    /** Scroll to the heading with this documentation-base section slug (`docsSlug`'s rule, not GitHub's). Waits briefly for the document to load. */
+    revealSection(slug: string): void;
     /**
      * Select and scroll to a match in the markdown source: 1-based `line`,
      * 1-based `column` in UTF-16 units, `length` of the match. Exact in source

package/dist/{types-CgEeIUhi.d.ts → types-DO8UBybZ.d.ts}

@@ -126,6 +126,24 @@ interface AiFeatureSetting {
     enabled?: boolean;
     /** Task override, e.g. `{ task: 'vision' }`. */
     task?: string;
+    /** `ghostText` only (see `AiGhostTextOptions`; read through `ghostTextOptions`). */
+    delayMs?: number;
+    maxTokens?: number;
+    trigger?: AiGhostTrigger;
+    localOnly?: boolean;
+}
+/** When Inline suggestions fire: after an idle pause, or only from the shortcut / menu. */
+type AiGhostTrigger = 'auto' | 'manual';
+/** The `features.ghostText` knobs with defaults applied and ranges clamped (`ghostTextOptions`). */
+interface AiGhostTextOptions {
+    /** Idle time after a keystroke before a request fires, in ms. Default 400. */
+    delayMs: number;
+    /** Output budget in tokens. Default 48. */
+    maxTokens: number;
+    /** Default `auto`. */
+    trigger: AiGhostTrigger;
+    /** Reject cloud engines for this feature. Default true. */
+    localOnly: boolean;
 }
 /** Open map keyed by feature id (see `AI_FEATURES`). */
 type AiFeatureSettings = Record<string, AiFeatureSetting>;
@@ -142,6 +160,198 @@ interface AiSettings {
     localNetworks: string[];
     /** The AI button on the toolbar (hosts with AI support only). Default true. */
     showToolbarButton: boolean;
+    /** Record what each AI request sent and received, in memory, and show it in the Activity panel. Default false. */
+    activityPanel: boolean;
+    /**
+     * Documentation bases (`mikedown.ai.docBases`). User-level only: a host
+     * reads this key from its user settings and never from a workspace, so a
+     * repository cannot add or redirect a base. `parseAiSettings` drops invalid
+     * entries with a reason (see `parseDocBases`).
+     */
+    docBases: AiDocBase[];
+    /** Advanced options for chatting with the bases (`mikedown.ai.docs`), user-level only like `docBases`. */
+    docs: AiDocsOptions;
+}
+/**
+ * One documentation base: user-level folders of markdown the chat can
+ * navigate and answer from. Roots are absolute, normalized folder paths.
+ */
+interface AiDocBase {
+    /** Stable, generated once, never shown. The wire and the consent dialog name a base by id; the host maps it to a name from its own settings. */
+    id: string;
+    name: string;
+    /** Absolute normalized folders (`validateDocRoot`). At least one. */
+    roots: string[];
+    /** Per-base override for the home document's file name, relative to each root (`HOME.md`). Absent: `INDEX.md`, `README.md`, then a map. */
+    homeFile?: string;
+    /** May pages from this base be sent to a cloud engine. Default false. */
+    allowCloud: boolean;
+    /** A disabled base is never indexed for or sent with a request. Default true. */
+    enabled: boolean;
+}
+type AiDocsNavigateBy = 'section' | 'page';
+declare const AI_DOCS_NAVIGATE_BY: readonly AiDocsNavigateBy[];
+/** The advanced options (`ai.docs`), without the bases. */
+interface AiDocsOptions {
+    /** Navigation calls before the answer. Clamped to `AI_DOCS_MAX_HOPS_MIN`..`AI_DOCS_MAX_HOPS_MAX`. Default 3. */
+    maxHops: number;
+    /** Percent of the route's context the answer's sections may take. Clamped to `AI_DOCS_SOURCE_SHARE_MIN`..`AI_DOCS_SOURCE_SHARE_MAX`. Default 60. */
+    sourceShare: number;
+    /** Whether the model asks for `page#heading` sections or whole pages. Default `section`. */
+    navigateBy: AiDocsNavigateBy;
+}
+/** The options the loop runs with: `ai.docs` plus the bases (`resolveDocsSettings`). */
+interface AiDocsSettings extends AiDocsOptions {
+    bases: AiDocBase[];
+}
+declare const AI_DOCS_MAX_HOPS_MIN = 1;
+declare const AI_DOCS_MAX_HOPS_MAX = 5;
+/**
+ * The most requests one "Allow once" can admit in a chat turn: a navigation
+ * call and its one repair per hop, then the answer. Hosts stop honouring a grant
+ * past this, so a webview that never ends its turn cannot keep sending on it.
+ * `TURN_GRANT_MAX_USES` in Desktop's `commands/ai.rs` is the same number.
+ */
+declare const AI_TURN_GRANT_MAX_USES: number;
+declare const AI_DOCS_MAX_HOPS_DEFAULT = 3;
+declare const AI_DOCS_SOURCE_SHARE_MIN = 30;
+declare const AI_DOCS_SOURCE_SHARE_MAX = 80;
+declare const AI_DOCS_SOURCE_SHARE_DEFAULT = 60;
+declare const AI_DOCS_NAVIGATE_BY_DEFAULT: AiDocsNavigateBy;
+/** Where a root's home document came from (decision 3). `map` means none was found and core builds an in-memory map. */
+type AiDocHomeKind = 'override' | 'index' | 'readme' | 'map';
+/** One root of a base, as the host last saw it. */
+interface AiDocRootStatus {
+    /** The root as configured (absolute). */
+    root: string;
+    /** The label ids use for this root (the same rule on both hosts; `docs/index.ts`). */
+    label: string;
+    /** The folder exists and is readable. False: "Root not found"; the root is skipped for requests, never deleted. */
+    found: boolean;
+    /** Which home precedence step won; `map` is the "No home document" state. Absent when the root is not found. */
+    home?: AiDocHomeKind;
+    /** The home document's path relative to the root, when `home` is not `map`. */
+    homePath?: string;
+    /** Markdown files indexed under this root. */
+    fileCount: number;
+    /** Files over the byte cap, skipped. */
+    oversizeSkipped: number;
+    /** The file cap was reached; later files were not indexed. */
+    capReached: boolean;
+    /** Files that are not UTF-8 text (a UTF-16 or UTF-32 byte order mark, or NUL bytes), skipped. */
+    notTextSkipped?: number;
+    /** The folder cap was reached; later folders were not read. */
+    dirCapReached?: boolean;
+    /** The build's time budget ran out; the index covers what was read before that. */
+    timedOut?: boolean;
+}
+/**
+ * A base plus its health, as `listBases` reports it. Computed when the
+ * manager page opens and on Refresh. "Active" means enabled with at least one
+ * root found; only active bases are indexed for or sent to a request.
+ */
+interface AiDocBaseStatus {
+    base: AiDocBase;
+    /** Enabled and at least one root found. */
+    active: boolean;
+    roots: AiDocRootStatus[];
+    /** Sum over roots. */
+    fileCount: number;
+    oversizeSkipped: number;
+    /** Roots not found on disk. */
+    rootsMissing: number;
+    /** Any root hit the file cap. */
+    capReached: boolean;
+    /** Files skipped because they are not UTF-8 text, over every root. */
+    notTextSkipped?: number;
+    /** Any root hit the folder cap. */
+    dirCapReached?: boolean;
+    /** The build's time budget ran out; the index and the counts cover what was read before that. */
+    timedOut?: boolean;
+    /** Relative links that leave every root or point at no page. Absent when the host did not compute it. */
+    brokenLinks?: number;
+}
+/** A heading in the index (a section starts at each). Bodies are never in the index. */
+interface AiDocsHeading {
+    /** The section id: `<page id>#<slug>`. */
+    id: string;
+    /** 1 to 6. */
+    level: number;
+    text: string;
+    slug: string;
+}
+/** A link as written in a page. Core resolves it (`docs/links.ts`); the host only extracts. */
+interface AiDocsLink {
+    /** The target as written: a relative path with an optional `#fragment`, or a wikilink name. */
+    target: string;
+    /** The link text. */
+    text: string;
+    kind: 'markdown' | 'wikilink';
+}
+/** One markdown page of a base, without its body. */
+interface AiDocsPage {
+    /** `<root label>/<rel path>`, with `/` separators (`docs/index.ts`). The only thing the model names. */
+    id: string;
+    /** The root's label (the first segment of `id`). */
+    root: string;
+    /** Path relative to the root, with `/` separators. */
+    relPath: string;
+    /** Frontmatter title, else the first heading, else the file name. */
+    title: string;
+    headings: AiDocsHeading[];
+    links: AiDocsLink[];
+    /** Size of the file in characters (not bytes), for the budget. */
+    chars: number;
+}
+/** The home document chosen for a root. */
+interface AiDocsHome {
+    /** The root's label. */
+    root: string;
+    kind: AiDocHomeKind;
+    /** The home page's id; null for `map`. */
+    pageId: string | null;
+}
+/** A base's index: pages with headings and links, no bodies. Built lazily on the host, in memory. */
+interface AiDocsIndex {
+    baseId: string;
+    /** Roots that were found, in configured order. */
+    roots: Array<{
+        label: string;
+    }>;
+    pages: AiDocsPage[];
+    homes: AiDocsHome[];
+    /** The file cap cut the walk short. */
+    truncated: boolean;
+    oversizeSkipped: number;
+    /** Unix milliseconds the index was built. */
+    builtAt: number;
+}
+/** A section (or whole page) as `readSections` returns it: the only call that carries a body. */
+interface AiDocsSection {
+    /** The id that was asked for: `<page id>#<slug>` or a page id. */
+    id: string;
+    pageId: string;
+    /** The page's title. */
+    title: string;
+    /** Path relative to the root, for the chip and the relative link. */
+    relPath: string;
+    /** The section's heading text; absent for a whole page. */
+    heading?: string;
+    /** The markdown, capped at the section byte cap by the host. */
+    text: string;
+    /** The host cut `text` at the cap. */
+    truncated: boolean;
+}
+/** A keyword match: ids and labels only, no text. The loop reads the bodies through `readSections`. */
+interface AiDocsSectionRef {
+    /** `<page id>#<slug>`, or a page id for text before the first heading. */
+    id: string;
+    pageId: string;
+    title: string;
+    relPath: string;
+    heading?: string;
+    /** Higher is a better match; the order is `docs/keyword.ts`'s. */
+    score: number;
 }
 type AiMessagePart = {
     type: 'text';
@@ -173,6 +383,23 @@ interface AiCompletionRequest {
      * request wins. Tier-1 hosts may ignore them.
      */
     requestOverrides?: Record<string, unknown>;
+    /** Set on every request of a chat turn (`AiRoutePin`); absent on every other request. */
+    turn?: AiCompletionTurn;
+}
+/**
+ * What a request of a chat turn says about that turn. A host uses it to find
+ * the "Allow once" it holds for the turn, and to word a dialog it has to raise
+ * in the middle of one (`sends`, and `baseIds`, which it maps to names from its
+ * own settings). It is a claim, not consent: a host admits the request only
+ * against a grant it made itself when the user answered, for this panel or
+ * window, this turn, this engine and this set of bases.
+ */
+interface AiCompletionTurn {
+    id: string;
+    sends?: AiSendsScope;
+    baseIds?: string[];
+    /** The engine's locality when the turn was routed. A host fails the request if it no longer holds. */
+    isLocal?: boolean;
 }
 interface AiServedBy {
     engineId?: string;
@@ -354,6 +581,18 @@ interface MikeDownAiHost {
      * dialog can say what is sent (`aiConsentText`).
      */
     requestCloudConsent?(engineId: string, about?: AiConsentAbout): Promise<AiConsentReply>;
+    /**
+     * `requestCloudConsent` for a chat turn, where `'once'` means the whole turn:
+     * the host holds the grant and admits the turn's requests (`req.turn`) on it.
+     * Absent: core asks `requestCloudConsent`.
+     */
+    requestTurnConsent?(engineId: string, about: AiTurnConsentAbout): Promise<AiConsentReply>;
+    /**
+     * The chat turn `turnId` is over (answered, refused, failed or cancelled):
+     * forget any "Allow once" held for it. Fire and forget. A host that holds no
+     * grant per turn can leave it out.
+     */
+    endTurn?(turnId: string): void;
     /**
      * The cloud consents for this workspace or folder, for the Cloud consents
      * list on the AI tab: the stored answers, plus this session's "Don't
@@ -367,7 +606,7 @@ interface MikeDownAiHost {
 /**
  * What `requestCloudConsent` resolves to: `true` allowed for the workspace
  * (remembered), `'once'` allowed for this request only (the next one asks
- * again), `false` declined for this request (a host may also stop asking for
+ * again), or for the whole turn from `requestTurnConsent`, `false` declined for this request (a host may also stop asking for
  * the session; it then answers `false` without a dialog), `'never'` a stored
  * refusal from an older version (the host answers it without asking). A host
  * that only knows allow and decline keeps returning booleans.
@@ -385,14 +624,84 @@ interface AiConsentRecord {
 }
 /**
  * What a request sends to the engine, for the privacy copy (`whatIsSent`):
- * the selection with its neighbouring paragraphs, the whole document, or the
- * document with its frontmatter and the workspace's tag names.
+ * the selection with its neighbouring paragraphs, the whole document, the
+ * document with its frontmatter and the workspace's tag names, pages from
+ * the documentation bases the user turned on, or the text around the cursor
+ * on every pause (Inline suggestions).
+ */
+type AiSendsScope = 'selection' | 'document' | 'documentAndTags' | 'docsBase' | 'cursor';
+/**
+ * The request behind a consent prompt. `sends` overrides the feature's own
+ * scope (whole-document Translate; the docs chat sends `docsBase`).
  */
-type AiSendsScope = 'selection' | 'document' | 'documentAndTags';
-/** The request behind a consent prompt. `sends` overrides the feature's own scope (whole-document Translate). */
 interface AiConsentAbout {
     feature?: string;
     sends?: AiSendsScope;
+    /**
+     * The documentation bases the request would send pages from, by id. The
+     * host maps ids to names from its own user-level settings and drops unknown
+     * ids, so a name from the webview never reaches its modal.
+     */
+    baseIds?: string[];
+}
+/** A consent prompt from a chat turn (`AiCompletionTurn.id`): an "Allow once" holds for that turn and no other. */
+interface AiTurnConsentAbout extends AiConsentAbout {
+    turnId: string;
+}
+/**
+ * The `docs` group on `MikeDownHost`: documentation bases, read through the
+ * host. Absent (npm consumers): the chat's scope picker shows "This document"
+ * only. Defined next to `MikeDownAiHost` so hosts reach it through
+ * `@mikedown/core/ai`; `host.ts` re-exports it.
+ *
+ * Containment is the host's job and is code, not prompt (S1, S2, S3, S9):
+ *
+ * - Every method takes a base id and resolves the roots from the host's own
+ *   user-level configuration. A root that configuration does not list is
+ *   refused, so a webview message can never name a folder. A disabled base is
+ *   refused.
+ * - `readSections` looks ids up in the host's own index and refuses anything
+ *   else. No path is ever built from an id's text.
+ * - Reads canonicalize the root and the file, refuse anything outside the
+ *   root (whole path components), non-markdown, symlinks, non-regular files
+ *   and oversize files.
+ * - The model names ids from core's index and nothing else.
+ */
+interface MikeDownDocsHost {
+    /**
+     * Every configured base with its health (disabled ones included). The bases
+     * themselves (`enabled`, `allowCloud`, names) are read afresh on every call.
+     * A plain call is cheap and must not walk a base that already has a usable
+     * index: the chat loop calls it once per turn. `refresh: true` forces a walk
+     * and fills the health (file counts, broken links); the manager page passes
+     * it when its section opens and on Refresh.
+     */
+    listBases(opts?: {
+        refresh?: boolean;
+    }): Promise<AiDocBaseStatus[]>;
+    /** The base's index (pages, headings, links, homes; no bodies), built lazily and kept in memory. Rejects for an unknown, disabled or inactive base. */
+    index(baseId: string): Promise<AiDocsIndex>;
+    /**
+     * Bodies for section ids (`<page id>#<slug>`) or page ids, each capped at
+     * the section byte cap. Ids the host's index does not know are left out of
+     * the result (never an error, never a path); a read that fails a
+     * containment check is left out too. Order follows `ids`.
+     */
+    readSections(baseId: string, ids: string[]): Promise<AiDocsSection[]>;
+    /** Case-folded scan over the base's files, headings weighted, best first, at most 20 (`docs/keyword.ts`). Ids and labels only. */
+    keywordSearch(baseId: string, query: string): Promise<AiDocsSectionRef[]>;
+    /** Tell core when the base's files change (a watcher per root only). Returns the function that stops watching. */
+    watch?(baseId: string, onChange: () => void): () => void;
+    /**
+     * Save the user's bases. The host re-validates with `parseAiSettings` and
+     * writes the user-level setting only, never a workspace one. Rejects when
+     * nothing valid is left to write over something valid.
+     */
+    saveBases(bases: AiDocBase[]): Promise<void>;
+    /** VS Code: offer the open workspace folders (a picker when there are several) and resolve one's absolute path; null when cancelled or none is open. */
+    addWorkspaceFolder?(): Promise<string | null>;
+    /** Desktop: the native folder picker; resolves the chosen absolute path, null when cancelled. */
+    pickFolder?(): Promise<string | null>;
 }
 /** A model as one discovery call reported it, before merging into settings. */
 interface AiDiscoveredModel {
@@ -428,5 +737,5 @@ interface ProviderAdapter {
     embed?(engine: AiEngineConfig, apiKey: string | null, model: AiModelConfig, texts: string[], signal: AbortSignal): Promise<number[][]>;
 }
 
-export { AI_HOST_ENGINE_KINDS as B, DEFAULT_CONTEXT_TOKENS as Q, AI_CAPABILITY_FLAGS as w, AI_ENGINE_KINDS as x, AI_ERROR_CODES as y, AI_FALLBACK_MODES as z };
-export type { AiSettings as A, AiCapabilitiesSource as C, AiConsentAbout as D, AiConsentReply as E, AiEngineStatusModel as F, AiFallbackMode as G, AiFeatureSetting as H, AiKeySource as I, AiLocalitySetting as J, AiMessagePart as K, AiRoute as L, MikeDownAiHost as M, AiRouting as N, AiServedBy as O, AiTiming as P, ProviderAdapter as R, AiEngineStatus as a, AiModelCapabilities as b, AiCapabilityFlag as c, AiSendsScope as d, AiFeatureSettings as e, AiLocality as f, AiEngineConfig as g, AiEngineKind as h, AiModelConfig as i, AiDiscoveredModel as j, AiApiKeyFile as k, AiFinishReason as l, AiUsage as m, AiErrorCode as n, AiCompletionResult as o, AiCompletionRequest as p, AiMessage as q, AiError as r, AiConsentRecord as s, AiLocalServerProbe as t, AiHardwareInfo as u, AiHostEngineProbe as v };
+export { AI_CAPABILITY_FLAGS as H, AI_DOCS_MAX_HOPS_DEFAULT as I, AI_DOCS_MAX_HOPS_MAX as J, AI_DOCS_MAX_HOPS_MIN as K, AI_DOCS_NAVIGATE_BY as L, AI_DOCS_NAVIGATE_BY_DEFAULT as N, AI_DOCS_SOURCE_SHARE_DEFAULT as O, AI_DOCS_SOURCE_SHARE_MAX as P, AI_DOCS_SOURCE_SHARE_MIN as Q, AI_ENGINE_KINDS as R, AI_ERROR_CODES as S, AI_FALLBACK_MODES as T, AI_HOST_ENGINE_KINDS as U, AI_TURN_GRANT_MAX_USES as V, DEFAULT_CONTEXT_TOKENS as ag };
+export type { AiDocHomeKind as $, AiSettings as A, AiDocBaseStatus as B, AiDocsNavigateBy as C, AiConsentRecord as D, AiLocalServerProbe as E, AiHardwareInfo as F, AiHostEngineProbe as G, MikeDownAiHost as M, AiCapabilitiesSource as W, AiCompletionTurn as X, AiConsentAbout as Y, AiConsentReply as Z, AiDocBase as _, AiEngineStatus as a, AiDocRootStatus as a0, AiDocsHeading as a1, AiDocsSettings as a2, AiEngineStatusModel as a3, AiFallbackMode as a4, AiFeatureSetting as a5, AiGhostTextOptions as a6, AiGhostTrigger as a7, AiKeySource as a8, AiLocalitySetting as a9, AiMessagePart as aa, AiRoute as ab, AiRouting as ac, AiServedBy as ad, AiTiming as ae, AiTurnConsentAbout as af, ProviderAdapter as ah, MikeDownDocsHost as b, AiModelCapabilities as c, AiCapabilityFlag as d, AiSendsScope as e, AiFeatureSettings as f, AiLocality as g, AiEngineConfig as h, AiEngineKind as i, AiModelConfig as j, AiDiscoveredModel as k, AiApiKeyFile as l, AiDocsOptions as m, AiFinishReason as n, AiUsage as o, AiErrorCode as p, AiCompletionResult as q, AiCompletionRequest as r, AiMessage as s, AiError as t, AiDocsLink as u, AiDocsIndex as v, AiDocsPage as w, AiDocsHome as x, AiDocsSectionRef as y, AiDocsSection as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikedown/core",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "MikeDown WYSIWYG markdown editor core (TipTap + CodeMirror), framework-agnostic.",
   "license": "MIT",
   "type": "module",