@mikedown/core 0.1.0 → 0.3.0

package/dist/types-CsVNVSNY.d.ts

@@ -0,0 +1,597 @@
+import { Editor } from '@tiptap/core';
+import { M as MikeDownAiHost, A as AiSettings, O as AiServedBy, a as AiEngineStatus } from './types-CgEeIUhi.js';
+
+/**
+ * Toolbar layout model: schema, parse, normalize, migrate and edit helpers.
+ *
+ * Pure logic, no DOM. A layout is one self-contained, versioned value:
+ *
+ *     { version: 1, items: ['textFormat', ..., '|', ..., '~', ..., 'more'], seen: [...] }
+ *
+ * `items` holds registry ids plus `'|'` (separator) and `'~'` (flexible
+ * spacer). `seen` lists every registry id the layout has been reconciled
+ * against, so a button added by a later core is inserted next to its default
+ * neighbor while a button the user removed stays removed.
+ *
+ * Normalization rules (D15), applied by {@link normalizeToolbarLayout}:
+ *
+ * - Non-string entries are dropped.
+ * - Duplicate ids keep the first occurrence.
+ * - `textFormat` is moved or inserted first; `more` is moved or appended last;
+ *   `settings` is appended before `more` if missing.
+ * - Runs of the same divider collapse to one (`| |` is one separator, `~ ~` one
+ *   spacer). A separator next to a spacer is kept: a line followed by flexible
+ *   space is a deliberate arrangement, and the renderer shows both.
+ * - Leading and trailing `'|'`/`'~'` are trimmed (of the list as written; a
+ *   separator right after `textFormat` or right before `more` is a deliberate
+ *   placement and is kept).
+ * - Unknown ids are kept in place (skipped at render, preserved on save).
+ * - A `version` greater than 1 is read the same way.
+ * - Non-object or wrong-shape values mean the default layout (nothing is
+ *   written back until the next save).
+ */
+
+/**
+ * A toolbar layout. `items` and `seen` are plain strings (not
+ * {@link ToolbarLayoutToken}) because a hand-edited or newer-version layout may
+ * carry ids this core does not know; they are skipped at render and preserved
+ * on save. All helpers return new objects and never mutate their input.
+ */
+interface ToolbarLayout {
+    /** Schema version. Higher versions are accepted and preserved. */
+    readonly version: number;
+    /** Registry ids, `'|'` separators and `'~'` flexible spacers, in toolbar order. */
+    readonly items: readonly string[];
+    /** Every registry id this layout has been reconciled against. */
+    readonly seen: readonly string[];
+}
+/** Ids may be passed as a set or any iterable (e.g. `TOOLBAR_ITEM_IDS`). */
+type ToolbarKnownIds = ReadonlySet<string> | Iterable<string>;
+/** The default layout: today's toolbar, every non-optional known id marked seen. Frozen. */
+declare const DEFAULT_TOOLBAR_LAYOUT: ToolbarLayout;
+/**
+ * Apply the D15 rules so the toolbar always renders something sane: drop
+ * non-strings, dedupe ids keeping the first, put `textFormat` first and `more`
+ * last, append `settings` before `more` if missing, collapse runs of the same
+ * divider (`'|'` or `'~'`) to one and trim leading/trailing ones. Unknown ids (not in `knownIds`) stay in
+ * place. `version` is preserved (a version above 1 is read the same way). `seen`
+ * is reduced to unique strings. Idempotent.
+ *
+ * `knownIds` is accepted for symmetry with the other entry points; the rules
+ * above only need to know which ids are pinned, which the shared table covers.
+ */
+declare function normalizeToolbarLayout(layout: ToolbarLayout, knownIds?: ToolbarKnownIds): ToolbarLayout;
+
+/**
+ * MikeDown host adapter.
+ *
+ * The editor core never talks to its environment directly. Everything that
+ * needs the outside world (saving, file system, workspace search, opening
+ * links, persisting settings) goes through a `MikeDownHost` the embedding
+ * application passes to `createMikeDownEditor`.
+ *
+ * Rules (see core-extraction-decisions.md section 5):
+ *
+ * - `onChange` is the only required method.
+ * - Every other method is optional. An absent method turns its feature off
+ *   and hides its UI (toolbar button, slash command, sidebar section,
+ *   settings control).
+ * - Request/response pairs are Promise-returning methods. Correlation ids,
+ *   retries and transport details stay inside the host implementation.
+ */
+
+/** How a link should open. Absent means the host's default. */
+type LinkOpenBehavior = 'navigateCurrentTab' | 'openNewTab';
+/** A link target offered by the link dialog autocomplete. */
+interface LinkSuggestion {
+    label: string;
+    href: string;
+    type: 'file' | 'anchor' | 'inDoc' | 'external';
+    /** Heading level (1-6) for anchor items, used for hierarchical indentation. */
+    level?: number;
+}
+/**
+ * Result of resolving one `[[wikilink]]` target. `href` is null when no
+ * document matches. `count` is how many documents share the name: 0 means
+ * unresolved, 1 unique, more than 1 ambiguous (the host picked the nearest).
+ */
+interface WikilinkResolution {
+    target: string;
+    href: string | null;
+    count?: number;
+}
+/** One workspace tag with the number of documents that carry it. */
+interface TagCount {
+    tag: string;
+    count: number;
+}
+/** A backlink to the current document, rendered in the sidebar. */
+interface BacklinkItem {
+    uri: string;
+    displayPath: string;
+    line: number;
+    lineText?: string;
+    /** Href of the link in the source doc, so the opened doc can scroll to it. */
+    linkHref?: string;
+    /** Which occurrence of linkHref this is (0-based). */
+    occurrence?: number;
+}
+/** Image bytes from a paste or drop. */
+interface ImageUploadRequest {
+    mime: string;
+    bytes: Uint8Array;
+    name?: string;
+}
+/** Where an uploaded or picked image lives, as the editor should render it. */
+interface ImageInsertResult {
+    src: string;
+    alt?: string;
+}
+/** A downscaled copy of an image already in the document. */
+interface ImageResizeRequest {
+    /** The image's current `src` attribute. */
+    currentSrc: string;
+    mime: string;
+    bytes: Uint8Array;
+    /** Percentage of the natural size (1 to 200). */
+    percent: number;
+}
+interface ImageResizeResult {
+    /** The `src` to render the resized image from. */
+    src: string;
+    /** True when the original file was replaced (the editor cache-busts the src). */
+    overwritten: boolean;
+}
+/** A link the editor asks the host to validate. */
+interface LinkCheckRequest {
+    href: string;
+    type: 'anchor' | 'file' | 'fileAnchor';
+}
+/** The committed version of the document, for change highlighting. */
+interface DiffBaseline {
+    headContent: string | null;
+    hasChanges: boolean;
+}
+/** Status-bar style statistics. Either field may be present. */
+interface MikeDownStats {
+    /** Full plain text of the document (for word count and reading time). */
+    document?: string;
+    /** Selection size, or null when nothing is selected. */
+    selection?: {
+        words: number;
+        chars: number;
+    } | null;
+}
+/** Sidebar preference persistence. Absent means in-memory defaults. */
+interface MikeDownSidebarPrefs {
+    /** Ask for the persisted sidebar state; the host answers with `handle.setSidebarState`. */
+    requestState(): void;
+    /** The pin toggle changed the default visibility for new documents. */
+    setPref(pref: 'always' | 'never'): void;
+    /** "Apply to open documents" in Settings. */
+    applyDefaults(): void;
+    /** A sidebar section was collapsed or expanded by the user. */
+    sectionCollapsed(section: string, collapsed: boolean): void;
+}
+interface MikeDownHost {
+    /**
+     * The document changed. `pristine` is true when the content matches the
+     * last load or save exactly (the user undid every change), in which case
+     * `markdown` is the original text byte for byte.
+     */
+    onChange(markdown: string, meta: {
+        pristine: boolean;
+    }): void;
+    /** Word count and selection statistics. */
+    onStats?(stats: MikeDownStats): void;
+    /**
+     * 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).
+     */
+    openLink?(href: string, behavior?: LinkOpenBehavior, reveal?: {
+        href?: string;
+        occurrence?: number;
+    }): void;
+    /**
+     * Persist settings. Absent means changes made in the Settings modal last
+     * for the session only. `source: 'slashMenu'` marks the slash menu's
+     * "Turn off slash commands" row; `silent` marks background saves (wheel
+     * zoom, Add to Dictionary) that should not show a confirmation.
+     */
+    saveSettings?(patch: MikeDownSettingsPatch, opts?: {
+        source?: 'slashMenu';
+        silent?: boolean;
+    }): void;
+    /** Flip light and dark. Absent means the editor flips its own theme. */
+    toggleTheme?(): void;
+    /** "Customize" button on the Hotkeys settings tab. Hidden when absent. */
+    openKeybindings?(): void;
+    /** Store pasted or dropped image bytes. Absent disables image paste and drop. */
+    uploadImage?(file: ImageUploadRequest): Promise<ImageInsertResult>;
+    /** Native file picker. Resolves null when cancelled. Absent hides `/image`. */
+    pickImage?(): Promise<ImageInsertResult | null>;
+    /** Save a resized copy of an image. Absent hides the resize menu items. */
+    resizeImage?(req: ImageResizeRequest): Promise<ImageResizeResult>;
+    /**
+     * Image source policy. The core renders `http:`, `https:`, `data:` and
+     * `blob:` sources as they are. For any other source (a relative or
+     * absolute path) it calls this and renders the non-null result. Absent, or
+     * returning null, the image shows the missing-image placeholder with the raw
+     * path. Only the rendered `<img src>` changes; the stored `src`, and so the
+     * markdown, is never rewritten.
+     */
+    resolveImageSrc?(src: string): string | null;
+    /** Files and anchors for link autocomplete and `[[` wikilink autocomplete. */
+    getLinkSuggestions?(): Promise<LinkSuggestion[]>;
+    /** Heading anchors of another document, for `file.md#` completion. */
+    getFileHeadings?(path: string): Promise<LinkSuggestion[]>;
+    /** Resolve `[[wikilink]]` targets to hrefs. */
+    resolveWikilinks?(targets: string[]): Promise<WikilinkResolution[]>;
+    /**
+     * Cmd/Ctrl+click on an unresolved wikilink (only when the
+     * `wikilinkCreateOnClick` setting is on). May resolve with the new
+     * resolution so the link lights up without a reload.
+     */
+    createWikilink?(target: string): Promise<WikilinkResolution[] | void> | void;
+    /** Validate relative links. Resolves with the hrefs that are broken. */
+    checkLinks?(links: LinkCheckRequest[]): Promise<string[]>;
+    /** Workspace tag index. Also enables the sidebar Tags section and `#` autocomplete. */
+    getTags?(): Promise<TagCount[]>;
+    /** Tag click (sidebar or Cmd/Ctrl+click in the document). */
+    openTag?(tag: string): void;
+    /** Committed version of the document for change highlighting. */
+    getDiffBaseline?(): Promise<DiffBaseline>;
+    /** A heading's anchor slug changed; in-document links are already fixed. */
+    onHeadingRenamed?(oldSlug: string, newSlug: string): void;
+    /** A renamed heading's slug is duplicated in the document; nothing was fixed. */
+    onHeadingRenameAmbiguous?(baseName: string): void;
+    exportHtml?(html: string): void;
+    printDocument?(html: string): void;
+    viewInBrowser?(html: string): void;
+    sidebarPrefs?: MikeDownSidebarPrefs;
+    /**
+     * Inference through the host. `complete` alone (tier 1) turns the features
+     * on; the registry methods (tier 2) turn on the engine UI and core routing.
+     * Types and helpers live in `@mikedown/core/ai`.
+     */
+    ai?: MikeDownAiHost;
+}
+/** A host with every optional method absent. `onChange` does nothing. */
+declare class NoopHost implements MikeDownHost {
+    onChange(_markdown: string, _meta: {
+        pristine: boolean;
+    }): void;
+}
+
+/**
+ * Public types for the MikeDown editor core: settings, feature flags, the
+ * factory options and the editor handle. The host adapter lives in host.ts.
+ */
+
+interface NormalizationStyle {
+    boldMarker: '**' | '__';
+    italicMarker: '*' | '_';
+    listMarker: '-' | '*' | '+';
+    headingStyle: 'atx' | 'setext';
+}
+/** A webview-resolvable URL prefix and the on-disk folder it maps to. */
+interface ImagePathMapping {
+    prefix: string;
+    fsPath: string;
+}
+/**
+ * Settings the editor core owns (decisions section 6). Field names match the
+ * keys the editor sends to `host.saveSettings`.
+ */
+interface MikeDownSettings {
+    fontFamily: string;
+    headingFontFamily: string;
+    /** Pixels. */
+    fontSize: number;
+    /** CSS max width of the content column, e.g. "100%" or "780px". */
+    contentWidth: string;
+    ctrlWheelZoom: boolean;
+    editorTheme: 'auto' | 'light' | 'dark';
+    headingNumbering: 'off' | 'fromH1' | 'fromH2';
+    linkClickBehavior: 'navigateCurrentTab' | 'openNewTab' | 'showContextMenu';
+    slashCommandsEnabled: boolean;
+    slashCommandsDateFormat: 'iso' | 'long';
+    /** "local", "UTC" or an IANA zone. */
+    slashCommandsTimeZone: string;
+    renderMermaidDiagrams: boolean;
+    renderMath: boolean;
+    tagsEnabled: boolean;
+    /** What Insert > Table of Contents creates (existing TOCs keep their style). */
+    tocStyle: 'list' | 'placeholder';
+    /** Pad Markdown table cells to a common column width when saving. */
+    tablePadColumns: boolean;
+    markdownNormalization: 'preserve' | 'normalize';
+    normalizationStyle: NormalizationStyle;
+    spellCheckEnabled: boolean;
+    spellCheckLanguage: 'en' | 'en-GB';
+    spellCheckIgnoreCodeBlocks: boolean;
+    spellCheckUserWords: string[];
+    /**
+     * `mikedown.ai.*`, parsed by `parseAiSettings` from `@mikedown/core/ai`.
+     * Absent means the defaults (off). Saved as `ai.*` patch keys built by
+     * `serializeAiSettings`; API keys are never part of it (`host.ai.setSecret`).
+     */
+    ai?: AiSettings;
+    /** Words accepted by the spell checker but owned elsewhere (read-only chips). */
+    spellCheckExternalWords?: string[];
+    /** Cmd/Ctrl+click on an unresolved wikilink calls `host.createWikilink`. */
+    wikilinkCreateOnClick?: boolean;
+    /** `never` turns off in-document link fixing and `onHeadingRenamed`. */
+    headingRenameUpdateLinks?: 'ask' | 'always' | 'never';
+    /** Image src rewriting for display in the image popover. */
+    imagePathMappings?: ImagePathMapping[];
+    /** On-disk folder of the current document (pairs with imagePathMappings). */
+    docDir?: string;
+    /**
+     * The customized toolbar layout: one self-contained, versioned blob
+     * (`{ version, items, seen }`, see `ToolbarLayout`). `null`, absent or an
+     * invalid value means the default layout. Saved through
+     * `host.saveSettings({ toolbarLayout })`; `null` clears a stored layout
+     * (Reset to Default). Hand-edited values are normalized on read.
+     */
+    toolbarLayout?: ToolbarLayout | null;
+}
+/**
+ * A settings patch. Core-owned keys are typed; a host's own sections in the
+ * Settings modal (see `extraSettingsSections`) add their own keys, which pass
+ * through to `host.saveSettings` untouched.
+ */
+type MikeDownSettingsPatch = Partial<MikeDownSettings> & Record<string, unknown>;
+/**
+ * Feature switches. A feature that needs a host method (wikilinks, tags,
+ * images, export) is also off when that method is absent.
+ */
+interface MikeDownFeatures {
+    /** Formatting toolbar. Default on. */
+    toolbar: boolean;
+    /** Outline / Properties / Backlinks / Tags sidebar. Default off. */
+    sidebar: boolean;
+    /** CodeMirror source view (Cmd+/). Default on. */
+    sourceMode: boolean;
+    /** `/` command menu. Default on. */
+    slashCommands: boolean;
+    /** Spell checking. Default on, but inert unless `spellcheckDictionaryUrl` is set. */
+    spellcheck: boolean;
+    /** KaTeX math rendering. Default on. */
+    math: boolean;
+    /** Mermaid diagram rendering. Default on. */
+    mermaid: boolean;
+    /** Support entry point in the sidebar footer (VS Code only). Default off. */
+    supportCard: boolean;
+    /** Find and replace bar (Cmd+F / Cmd+H). Default on. */
+    findReplace: boolean;
+    /** Collapsible frontmatter block above the document. Default on. */
+    frontmatter: boolean;
+    /** AI features and the AI settings tab. Default on, but inert unless `host.ai` is set. */
+    ai: boolean;
+    /**
+     * "Customize Toolbar" entry points and the Toolbar section in Settings.
+     * Default on. Off keeps the toolbar fixed for the user; a `toolbarLayout`
+     * setting still applies.
+     */
+    customizeToolbar: boolean;
+}
+declare const DEFAULT_FEATURES: MikeDownFeatures;
+/** Row builders the Settings modal hands to host sections, so they match. */
+interface MikeDownSettingsSectionContext {
+    makeRow(label: string, description: string, layout?: 'inline' | 'stacked'): HTMLElement;
+    makeGroup(...rows: HTMLElement[]): HTMLDivElement;
+    makeFieldLabel(text: string, hint: string, layout?: 'inline' | 'stacked'): HTMLLabelElement;
+    makeCheckboxRow(label: string, description: string, current: boolean): {
+        row: HTMLElement;
+        input: HTMLInputElement;
+    };
+    makeSelectRow<T extends string>(label: string, description: string, current: T, options: Array<{
+        value: T;
+        label: string;
+    }>): {
+        row: HTMLElement;
+        select: HTMLSelectElement;
+    };
+    /** Close the modal without saving. */
+    close(): void;
+    /** Open an external link through the host (`host.openLink`). Absent: links are plain anchors. */
+    openLink?: (href: string) => void;
+}
+interface MikeDownSettingsSectionBuild {
+    /** Rows appended to the tab, in order. */
+    rows: HTMLElement[];
+    /** Values merged into the patch sent to `host.saveSettings` on Save. */
+    collect?(): Record<string, unknown>;
+    /** Runs after Save, once the patch was sent. */
+    onSaved?(): void;
+    /** Runs when the modal closes without saving (close button, Escape, backdrop, reopen, destroy). */
+    onDiscarded?(): void;
+}
+/** A host-owned block of rows in the Settings modal. */
+interface MikeDownSettingsSection {
+    /** Core tab id ('appearance', 'behavior', 'markdown', 'spelling', 'hotkeys') or a new tab id. */
+    tab: string;
+    /** Label for a new tab. Ignored for core tabs. */
+    tabLabel?: string;
+    /** Insert a new tab after this tab id. Default: after the last tab. */
+    afterTab?: string;
+    /** Extra class on a new tab's panel (e.g. 'settings-panel--about'). */
+    panelClassName?: string;
+    /**
+     * Where the rows go inside the tab: before the core rows, after them
+     * (default), or after the core row with this setting key.
+     */
+    placement?: 'start' | 'end' | {
+        after: keyof MikeDownSettings;
+    };
+    build(ctx: MikeDownSettingsSectionContext): MikeDownSettingsSectionBuild;
+}
+interface MikeDownOptions {
+    host: MikeDownHost;
+    /** Loaded as the pristine baseline. */
+    initialMarkdown?: string;
+    /** Initial core settings. */
+    settings?: Partial<MikeDownSettings>;
+    features?: Partial<MikeDownFeatures>;
+    /** Overrides `settings.editorTheme`. */
+    theme?: 'light' | 'dark' | 'auto';
+    readOnly?: boolean;
+    /** Base URL of the spell-check dictionaries (contains `en/` and `en-GB/`). */
+    spellcheckDictionaryUrl?: string;
+    /** Host sections in the Settings modal. */
+    extraSettingsSections?: MikeDownSettingsSection[];
+    /** Text beside the Settings modal's Save button. */
+    settingsFooterNote?: string;
+    /**
+     * True when the host binds editor shortcuts itself, as the VS Code
+     * keybinding does for Cmd/Ctrl+/. The core then leaves `Mod-/` alone so the
+     * source toggle never fires twice. Default false: the core binds it, in both
+     * the rich editor and source mode.
+     */
+    hostOwnsShortcuts?: boolean;
+    /** Empty-document placeholder. Default: "Type / for commands…" or "Start writing…". */
+    placeholder?: string;
+    /** `id` of the editable surface (the contenteditable, and the source view's content). */
+    id?: string;
+    /** Accessible name of the editable surface. Default "Document text". */
+    ariaLabel?: string;
+    /** Id of the element that names the editable surface. Wins over `ariaLabel`'s default. */
+    ariaLabelledBy?: string;
+    /**
+     * Put `role="main"` on the editor container. Default true (VS Code, Desktop).
+     * Embedded form fields pass false, since a field is not a page landmark.
+     */
+    landmark?: boolean;
+}
+type MikeDownCommand = 'toggleBold' | 'toggleItalic' | 'toggleStrike' | 'toggleHighlight' | 'toggleCode' | 'toggleBulletList' | 'toggleOrderedList' | 'toggleTaskList' | 'pasteWithoutFormatting' | 'openEmojiPicker' | 'undo' | 'redo' | 'toggleSource' | 'toggleSidebar' | 'openSettings'
+/**
+ * Open the Settings modal on the AI tab (no-op without `host.ai`). With
+ * `{ page: true }`, open the full-window AI Engines page instead (engines
+ * and routing; hosts with an engine registry only, others get the tab).
+ */
+ | 'openAiSettings'
+/** Rewrite the selection with AI: opens the rewrite popover's choices (no-op without `host.ai`). */
+ | 'aiRewrite'
+/** Explain the selection with AI: the read-only popover (no-op without `host.ai`). */
+ | 'aiExplain'
+/** Translate with AI: the popover's language picker; with nothing selected, the whole document. */
+ | 'aiTranslate'
+/** Summarize the document with AI: the popover streams a TL;DR, Insert puts it at the cursor (no-op without `host.ai`). */
+ | 'aiSummarize'
+/** 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';
+type MikeDownEvent = 'change' | 'focus' | 'blur' | 'ready';
+/**
+ * Where the user is in the document: which view is showing, the caret and
+ * the scroll offset of that view. A host that keeps several documents in one
+ * editor (tabs) saves it when a tab deactivates and restores it when the tab
+ * comes back, or across sessions.
+ */
+interface MikeDownViewState {
+    sourceMode: boolean;
+    /** Caret position in the showing view: a ProseMirror position in rich text, a character offset in source mode. */
+    cursor: number;
+    /** Scroll offset of the showing view's scroller, in CSS pixels. */
+    scrollTop: number;
+}
+/** Sidebar layout and per-document section state pushed by the host. */
+interface SidebarStateUpdate {
+    pref?: 'always' | 'never';
+    width?: number;
+    position?: 'left' | 'right';
+    sectionPrefs?: Record<string, boolean>;
+}
+/** Sidebar footer link (the VS Code support appeal uses it). */
+interface SidebarFooterLink {
+    label: string;
+    dismissLabel: string;
+    dismissConfirmation: string;
+    onOpen(): void;
+    onDismiss(): void;
+}
+interface MikeDownEditorHandle {
+    /** Replace the document. `pristine` (default true) makes it the clean baseline. */
+    setMarkdown(markdown: string, opts?: {
+        pristine?: boolean;
+    }): void;
+    getMarkdown(): string;
+    focus(): void;
+    setReadOnly(readOnly: boolean): void;
+    setTheme(theme: 'light' | 'dark' | 'auto'): void;
+    /** Run a toolbar or keybinding command. `openSettings` takes `{ tab }`, `openAiSettings` takes `{ page }`. */
+    command(name: MikeDownCommand, args?: {
+        tab?: string;
+        page?: boolean;
+    }): void;
+    /** Apply settings without persisting them. */
+    updateSettings(patch: Partial<MikeDownSettings>): void;
+    /** The host saved the document; `content` (default: current markdown) is the new baseline. */
+    markSaved(content?: string): void;
+    /** Rendered HTML of the document (for export and print). */
+    getHtml(): string;
+    scrollToAnchor(slug: string): void;
+    /** Scroll to and flash the Nth link with this href. */
+    revealLink(href: string, occurrence?: number): 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
+     * mode; in rich text the matched string is found again in the rendered text.
+     */
+    revealText(line: number, column: number, length?: number): void;
+    /** Mark images rendered from `src` as missing or present again. */
+    setImageStatus(src: string, status: 'found' | 'missing', detail?: string): void;
+    /** Insert a link at the cursor (rich text or source mode). `text` defaults to the href. */
+    insertLink(href: string, text?: string): void;
+    /** Insert an image at the cursor, e.g. the result of `host.uploadImage` for a dropped file. */
+    insertImage(image: ImageInsertResult): void;
+    /**
+     * Files around the document changed: re-resolve `[[wikilinks]]`, re-check
+     * relative links and refresh file suggestions. Also call it after adding
+     * the knowledge-base host methods to a host that started without them.
+     */
+    refreshLinks(): void;
+    setTags(tags: TagCount[]): void;
+    /** Push link suggestions without being asked (same data as `host.getLinkSuggestions`). */
+    setLinkSuggestions(suggestions: LinkSuggestion[]): void;
+    setBacklinks(items: BacklinkItem[]): void;
+    setDocMeta(meta: {
+        mtimeMs?: number | null;
+    }): void;
+    setSidebarState(state: SidebarStateUpdate): void;
+    /** Show or hide the sidebar footer link (requires `features.supportCard`). */
+    setSidebarFooterLink(link: SidebarFooterLink | null): void;
+    setDiffAvailable(available: boolean): void;
+    /**
+     * Show which engine served the last AI request in the sidebar's AI chip
+     * (`AI: local · oMLX · Qwen 3.8 Flash Next`). `viaFallback` adds
+     * "(fallback)". Null forgets it, so the chip shows the route again.
+     */
+    setAiServed(served: AiServedBy | null, opts?: {
+        viaFallback?: boolean;
+    }): void;
+    /** Push engine statuses the host learned on its own (VS Code's `aiEngines` broadcast). */
+    setAiEngineStatuses(statuses: AiEngineStatus[]): void;
+    /** True while the Settings modal or another core modal is open. */
+    isModalOpen(): boolean;
+    /** Which view is showing, where the caret is and how far it is scrolled. */
+    getViewState(): MikeDownViewState;
+    /**
+     * Restore a saved view state: switches views when `sourceMode` differs,
+     * then places the caret (clamped to the document) and the scroll offset.
+     * Call it after `setMarkdown`. Missing fields keep their current value.
+     */
+    setViewState(state: Partial<MikeDownViewState>): void;
+    /** Subscribe to an event. Returns an unsubscribe function. */
+    on(event: MikeDownEvent, fn: (...args: any[]) => void): () => void;
+    /** Tear down the editor and every listener it attached to window or document. */
+    destroy(): void;
+    /** The underlying TipTap editor. Escape hatch for tests and advanced hosts; not a stable API. */
+    readonly tiptap: Editor;
+}
+
+export { DEFAULT_FEATURES as D, NoopHost as N, DEFAULT_TOOLBAR_LAYOUT as d, normalizeToolbarLayout as y };
+export type { BacklinkItem as B, ImageInsertResult as I, LinkCheckRequest as L, MikeDownSettingsSectionContext as M, SidebarFooterLink as S, TagCount as T, WikilinkResolution as W, MikeDownOptions as a, MikeDownEditorHandle as b, MikeDownHost as c, DiffBaseline as e, ImagePathMapping as f, ImageResizeRequest as g, ImageResizeResult as h, ImageUploadRequest as i, LinkOpenBehavior as j, LinkSuggestion as k, MikeDownCommand as l, MikeDownEvent as m, MikeDownFeatures as n, MikeDownSettings as o, MikeDownSettingsPatch as p, MikeDownSettingsSection as q, MikeDownSettingsSectionBuild as r, MikeDownSidebarPrefs as s, MikeDownStats as t, MikeDownViewState as u, NormalizationStyle as v, SidebarStateUpdate as w, ToolbarLayout as x };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikedown/core",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "MikeDown WYSIWYG markdown editor core (TipTap + CodeMirror), framework-agnostic.",
   "license": "MIT",
   "type": "module",
@@ -19,6 +19,21 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./binding": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./ai": {
+      "types": "./dist/ai/index.d.ts",
+      "import": "./dist/ai/index.js",
+      "default": "./dist/ai/index.js"
+    },
+    "./ai/engines-page": {
+      "types": "./dist/ai/engines-page.d.ts",
+      "import": "./dist/ai/engines-page.js",
+      "default": "./dist/ai/engines-page.js"
+    },
     "./styles.css": "./dist/styles.css",
     "./tokens.css": "./dist/tokens.css",
     "./shared/*": {
@@ -111,7 +126,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/mikejoseph23/mikedown.git",
+    "url": "git+https://github.com/mikejoseph23/mikedown.git",
     "directory": "packages/core"
   }
 }