creo-edit 0.1.0

package/dist/plugin/types.d.ts

@@ -0,0 +1,188 @@
+import type { PublicView, Store } from "creo";
+import type { Anchor, Block, BlockId, BlockSpec, DocState, InlineRun, Selection } from "../model/types";
+export type RunsCtx = {
+    runs: InlineRun[];
+    setRuns: (newRuns: InlineRun[]) => Block;
+};
+export type DomPoint = {
+    node: Node;
+    offset: number;
+};
+export type AnchorCodec = {
+    /**
+     * Given the outer block element + a DOM hit (node, localOffset) inside it,
+     * produce an Anchor. Plugins for tables / columns walk into their cell
+     * sub-element and extract row/col from data-cell / data-col before
+     * computing the visible-character offset.
+     */
+    domToAnchor(blockEl: HTMLElement, hit: Node, localOffset: number): Anchor | null;
+    /**
+     * Given an Anchor, locate the (DOM node, offset) within the block's
+     * mounted DOM. Returns null when the relevant sub-element isn't currently
+     * mounted (e.g. virtualized off-screen).
+     */
+    anchorToDom(blockEl: HTMLElement, a: Anchor): DomPoint | null;
+    /**
+     * Return the scope element for IME composition diffing — e.g. the active
+     * <td> for a table caret, or the active <div data-col> for columns.
+     * Defaults to the block element itself for blocks without sub-scopes.
+     */
+    domScope?(blockEl: HTMLElement, a: Anchor): HTMLElement | null;
+};
+export type HtmlParseCtx = {
+    /** Active inline marks (b/i/u/s/code) collected from ancestor elements. */
+    marks: import("../model/types").Mark[];
+};
+export type HtmlBlockCodec = {
+    /**
+     * HTML tag names this block claims when parsing. The parser walks fragment
+     * children, finds the first registered codec whose `matchHTML` includes
+     * the tag, and calls `parseHTML`. Order = plugin registration order, so
+     * built-ins should register `table` before generic `<div>` parsers.
+     */
+    matchHTML?: string[];
+    parseHTML?(el: HTMLElement, ctx: HtmlParseCtx): BlockSpec | null;
+    serializeHTML?(b: Block): string;
+};
+export type SerializeCodec = {
+    serialize(b: Block): unknown;
+    deserialize(s: unknown, id: BlockId): BlockSpec;
+};
+export type BlockDef<B extends Block = Block> = {
+    /** Discriminator — must match block.type. */
+    type: B["type"];
+    /** Creo view rendering the block. Receives the block + a stable key. */
+    view: PublicView<{
+        block: B;
+        key?: string;
+    }, void>;
+    /**
+     * Resolve the runs slot at `anchor`. Defaults to "block.runs if present,
+     * else null" (covers all text-bearing blocks). Override for blocks with
+     * nested cells (table, columns).
+     */
+    runsAt?(b: B, a: Anchor): RunsCtx | null;
+    /**
+     * Whether the block is "text-bearing" — has a top-level `runs: InlineRun[]`
+     * field that text commands operate on directly. Inferred from `runsAt`
+     * presence at registration time when omitted; defaults to true if the
+     * block exposes a `runs` field at runtime.
+     */
+    isTextBearing?: boolean;
+    /**
+     * "Atomic" non-editable block — caret can only sit before (side 0) or
+     * after (side 1), never inside. Path encoding is `[side]`. The view should
+     * render the outer element with `contenteditable="false"` so the browser
+     * places the native caret around the block, not inside it. Backspace /
+     * Delete on the block deletes the whole block. Implies `isTextBearing:
+     * false` and uses `atomicCodec` by default if no `anchorCodec` is given.
+     */
+    isAtomic?: boolean;
+    /** DOM ↔ anchor mapping. Optional — text-bearing blocks fall back to a
+     *  shared default that walks visible text by character offset. */
+    anchorCodec?: AnchorCodec;
+    /** HTML round-trip. Optional — only needed for blocks that survive
+     *  copy / paste with external apps. */
+    htmlCodec?: HtmlBlockCodec;
+    /** JSON SerializedBlock round-trip. Required for blocks that should
+     *  survive `toJSON()` / `setDoc()`. */
+    serializeCodec?: SerializeCodec;
+};
+export type CommandCtx = {
+    docStore: Store<DocState>;
+    selStore: Store<Selection>;
+};
+export type CommandDef<P = unknown> = {
+    t: string;
+    /** Run the command. Return `false` to signal the command did not apply
+     *  (e.g. arrow-nav at the table edge); the keymap dispatcher uses this to
+     *  decide whether to preventDefault. Returning void or true means handled. */
+    run(ctx: CommandCtx, payload: P): boolean | void;
+};
+export type KeymapDef = {
+    /**
+     * Chord string. Modifiers join with "+". The platform-specific Mod token
+     * resolves to Cmd on macOS, Ctrl elsewhere. Examples:
+     *   "Mod+B", "Mod+Shift+S", "Tab", "Shift+Tab", "ArrowLeft".
+     */
+    chord: string;
+    when?(ctx: CommandCtx): boolean;
+    /** Command t + payload to dispatch when chord matches. */
+    command: {
+        t: string;
+        payload?: unknown;
+    };
+};
+export type TriggerCtx = {
+    /** Anchor of the trigger character that fired the match. */
+    at: Anchor;
+    docStore: Store<DocState>;
+    selStore: Store<Selection>;
+    /**
+     * Dispatch a command. Accepts the typed `Command` shape (preferred for
+     * built-ins so payload fields land in the right place) or the open
+     * `{ t: string; payload?: unknown }` shape for plugin commands.
+     *
+     * Two-arg form `(t, payload)` is sugar for `{ t, payload }`.
+     */
+    dispatch(cmd: {
+        t: string;
+        [k: string]: unknown;
+    }): void;
+    dispatch(t: string, payload?: unknown): void;
+    /** Element where popover UI should anchor. */
+    caretRect(): DOMRect | null;
+    /**
+     * Request the trigger manager to close this trigger. Idempotent. Call
+     * after committing the trigger's action so subsequent keystrokes (e.g.
+     * Enter to split a block) flow through to the editor instead of being
+     * captured by a stale controller.
+     */
+    close(): void;
+};
+export type TriggerController = {
+    onTextChange?(query: string): void;
+    onKey?(e: KeyboardEvent): boolean;
+    close(): void;
+};
+export type TriggerDef = {
+    /**
+     * String prefix or RegExp matched against the most recently inserted
+     * characters at the caret. String matches treat the value as a literal
+     * trigger char (e.g. "/").
+     */
+    match: string | RegExp;
+    open(ctx: TriggerCtx): TriggerController | null;
+};
+/**
+ * DecorationManager passed to mount fns so plugins can read state-without-
+ * subscribing-to-doc — e.g. "is this block currently hovered?". Decorations
+ * MUST NOT subscribe directly to docStore inside mount; that would re-render
+ * on every keystroke. Read live state via this handle on pointer events.
+ */
+export type DecorationHandle = {
+    hoveredBlock(): import("../model/types").BlockId | null;
+};
+export type DecorationDef = {
+    id: string;
+    match(b: Block): boolean;
+    /**
+     * Mount the decoration's UI into the supplied `host` element. Return an
+     * optional cleanup fn (called on unmount). The decoration's UI is plain
+     * DOM — plugins that want a creo subtree create their own creo app
+     * inside `mount` and dispose it in the returned cleanup.
+     */
+    mount(block: Block, blockEl: HTMLElement, host: HTMLElement, handle: DecorationHandle): (() => void) | void;
+    layer: "left" | "right" | "top" | "bottom" | "absolute";
+};
+export type EditorPlugin = {
+    name: string;
+    blocks?: BlockDef<Block>[];
+    commands?: CommandDef<unknown>[];
+    keymap?: KeymapDef[];
+    triggers?: TriggerDef[];
+    decorations?: DecorationDef[];
+    /** Tag prefixes whose history snapshots may coalesce. Defaults are
+     *  ["text:"]; plugins can declare their own (e.g. "myPlugin:typing"). */
+    historyCoalescePrefixes?: string[];
+};

package/dist/plugins/add-block/index.d.ts

@@ -0,0 +1,17 @@
+import type { Block } from "../../model/types";
+import type { EditorPlugin } from "../../plugin/types";
+import { type SlashItem } from "../slash/items";
+export type AddBlockOptions = {
+    /** Show on hover only (default). */
+    hoverOnly?: boolean;
+    /**
+     * Custom click handler. When provided, replaces the default behavior of
+     * opening the picker menu — useful for hosts that want a different UI
+     * or that want to insert a fixed block kind without prompting.
+     */
+    onClick?: (block: Block, blockEl: HTMLElement) => void;
+    /** Replace or extend the items shown in the picker. Defaults to the
+     *  same set as the slash menu. */
+    items?: SlashItem[];
+};
+export declare function addBlockPlugin(opts?: AddBlockOptions): EditorPlugin;

package/dist/plugins/calendar/index.d.ts

@@ -0,0 +1,7 @@
+import type { EditorPlugin } from "../../plugin/types";
+import type { SlashItem } from "../slash/items";
+/** Slash-menu item — append to your slash items array to expose calendar
+ *  insertion at the `/` trigger. */
+export declare const calendarSlashItem: SlashItem;
+export declare function calendarPlugin(): EditorPlugin;
+export { CalendarView, DateMarkerView, calendarHelpers } from "./view";

package/dist/plugins/calendar/view.d.ts

@@ -0,0 +1,29 @@
+import type { CalendarBlock, DateMarkerBlock } from "../../model/types";
+declare function todayIso(): string;
+declare function formatIso(d: Date): string;
+declare function parseIso(s: string): Date;
+declare function addDays(d: Date, n: number): Date;
+export declare const CalendarView: (props: {
+    block: CalendarBlock;
+} & {
+    key?: import("creo").Key;
+    ref?: import("creo").Ref<void> | undefined;
+}, slot?: import("creo").SlotContent) => void;
+/**
+ * DateMarkerView — slim non-editable atomic block that renders a single
+ * "Wednesday, 2 Sep." line. Used as a separator block in journal /
+ * planner UX where the user writes editable paragraphs between days.
+ */
+export declare const DateMarkerView: (props: {
+    block: DateMarkerBlock;
+} & {
+    key?: import("creo").Key;
+    ref?: import("creo").Ref<void> | undefined;
+}, slot?: import("creo").SlotContent) => void;
+export declare const calendarHelpers: {
+    todayIso: typeof todayIso;
+    formatIso: typeof formatIso;
+    parseIso: typeof parseIso;
+    addDays: typeof addDays;
+};
+export {};

package/dist/plugins/cells/codecs.d.ts

@@ -0,0 +1,6 @@
+import type { Anchor, ColumnsBlock, TableBlock } from "../../model/types";
+import type { AnchorCodec, RunsCtx } from "../../plugin/types";
+export declare function tableRunsAt(b: TableBlock, a: Anchor): RunsCtx | null;
+export declare const tableAnchorCodec: AnchorCodec;
+export declare function columnsRunsAt(b: ColumnsBlock, a: Anchor): RunsCtx | null;
+export declare const columnsAnchorCodec: AnchorCodec;

package/dist/plugins/cells/commands.d.ts

@@ -0,0 +1,5 @@
+import type { DocState, Selection } from "../../model/types";
+import type { CommandDef } from "../../plugin/types";
+export declare function isInTable(doc: DocState, sel: Selection): boolean;
+export declare function isInColumns(doc: DocState, sel: Selection): boolean;
+export declare const tableCommandDefs: CommandDef<unknown>[];

package/dist/plugins/cells/controls.d.ts

@@ -0,0 +1,3 @@
+import type { DecorationDef } from "../../plugin/types";
+export declare const tableControlsDecoration: DecorationDef;
+export declare const columnsControlsDecoration: DecorationDef;

package/dist/plugins/cells/htmlCodec.d.ts

@@ -0,0 +1,6 @@
+import type { Block, BlockSpec, Mark } from "../../model/types";
+export declare function parseTableHTML(el: HTMLElement, ctx: {
+    marks: Mark[];
+}): BlockSpec | null;
+export declare function serializeTableHTML(b: Block): string;
+export declare function serializeColumnsHTML(b: Block): string;

package/dist/plugins/cells/index.d.ts

@@ -0,0 +1,3 @@
+import type { EditorPlugin } from "../../plugin/types";
+export declare const cellsPlugin: EditorPlugin;
+export { isInTable } from "./commands";

package/dist/plugins/cells/views.d.ts

@@ -0,0 +1,27 @@
+import type { ColumnsBlock, TableBlock } from "../../model/types";
+/**
+ * Render a TableBlock as <table><tbody> with keyed rows + cells.
+ *
+ * NOTE: intermediate primitives (tbody, tr) get FRESH prop objects each
+ * render, not the `_` no-props constant. The reconciler skips descent
+ * when an intermediate primitive's props are reference-equal to the
+ * previous render — using `_` everywhere causes that shortcut to fire
+ * and changes inside cells (e.g. typed text) never make it to the DOM.
+ */
+export declare const TableViewPlugin: (props: {
+    block: TableBlock;
+} & {
+    key?: import("creo").Key;
+    ref?: import("creo").Ref<void> | undefined;
+}, slot?: import("creo").SlotContent) => void;
+/**
+ * Render a ColumnsBlock as a flex row of equal-width column divs. Each
+ * column carries `data-block-id` (so caret-overlay queries find the owner)
+ * AND `data-col="<index>"` so pointToAnchor can reconstruct the column.
+ */
+export declare const ColumnsViewPlugin: (props: {
+    block: ColumnsBlock;
+} & {
+    key?: import("creo").Key;
+    ref?: import("creo").Ref<void> | undefined;
+}, slot?: import("creo").SlotContent) => void;

package/dist/plugins/drag-handle/index.d.ts

@@ -0,0 +1,6 @@
+import type { EditorPlugin } from "../../plugin/types";
+export type DragHandleOptions = {
+    /** Show on hover only (default). When `false`, handles are always visible. */
+    hoverOnly?: boolean;
+};
+export declare function dragHandlePlugin(opts?: DragHandleOptions): EditorPlugin;

package/dist/plugins/infinite-scroll/index.d.ts

@@ -0,0 +1,44 @@
+import type { BlockId, DistOmit, BlockSpec, DocState, Selection } from "../../model/types";
+import type { EditorPlugin } from "../../plugin/types";
+type Input = DistOmit<BlockSpec, "id"> & {
+    id?: BlockId;
+};
+export type InfiniteScrollEditor = {
+    docStore: {
+        get: () => DocState;
+        subscribe: (fn: () => void) => () => void;
+    };
+    selStore: {
+        get: () => Selection;
+    };
+    appendBlocks: (specs: Input[]) => BlockId[];
+    prependBlocks: (specs: Input[]) => BlockId[];
+};
+export type InfiniteScrollOptions = {
+    /**
+     * The scrolling element to watch. Either an element, or a getter (the
+     * element may not exist at editor-mount time). When omitted, the
+     * plugin walks up from the editor root looking for the nearest
+     * `overflow-y: auto|scroll` ancestor; falls back to `window`.
+     */
+    scrollContainer?: HTMLElement | (() => HTMLElement | null);
+    /** Called when the user scrolls within `threshold` of the bottom. */
+    loadAfter?: (editor: InfiniteScrollEditor) => void;
+    /**
+     * Called when the user scrolls within `threshold` of the top. The
+     * plugin re-anchors `scrollTop` after the load so the viewport doesn't
+     * jump.
+     */
+    loadBefore?: (editor: InfiniteScrollEditor) => void;
+    /** Pixel distance from an edge that triggers a load. Default: 240. */
+    threshold?: number;
+    /**
+     * Minimum gap between successive triggers in the SAME direction (ms).
+     * Prevents back-to-back appends while the user is mid-flick. Default
+     * 60ms — short enough to feel responsive while letting the renderer
+     * commit a frame in between.
+     */
+    cooldownMs?: number;
+};
+export declare function infiniteScrollPlugin(opts: InfiniteScrollOptions): EditorPlugin;
+export {};

package/dist/plugins/md-shortcuts/index.d.ts

@@ -0,0 +1,2 @@
+import type { EditorPlugin } from "../../plugin/types";
+export declare function mdShortcutsPlugin(): EditorPlugin;

package/dist/plugins/search/engine.d.ts

@@ -0,0 +1,33 @@
+import type { Anchor, Block, BlockId, DocState } from "../../model/types";
+export type SearchMatch = {
+    blockId: BlockId;
+    start: Anchor;
+    end: Anchor;
+    /** Slice of the matched text — used for backend results that don't
+     *  resolve to a live block; engine results include it for parity. */
+    snippet?: string;
+};
+export type SearchOpts = {
+    caseSensitive: boolean;
+    wholeWord: boolean;
+    regex: boolean;
+};
+type Slot = {
+    text: string;
+    /** Anchor path prefix this slot belongs to. Concatenated with charOffset
+     *  to form the final anchor path. */
+    prefix: number[];
+};
+/** Yield every searchable text slot for a block, with the anchor prefix
+ *  needed to address positions inside it. Skips non-text blocks (img,
+ *  calendar, date-marker). */
+export declare function slotsOf(block: Block): Generator<Slot>;
+/** Build a sticky-global regex for the query + options. Throws if the user
+ *  supplied an invalid `regex: true` pattern — caller should catch and show
+ *  a UI error. */
+export declare function buildMatcher(query: string, opts: SearchOpts): RegExp;
+/** Scan every block in the doc and return all matches, in document order. */
+export declare function searchDoc(doc: DocState, query: string, opts: SearchOpts): SearchMatch[];
+/** Stable key for dedupe across re-scans. */
+export declare function matchKey(m: SearchMatch): string;
+export {};

package/dist/plugins/search/highlight.d.ts

@@ -0,0 +1,13 @@
+import type { SearchMatch } from "./engine";
+export declare const HL_ALL = "creo-search";
+export declare const HL_CURRENT = "creo-search-current";
+export declare function isHighlightApiSupported(): boolean;
+/**
+ * Sync the named highlights with the current match list and active index.
+ *
+ * Returns the number of matches that landed in DOM (i.e. mounted). The
+ * caller can use it for diagnostics — e.g. if `0 < total`, some matches
+ * are off-screen and waiting on virtualization to mount their blocks.
+ */
+export declare function paintHighlights(root: HTMLElement, matches: readonly SearchMatch[], activeIndex: number): number;
+export declare function clearHighlights(): void;

package/dist/plugins/search/index.d.ts

@@ -0,0 +1,5 @@
+import type { EditorPlugin } from "../../plugin/types";
+import type { SearchOptions } from "./types";
+export type { SearchController, SearchOptions, SearchSource, SearchState, SearchToggle, } from "./types";
+export type { SearchMatch, SearchOpts } from "./engine";
+export declare function searchPlugin(opts?: SearchOptions): EditorPlugin;

package/dist/plugins/search/navigate.d.ts

@@ -0,0 +1,15 @@
+import type { BlockId, DocState } from "../../model/types";
+import type { SearchMatch } from "./engine";
+import type { SearchSource } from "./types";
+export type EditorScrollHandle = {
+    docStore: {
+        get(): DocState;
+    };
+    scrollToBlock(blockId: BlockId, opts?: {
+        block?: "start" | "center" | "end" | "nearest";
+        behavior?: ScrollBehavior;
+    }): void;
+};
+export declare function jumpToMatch(editor: EditorScrollHandle, match: SearchMatch, source?: SearchSource): Promise<void>;
+export declare function nextIndex(current: number, total: number): number;
+export declare function prevIndex(current: number, total: number): number;

package/dist/plugins/search/styles.d.ts

@@ -0,0 +1 @@
+export declare function ensureStylesInjected(): void;

package/dist/plugins/search/types.d.ts

@@ -0,0 +1,73 @@
+import type { BlockId } from "../../model/types";
+import type { SearchMatch, SearchOpts } from "./engine";
+export type { SearchMatch, SearchOpts } from "./engine";
+export type SearchToggle = "caseSensitive" | "wholeWord" | "regex";
+export type SearchSource = {
+    /** Replace (or augment) the in-doc scan. Async OK. */
+    search(query: string, opts: SearchOpts): SearchMatch[] | Promise<SearchMatch[]>;
+    /** Called before jump-to-match for a blockId not yet in docStore. The
+     *  host should load the chunk that contains the block and resolve when
+     *  the block lands in docStore. */
+    ensureLoaded?(blockId: BlockId): Promise<void>;
+};
+export type SearchToggleOpt = {
+    initial?: boolean;
+    show?: boolean;
+};
+export type SearchOptions = {
+    /**
+     * When true, the plugin claims `Mod+F` and prevents the browser's find
+     * UI from opening. Default: `false` — opt-in to avoid surprising users
+     * who expect native Cmd+F.
+     */
+    interceptBrowserFind?: boolean;
+    /** Initial values + UI visibility for each toggle. Omitted toggles use
+     *  `{ initial: false, show: false }`. */
+    toggles?: {
+        caseSensitive?: SearchToggleOpt;
+        wholeWord?: SearchToggleOpt;
+        regex?: SearchToggleOpt;
+    };
+    /** Backend search source (for infinite-scroll). When omitted, the
+     *  plugin scans `docStore` only. */
+    source?: SearchSource;
+    /**
+     * Render the UI yourself. When provided, the default panel is NOT
+     * mounted — the callback gets a controller and a host element to
+     * render whatever it wants. Return a cleanup fn called on plugin
+     * teardown.
+     */
+    renderUI?: (controller: SearchController, host: HTMLElement) => () => void;
+    /** Debounce (ms) on input change. Default: 80. */
+    debounceMs?: number;
+};
+export type SearchState = {
+    isOpen: boolean;
+    query: string;
+    caseSensitive: boolean;
+    wholeWord: boolean;
+    regex: boolean;
+    matches: readonly SearchMatch[];
+    activeIndex: number;
+    /** Last engine error (e.g. invalid regex) — UI shows it inline. */
+    error: string | null;
+};
+export type SearchController = {
+    open(): void;
+    close(): void;
+    toggleOpen(): void;
+    isOpen(): boolean;
+    setQuery(q: string): void;
+    query(): string;
+    setToggle(t: SearchToggle, v: boolean): void;
+    toggle(t: SearchToggle): boolean;
+    matches(): readonly SearchMatch[];
+    activeIndex(): number;
+    setActiveIndex(i: number): void;
+    next(): void;
+    prev(): void;
+    /** Subscribe to state changes; returns unsubscribe. */
+    subscribe(fn: () => void): () => void;
+    /** Snapshot the full state. */
+    state(): SearchState;
+};

package/dist/plugins/search/ui.d.ts

@@ -0,0 +1,2 @@
+import type { SearchController, SearchOptions } from "./types";
+export declare function mountDefaultPanel(host: HTMLElement, controller: SearchController, options: SearchOptions): () => void;

package/dist/plugins/slash/index.d.ts

@@ -0,0 +1,12 @@
+import type { EditorPlugin } from "../../plugin/types";
+import { type SlashItem } from "./items";
+export type SlashOptions = {
+    /** Replace or extend the default item list. */
+    items?: SlashItem[];
+    /** Custom filter — defaults to case-insensitive substring on title+keywords. */
+    filter?: (items: SlashItem[], query: string) => SlashItem[];
+};
+export declare function slashCommandsPlugin(opts?: SlashOptions): EditorPlugin;
+export type { SlashItem } from "./items";
+export { defaultSlashItems, defaultFilter } from "./items";
+export { mountSlashMenu, type MenuHandle, type MenuOptions } from "./menu";

package/dist/plugins/slash/items.d.ts

@@ -0,0 +1,21 @@
+import type { CommandCtx } from "../../plugin/types";
+import type { DispatchableCommand } from "../../createEditor";
+export type SlashItem = {
+    id: string;
+    title: string;
+    description?: string;
+    /** Lowercase keywords used by the default fuzzy filter. */
+    keywords?: string[];
+    /**
+     * Run the action. The slash menu has already removed the trigger char(s)
+     * from the document by the time this fires, and the caret is back where
+     * the trigger was — this fn just dispatches whatever should happen.
+     */
+    run(ctx: CommandCtx & {
+        dispatch: (cmd: DispatchableCommand) => void;
+    }): void;
+};
+export declare const defaultSlashItems: SlashItem[];
+/** Default fuzzy filter — case-insensitive substring match against title +
+ *  keywords. Plugins can pass a custom matcher via slashCommandsPlugin opts. */
+export declare function defaultFilter(items: SlashItem[], query: string): SlashItem[];

package/dist/plugins/slash/menu.d.ts

@@ -0,0 +1,17 @@
+import type { SlashItem } from "./items";
+export type MenuOptions = {
+    items: SlashItem[];
+    filter?: (items: SlashItem[], query: string) => SlashItem[];
+    caretRect: DOMRect | null;
+    /** Called when the user picks an item (Enter or click). */
+    onPick(item: SlashItem): void;
+    /** Called when the user hits Escape, clicks away, or otherwise dismisses. */
+    onCancel(): void;
+};
+export type MenuHandle = {
+    setQuery(q: string): void;
+    /** Returns true if the key was consumed (arrow nav / Enter / Esc). */
+    handleKey(e: KeyboardEvent): boolean;
+    destroy(): void;
+};
+export declare function mountSlashMenu(opts: MenuOptions): MenuHandle;