@wonderwhy-er/desktop-commander 0.2.38 → 0.2.40

package/dist/ui/file-preview/src/file-type-handlers.js

@@ -0,0 +1,98 @@
+import { formatJsonIfPossible, inferLanguageFromPath, renderCodeViewer } from './components/code-viewer.js';
+import { escapeHtml } from './components/highlighting.js';
+import { renderHtmlPreview } from './components/html-renderer.js';
+import { renderDirectoryBody } from './directory-controller.js';
+import { stripReadStatusLine } from './document-workspace.js';
+import { isAllowedImageMimeType, normalizeImageMimeType } from './image-preview.js';
+import { isLikelyUrl } from './payload-utils.js';
+function renderRawFallback(source) {
+    return `<pre class="code-viewer"><code class="hljs language-text">${escapeHtml(source)}</code></pre>`;
+}
+function renderImageBody(payload) {
+    const mimeType = normalizeImageMimeType(payload.mimeType);
+    if (!isAllowedImageMimeType(mimeType)) {
+        return {
+            notice: 'Preview is unavailable for this image format.',
+            html: '<div class="panel-content source-content"></div>',
+        };
+    }
+    if (!payload.imageData || payload.imageData.trim().length === 0) {
+        return {
+            notice: 'Preview is unavailable because image data is missing.',
+            html: '<div class="panel-content source-content"></div>',
+        };
+    }
+    const src = `data:${mimeType};base64,${payload.imageData}`;
+    return {
+        html: `<div class="panel-content image-content"><div class="image-preview"><img src="${escapeHtml(src)}" alt="${escapeHtml(payload.fileName)}" loading="eager" decoding="async"></div></div>`,
+    };
+}
+function buildPreviewCapabilities(payload, canCopy) {
+    return {
+        supportsPreview: true,
+        canCopy,
+        canOpenInFolder: !isLikelyUrl(payload.filePath),
+    };
+}
+const handlerRegistry = {
+    directory: {
+        getCapabilities: (payload) => buildPreviewCapabilities(payload, false),
+        renderBody: ({ payload }) => renderDirectoryBody(stripReadStatusLine(payload.content), payload.filePath),
+    },
+    html: {
+        getCapabilities: (payload) => buildPreviewCapabilities(payload, true),
+        renderBody: ({ payload, htmlMode }) => renderHtmlPreview(stripReadStatusLine(payload.content), htmlMode),
+    },
+    image: {
+        getCapabilities: (payload) => buildPreviewCapabilities(payload, false),
+        renderBody: ({ payload }) => renderImageBody(payload),
+    },
+    markdown: {
+        getCapabilities: (payload) => buildPreviewCapabilities(payload, false),
+        renderBody: ({ payload, markdownController }) => {
+            try {
+                return markdownController.buildBody(payload);
+            }
+            catch {
+                return {
+                    notice: 'Markdown renderer failed. Showing raw source instead.',
+                    html: `<div class="panel-content source-content">${renderRawFallback(stripReadStatusLine(payload.content))}</div>`,
+                };
+            }
+        },
+    },
+    text: {
+        getCapabilities: (payload) => buildPreviewCapabilities(payload, true),
+        renderBody: ({ payload, startLine }) => {
+            const cleanedContent = stripReadStatusLine(payload.content);
+            const detectedLanguage = inferLanguageFromPath(payload.filePath);
+            const formatted = formatJsonIfPossible(cleanedContent, payload.filePath);
+            return {
+                notice: formatted.notice,
+                html: `<div class="panel-content source-content">${renderCodeViewer(formatted.content, detectedLanguage, startLine)}</div>`,
+            };
+        },
+    },
+    unsupported: {
+        getCapabilities: () => ({
+            supportsPreview: false,
+            canCopy: false,
+            canOpenInFolder: true,
+        }),
+        renderBody: () => ({
+            notice: 'Preview is not available for this file type.',
+            html: '<div class="panel-content source-content"></div>',
+        }),
+    },
+};
+export function getFileTypeCapabilities(payload) {
+    return handlerRegistry[payload.fileType]?.getCapabilities(payload) ?? {
+        supportsPreview: false,
+        canCopy: false,
+        canOpenInFolder: !isLikelyUrl(payload.filePath),
+    };
+}
+export function renderPayloadBody(options) {
+    const handler = handlerRegistry[options.payload.fileType] ?? handlerRegistry.text;
+    return handler.renderBody(options);
+}

package/dist/ui/file-preview/src/host/external-actions.d.ts

@@ -0,0 +1,19 @@
+export declare function shellQuote(value: string): string;
+export declare function encodePowerShellCommand(script: string): string;
+export declare function buildOpenInFolderCommand(filePath: string, isLikelyUrl: (filePath: string) => boolean): string | undefined;
+export declare function buildOpenInEditorCommand(filePath: string, isLikelyUrl: (filePath: string) => boolean, editorAppCache: Map<string, {
+    appName: string;
+    appPath?: string;
+}>): string | undefined;
+export declare function detectDefaultMarkdownEditor(options: {
+    filePath: string;
+    editorAppCache: Map<string, {
+        appName: string;
+        appPath?: string;
+    }>;
+    editorAppPending: Set<string>;
+    callTool?: (name: string, args: Record<string, unknown>) => Promise<unknown | undefined>;
+    extractToolText: (value: unknown) => string | undefined;
+    onDetected?: () => void;
+}): Promise<void>;
+export declare function renderMarkdownEditorAppIcon(): string;

package/dist/ui/file-preview/src/host/external-actions.js

@@ -0,0 +1,94 @@
+import { getParentDirectory } from '../path-utils.js';
+export function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+export function encodePowerShellCommand(script) {
+    const utf16leBytes = [];
+    for (let index = 0; index < script.length; index += 1) {
+        const codeUnit = script.charCodeAt(index);
+        utf16leBytes.push(codeUnit & 0xff, codeUnit >> 8);
+    }
+    let binary = '';
+    for (const byte of utf16leBytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary);
+}
+export function buildOpenInFolderCommand(filePath, isLikelyUrl) {
+    const trimmedPath = filePath.trim();
+    if (!trimmedPath || isLikelyUrl(trimmedPath)) {
+        return undefined;
+    }
+    const userAgent = navigator.userAgent.toLowerCase();
+    if (userAgent.includes('win')) {
+        const escapedForPowerShell = trimmedPath.replace(/'/g, "''");
+        const script = `Start-Process -FilePath explorer.exe -ArgumentList @('/select,','${escapedForPowerShell}')`;
+        return `powershell.exe -NoProfile -NonInteractive -EncodedCommand ${encodePowerShellCommand(script)}`;
+    }
+    if (userAgent.includes('mac')) {
+        return `open -R ${shellQuote(trimmedPath)}`;
+    }
+    return `xdg-open ${shellQuote(getParentDirectory(trimmedPath))}`;
+}
+export function buildOpenInEditorCommand(filePath, isLikelyUrl, editorAppCache) {
+    const trimmedPath = filePath.trim();
+    if (!trimmedPath || isLikelyUrl(trimmedPath)) {
+        return undefined;
+    }
+    const cachedApp = editorAppCache.get(trimmedPath);
+    if (cachedApp?.appPath && navigator.userAgent.toLowerCase().includes('mac')) {
+        return `open -a ${shellQuote(cachedApp.appPath)} ${shellQuote(trimmedPath)}`;
+    }
+    const userAgent = navigator.userAgent.toLowerCase();
+    if (userAgent.includes('win')) {
+        const escapedForPowerShell = trimmedPath.replace(/'/g, "''");
+        const script = `Start-Process -FilePath '${escapedForPowerShell}'`;
+        return `powershell.exe -NoProfile -NonInteractive -EncodedCommand ${encodePowerShellCommand(script)}`;
+    }
+    if (userAgent.includes('mac')) {
+        return `open ${shellQuote(trimmedPath)}`;
+    }
+    return `xdg-open ${shellQuote(trimmedPath)}`;
+}
+export async function detectDefaultMarkdownEditor(options) {
+    const trimmedPath = options.filePath.trim();
+    if (!trimmedPath || options.editorAppCache.has(trimmedPath) || options.editorAppPending.has(trimmedPath)) {
+        return;
+    }
+    const userAgent = navigator.userAgent.toLowerCase();
+    if (!userAgent.includes('mac')) {
+        return;
+    }
+    options.editorAppPending.add(trimmedPath);
+    try {
+        const detectCommand = `osascript -e ${shellQuote(`set appAlias to default application of (info for POSIX file "${trimmedPath.replace(/"/g, '\\"')}")
+return (name of (info for appAlias)) & linefeed & POSIX path of appAlias`)}`;
+        const detectResult = await options.callTool?.('start_process', {
+            command: detectCommand,
+            timeout_ms: 12000,
+        });
+        const text = options.extractToolText(detectResult) ?? '';
+        if (!text || text.toLowerCase().includes('error') || text.toLowerCase().includes('execution')) {
+            return;
+        }
+        const lines = text.split('\n').map((line) => line.trim()).filter(Boolean);
+        const appName = lines[lines.length - 2]?.replace(/\.app$/i, '') ?? '';
+        const appPath = lines[lines.length - 1] ?? '';
+        if (appName && appPath.startsWith('/')) {
+            options.editorAppCache.set(trimmedPath, {
+                appName,
+                appPath,
+            });
+            options.onDetected?.();
+        }
+    }
+    catch {
+        // Fall back to generic editor label.
+    }
+    finally {
+        options.editorAppPending.delete(trimmedPath);
+    }
+}
+export function renderMarkdownEditorAppIcon() {
+    return '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M12 20h9"/><path d="M16.5 3.5a2.1 2.1 0 1 1 3 3L7 19l-4 1 1-4Z"/></svg>';
+}

package/dist/ui/file-preview/src/host/selection-context.d.ts

@@ -0,0 +1,9 @@
+import type { RenderPayload } from '../model.js';
+export declare function attachSelectionContext(options: {
+    payload: RenderPayload;
+    isMarkdownEditing: boolean;
+    updateContext?: (text: string) => void;
+    trackUiEvent?: (event: string, params?: Record<string, unknown>) => void;
+    getFileExtensionForAnalytics: (filePath: string) => string;
+    previousAbortController: AbortController | null;
+}): AbortController | null;

package/dist/ui/file-preview/src/host/selection-context.js

@@ -0,0 +1,106 @@
+export function attachSelectionContext(options) {
+    if (options.isMarkdownEditing) {
+        if (options.previousAbortController) {
+            options.previousAbortController.abort();
+        }
+        return null;
+    }
+    const contentWrapper = document.querySelector('.panel-content-wrapper');
+    if (!contentWrapper) {
+        return options.previousAbortController;
+    }
+    const wrapper = contentWrapper;
+    options.previousAbortController?.abort();
+    const abortController = new AbortController();
+    let hintEl = null;
+    let lastSelectedText = '';
+    let hideTimer = null;
+    function positionHint(selection) {
+        if (!hintEl)
+            return;
+        const range = selection.getRangeAt(0);
+        const rect = range.getBoundingClientRect();
+        const wrapperRect = wrapper.getBoundingClientRect();
+        let left = rect.left + rect.width / 2 - wrapperRect.left;
+        let top = rect.top - wrapperRect.top + wrapper.scrollTop - 32;
+        const hintWidth = hintEl.offsetWidth || 200;
+        left = Math.max(8, Math.min(left - hintWidth / 2, wrapper.clientWidth - hintWidth - 8));
+        top = Math.max(4, top);
+        hintEl.style.left = `${left}px`;
+        hintEl.style.top = `${top}px`;
+    }
+    function showHint(selection) {
+        if (hideTimer) {
+            clearTimeout(hideTimer);
+            hideTimer = null;
+        }
+        if (!hintEl) {
+            hintEl = document.createElement('div');
+            hintEl.className = 'selection-hint';
+            hintEl.textContent = 'AI can see your selection';
+            wrapper.appendChild(hintEl);
+        }
+        hintEl.classList.add('visible');
+        positionHint(selection);
+    }
+    function hideHint() {
+        if (!hintEl)
+            return;
+        hintEl.classList.remove('visible');
+        hideTimer = setTimeout(() => {
+            hintEl?.remove();
+            hintEl = null;
+        }, 200);
+    }
+    function getLineInfo(selection) {
+        const anchorRow = selection.anchorNode?.parentElement?.closest('.code-line');
+        const focusRow = selection.focusNode?.parentElement?.closest('.code-line');
+        if (anchorRow && focusRow) {
+            const anchorLine = parseInt(anchorRow.dataset.line ?? '', 10);
+            const focusLine = parseInt(focusRow.dataset.line ?? '', 10);
+            if (!isNaN(anchorLine) && !isNaN(focusLine)) {
+                const low = Math.min(anchorLine, focusLine);
+                const high = Math.max(anchorLine, focusLine);
+                return low === high ? `line ${low}` : `lines ${low}–${high}`;
+            }
+        }
+        return '';
+    }
+    document.addEventListener('selectionchange', () => {
+        const selection = document.getSelection();
+        if (!selection || selection.isCollapsed) {
+            if (lastSelectedText) {
+                lastSelectedText = '';
+                options.updateContext?.('');
+                hideHint();
+            }
+            return;
+        }
+        const text = selection.toString().trim();
+        if (!text || text === lastSelectedText) {
+            return;
+        }
+        const anchorInContent = wrapper.contains(selection.anchorNode);
+        const focusInContent = wrapper.contains(selection.focusNode);
+        if (!anchorInContent && !focusInContent) {
+            if (lastSelectedText) {
+                lastSelectedText = '';
+                options.updateContext?.('');
+                hideHint();
+            }
+            return;
+        }
+        lastSelectedText = text;
+        const lineInfo = getLineInfo(selection);
+        const locationPart = lineInfo ? ` (${lineInfo})` : '';
+        const context = `User selected text from file ${options.payload.filePath}${locationPart}:\n\`\`\`\n${text}\n\`\`\``;
+        options.updateContext?.(context);
+        showHint(selection);
+        options.trackUiEvent?.('text_selected', {
+            file_type: options.payload.fileType,
+            file_extension: options.getFileExtensionForAnalytics(options.payload.filePath),
+            char_count: text.length,
+        });
+    }, { signal: abortController.signal });
+    return abortController;
+}

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

@@ -0,0 +1,40 @@
+/**
+ * The "file changed on disk" conflict resolver.
+ *
+ * Shown when saveDocument detected that disk differs from what the editor
+ * thought it had. The editor has already re-synced its sourceContent to the
+ * fresh disk content with keepDraft: true — so the dialog's two actions map
+ * onto concrete state transitions:
+ *
+ *   "Use disk version"   — replace the draft with disk content
+ *                          (syncStateFromContent without keepDraft).
+ *                          Destroys unsaved edits.
+ *
+ *   "Save my changes"    — close the dialog and re-run saveDocument.
+ *                          computeEditBlocks will now diff against the fresh
+ *                          disk content, so non-overlapping edits merge in
+ *                          and overlapping edits win over disk for the
+ *                          lines the user actually touched.
+ *
+ * The dialog is modal (dimmed backdrop, keyboard-trapped, click-outside does
+ * not dismiss). Escape and the ✕ button both close it without taking either
+ * action — equivalent to "I'll deal with this later"; the save button stays
+ * dirty so the user can retry or keep editing.
+ */
+export interface OpenConflictDialogOptions {
+    fileName: string;
+    onUseDiskVersion: () => void;
+    onSaveMyChanges: () => void;
+    onCancel?: () => void;
+}
+export interface ConflictDialogController {
+    open: (options: OpenConflictDialogOptions) => void;
+    close: () => void;
+    isOpen: () => boolean;
+}
+export declare function renderConflictDialogMarkup(): string;
+interface CreateConflictDialogOptions {
+    container: ParentNode;
+}
+export declare function createConflictDialogController(options: CreateConflictDialogOptions): ConflictDialogController;
+export {};

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

@@ -0,0 +1,163 @@
+/**
+ * The "file changed on disk" conflict resolver.
+ *
+ * Shown when saveDocument detected that disk differs from what the editor
+ * thought it had. The editor has already re-synced its sourceContent to the
+ * fresh disk content with keepDraft: true — so the dialog's two actions map
+ * onto concrete state transitions:
+ *
+ *   "Use disk version"   — replace the draft with disk content
+ *                          (syncStateFromContent without keepDraft).
+ *                          Destroys unsaved edits.
+ *
+ *   "Save my changes"    — close the dialog and re-run saveDocument.
+ *                          computeEditBlocks will now diff against the fresh
+ *                          disk content, so non-overlapping edits merge in
+ *                          and overlapping edits win over disk for the
+ *                          lines the user actually touched.
+ *
+ * The dialog is modal (dimmed backdrop, keyboard-trapped, click-outside does
+ * not dismiss). Escape and the ✕ button both close it without taking either
+ * action — equivalent to "I'll deal with this later"; the save button stays
+ * dirty so the user can retry or keep editing.
+ */
+export function renderConflictDialogMarkup() {
+    return `
+        <div class="md-conflict-modal" id="md-conflict-modal" role="dialog" aria-modal="true" aria-labelledby="md-conflict-title" aria-describedby="md-conflict-body" hidden>
+          <div class="md-conflict-card">
+            <header class="md-conflict-header">
+              <h3 id="md-conflict-title">⚠ This file changed on disk</h3>
+              <button type="button" class="md-conflict-close" id="md-conflict-close" aria-label="Close">
+                <svg viewBox="0 0 24 24" aria-hidden="true" focusable="false">
+                  <path d="M7 7l10 10M17 7L7 17" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"/>
+                </svg>
+              </button>
+            </header>
+            <div class="md-conflict-body" id="md-conflict-body">
+              <p>
+                Something else modified
+                <strong class="md-conflict-filename" id="md-conflict-filename"></strong>
+                while you were editing. Your unsaved edits are preserved.
+              </p>
+              <p>If you save now:</p>
+              <ul>
+                <li>Changes you made to lines the external edit didn't touch will be saved alongside the external changes.</li>
+                <li>Changes you made to lines that also changed externally will overwrite the external version on those lines.</li>
+              </ul>
+            </div>
+            <footer class="md-conflict-footer">
+              <button type="button" class="md-conflict-btn md-conflict-btn--secondary" id="md-conflict-use-disk">
+                Use disk version
+              </button>
+              <button type="button" class="md-conflict-btn md-conflict-btn--primary" id="md-conflict-save-mine">
+                Save my changes
+              </button>
+            </footer>
+          </div>
+        </div>
+    `;
+}
+export function createConflictDialogController(options) {
+    const { container } = options;
+    const modal = container.querySelector('#md-conflict-modal');
+    const filenameEl = container.querySelector('#md-conflict-filename');
+    const useDiskBtn = container.querySelector('#md-conflict-use-disk');
+    const saveMineBtn = container.querySelector('#md-conflict-save-mine');
+    const closeBtn = container.querySelector('#md-conflict-close');
+    let currentOptions = null;
+    let previousActiveElement = null;
+    const close = () => {
+        if (!modal || modal.hidden) {
+            return;
+        }
+        modal.hidden = true;
+        document.removeEventListener('keydown', handleKeyDown, true);
+        modal.removeEventListener('click', handleBackdropClick);
+        const cancel = currentOptions?.onCancel;
+        currentOptions = null;
+        // Restore focus to whatever the user was on before the dialog opened.
+        if (previousActiveElement && document.contains(previousActiveElement)) {
+            try {
+                previousActiveElement.focus();
+            }
+            catch {
+                /* focus can throw on removed nodes — ignore */
+            }
+        }
+        previousActiveElement = null;
+        cancel?.();
+    };
+    const handleKeyDown = (event) => {
+        if (!modal || modal.hidden) {
+            return;
+        }
+        if (event.key === 'Escape') {
+            event.stopPropagation();
+            event.preventDefault();
+            close();
+            return;
+        }
+        if (event.key === 'Tab') {
+            // Minimal focus trap between the three buttons.
+            const focusable = [useDiskBtn, saveMineBtn, closeBtn].filter((el) => !!el);
+            if (focusable.length === 0)
+                return;
+            const active = document.activeElement;
+            const currentIndex = active ? focusable.indexOf(active) : -1;
+            const direction = event.shiftKey ? -1 : 1;
+            const nextIndex = currentIndex === -1
+                ? (direction === 1 ? 0 : focusable.length - 1)
+                : (currentIndex + direction + focusable.length) % focusable.length;
+            event.preventDefault();
+            focusable[nextIndex].focus();
+        }
+    };
+    const handleBackdropClick = (event) => {
+        // Click on the dimmed backdrop (the modal element itself, not the card)
+        // is deliberately not a dismiss — the user must make a choice or hit ✕.
+        if (event.target === modal) {
+            event.stopPropagation();
+        }
+    };
+    const handleUseDisk = () => {
+        const cb = currentOptions?.onUseDiskVersion;
+        // Clear currentOptions first so close() doesn't also fire onCancel.
+        currentOptions = null;
+        close();
+        cb?.();
+    };
+    const handleSaveMine = () => {
+        const cb = currentOptions?.onSaveMyChanges;
+        currentOptions = null;
+        close();
+        cb?.();
+    };
+    useDiskBtn?.addEventListener('click', handleUseDisk);
+    saveMineBtn?.addEventListener('click', handleSaveMine);
+    closeBtn?.addEventListener('click', close);
+    return {
+        open: (options) => {
+            if (!modal) {
+                // No-op if the markup wasn't injected — fall back to cancel callback
+                // so the editor can still notify the user via the inline path.
+                options.onCancel?.();
+                return;
+            }
+            currentOptions = options;
+            if (filenameEl) {
+                filenameEl.textContent = options.fileName;
+            }
+            previousActiveElement = document.activeElement ?? null;
+            modal.hidden = false;
+            document.addEventListener('keydown', handleKeyDown, true);
+            modal.addEventListener('click', handleBackdropClick);
+            // Default focus goes to the safer action ("Save my changes" is the
+            // non-destructive intent — it doesn't discard the user's draft).
+            window.requestAnimationFrame(() => {
+                saveMineBtn?.focus();
+            });
+        },
+        close,
+        isOpen: () => !!modal && !modal.hidden,
+    };
+}

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

@@ -0,0 +1,44 @@
+import type { MarkdownWorkspaceState, RenderBodyResult, RenderPayload } from '../model.js';
+import { type MarkdownEditRange, type MarkdownEditorView } from './editor.js';
+import type { OpenConflictDialogOptions } from './conflict-dialog.js';
+export interface MarkdownControllerDependencies {
+    callTool?: (name: string, args: Record<string, unknown>) => Promise<unknown | undefined>;
+    openExternalLink?: (url: string) => Promise<boolean | undefined>;
+    requestDisplayMode?: (mode: 'inline' | 'fullscreen') => Promise<string | null | undefined>;
+    getAvailableDisplayModes: () => string[];
+    getCurrentDisplayMode: () => string | null;
+    getCurrentPayload: () => RenderPayload | undefined;
+    setExpanded: (expanded: boolean) => void;
+    syncPayload?: (payload?: RenderPayload) => void;
+    storePayloadOverride: (payload: RenderPayload) => void;
+    rerender: () => void;
+    updateSaveStatus: (label: string, statusClass: string) => void;
+    trackUiEvent?: (event: string, params?: Record<string, unknown>) => void;
+    showConflictDialog?: (options: OpenConflictDialogOptions) => void;
+}
+interface EditBlock {
+    old_string: string;
+    new_string: string;
+}
+export declare function computeEditBlocks(oldText: string, newText: string, changedRanges?: MarkdownEditRange[]): EditBlock[];
+export declare function createMarkdownController(dependencies: MarkdownControllerDependencies): {
+    attachHandlers: (payload: RenderPayload) => void;
+    buildBody: (payload: RenderPayload) => RenderBodyResult;
+    clear: () => void;
+    disposeHandles: () => void;
+    ensureCompletePayload: (payload: RenderPayload) => Promise<RenderPayload>;
+    getCopyText: (payload: RenderPayload) => string | null;
+    getState: (payload: RenderPayload) => MarkdownWorkspaceState;
+    handleInlineExitFromFullscreen: (originalPayload?: RenderPayload) => Promise<RenderPayload | undefined>;
+    isUndoAvailable: (state: MarkdownWorkspaceState) => boolean;
+    readCompletePayload: (filePath: string) => Promise<RenderPayload | null>;
+    readPayload: (filePath: string, length?: number, offset?: number) => Promise<RenderPayload | null>;
+    readPayloadContent: (payload: RenderPayload) => string;
+    refreshFromDisk: (payload: RenderPayload) => Promise<void>;
+    requestEditMode: (payload: RenderPayload) => Promise<void>;
+    requestFullscreen: () => Promise<boolean>;
+    saveDocument: () => Promise<void>;
+    setEditorView: (payload: RenderPayload, view: MarkdownEditorView) => void;
+};
+export type MarkdownController = ReturnType<typeof createMarkdownController>;
+export {};