@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/inline-menu/inline-menu-session.js

@@ -0,0 +1,98 @@
+/**
+ * The inline menu's rules: which source a just-typed trigger opens, where in a line of prose it
+ * may open at all, and what an open session's query is now. Pure, so all three are testable
+ * without an editor.
+ */
+import { constructContentRange } from '../core/inline';
+import { isInlineWidgetKind } from '../core/inline/inline-widgets';
+import { getInlineConstructPolicy } from '../schema/inline-construct-policy';
+/** The source a just-typed run opens; `from` is where the run began, since a burst of keystrokes
+ *  arrives as one change. The trigger nearest the caret wins, then the longer, so `[[` beats `[`. */
+export function findOpening(sources, raw, caret, from) {
+    const candidates = [];
+    for (const source of sources) {
+        const length = source.trigger.length;
+        // A trigger counts when its last byte was typed in this run, so the second `[` of `[[`
+        // opens over a first one that was already there.
+        for (let end = Math.max(from + 1, length); end <= caret; end++) {
+            if (raw.startsWith(source.trigger, end - length)) {
+                candidates.push({ source, start: end - length, end });
+            }
+        }
+    }
+    candidates.sort((a, b) => b.end - a.end || b.source.trigger.length - a.source.trigger.length);
+    for (const { source, start, end } of candidates) {
+        if (source.opensAt && !source.opensAt(raw, start))
+            continue;
+        if (!acceptsQuery(source, raw.slice(end, caret)))
+            continue;
+        return { source, start };
+    }
+    return null;
+}
+/** Whether a trigger at this offset sits in prose the author is writing, as each construct's
+ *  policy row declares: a link's text is prose, its destination and a code span are not. */
+export function isProseOffset(nodes, offset, grammar) {
+    for (const node of nodes) {
+        if (offset < node.start || offset >= node.end)
+            continue;
+        const extent = proseExtent(node.kind, grammar);
+        if (extent === 'none')
+            return false;
+        if (extent === 'content') {
+            const content = constructContentRange(node);
+            if (!content || offset < content.start || offset >= content.end)
+                return false;
+        }
+        return node.children ? isProseOffset(node.children, offset, grammar) : true;
+    }
+    return true;
+}
+// A widget kind with no row (a plugin's formula) shows source, never prose.
+function proseExtent(kind, grammar) {
+    const declared = getInlineConstructPolicy(kind)?.prose;
+    return declared ?? (isInlineWidgetKind(kind, grammar) ? 'none' : 'all');
+}
+/** Whether the offset sits in a destination opened with `](` and not yet closed: those bytes are
+ *  text until the `)` lands, so the inline tree has no link to decline. */
+export function isUnclosedDestination(raw, offset) {
+    const lineStart = raw.lastIndexOf('\n', offset - 1) + 1;
+    for (let i = offset - 1; i >= lineStart; i--) {
+        if (raw[i] === ')')
+            return false;
+        // A `](` with no `[` before it on the line is text, so the scan keeps going back.
+        if (raw[i] === '(' && raw[i - 1] === ']' && raw.lastIndexOf('[', i - 2) >= lineStart) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Where the just-typed run began, or null when the change from `previous` to `raw` is anything
+ *  but bytes inserted to end at the caret (a deletion, a caret move, an edit elsewhere). */
+export function typedRunStart(previous, raw, caret) {
+    const length = raw.length - previous.length;
+    if (length <= 0 || length > caret)
+        return null;
+    const from = caret - length;
+    return raw.slice(0, from) + raw.slice(caret) === previous ? from : null;
+}
+function acceptsQuery(source, query) {
+    return source.accepts ? source.accepts(query) : !/[\r\n]/.test(query);
+}
+/** The open session's query at this caret, or null once the session is over: the trigger is
+ *  gone, the caret stepped in front of the query, or the source declines what was typed. */
+export function sessionQuery(session, source, raw, caret) {
+    const queryStart = session.start + session.triggerLength;
+    if (caret < queryStart || caret > raw.length)
+        return null;
+    if (!raw.startsWith(source.trigger, session.start))
+        return null;
+    const query = raw.slice(queryStart, caret);
+    return acceptsQuery(source, query) ? query : null;
+}
+/** Step the active row, wrapping at both ends; a list of none has no active row. */
+export function stepActive(index, delta, count) {
+    if (count === 0)
+        return 0;
+    return (index + delta + count) % count;
+}

package/dist/inline-menu/inline-menu-state.svelte.d.ts

@@ -0,0 +1,63 @@
+/**
+ * One editor's inline-menu registry and the single session it can hold open. The session is
+ * identity only (source name, path, trigger start); the query and the replaced range are re-read
+ * from the live leaf after every edit and caret move, so nothing here can address bytes that moved.
+ */
+import type { DocumentView } from '../core/node-views';
+import type { EditorEvents } from '../editor-events';
+import type { PresentationMode } from '../presentation-mode';
+import type { EditorSelection } from '../selection/primitives';
+import type { InlineMenuItem, InlineMenuRegistry, InlineMenuSource } from './types';
+import type { Reading } from '../schema/reading';
+export interface InlineMenuStateDeps {
+    getDoc: () => DocumentView;
+    getSelection: () => EditorSelection | null;
+    getMode: () => PresentationMode;
+    events: EditorEvents;
+    /** This instance's id, so two editors on one page never give their lists the same DOM id. */
+    editorId: string;
+    /** The editor's resolver and grammar, so a trigger inside a construct reads as the render drew it. */
+    reading: Reading;
+    /** Splice `bytes` over `[start, end)` of the leaf at `path` as one undo entry, caret landing at
+     *  `caretAfter` so the next key goes there; resolves to whether the leaf holds the bytes. */
+    commitRange: (path: number[], start: number, end: number, bytes: string, caretAfter: number) => Promise<boolean>;
+    /** One undo entry for a pick and the block its source inserts; `path` and `offset` are where undo
+     *  puts the caret back when nothing is focused. */
+    undoStep: (path: number[], offset: number, run: () => Promise<unknown>) => Promise<void>;
+}
+export interface InlineMenuState {
+    registry: InlineMenuRegistry;
+    /** The open session's raw range and list, or null. Reactive. */
+    getOpen(): InlineMenuOpenView | null;
+    /** The list element's DOM id, which `aria-controls` names. */
+    readonly listboxId: string;
+    /** The DOM id of the row a source gave this item id, which `aria-activedescendant` names. */
+    optionId(itemId: string): string;
+    /** What the editable at `path` must say about the list showing in it, or null when none is.
+     *  The editable renders these itself; nothing writes onto its element. Reactive. */
+    comboboxFor(path: readonly number[]): InlineMenuCombobox | null;
+    move(delta: 1 | -1): void;
+    setActive(index: number): void;
+    /** Take a baseline for the caret's leaf if none is held; the host calls it at beforeinput,
+     *  before the input's bytes exist. */
+    primeBaseline(): void;
+    /** Commit the active row, or the row at `index`. False with no row to commit. */
+    commit(index?: number): boolean;
+    close(): void;
+    dispose(): void;
+}
+/** The ids a focused editable points a screen reader at while an inline menu's list shows in it. */
+export interface InlineMenuCombobox {
+    listboxId: string;
+    activeOptionId: string;
+}
+export interface InlineMenuOpenView {
+    source: InlineMenuSource;
+    path: number[];
+    start: number;
+    end: number;
+    query: string;
+    items: InlineMenuItem[];
+    activeIndex: number;
+}
+export declare function createInlineMenuState(deps: InlineMenuStateDeps): InlineMenuState;

package/dist/inline-menu/inline-menu-state.svelte.js

@@ -0,0 +1,409 @@
+/**
+ * One editor's inline-menu registry and the single session it can hold open. The session is
+ * identity only (source name, path, trigger start); the query and the replaced range are re-read
+ * from the live leaf after every edit and caret move, so nothing here can address bytes that moved.
+ */
+import { tick } from 'svelte';
+import { isProseKind } from '../core/inline';
+import { resolvedInlineContent } from '../core/inline/inline-cache';
+import { isGridKind } from '../schema/block-kind-descriptor';
+import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
+import { findOpening, isProseOffset, isUnclosedDestination, sessionQuery, stepActive, typedRunStart } from './inline-menu-session';
+/** An item id as one DOM-id token, since a source may hand out `Meeting notes`. Every escape is
+ *  reversible, so two ids a source kept distinct never collide in the page. */
+function asIdToken(id) {
+    return id.replace(/[^A-Za-z0-9-]/gu, (char) => `_${char.codePointAt(0).toString(16)}_`);
+}
+/** Whether the leaf at `path` sits in a grid container's row, the way a table cell does. */
+function isGridCell(doc, path) {
+    if (path.length < 2)
+        return false;
+    const parent = nodeAt(doc, path.slice(0, -1));
+    return parent !== null && isBlockNode(parent) && isGridKind(parent.kind);
+}
+export function createInlineMenuState(deps) {
+    const sources = new Map();
+    const listboxId = `${deps.editorId}-inline-menu`;
+    // A row is named after its own item, not its place in the list, so the row a narrower query
+    // leaves active keeps the id the attribute pointing at it already held.
+    const optionId = (itemId) => `${listboxId}-${asIdToken(itemId)}`;
+    let session = $state.raw(null);
+    /** The open session's path as one string, joined once per session rather than per read. */
+    const sessionPathKey = $derived(session === null ? '' : session.path.join());
+    let query = $state('');
+    let end = $state(0);
+    let items = $state.raw([]);
+    let activeIndex = $state(0);
+    let pendingRead = null;
+    /**
+     * The caret's leaf as the last read saw it. A trigger is the difference from these bytes, so a
+     * caret that merely arrives beside an existing `#` has typed nothing and opens nothing.
+     */
+    let seen = null;
+    /** Set once a read has been held back, so the next change a caret cannot explain is adopted. */
+    let heldBack = false;
+    /** True across a write of this menu's own, whose bytes are not the author's typing. */
+    let writing = false;
+    let scheduled = false;
+    let disposed = false;
+    function report(error, source) {
+        const payload = { origin: 'subscriber', error, context: { source } };
+        deps.events.emit('error', payload);
+    }
+    /**
+     * The collapsed caret in a prose leaf, with that leaf: the only place a session lives. Never a
+     * table cell, whose line cannot take the blocks a pick may insert.
+     */
+    function caretLeaf() {
+        const selection = deps.getSelection();
+        if (!selection)
+            return null;
+        const { anchor, focus } = selection;
+        if (anchor.cellCoordinate || focus.cellCoordinate)
+            return null;
+        if (anchor.offset !== focus.offset || anchor.path.join() !== focus.path.join())
+            return null;
+        const doc = deps.getDoc();
+        const leaf = nodeAt(doc, focus.path);
+        if (leaf === null || !isBlockNode(leaf) || !isProseKind(leaf.kind))
+            return null;
+        if (isGridCell(doc, focus.path))
+            return null;
+        return { path: focus.path, offset: focus.offset, leaf };
+    }
+    function nodeRaw(path) {
+        const leaf = nodeAt(deps.getDoc(), path);
+        return leaf !== null && isBlockNode(leaf) ? leaf.raw : '';
+    }
+    function close() {
+        pendingRead?.abort();
+        pendingRead = null;
+        if (session === null)
+            return;
+        session = null;
+        items = [];
+        query = '';
+        activeIndex = 0;
+    }
+    /**
+     * The list with at most one row per id. Two rows under one id are one row to the render, which
+     * keys on it, so the later one is dropped and the source told rather than left to misdraw.
+     */
+    function uniqueRows(list, source) {
+        const ids = new Set();
+        const kept = [];
+        for (const row of list) {
+            if (ids.has(row.id))
+                continue;
+            ids.add(row.id);
+            kept.push(row);
+        }
+        if (kept.length !== list.length) {
+            report(new Error(`inlineMenus: source '${source}' offered rows sharing an id; all but the first ` +
+                `of each were dropped`), source);
+        }
+        return kept;
+    }
+    function read(source, live) {
+        pendingRead?.abort();
+        const controller = new AbortController();
+        pendingRead = controller;
+        const isCurrent = () => session === live && !controller.signal.aborted;
+        const land = (next) => {
+            if (!isCurrent())
+                return;
+            items = uniqueRows(next, source.name);
+            activeIndex = Math.min(activeIndex, Math.max(0, items.length - 1));
+        };
+        const fail = (error) => {
+            if (!isCurrent())
+                return;
+            report(error, source.name);
+            land([]);
+        };
+        try {
+            const result = source.items({
+                query,
+                path: live.path,
+                start: live.start,
+                end,
+                signal: controller.signal
+            });
+            // A synchronous list lands in this same turn, so a fast source never paints a frame
+            // of the previous query's rows.
+            if (Array.isArray(result))
+                land(result);
+            else
+                result.then(land, fail);
+        }
+        catch (error) {
+            fail(error);
+        }
+    }
+    function evaluate() {
+        if (disposed)
+            return;
+        // An editor nobody registered a menu on pays nothing per keystroke.
+        if (sources.size === 0 && session === null)
+            return;
+        const caret = deps.getMode() === 'reading' ? null : caretLeaf();
+        const previous = seen;
+        seen = caret ? { path: caret.path.join(), raw: caret.leaf.raw } : null;
+        if (session !== null) {
+            const live = session;
+            const source = sources.get(live.source);
+            if (!caret || !source || caret.path.join() !== sessionPathKey)
+                return close();
+            const next = sessionQuery(live, source, caret.leaf.raw, caret.offset);
+            if (next === null)
+                return close();
+            if (next === query && caret.offset === end)
+                return;
+            query = next;
+            end = caret.offset;
+            activeIndex = 0;
+            read(source, live);
+            return;
+        }
+        if (writing || !caret || !previous || previous.path !== caret.path.join())
+            return;
+        const from = typedRunStart(previous.raw, caret.leaf.raw, caret.offset);
+        if (from === null) {
+            // The bytes and the caret can move separately, so the older snapshot is held one more read;
+            // a change the next caret still cannot explain is adopted, so `seen` never goes stale.
+            const unexplained = previous.raw !== caret.leaf.raw;
+            if (unexplained && !heldBack)
+                seen = previous;
+            heldBack = unexplained && !heldBack;
+            return;
+        }
+        heldBack = false;
+        const opening = findOpening(sources.values(), caret.leaf.raw, caret.offset, from);
+        if (!opening)
+            return;
+        const inline = resolvedInlineContent(caret.leaf, deps.reading);
+        if (!isProseOffset(inline, opening.start, deps.reading.grammar))
+            return;
+        if (isUnclosedDestination(caret.leaf.raw, opening.start))
+            return;
+        begin(opening.source, caret.path, opening.start, caret.offset);
+    }
+    /** Takes a baseline for a leaf the caret reached with no read in between (a click, Enter onto
+     *  a new line). Never replaces one: mid-burst, the standing baseline predates the trigger. */
+    function primeBaseline() {
+        if (disposed || sources.size === 0 || session !== null || writing)
+            return;
+        const caret = deps.getMode() === 'reading' ? null : caretLeaf();
+        if (!caret)
+            return;
+        const path = caret.path.join();
+        if (seen?.path !== path)
+            seen = { path, raw: caret.leaf.raw };
+    }
+    /** After a write of this menu's own: those bytes are not the author's typing. */
+    function resnap() {
+        const caret = caretLeaf();
+        seen = caret ? { path: caret.path.join(), raw: caret.leaf.raw } : null;
+    }
+    function begin(source, path, start, caret) {
+        const typedQuery = sessionQuery({ source: source.name, path, start, triggerLength: source.trigger.length }, source, nodeRaw(path), caret);
+        // `open()` may have written a query the source declines: that session is over already.
+        if (typedQuery === null)
+            return;
+        const live = {
+            source: source.name,
+            path: [...path],
+            start,
+            triggerLength: source.trigger.length
+        };
+        session = live;
+        // A burst can carry the query's first bytes in with the trigger.
+        query = typedQuery;
+        end = caret;
+        activeIndex = 0;
+        items = [];
+        read(source, live);
+    }
+    // Evaluated a tick later, so an edit and its selectionchange are one read. The baseline is
+    // taken now, since one event can carry a caret's arrival in a new leaf and its first bytes.
+    function schedule() {
+        if (disposed || (sources.size === 0 && session === null))
+            return;
+        primeBaseline();
+        if (scheduled)
+            return;
+        scheduled = true;
+        void tick().then(() => {
+            scheduled = false;
+            evaluate();
+        });
+    }
+    const unsubscribeEdit = deps.events.on('edit', schedule);
+    const unsubscribeSelection = deps.events.on('selectionChange', schedule);
+    const unsubscribeMode = deps.events.on('presentationModeChange', schedule);
+    async function commitItem(item) {
+        const live = session;
+        if (!live)
+            return;
+        // One entry for the pick's own bytes and every block its source writes after them.
+        await deps.undoStep(live.path, live.start, () => writePick(live, item));
+    }
+    async function writePick(live, item) {
+        const source = sources.get(live.source);
+        const range = { query, path: [...live.path], start: live.start, end };
+        close();
+        // One leaf's raw must not hold a blank line: the tree would say one paragraph where a
+        // reload reads two.
+        if (/[\r\n]/.test(item.insert)) {
+            report(new Error(`inlineMenus: source '${live.source}' offered an insert with a line break; a pick ` +
+                `writes one line of inline bytes, and a block belongs in onCommit`), live.source);
+            return;
+        }
+        const caretAfter = range.start + item.insert.length;
+        // The write is this menu's own, not a keystroke: bytes ending in a trigger reopen nothing.
+        writing = true;
+        try {
+            // A pick whose bytes never landed has nothing for onCommit to follow.
+            if (!(await deps.commitRange(range.path, range.start, range.end, item.insert, caretAfter))) {
+                return;
+            }
+        }
+        catch (error) {
+            // Nobody is waiting on this write, so a refused one has to be reported here or vanish.
+            report(error, live.source);
+            return;
+        }
+        finally {
+            writing = false;
+            resnap();
+        }
+        try {
+            await source?.onCommit?.(item, range);
+        }
+        catch (error) {
+            report(error, live.source);
+        }
+    }
+    function open(name, options) {
+        const source = sources.get(name);
+        const typed = source ? source.trigger + (options?.query ?? '') : '';
+        if (!source || deps.getMode() === 'reading' || /[\r\n]/.test(typed))
+            return false;
+        const caret = caretLeaf();
+        if (!caret)
+            return false;
+        close();
+        const start = caret.offset;
+        const caretAfter = start + typed.length;
+        void (async () => {
+            writing = true;
+            try {
+                if (!(await deps.commitRange(caret.path, start, start, typed, caretAfter)))
+                    return;
+            }
+            catch (error) {
+                report(error, name);
+                return;
+            }
+            finally {
+                writing = false;
+                resnap();
+            }
+            if (disposed || !sources.has(name))
+                return;
+            begin(source, caret.path, start, caretAfter);
+        })();
+        return true;
+    }
+    const registry = {
+        addSource(source) {
+            if (disposed) {
+                throw new Error(`inlineMenus.addSource: this editor is gone, so source '${source.name}' would ` +
+                    `never open; add it from an onEditor callback and dispose it when that returns`);
+            }
+            if (sources.has(source.name)) {
+                throw new Error(`inlineMenus.addSource: a source named '${source.name}' already exists`);
+            }
+            if (source.trigger === '' || /[\r\n]/.test(source.trigger)) {
+                throw new Error(`inlineMenus.addSource: source '${source.name}' needs a trigger of one line that is ` +
+                    `not empty; an empty trigger would open on every keystroke`);
+            }
+            // Nothing read the leaf while no source was registered, so the baseline is from before
+            // whatever was typed since; the next event takes a fresh one.
+            if (sources.size === 0) {
+                seen = null;
+                heldBack = false;
+            }
+            sources.set(source.name, source);
+            return {
+                dispose: () => {
+                    if (sources.get(source.name) !== source)
+                        return;
+                    sources.delete(source.name);
+                    if (session?.source === source.name)
+                        close();
+                }
+            };
+        },
+        open,
+        close,
+        get isOpen() {
+            return session !== null && items.length > 0;
+        }
+    };
+    return {
+        registry,
+        listboxId,
+        optionId,
+        comboboxFor(path) {
+            if (session === null || items.length === 0)
+                return null;
+            if (sessionPathKey !== path.join())
+                return null;
+            return { listboxId, activeOptionId: optionId(items[activeIndex].id) };
+        },
+        getOpen() {
+            if (session === null)
+                return null;
+            const source = sources.get(session.source);
+            if (!source)
+                return null;
+            return {
+                source,
+                path: session.path,
+                start: session.start,
+                end,
+                query,
+                items,
+                activeIndex
+            };
+        },
+        move(delta) {
+            activeIndex = stepActive(activeIndex, delta, items.length);
+        },
+        setActive(index) {
+            if (index >= 0 && index < items.length)
+                activeIndex = index;
+        },
+        commit(index) {
+            // Enter can beat the last keystroke's read, and even its deferred edit event; read the
+            // leaf now so the pick replaces the query it holds, not the one last read.
+            evaluate();
+            const item = items[index ?? activeIndex];
+            if (!item)
+                return false;
+            void commitItem(item);
+            return true;
+        },
+        close,
+        primeBaseline,
+        dispose() {
+            disposed = true;
+            close();
+            sources.clear();
+            unsubscribeEdit();
+            unsubscribeSelection();
+            unsubscribeMode();
+        }
+    };
+}

package/dist/inline-menu/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Inline menus: a list the editor opens under the caret while the author types after a trigger,
+ * `#` for a tag or `[[` for a link. The editor owns what a host cannot do from outside without
+ * racing it: spotting the trigger as it is typed, holding the navigation keys while the list is
+ * up, and replacing the typed range with the pick as one undo entry. A source supplies the rest.
+ */
+import type { Component } from 'svelte';
+import type { MenuIconName } from '../menu-icons';
+export interface InlineMenuItem {
+    /** The row's key, unique within one result list. Where two rows share one, the first is kept
+     *  and the rest are dropped and reported on the `error` event. */
+    id: string;
+    label: string;
+    /** Secondary text painted dim beside the label: a path, a count. */
+    detail?: string;
+    /** A menu glyph drawn before the label by the default row. */
+    icon?: MenuIconName;
+    /** The bytes that replace the trigger and the query, the caret after them. One line: a line break
+     *  is refused and reported, and a block-level insert is `onCommit`'s job. Empty is legal. */
+    insert: string;
+}
+export interface InlineMenuQuery {
+    /** What the author typed after the trigger, up to the caret. */
+    query: string;
+    /** The leaf the session lives in. */
+    path: readonly number[];
+    /** The raw range a pick replaces: the trigger's first byte to the caret. */
+    start: number;
+    end: number;
+    /** Aborted once a later keystroke supersedes this read, or the menu closes. */
+    signal: AbortSignal;
+}
+export interface InlineMenuRowProps {
+    item: InlineMenuItem;
+    active: boolean;
+    query: string;
+}
+export interface InlineMenuSource {
+    /** Unique per editor; the name `open()` addresses. */
+    name: string;
+    /**
+     * The typed opener, one line and never empty; `addSource` throws otherwise. Where two sources'
+     * triggers both end at the caret, the longer wins.
+     */
+    trigger: string;
+    /** Whether a trigger whose first byte is `raw[pos]` opens (absent: anywhere), so a tag can
+     *  decline mid-word and `C#` stays text. `open()` never asks. */
+    opensAt?(raw: string, pos: number): boolean;
+    /** Whether the session outlives this query. Absent means any query without a line break. */
+    accepts?(query: string): boolean;
+    /** The list for a query. An empty list hides the menu and releases the keys but keeps the
+     *  session; a rejected promise reads as empty and is reported on the `error` event. */
+    items(query: InlineMenuQuery): InlineMenuItem[] | Promise<InlineMenuItem[]>;
+    /** Runs after the pick's bytes land, with the caret at `start + insert.length`. Writes made while
+     *  a returned promise is pending join the pick's undo entry, so await them. */
+    onCommit?(item: InlineMenuItem, query: Omit<InlineMenuQuery, 'signal'>): void | Promise<void>;
+    /** Paints one row's content in place of the default label and detail. */
+    row?: Component<InlineMenuRowProps>;
+}
+export interface InlineMenuSourceHandle {
+    dispose(): void;
+}
+export interface InlineMenuOpenOptions {
+    /** Typed after the trigger, so the list opens already narrowed. */
+    query?: string;
+}
+export interface InlineMenuRegistry {
+    addSource(source: InlineMenuSource): InlineMenuSourceHandle;
+    /** Types the source's trigger and `options.query` at the caret as one undo entry and opens the
+     *  menu. False, writing nothing, for an unknown name, reading mode, no prose caret, or a newline. */
+    open(name: string, options?: InlineMenuOpenOptions): boolean;
+    /** Close the open menu, leaving what was typed. */
+    close(): void;
+    /** True while a list is on screen, which is also while the editor holds the arrow keys, Enter,
+     *  Tab and Escape for it. Getter-backed, live. Change signal: the `menuChange` event. */
+    readonly isOpen: boolean;
+}

package/dist/inline-menu/types.js

@@ -0,0 +1,7 @@
+/**
+ * Inline menus: a list the editor opens under the caret while the author types after a trigger,
+ * `#` for a tag or `[[` for a link. The editor owns what a host cannot do from outside without
+ * racing it: spotting the trigger as it is typed, holding the navigation keys while the list is
+ * up, and replacing the typed range with the pick as one undo entry. A source supplies the rest.
+ */
+export {};

package/dist/invariants/child-id-parity.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A keyed container's `childIds` hold one id per child, at every depth: a container whose
+ * `children` outgrow its ids hands the keyed each block undefined keys, and the redraw after undo
+ * reconciles to something other than the tree. A container that never mounted has no `childIds`
+ * yet and passes, unless the caller seeded every container first and asks for `everyKeyed`.
+ */
+import type { NodeView } from '../core/node-views';
+import type { InvariantViolation } from '../assert';
+export interface ChildIdDrift {
+    /** Child indices from the checked node down to the container out of step. */
+    path: number[];
+    kind: string;
+    children: number;
+    ids: number | undefined;
+    /** The kinds from the checked node down, for a message a reader can follow. */
+    trail: string;
+}
+export interface ChildIdParityOptions {
+    everyKeyed?: boolean;
+}
+export declare function checkChildIdParity(node: NodeView, options?: ChildIdParityOptions): InvariantViolation | null;
+/** Every container under `node` (itself included) whose ids are out of step, in document order. */
+export declare function childIdDrifts(node: NodeView, options?: ChildIdParityOptions, limit?: number): ChildIdDrift[];