@wonderwhy-er/desktop-commander 0.2.37 → 0.2.39

package/dist/ui/file-preview/src/markdown/link-modal.d.ts

@@ -0,0 +1,13 @@
+import type { MarkdownLinkHeading, MarkdownLinkSearchItem } from './editor.js';
+export declare function renderLinkModalHtml(): string;
+export interface LinkModalHandle {
+    open(selectedText?: string): void;
+    close(): void;
+    destroy(): void;
+}
+export declare function attachLinkModal(options: {
+    root: HTMLElement;
+    searchLinks?: (query: string) => Promise<MarkdownLinkSearchItem[]>;
+    loadHeadings?: (filePath: string) => Promise<MarkdownLinkHeading[]>;
+    onInsert: (text: string) => void;
+}): LinkModalHandle;

package/dist/ui/file-preview/src/markdown/link-modal.js

@@ -0,0 +1,213 @@
+const SEARCH_DEBOUNCE_MS = 150;
+export function renderLinkModalHtml() {
+    return `
+      <div id="markdown-link-modal" class="markdown-link-modal" hidden>
+        <div class="markdown-link-modal-card">
+          <div class="markdown-link-mode-tabs">
+            <button type="button" id="markdown-link-mode-file" class="markdown-link-mode-tab is-active">File</button>
+            <button type="button" id="markdown-link-mode-url" class="markdown-link-mode-tab">URL</button>
+          </div>
+          <div id="markdown-link-file-fields">
+            <label class="markdown-link-modal-label" for="markdown-link-search">Find note</label>
+            <input id="markdown-link-search" class="markdown-link-modal-input" type="text" placeholder="Search files..." />
+            <div id="markdown-link-results" class="markdown-link-results"></div>
+            <label class="markdown-link-modal-label" for="markdown-link-heading">Heading</label>
+            <select id="markdown-link-heading" class="markdown-link-modal-input markdown-link-modal-select">
+              <option value="">None</option>
+            </select>
+            <label class="markdown-link-modal-label" for="markdown-link-alias">Alias</label>
+            <input id="markdown-link-alias" class="markdown-link-modal-input" type="text" placeholder="Optional label" />
+          </div>
+          <div id="markdown-link-url-fields" hidden>
+            <label class="markdown-link-modal-label" for="markdown-link-input">URL</label>
+            <input id="markdown-link-input" class="markdown-link-modal-input" type="url" placeholder="https://example.com" />
+            <label class="markdown-link-modal-label" for="markdown-link-label">Label</label>
+            <input id="markdown-link-label" class="markdown-link-modal-input" type="text" placeholder="Optional label" />
+          </div>
+          <div class="markdown-link-modal-actions">
+            <button type="button" id="markdown-link-cancel" class="markdown-link-modal-button">Cancel</button>
+            <button type="button" id="markdown-link-apply" class="markdown-link-modal-button markdown-link-modal-button--primary">Insert</button>
+          </div>
+        </div>
+      </div>
+    `;
+}
+export function attachLinkModal(options) {
+    const modalEl = options.root.querySelector('#markdown-link-modal');
+    if (!modalEl) {
+        return { open: () => undefined, close: () => undefined, destroy: () => undefined };
+    }
+    const modal = modalEl;
+    const tabFile = modal.querySelector('#markdown-link-mode-file');
+    const tabUrl = modal.querySelector('#markdown-link-mode-url');
+    const fileFields = modal.querySelector('#markdown-link-file-fields');
+    const urlFields = modal.querySelector('#markdown-link-url-fields');
+    const searchInput = modal.querySelector('#markdown-link-search');
+    const resultsEl = modal.querySelector('#markdown-link-results');
+    const headingSelect = modal.querySelector('#markdown-link-heading');
+    const aliasInput = modal.querySelector('#markdown-link-alias');
+    const urlInput = modal.querySelector('#markdown-link-input');
+    const labelInput = modal.querySelector('#markdown-link-label');
+    const applyBtn = modal.querySelector('#markdown-link-apply');
+    const cancelBtn = modal.querySelector('#markdown-link-cancel');
+    let mode = 'file';
+    let selectedItem = null;
+    let searchRequestId = 0;
+    let headingRequestId = 0;
+    let searchDebounce = null;
+    function setMode(next) {
+        mode = next;
+        tabFile.classList.toggle('is-active', mode === 'file');
+        tabUrl.classList.toggle('is-active', mode === 'url');
+        fileFields.hidden = mode !== 'file';
+        urlFields.hidden = mode !== 'url';
+    }
+    function renderResults(items, message) {
+        if (items.length === 0) {
+            resultsEl.innerHTML = `<div class="markdown-link-result markdown-link-result--empty">${message ?? 'No results'}</div>`;
+            return;
+        }
+        resultsEl.innerHTML = items.map((item, idx) => `
+          <button type="button" class="markdown-link-result${selectedItem?.path === item.path ? ' is-selected' : ''}" data-idx="${idx}">
+            <span class="markdown-link-result-title">${escapeHtml(item.title)}</span>
+            <span class="markdown-link-result-path">${escapeHtml(item.relativePath)}</span>
+          </button>
+        `).join('');
+        Array.from(resultsEl.querySelectorAll('[data-idx]')).forEach((btn) => {
+            btn.addEventListener('click', async () => {
+                const idx = Number(btn.dataset.idx);
+                selectedItem = items[idx] ?? null;
+                Array.from(resultsEl.querySelectorAll('.markdown-link-result')).forEach((el) => {
+                    el.classList.toggle('is-selected', el === btn);
+                });
+                await loadHeadingsFor(selectedItem);
+            });
+        });
+    }
+    async function loadHeadingsFor(item) {
+        headingSelect.innerHTML = '<option value="">None</option>';
+        if (!item || !options.loadHeadings)
+            return;
+        const myRequest = ++headingRequestId;
+        try {
+            const headings = await options.loadHeadings(item.path);
+            if (myRequest !== headingRequestId)
+                return;
+            for (const heading of headings) {
+                const option = document.createElement('option');
+                option.value = heading.id;
+                option.textContent = heading.text;
+                headingSelect.appendChild(option);
+            }
+        }
+        catch {
+            // ignore — heading load failures shouldn't block insertion
+        }
+    }
+    async function runSearch(query) {
+        if (!options.searchLinks) {
+            renderResults([], 'Search unavailable');
+            return;
+        }
+        const myRequest = ++searchRequestId;
+        try {
+            const items = await options.searchLinks(query);
+            if (myRequest !== searchRequestId)
+                return;
+            renderResults(items, query ? 'No files match' : 'Start typing to search');
+        }
+        catch (err) {
+            if (myRequest !== searchRequestId)
+                return;
+            renderResults([], `Search failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    function apply() {
+        if (mode === 'url') {
+            const url = urlInput.value.trim();
+            if (!url)
+                return;
+            const label = labelInput.value.trim();
+            options.onInsert(label ? `[${label}](${url})` : `<${url}>`);
+        }
+        else {
+            if (!selectedItem)
+                return;
+            const heading = headingSelect.value.trim();
+            const alias = aliasInput.value.trim();
+            let text = `[[${selectedItem.wikiPath}`;
+            if (heading)
+                text += `#${heading}`;
+            if (alias)
+                text += `|${alias}`;
+            text += ']]';
+            options.onInsert(text);
+        }
+        close();
+    }
+    function reset() {
+        setMode('file');
+        selectedItem = null;
+        searchInput.value = '';
+        aliasInput.value = '';
+        urlInput.value = '';
+        labelInput.value = '';
+        headingSelect.innerHTML = '<option value="">None</option>';
+        renderResults([], 'Start typing to search');
+    }
+    function open(selectedText) {
+        reset();
+        if (selectedText && /^https?:\/\//i.test(selectedText)) {
+            setMode('url');
+            urlInput.value = selectedText;
+        }
+        else if (selectedText) {
+            aliasInput.value = selectedText;
+            labelInput.value = selectedText;
+        }
+        modal.hidden = false;
+        (mode === 'file' ? searchInput : urlInput).focus();
+    }
+    function close() {
+        modal.hidden = true;
+    }
+    const onSearchInput = () => {
+        if (searchDebounce)
+            clearTimeout(searchDebounce);
+        searchDebounce = setTimeout(() => {
+            void runSearch(searchInput.value);
+        }, SEARCH_DEBOUNCE_MS);
+    };
+    const onKeyDown = (event) => {
+        if (event.key === 'Escape') {
+            event.preventDefault();
+            close();
+        }
+        else if (event.key === 'Enter' && !event.shiftKey) {
+            event.preventDefault();
+            apply();
+        }
+    };
+    tabFile.addEventListener('click', () => setMode('file'));
+    tabUrl.addEventListener('click', () => setMode('url'));
+    searchInput.addEventListener('input', onSearchInput);
+    applyBtn.addEventListener('click', apply);
+    cancelBtn.addEventListener('click', close);
+    modal.addEventListener('keydown', onKeyDown);
+    return {
+        open,
+        close,
+        destroy: () => {
+            if (searchDebounce)
+                clearTimeout(searchDebounce);
+            close();
+        },
+    };
+}
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}

package/dist/ui/file-preview/src/markdown/linking.d.ts

@@ -0,0 +1,16 @@
+export interface ResolvedMarkdownLink {
+    kind: 'external' | 'anchor' | 'file';
+    href: string;
+    url?: string;
+    targetPath?: string;
+    anchor?: string;
+}
+/**
+ * Invert `rewriteWikiLinks`: convert `[alias](href "mcp-wiki:ENCODED")` links
+ * back to their original `[[...]]` form. Used when serializing a WYSIWYG
+ * edit session back to markdown — the `mcp-wiki:` title prefix is the
+ * round-trip marker written by `rewriteWikiLinks`.
+ */
+export declare function restoreWikiLinks(markdown: string): string;
+export declare function rewriteWikiLinks(source: string): string;
+export declare function resolveMarkdownLink(currentPath: string, rawHref: string): ResolvedMarkdownLink;

package/dist/ui/file-preview/src/markdown/linking.js

@@ -0,0 +1,228 @@
+import { slugifyMarkdownHeading } from './slugify.js';
+import { getParentDirectory, isWindowsAbsolutePath, normalizeFilePath, normalizePathSeparators } from '../path-utils.js';
+const WIKI_LINK_PATTERN = /\[\[([^\]|#]*)(?:#([^\]|]+))?(?:\|([^\]]+))?\]\]/g;
+const FENCE_PATTERN = /^(`{3,}|~{3,})/;
+function encodeLinkPath(pathValue) {
+    return encodeURI(normalizePathSeparators(pathValue));
+}
+function safeDecodeURIComponent(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function parseWikiLink(rawHref) {
+    const match = rawHref.match(/^\[\[([^\]|#]*)(?:#([^\]|]+))?(?:\|([^\]]+))?\]\]$/);
+    if (!match) {
+        return null;
+    }
+    return {
+        path: (match[1] ?? '').trim(),
+        anchor: match[2]?.trim(),
+        alias: match[3]?.trim(),
+    };
+}
+function buildWikiDisplayText(link) {
+    if (link.alias && link.alias.length > 0) {
+        return link.alias;
+    }
+    if (link.path && link.anchor) {
+        return `${link.path}#${link.anchor}`;
+    }
+    if (link.path) {
+        return link.path;
+    }
+    return link.anchor ?? '';
+}
+function appendMarkdownExtension(pathValue) {
+    if (/\.[A-Za-z0-9_-]+$/.test(pathValue)) {
+        return pathValue;
+    }
+    return `${pathValue}.md`;
+}
+function buildWikiHref(link) {
+    if (!link.path) {
+        if (!link.anchor) {
+            return '#';
+        }
+        return `#${slugifyMarkdownHeading(link.anchor)}`;
+    }
+    const normalizedPath = appendMarkdownExtension(normalizePathSeparators(link.path));
+    const prefixedPath = normalizedPath.startsWith('./')
+        || normalizedPath.startsWith('../')
+        || normalizedPath.startsWith('/')
+        || isWindowsAbsolutePath(normalizedPath)
+        ? normalizedPath
+        : `./${normalizedPath}`;
+    const encodedPath = encodeLinkPath(prefixedPath);
+    if (!link.anchor) {
+        return encodedPath;
+    }
+    return `${encodedPath}#${slugifyMarkdownHeading(link.anchor)}`;
+}
+function rewriteWikiLinksInPlainText(segment) {
+    return segment.replace(WIKI_LINK_PATTERN, (match) => {
+        const parsed = parseWikiLink(match);
+        if (!parsed) {
+            return match;
+        }
+        const displayText = buildWikiDisplayText(parsed);
+        const href = buildWikiHref(parsed);
+        return `[${displayText}](${href} "mcp-wiki:${encodeURIComponent(match)}")`;
+    });
+}
+function replaceWikiLinksOutsideInlineCode(line) {
+    let result = '';
+    let cursor = 0;
+    while (cursor < line.length) {
+        const codeStart = line.indexOf('`', cursor);
+        if (codeStart === -1) {
+            result += rewriteWikiLinksInPlainText(line.slice(cursor));
+            break;
+        }
+        result += rewriteWikiLinksInPlainText(line.slice(cursor, codeStart));
+        let delimiterEnd = codeStart;
+        while (delimiterEnd < line.length && line[delimiterEnd] === '`') {
+            delimiterEnd += 1;
+        }
+        const delimiter = line.slice(codeStart, delimiterEnd);
+        const codeEnd = line.indexOf(delimiter, delimiterEnd);
+        if (codeEnd === -1) {
+            result += line.slice(codeStart);
+            break;
+        }
+        result += line.slice(codeStart, codeEnd + delimiter.length);
+        cursor = codeEnd + delimiter.length;
+    }
+    return result;
+}
+function decodeAnchorFragment(fragment) {
+    if (!fragment || fragment.length === 0) {
+        return undefined;
+    }
+    return safeDecodeURIComponent(fragment);
+}
+function splitHref(rawHref) {
+    const hashIndex = rawHref.indexOf('#');
+    if (hashIndex === -1) {
+        return { pathPart: rawHref };
+    }
+    return {
+        pathPart: rawHref.slice(0, hashIndex),
+        anchorPart: rawHref.slice(hashIndex + 1),
+    };
+}
+function toDirectoryFileUrl(directoryPath) {
+    const normalized = normalizeFilePath(directoryPath);
+    const withTrailingSlash = normalized.endsWith('/') ? normalized : `${normalized}/`;
+    if (isWindowsAbsolutePath(withTrailingSlash)) {
+        return new URL(`file:///${encodeLinkPath(withTrailingSlash)}`);
+    }
+    if (withTrailingSlash.startsWith('/')) {
+        return new URL(`file://${encodeLinkPath(withTrailingSlash)}`);
+    }
+    return new URL(`file:///${encodeLinkPath(withTrailingSlash)}`);
+}
+function fromFileUrl(url) {
+    const decodedPath = safeDecodeURIComponent(url.pathname);
+    if (/^\/[A-Za-z]:\//.test(decodedPath)) {
+        return decodedPath.slice(1);
+    }
+    return decodedPath;
+}
+function isExternalHref(rawHref) {
+    return /^[A-Za-z][A-Za-z0-9+.-]*:/.test(rawHref) && !isWindowsAbsolutePath(rawHref);
+}
+function resolveFileTargetPath(currentPath, rawPath) {
+    const normalizedRawPath = normalizePathSeparators(safeDecodeURIComponent(rawPath));
+    if (normalizedRawPath.startsWith('/') || isWindowsAbsolutePath(normalizedRawPath)) {
+        return normalizeFilePath(normalizedRawPath);
+    }
+    const baseDirectory = getParentDirectory(currentPath);
+    if (baseDirectory === '.' && !normalizeFilePath(currentPath).includes('/')) {
+        return normalizeFilePath(normalizedRawPath);
+    }
+    const resolvedUrl = new URL(encodeURI(normalizedRawPath), toDirectoryFileUrl(baseDirectory));
+    return normalizeFilePath(fromFileUrl(resolvedUrl));
+}
+/**
+ * Invert `rewriteWikiLinks`: convert `[alias](href "mcp-wiki:ENCODED")` links
+ * back to their original `[[...]]` form. Used when serializing a WYSIWYG
+ * edit session back to markdown — the `mcp-wiki:` title prefix is the
+ * round-trip marker written by `rewriteWikiLinks`.
+ */
+export function restoreWikiLinks(markdown) {
+    return markdown.replace(/\[([^\]]*)\]\(([^)\s]*)(?:\s+"mcp-wiki:([^"]+)")\)/g, (_, _alias, _href, encoded) => {
+        try {
+            return decodeURIComponent(encoded);
+        }
+        catch {
+            return `[[${encoded}]]`;
+        }
+    });
+}
+export function rewriteWikiLinks(source) {
+    const lines = source.split('\n');
+    let activeFence = null;
+    return lines.map((line) => {
+        const trimmedStart = line.trimStart();
+        const fenceMatch = trimmedStart.match(FENCE_PATTERN);
+        if (fenceMatch) {
+            const marker = fenceMatch[1];
+            if (!activeFence) {
+                activeFence = marker;
+            }
+            else if (marker[0] === activeFence[0] && marker.length >= activeFence.length) {
+                activeFence = null;
+            }
+            return line;
+        }
+        if (activeFence) {
+            return line;
+        }
+        return replaceWikiLinksOutsideInlineCode(line);
+    }).join('\n');
+}
+export function resolveMarkdownLink(currentPath, rawHref) {
+    const wikiLink = parseWikiLink(rawHref);
+    if (wikiLink) {
+        const href = buildWikiHref(wikiLink);
+        if (href.startsWith('#')) {
+            return {
+                kind: 'anchor',
+                href: rawHref,
+                anchor: decodeAnchorFragment(href.slice(1)),
+            };
+        }
+        const [pathPart, anchorPart] = href.split('#');
+        return {
+            kind: 'file',
+            href: rawHref,
+            targetPath: resolveFileTargetPath(currentPath, pathPart),
+            ...(anchorPart ? { anchor: decodeAnchorFragment(anchorPart) } : {}),
+        };
+    }
+    if (isExternalHref(rawHref)) {
+        return {
+            kind: 'external',
+            href: rawHref,
+            url: rawHref,
+        };
+    }
+    if (rawHref.startsWith('#')) {
+        return {
+            kind: 'anchor',
+            href: rawHref,
+            anchor: decodeAnchorFragment(rawHref.slice(1)),
+        };
+    }
+    const { pathPart, anchorPart } = splitHref(rawHref);
+    return {
+        kind: 'file',
+        href: rawHref,
+        targetPath: resolveFileTargetPath(currentPath, pathPart),
+        ...(anchorPart ? { anchor: decodeAnchorFragment(anchorPart) } : {}),
+    };
+}

package/dist/ui/file-preview/src/markdown/outline.d.ts

@@ -0,0 +1,2 @@
+import type { DocumentOutlineItem } from '../document-outline.js';
+export declare function extractMarkdownOutline(source: string): DocumentOutlineItem[];

package/dist/ui/file-preview/src/markdown/outline.js

@@ -0,0 +1,16 @@
+import { createMarkdownIt, prepareMarkdownSource, readHeadingProjection } from './parser.js';
+import { createSlugTracker } from './slugify.js';
+const outlineParser = createMarkdownIt();
+export function extractMarkdownOutline(source) {
+    const tokens = outlineParser.parse(prepareMarkdownSource(source), {});
+    const nextSlug = createSlugTracker();
+    const outline = [];
+    for (let index = 0; index < tokens.length; index += 1) {
+        const heading = readHeadingProjection(tokens, index, nextSlug);
+        if (!heading) {
+            continue;
+        }
+        outline.push(heading);
+    }
+    return outline;
+}

package/dist/ui/file-preview/src/markdown/parser.d.ts

@@ -0,0 +1,30 @@
+import type { MarkdownSlugTracker } from './slugify.js';
+export interface MarkdownToken {
+    type?: string;
+    tag?: string;
+    map?: number[];
+    children?: unknown;
+    content?: unknown;
+    attrSet?: (name: string, value: string) => void;
+    attrGet?: (name: string) => string | null;
+    attrs?: Array<[string, string]>;
+}
+interface MarkdownItInstance {
+    render: (source: string, env?: Record<string, unknown>) => string;
+    parse: (source: string, env?: Record<string, unknown>) => MarkdownToken[];
+    renderer: {
+        rules: Record<string, (...args: unknown[]) => string>;
+    };
+}
+export interface MarkdownHeadingProjection {
+    id: string;
+    text: string;
+    level: number;
+    line: number;
+}
+export declare function createMarkdownIt(options?: {
+    highlight?: (code: string, language: string) => string;
+}): MarkdownItInstance;
+export declare function prepareMarkdownSource(source: string): string;
+export declare function readHeadingProjection(tokens: MarkdownToken[], index: number, nextSlug: MarkdownSlugTracker): MarkdownHeadingProjection | null;
+export {};

package/dist/ui/file-preview/src/markdown/parser.js

@@ -0,0 +1,38 @@
+// markdown-it is intentionally typed locally here to avoid maintaining ambient module declarations.
+import MarkdownIt from 'markdown-it';
+import { rewriteWikiLinks } from './linking.js';
+import { extractInlineText } from './utils.js';
+const MarkdownItCtor = MarkdownIt;
+export function createMarkdownIt(options = {}) {
+    return new MarkdownItCtor({
+        html: false,
+        linkify: true,
+        typographer: false,
+        ...(options.highlight ? { highlight: options.highlight } : {}),
+    });
+}
+export function prepareMarkdownSource(source) {
+    return rewriteWikiLinks(source);
+}
+export function readHeadingProjection(tokens, index, nextSlug) {
+    const token = tokens[index];
+    if (token?.type !== 'heading_open' || typeof token.tag !== 'string') {
+        return null;
+    }
+    const level = Number.parseInt(token.tag.replace(/^h/i, ''), 10);
+    if (!Number.isFinite(level)) {
+        return null;
+    }
+    const inlineToken = tokens[index + 1];
+    const text = extractInlineText(inlineToken).trim();
+    if (!text) {
+        return null;
+    }
+    const lineMap = Array.isArray(token.map) ? token.map : undefined;
+    return {
+        id: nextSlug(text),
+        text,
+        level,
+        line: typeof lineMap?.[0] === 'number' ? lineMap[0] + 1 : index + 1,
+    };
+}

package/dist/ui/file-preview/src/markdown/preview.d.ts

@@ -0,0 +1 @@
+export declare function getRenderedMarkdownCopyText(content: string): string;

package/dist/ui/file-preview/src/markdown/preview.js

@@ -0,0 +1,20 @@
+import { renderMarkdown } from '../components/markdown-renderer.js';
+export function getRenderedMarkdownCopyText(content) {
+    const html = renderMarkdown(content);
+    const normalizedHtml = html
+        .replace(/<\s*br\s*\/?>/gi, '\n')
+        .replace(/<\/p>/gi, '\n\n')
+        .replace(/<\/h[1-6]>/gi, '\n\n')
+        .replace(/<\/li>/gi, '\n')
+        .replace(/<li>/gi, '- ')
+        .replace(/<[^>]+>/g, '');
+    return normalizedHtml
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&#39;/g, "'")
+        .replace(/&quot;/g, '"')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}

package/dist/ui/file-preview/src/markdown/raw-editor.d.ts

@@ -0,0 +1,8 @@
+import type { MarkdownEditorHandle } from './editor.js';
+export declare function mountCodeMirrorRaw(options: {
+    target: HTMLElement;
+    value: string;
+    initialScrollTop?: number;
+    onChange: (value: string) => void;
+    onBlur?: () => void;
+}): MarkdownEditorHandle;

package/dist/ui/file-preview/src/markdown/raw-editor.js

@@ -0,0 +1,61 @@
+import { defaultKeymap, history, historyKeymap } from '@codemirror/commands';
+import { markdown } from '@codemirror/lang-markdown';
+import { defaultHighlightStyle, syntaxHighlighting } from '@codemirror/language';
+import { EditorState } from '@codemirror/state';
+import { oneDark } from '@codemirror/theme-one-dark';
+import { EditorView, keymap, lineNumbers } from '@codemirror/view';
+export function mountCodeMirrorRaw(options) {
+    const state = EditorState.create({
+        doc: options.value,
+        extensions: [
+            lineNumbers(),
+            history(),
+            markdown(),
+            oneDark,
+            syntaxHighlighting(defaultHighlightStyle, { fallback: true }),
+            keymap.of([...defaultKeymap, ...historyKeymap]),
+            EditorView.lineWrapping,
+            EditorView.updateListener.of((update) => {
+                if (update.docChanged) {
+                    options.onChange(update.state.doc.toString());
+                }
+            }),
+            EditorView.domEventHandlers({
+                blur: () => {
+                    options.onBlur?.();
+                    return false;
+                },
+            }),
+        ],
+    });
+    const view = new EditorView({ state, parent: options.target });
+    if (typeof options.initialScrollTop === 'number') {
+        view.scrollDOM.scrollTop = options.initialScrollTop;
+    }
+    return {
+        destroy: () => view.destroy(),
+        focus: () => view.focus(),
+        getValue: () => view.state.doc.toString(),
+        setValue: (value) => {
+            const current = view.state.doc.toString();
+            if (current === value)
+                return;
+            view.dispatch({
+                changes: { from: 0, to: view.state.doc.length, insert: value },
+            });
+        },
+        revealLine: (lineNumber) => {
+            const total = view.state.doc.lines;
+            const clamped = Math.max(1, Math.min(lineNumber, total));
+            const line = view.state.doc.line(clamped);
+            view.dispatch({
+                selection: { anchor: line.from },
+                scrollIntoView: true,
+            });
+            view.focus();
+        },
+        setScrollTop: (scrollTop) => {
+            view.scrollDOM.scrollTop = scrollTop;
+        },
+    };
+}

package/dist/ui/file-preview/src/markdown/selection-toolbar.d.ts

@@ -0,0 +1,14 @@
+export interface SelectionToolbarHandle {
+    destroy(): void;
+}
+export interface SelectionToolbarOptions {
+    editorRoot: HTMLElement;
+    onLinkRequest?: (selectedText: string) => void;
+}
+/**
+ * Floating selection toolbar that appears above non-empty text selections
+ * inside the editor root. Uses `document.execCommand` for formatting so it
+ * works uniformly with ProseMirror (which intercepts beforeinput) and plain
+ * contenteditable.
+ */
+export declare function attachSelectionToolbar(options: SelectionToolbarOptions): SelectionToolbarHandle;