@wonderwhy-er/desktop-commander 0.2.38 → 0.2.39

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/block-merge.d.ts

@@ -0,0 +1,25 @@
+export interface Block {
+    start: number;
+    end: number;
+    text: string;
+}
+/**
+ * Split markdown source into top-level blocks with source ranges. The ranges
+ * drive byte-exact preservation of untouched content when merging Milkdown's
+ * re-serialized output back into the original on-disk source.
+ */
+export declare function extractBlocks(source: string): Block[];
+export interface MergeReport {
+    merged: string;
+    preservedCount: number;
+    rewrittenCount: number;
+    /** Populated when block counts don't align and we fell back to the full output. */
+    fallback?: string;
+}
+/**
+ * Merge Milkdown's current serialization back into the original on-disk source
+ * block-by-block. Blocks whose Milkdown representation is unchanged since mount
+ * are emitted byte-identical to disk; edited blocks take Milkdown's output.
+ * Separators between blocks come from the original source.
+ */
+export declare function mergeBlocks(originalSource: string, originalBlocks: Block[], baselineBlocks: Block[], currentSerialization: string, currentBlocks: Block[]): MergeReport;

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

@@ -0,0 +1,86 @@
+// markdown-it ships without TypeScript typings in this setup; reuse the
+// existing ambient-import pattern from parser.ts.
+// @ts-expect-error markdown-it does not provide local TypeScript typings in this setup.
+import MarkdownIt from 'markdown-it';
+const parser = new MarkdownIt({ html: true });
+/**
+ * Split markdown source into top-level blocks with source ranges. The ranges
+ * drive byte-exact preservation of untouched content when merging Milkdown's
+ * re-serialized output back into the original on-disk source.
+ */
+export function extractBlocks(source) {
+    const tokens = parser.parse(source, {});
+    const lines = source.split('\n');
+    const lineOffsets = [0];
+    for (let i = 0; i < lines.length; i++) {
+        lineOffsets.push(lineOffsets[i] + lines[i].length + 1);
+    }
+    const blocks = [];
+    let lastEndLine = 0;
+    for (const token of tokens) {
+        if (!token.map || token.map.length < 2)
+            continue;
+        const [startLine, endLine] = token.map;
+        const t = token.type;
+        const isOpening = typeof t === 'string' && (t.endsWith('_open')
+            || t === 'hr'
+            || t === 'fence'
+            || t === 'code_block'
+            || t === 'html_block');
+        if (!isOpening || startLine < lastEndLine)
+            continue;
+        const start = lineOffsets[startLine];
+        const rawEnd = lineOffsets[endLine] ?? source.length;
+        const end = Math.min(source.length, Math.max(start, rawEnd - 1));
+        blocks.push({ start, end, text: source.slice(start, end) });
+        lastEndLine = endLine;
+    }
+    return blocks;
+}
+/**
+ * Merge Milkdown's current serialization back into the original on-disk source
+ * block-by-block. Blocks whose Milkdown representation is unchanged since mount
+ * are emitted byte-identical to disk; edited blocks take Milkdown's output.
+ * Separators between blocks come from the original source.
+ */
+export function mergeBlocks(originalSource, originalBlocks, baselineBlocks, currentSerialization, currentBlocks) {
+    if (originalBlocks.length !== baselineBlocks.length) {
+        return {
+            merged: currentSerialization,
+            preservedCount: 0,
+            rewrittenCount: currentBlocks.length,
+            fallback: `original parses to ${originalBlocks.length} blocks but baseline parses to ${baselineBlocks.length}`,
+        };
+    }
+    if (baselineBlocks.length !== currentBlocks.length) {
+        return {
+            merged: currentSerialization,
+            preservedCount: 0,
+            rewrittenCount: currentBlocks.length,
+            fallback: `block count changed (baseline=${baselineBlocks.length}, current=${currentBlocks.length})`,
+        };
+    }
+    const parts = [];
+    let preserved = 0;
+    let rewritten = 0;
+    parts.push(originalSource.slice(0, originalBlocks[0]?.start ?? 0));
+    for (let i = 0; i < originalBlocks.length; i++) {
+        if (baselineBlocks[i].text === currentBlocks[i].text) {
+            parts.push(originalBlocks[i].text);
+            preserved++;
+        }
+        else {
+            parts.push(currentBlocks[i].text);
+            rewritten++;
+        }
+        const nextStart = i + 1 < originalBlocks.length
+            ? originalBlocks[i + 1].start
+            : originalSource.length;
+        parts.push(originalSource.slice(originalBlocks[i].end, nextStart));
+    }
+    return {
+        merged: parts.join(''),
+        preservedCount: preserved,
+        rewrittenCount: rewritten,
+    };
+}

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,38 @@
+import type { MarkdownWorkspaceState, RenderBodyResult, RenderPayload } from '../model.js';
+import { 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;
+}
+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>;