@rightkit/document-workspace 0.0.0-stage → 0.1.1

package/dist/app/Sidebar.d.ts

@@ -0,0 +1,36 @@
+import { type ReactNode } from "react";
+import type { FileEntry, PinEntry } from "../state/library.js";
+export interface SidebarProps {
+    activePath: string | null;
+    /** Paths of documents that currently have a tab — used for "open in a tab" row styling and for
+     *  activate-instead-of-open when a pinned/explorer file is already open. */
+    openPaths: ReadonlySet<string>;
+    recents: FileEntry[];
+    /** File+dir pins (integrator keeps it current, dirs included). */
+    pinnedPaths: ReadonlySet<string>;
+    /** Full pin rows for the Pinned section (dirs first, as the backend returns them). */
+    pinnedEntries: PinEntry[];
+    /** Focus an already-open doc's tab. */
+    onActivate: (path: string) => void;
+    /** Open a recents entry — same path the recents flow uses (token-based). */
+    onOpenRecent: (entry: FileEntry) => Promise<unknown> | undefined;
+    /** Open a broker-granted explorer path (integrator makes it open-or-activate). */
+    onOpenPath: (path: string) => void;
+    /** FILE pin toggle (existing app callback). */
+    onTogglePin: (path: string) => void;
+    /** DIRECTORY pin toggle. */
+    onTogglePinDir: (path: string, label: string) => void;
+    onClearRecents: () => void;
+    onOpenDialog: () => void;
+    onOpenUrl: () => void;
+    onOpenClipboard: () => void;
+    onNew: () => void;
+    onOpenSettings: () => void;
+    onCollapsedChange: (collapsed: boolean) => void;
+    /** In-window menus (Windows/Linux File · Edit · View) shown at the left of the sidebar's
+     *  titlebar row while the sidebar is open — the window's far left, like macOS traffic lights. */
+    titlebarSlot?: ReactNode;
+}
+export declare const Sidebar: import("react").MemoExoticComponent<typeof SidebarImpl>;
+declare function SidebarImpl(props: SidebarProps): import("react").JSX.Element | null;
+export {};

package/dist/app/Sidebar.js

@@ -0,0 +1,121 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// The sidebar shell. Open documents moved to the titlebar tab strip — the sidebar is now a file
+// explorer (Pinned / Recent / Locations). Collapsed shows a thin rail (expand, New, Recent, pinned
+// files, Settings); "viewright:toggle-sidebar" + "vr.sidebar.pinned" still drive it.
+import { memo, useEffect, useRef, useState, } from "react";
+import { useMediaQuery } from "@rightkit/react-shell/react";
+import { loadExplorerPersisted, saveExplorerPersisted } from "./sidebar/explorer/explorerState.js";
+import { SidebarExpandedPanel } from "./sidebar/SidebarExpandedPanel.js";
+import { SidebarRail } from "./sidebar/SidebarRail.js";
+const SIDEBAR_DEFAULT_WIDTH = 256;
+const SIDEBAR_MIN_WIDTH = 224;
+const SIDEBAR_MAX_WIDTH = 420;
+const SIDEBAR_COLLAPSE_WIDTH = 80;
+function initialSidebarWidth() {
+    if (typeof localStorage === "undefined")
+        return SIDEBAR_DEFAULT_WIDTH;
+    const raw = localStorage.getItem("vr.sidebar.width");
+    if (raw == null)
+        return SIDEBAR_DEFAULT_WIDTH;
+    const stored = Number(raw);
+    if (!Number.isFinite(stored))
+        return SIDEBAR_DEFAULT_WIDTH;
+    return Math.max(SIDEBAR_MIN_WIDTH, Math.min(SIDEBAR_MAX_WIDTH, stored));
+}
+// Memoized: App re-renders on every keystroke (edits state), but the sidebar's inputs don't change
+// on a keystroke, so it must skip that re-render instead of reconciling the whole explorer tree.
+export const Sidebar = memo(SidebarImpl);
+function SidebarImpl(props) {
+    const { onCollapsedChange } = props;
+    const widthDrag = useRef(null);
+    const [sidebarWidth, setSidebarWidth] = useState(initialSidebarWidth);
+    // Manual open/close only — no hover auto-expand. Collapsed = hidden entirely (no rail).
+    const [open, setOpen] = useState(() => localStorage.getItem("vr.sidebar.pinned") !== "0");
+    const compact = useMediaQuery("(max-width: 640px)");
+    const collapsed = !open || compact;
+    useEffect(() => {
+        localStorage.setItem("vr.sidebar.pinned", open ? "1" : "0");
+    }, [open]);
+    // Ctrl+E (App dispatches this) toggles the sidebar from anywhere in the app.
+    useEffect(() => {
+        const toggle = () => setOpen((o) => !o);
+        window.addEventListener("viewright:toggle-sidebar", toggle);
+        return () => window.removeEventListener("viewright:toggle-sidebar", toggle);
+    }, []);
+    useEffect(() => {
+        onCollapsedChange?.(collapsed);
+    }, [collapsed, onCollapsedChange]);
+    // Hydrate the width from the explorer settings mirror only when localStorage has nothing —
+    // localStorage always wins so a migrated/reset profile can't stomp the fast path.
+    useEffect(() => {
+        let live = true;
+        void loadExplorerPersisted().then((persisted) => {
+            if (!live)
+                return;
+            if (localStorage.getItem("vr.sidebar.width") != null)
+                return;
+            if (persisted.width >= SIDEBAR_MIN_WIDTH && persisted.width <= SIDEBAR_MAX_WIDTH) {
+                setSidebarWidth(persisted.width);
+            }
+        });
+        return () => {
+            live = false;
+        };
+    }, []);
+    const startWidthResize = (event) => {
+        event.preventDefault();
+        event.currentTarget.setPointerCapture?.(event.pointerId);
+        widthDrag.current = {
+            pointerId: event.pointerId,
+            startX: event.clientX,
+            startWidth: sidebarWidth,
+        };
+        document.body.style.cursor = "col-resize";
+        document.body.style.userSelect = "none";
+    };
+    useEffect(() => {
+        const onMove = (event) => {
+            const drag = widthDrag.current;
+            if (!drag || event.pointerId !== drag.pointerId)
+                return;
+            const raw = drag.startWidth + event.clientX - drag.startX;
+            if (raw <= SIDEBAR_COLLAPSE_WIDTH) {
+                setOpen(false);
+                return;
+            }
+            const next = Math.max(SIDEBAR_MIN_WIDTH, Math.min(SIDEBAR_MAX_WIDTH, raw));
+            setSidebarWidth(next);
+            drag.lastWidth = next;
+        };
+        const finish = (event) => {
+            const drag = widthDrag.current;
+            if (!drag || event.pointerId !== drag.pointerId)
+                return;
+            widthDrag.current = null;
+            if (drag.lastWidth !== undefined) {
+                const width = Math.round(drag.lastWidth);
+                localStorage.setItem("vr.sidebar.width", String(width));
+                saveExplorerPersisted({ width });
+            }
+            document.body.style.cursor = "";
+            document.body.style.userSelect = "";
+        };
+        window.addEventListener("pointermove", onMove);
+        window.addEventListener("pointerup", finish);
+        window.addEventListener("pointercancel", finish);
+        return () => {
+            window.removeEventListener("pointermove", onMove);
+            window.removeEventListener("pointerup", finish);
+            window.removeEventListener("pointercancel", finish);
+            if (widthDrag.current) {
+                document.body.style.cursor = "";
+                document.body.style.userSelect = "";
+            }
+            widthDrag.current = null;
+        };
+    }, []);
+    // Collapsed = the thin rail (narrow/compact windows hide the sidebar entirely).
+    if (collapsed)
+        return compact ? null : _jsx(SidebarRail, { ...props, setOpen: setOpen });
+    return (_jsx(SidebarExpandedPanel, { ...props, sidebarWidth: sidebarWidth, startWidthResize: startWidthResize, setOpen: setOpen, SIDEBAR_MIN_WIDTH: SIDEBAR_MIN_WIDTH, SIDEBAR_MAX_WIDTH: SIDEBAR_MAX_WIDTH }));
+}

package/dist/app/ToastViewport.d.ts

@@ -0,0 +1 @@
+export declare function ToastViewport(): import("react").JSX.Element;

package/dist/app/ToastViewport.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { CheckCircle } from "@phosphor-icons/react/dist/icons/CheckCircle";
+import { Info } from "@phosphor-icons/react/dist/icons/Info";
+import { WarningCircle } from "@phosphor-icons/react/dist/icons/WarningCircle";
+import { defaultToastBus } from "@rightkit/platform-ui/headless";
+import { ToastViewport as ShellToastViewport, } from "@rightkit/react-shell/react";
+const KIND_ICON = {
+    info: Info,
+    success: CheckCircle,
+    warning: WarningCircle,
+    error: WarningCircle,
+};
+// the host app row markup, unchanged. The shell supplies the timers, bus subscription, stack cap
+// and exit timing; `leaving` ignores a second dismiss during the exit animation, as before.
+function renderToastRow({ toast, leaving, dismiss, role }) {
+    const KindIcon = KIND_ICON[toast.kind];
+    return (_jsxs("div", { role: role, className: `vr-toast-row${leaving ? " vr-toast-exit" : ""} vr-capsule vr-over-content pointer-events-auto h-10 w-fit max-w-full gap-2.5 pl-4 pr-2 font-sans text-chrome-md font-medium text-paper`, children: [_jsx(KindIcon, { size: 16, weight: "regular", "aria-hidden": "true", className: "shrink-0 text-copper" }), _jsx("span", { className: "min-w-0 flex-1 truncate", children: toast.message }), toast.action && (_jsx("button", { type: "button", onClick: () => {
+                    if (leaving)
+                        return;
+                    toast.action?.run();
+                    dismiss();
+                }, className: "vr-press vr-focus flex h-6 shrink-0 items-center rounded-full px-2.5 text-copper hover:bg-ink/40 hover:text-paper", children: toast.action.label })), _jsx("button", { type: "button", onClick: () => {
+                    if (!leaving)
+                        dismiss();
+                }, "aria-label": "Dismiss notification", className: "vr-press vr-focus flex h-6 w-6 shrink-0 items-center justify-center rounded-full text-muted-2 hover:bg-ink/40 hover:text-paper", children: "\u2715" })] }));
+}
+// Single mount point for the toast bus. Centred bottom capsules; the live region announces new
+// toasts to assistive tech (polite for info/success, the error rows carry role="alert").
+export function ToastViewport() {
+    return (_jsx(ShellToastViewport, { bus: defaultToastBus, className: "no-print pointer-events-none fixed bottom-4 left-1/2 z-[95] flex max-h-[calc(100vh-2rem)] w-[min(24rem,calc(100vw-2rem))] -translate-x-1/2 flex-col items-center gap-2 overflow-y-auto", roles: { error: "alert", info: null, success: null, warning: null }, renderRow: renderToastRow }));
+}

package/dist/app/Toolbar.d.ts

@@ -0,0 +1,26 @@
+import { type ReactNode } from "react";
+import type { LoadedDocument } from "@rightkit/document-core/documents/types";
+import { type TabStripProps } from "./tabs/TabStrip.js";
+interface Props {
+    doc: LoadedDocument | null;
+    title: string;
+    menuSlot?: ReactNode;
+    modeSlot?: ReactNode;
+    /** Centre-of-toolbar slot (Wave 2 Read/Edit control) — floats inside the drag region. */
+    centerSlot?: ReactNode;
+    sidebarCollapsed?: boolean;
+    compute?: (doc: LoadedDocument) => string;
+    subscribeEdits?: (path: string, cb: () => void) => () => void;
+    getEditSnapshot?: (path: string) => string | undefined;
+    isDirty?: (doc: LoadedDocument) => boolean;
+    dirtyPaths?: ReadonlySet<string>;
+    subscribeDirty?: (path: string, cb: () => void) => () => void;
+    /** Titlebar tab strip (Part A tabs+explorer): when provided, the middle stretch renders
+     *  open-document tabs instead of empty drag space, and the left title block is dropped —
+     *  the strip's active tab carries the document name. Absent = standalone/test layout. */
+    tabs?: TabStripProps;
+}
+export declare const KIND_LABEL: Record<LoadedDocument["format"], string>;
+export declare const Toolbar: import("react").MemoExoticComponent<typeof ToolbarImpl>;
+declare function ToolbarImpl({ doc, title, menuSlot, modeSlot, centerSlot, sidebarCollapsed, compute, subscribeEdits, getEditSnapshot, isDirty, dirtyPaths, subscribeDirty, tabs, }: Props): import("react").JSX.Element;
+export {};

package/dist/app/Toolbar.js

@@ -0,0 +1,63 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo } from "react";
+import { createWindowControlLabels } from "@rightkit/platform-ui";
+import { usePlatform } from "@rightkit/platform-ui/react";
+import { Titlebar } from "@rightkit/react-shell/react";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+import { inTauri } from "@rightkit/document-core/state/tauriBridge";
+import { LiveTitle } from "./LiveTitle.js";
+import { useTabDirty } from "./tabs/useTabDirty.js";
+import { TabStrip } from "./tabs/TabStrip.js";
+const NO_DIRTY = new Set();
+// Subtitle kind labels — the human format names from the Wave 1 title-bar spec. Exported for the
+// Wave 3 Info inspector, which must show the same "Kind" the title subtitle shows.
+export const KIND_LABEL = {
+    md: "Markdown",
+    mdx: "Markdown",
+    txt: "Text",
+    pdf: "PDF Document",
+    docx: "Word Document",
+    html: "HTML",
+    image: "Image",
+    web: "Web Preview",
+    unknown: "Document",
+};
+const windowAdapter = {
+    minimize: () => getCurrentWindow().minimize(),
+    toggleMaximize: () => getCurrentWindow().toggleMaximize(),
+    close: () => getCurrentWindow().close(),
+};
+const windowControlLabels = createWindowControlLabels({
+    minimize: "Minimize",
+    maximize: "Maximize",
+    close: "Close",
+});
+// Title bar: document menus, the left-aligned document title block (name over kind/dirty subtitle),
+// and window controls. On macOS the sidebar tells us when the native traffic lights are inside the
+// content titlebar; only that collapsed state needs padding.
+export const Toolbar = memo(ToolbarImpl);
+function ToolbarImpl({ doc, title, menuSlot, modeSlot, centerSlot, sidebarCollapsed = false, compute, subscribeEdits, getEditSnapshot, isDirty, dirtyPaths, subscribeDirty, tabs, }) {
+    const mac = usePlatform() === "macos";
+    // Collapsed-mac traffic-light clearance: standalone mode pads the left menu cluster;
+    // with tabs, the strip's own leading cluster carries that inset instead.
+    const menuPadding = mac && sidebarCollapsed && !tabs ? "pl-24" : "pl-3";
+    const titleNode = doc && compute && subscribeEdits && getEditSnapshot ? (_jsx(LiveTitle, { doc: doc, compute: compute, subscribeEdits: subscribeEdits, getEditSnapshot: getEditSnapshot })) : (title);
+    const hasTitle = !!(tabs || centerSlot);
+    // `Titlebar` owns the drag-region header, the macOS traffic-light slot (hidden here: the sidebar,
+    // or the tab strip's lead spacer, already clears the lights) and the Windows/Linux caption buttons
+    // (drawn only in a native window; macOS has its own overlay title bar).
+    return (_jsx(Titlebar, { className: "no-print vr-chrome relative bg-panel", startWidth: "auto", windowControls: inTauri() ? windowAdapter : undefined, windowControlLabels: windowControlLabels, slots: {
+            side: `relative z-10 min-w-0 ${menuPadding}`,
+            lights: "hidden",
+            title: "relative h-full min-w-3 flex-1 self-stretch",
+            drag: hasTitle ? "hidden" : "",
+            end: "relative z-10",
+        }, start: _jsxs(_Fragment, { children: [(!tabs || sidebarCollapsed) && menuSlot, doc && !tabs ? (_jsx(ToolbarTitle, { doc: doc, titleNode: titleNode, isDirty: isDirty, dirtyPaths: dirtyPaths, subscribeDirty: subscribeDirty })) : null] }), title: hasTitle ? (_jsxs(_Fragment, { children: [tabs ? _jsx(TabStrip, { ...tabs }) : null, centerSlot ? (_jsx("div", { className: "pointer-events-none absolute inset-0 flex items-center justify-center", children: _jsx("div", { className: "pointer-events-auto", children: centerSlot }) })) : null] })) : undefined, end: modeSlot ? _jsx("div", { className: "mr-3 flex items-center", children: modeSlot }) : undefined }));
+}
+// Left-aligned document title: 15px semibold name over an 11px muted `<Kind> — Edited` subtitle.
+// Subscribes to per-tab dirty changes so text-buffer edits flip "— Edited" without an App render.
+function ToolbarTitle({ doc, titleNode, isDirty, dirtyPaths, subscribeDirty, }) {
+    const dirty = useTabDirty(doc, (dirtyPaths ?? NO_DIRTY).has(doc.path), isDirty ?? (() => false), subscribeDirty ?? (() => () => { }));
+    const kind = KIND_LABEL[doc.format] ?? "Document";
+    return (_jsxs("div", { className: "ml-2 flex min-w-0 flex-col justify-center leading-tight", "data-vr-doc-title": true, children: [_jsx("span", { className: "truncate font-sans text-[15px] font-semibold text-paper", children: titleNode }), _jsxs("span", { className: "truncate font-sans text-chrome-xs text-muted", children: [kind, dirty ? " — Edited" : ""] })] }));
+}

package/dist/app/activeFormatSavers.d.ts

@@ -0,0 +1,7 @@
+import type { ImageSaveFunction } from "@rightkit/media-ui";
+type MutableCurrent<T> = {
+    current: T;
+};
+type DocxSaveFunction = () => Promise<ArrayBuffer | null>;
+export declare function syncActiveFormatSavers(activePath: string | null, docxSaver: MutableCurrent<DocxSaveFunction | null>, imageSaver: MutableCurrent<ImageSaveFunction | null>, docxSavers: ReadonlyMap<string, DocxSaveFunction>, imageSavers: ReadonlyMap<string, ImageSaveFunction>): void;
+export {};

package/dist/app/activeFormatSavers.js

@@ -0,0 +1,4 @@
+export function syncActiveFormatSavers(activePath, docxSaver, imageSaver, docxSavers, imageSavers) {
+    docxSaver.current = activePath ? (docxSavers.get(activePath) ?? null) : null;
+    imageSaver.current = activePath ? (imageSavers.get(activePath) ?? null) : null;
+}

package/dist/app/clipboardPaths.d.ts

@@ -0,0 +1 @@
+export declare function localPathFromClipboardText(text: string): string | null;

package/dist/app/clipboardPaths.js

@@ -0,0 +1,31 @@
+import { formatFromPath } from "@rightkit/document-core/documents/types";
+export function localPathFromClipboardText(text) {
+    const trimmed = text.trim();
+    if (!trimmed || /\r|\n/.test(trimmed))
+        return null;
+    const unquoted = trimmed.replace(/^(['"`])(.+)\1$/, "$2").trim();
+    const path = fileUrlToLocalPath(unquoted) ?? unquoted;
+    const isWindowsDrive = /^[a-z]:[\\/].+/i.test(path);
+    const isUnc = /^\\\\[^\\\/]+[\\\/][^\\\/]+[\\\/].+/.test(path);
+    const isPosixAbsolute = /^\/[^/].+/.test(path);
+    if (!isWindowsDrive && !isUnc && !isPosixAbsolute)
+        return null;
+    return formatFromPath(path) === "unknown" ? null : path;
+}
+function fileUrlToLocalPath(input) {
+    let url;
+    try {
+        url = new URL(input);
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== "file:")
+        return null;
+    const decoded = decodeURIComponent(url.pathname);
+    if (/^\/[a-z]:\//i.test(decoded))
+        return decoded.slice(1).replace(/\//g, "\\");
+    if (url.hostname)
+        return `\\\\${url.hostname}${decoded.replace(/\//g, "\\")}`;
+    return decoded;
+}

package/dist/app/documentDrafts.d.ts

@@ -0,0 +1,17 @@
+export declare const draftKey: (path: string) => string;
+export declare function readDraft(path: string): string | null;
+export declare function writeDraft(path: string, text: string): void;
+export declare function clearDraft(path: string): void;
+export interface FileDraft {
+    base: string;
+    text: string;
+}
+export declare function readFileDraft(path: string): FileDraft | null;
+export declare function writeFileDraft(path: string, draft: FileDraft): void;
+export declare function clearFileDraft(path: string): void;
+export declare function writeDraftDebounced(path: string, text: string): void;
+export declare function writeFileDraftDebounced(path: string, draft: FileDraft): void;
+/** Synchronously commit path's pending debounced write (if any) right now. Idempotent/no-op if nothing pending. */
+export declare function flushDraft(path: string): void;
+/** Synchronously commit every pending debounced draft write. Call before the process may exit. */
+export declare function flushDrafts(): void;

package/dist/app/documentDrafts.js

@@ -0,0 +1,104 @@
+// ── Debounced writers (T2-1) ────────────────────────────────────────────────────────────────────
+// writeDraft/writeFileDraft below are synchronous localStorage.setItem calls — JSON.stringify-ing the
+// whole document on every keystroke is O(doc) blocking I/O per char. writeDraftDebounced/
+// writeFileDraftDebounced (further down) are what onTxtChange calls instead: they coalesce rapid
+// keystrokes into one write ~400ms after typing pauses (matches the useViewState house debounce),
+// keyed per-path so two files being edited in quick succession never clobber each other's pending
+// write. The pending-write maps live up top so clearDraft/clearFileDraft can cancel them.
+//
+// Data-loss guardrails:
+//  - clearDraft/clearFileDraft cancel any pending write for that path before removing the key, so a
+//    save/discard can never be undone by a stale debounced write landing afterward.
+//  - flushDraft/flushDrafts synchronously commit a pending write immediately; callers invoke these
+//    before an operation that may read the draft back or before the process may exit (save, close,
+//    beforeunload/visibilitychange-hidden) so no in-flight edit is silently dropped.
+const DRAFT_DEBOUNCE_MS = 400;
+const untitledPending = new Map();
+const fileDraftPending = new Map();
+export const draftKey = (path) => `vr.draft.${path}`;
+export function readDraft(path) {
+    return localStorage.getItem(draftKey(path));
+}
+export function writeDraft(path, text) {
+    localStorage.setItem(draftKey(path), text);
+}
+export function clearDraft(path) {
+    const pending = untitledPending.get(path);
+    if (pending) {
+        clearTimeout(pending.timer);
+        untitledPending.delete(path);
+    }
+    localStorage.removeItem(draftKey(path));
+}
+const fileDraftKey = (path) => `vr.filedraft.${path}`;
+export function readFileDraft(path) {
+    try {
+        const raw = localStorage.getItem(fileDraftKey(path));
+        if (!raw)
+            return null;
+        const d = JSON.parse(raw);
+        if (typeof d.base === "string" && typeof d.text === "string") {
+            return { base: d.base, text: d.text };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeFileDraft(path, draft) {
+    try {
+        localStorage.setItem(fileDraftKey(path), JSON.stringify(draft));
+    }
+    catch {
+        /* storage full — skip */
+    }
+}
+export function clearFileDraft(path) {
+    const pending = fileDraftPending.get(path);
+    if (pending) {
+        clearTimeout(pending.timer);
+        fileDraftPending.delete(path);
+    }
+    localStorage.removeItem(fileDraftKey(path));
+}
+export function writeDraftDebounced(path, text) {
+    const prior = untitledPending.get(path);
+    if (prior)
+        clearTimeout(prior.timer);
+    const timer = setTimeout(() => {
+        untitledPending.delete(path);
+        writeDraft(path, text);
+    }, DRAFT_DEBOUNCE_MS);
+    untitledPending.set(path, { timer, text });
+}
+export function writeFileDraftDebounced(path, draft) {
+    const prior = fileDraftPending.get(path);
+    if (prior)
+        clearTimeout(prior.timer);
+    const timer = setTimeout(() => {
+        fileDraftPending.delete(path);
+        writeFileDraft(path, draft);
+    }, DRAFT_DEBOUNCE_MS);
+    fileDraftPending.set(path, { timer, draft });
+}
+/** Synchronously commit path's pending debounced write (if any) right now. Idempotent/no-op if nothing pending. */
+export function flushDraft(path) {
+    const untitled = untitledPending.get(path);
+    if (untitled) {
+        clearTimeout(untitled.timer);
+        untitledPending.delete(path);
+        writeDraft(path, untitled.text);
+    }
+    const file = fileDraftPending.get(path);
+    if (file) {
+        clearTimeout(file.timer);
+        fileDraftPending.delete(path);
+        writeFileDraft(path, file.draft);
+    }
+}
+/** Synchronously commit every pending debounced draft write. Call before the process may exit. */
+export function flushDrafts() {
+    for (const path of new Set([...untitledPending.keys(), ...fileDraftPending.keys()]))
+        flushDraft(path);
+}

package/dist/app/draftResolution.d.ts

@@ -0,0 +1,5 @@
+import type { BlockDraftDecision, BlockDraftIntent, BlockDraftRegistry } from "@rightkit/document-core/app/blockDrafts";
+/** Resolve every modified draft for one document in order; first cancellation/failure wins. */
+export declare function resolveDocumentDrafts(registry: BlockDraftRegistry, documentPath: string, intent: BlockDraftIntent, decision: BlockDraftDecision): Promise<"resolved" | "cancelled" | "failed">;
+/** Resolve every modified draft in the registry (close-all / quit / setup replacement). */
+export declare function resolveAllDrafts(registry: BlockDraftRegistry, intent: BlockDraftIntent, decision: BlockDraftDecision): Promise<"resolved" | "cancelled" | "failed">;

package/dist/app/draftResolution.js

@@ -0,0 +1,25 @@
+/** Resolve every modified draft for one document in order; first cancellation/failure wins. */
+export async function resolveDocumentDrafts(registry, documentPath, intent, decision) {
+    const drafts = registry.snapshotModified(documentPath);
+    for (const draft of drafts) {
+        const result = await registry.resolve(draft.identity, intent, decision);
+        if (result.outcome === "cancelled")
+            return "cancelled";
+        if (result.outcome === "failed")
+            return "failed";
+        // done / discarded / missing → continue to the next draft
+    }
+    return "resolved";
+}
+/** Resolve every modified draft in the registry (close-all / quit / setup replacement). */
+export async function resolveAllDrafts(registry, intent, decision) {
+    const drafts = registry.snapshotModified();
+    for (const draft of drafts) {
+        const result = await registry.resolve(draft.identity, intent, decision);
+        if (result.outcome === "cancelled")
+            return "cancelled";
+        if (result.outcome === "failed")
+            return "failed";
+    }
+    return "resolved";
+}

package/dist/app/markdownPaletteActions.d.ts

@@ -0,0 +1,8 @@
+import type { LoadedDocument } from "@rightkit/document-core/documents/types";
+import type { MarkdownExportApi } from "@rightkit/markdown-editor/documents/markdown/export/markdownExportTypes";
+/** Command-palette "Export as…" action for md/mdx, or null for other formats. */
+export declare function buildExportMarkdown(active: LoadedDocument | null, markdownExport: MarkdownExportApi | null, activeText: string): ((target: "html" | "txt") => void) | null;
+/** Command-palette "Copy rendered" action for md/mdx, or null for other formats. */
+export declare function buildCopyRendered(active: LoadedDocument | null, markdownExport: MarkdownExportApi | null, activeText: string): (() => void) | null;
+/** Command-palette "Copy as Markdown" for PDF and DOCX (converted from document text/model). */
+export declare function buildCopyAsMarkdown(active: LoadedDocument | null): (() => void) | null;

package/dist/app/markdownPaletteActions.js

@@ -0,0 +1,107 @@
+import { toast } from "@rightkit/platform-ui/headless";
+import { isMarkdownFormat } from "../documents/capabilities.js";
+import { baseName } from "@rightkit/document-core/documents/types";
+import { saveFileDialog, writeDocument } from "@rightkit/document-core/state/tauriBridge";
+import { errorMessage } from "@rightkit/document-core/state/errors";
+import { writeClipboardText } from "@rightkit/document-core/state/tauriBridge";
+const isMarkdownLike = (active) => !!active && isMarkdownFormat(active?.format);
+/** Command-palette "Export as…" action for md/mdx, or null for other formats. */
+export function buildExportMarkdown(active, markdownExport, activeText) {
+    if (!isMarkdownLike(active))
+        return null;
+    return (target) => {
+        const stem = baseName(active.path).replace(/\.(md|mdx|markdown)$/i, "");
+        if (active.format === "md") {
+            if (markdownExport?.documentPath !== active.path) {
+                toast("Markdown renderer is still loading", "info");
+                return;
+            }
+            void markdownExport
+                .createSnapshot()
+                .then(async (snapshot) => {
+                const path = await saveFileDialog(`${stem}.${target === "html" ? "html" : "txt"}`, target === "html" ? "html" : "txt");
+                if (!path)
+                    return;
+                await writeDocument(path, target === "html" ? snapshot.htmlDocument : snapshot.plainText);
+                toast(snapshot.warnings.length
+                    ? `Exported ${baseName(path)} with ${snapshot.warnings.length} warning${snapshot.warnings.length === 1 ? "" : "s"}`
+                    : `Exported ${baseName(path)}`, snapshot.warnings.length ? "info" : "success");
+            })
+                .catch((error) => toast(`Export failed: ${errorMessage(error)}`, "error"));
+            return;
+        }
+        // Lazy: exportMarkdown pulls the whole unified/remark toolchain. Only pay for it once the
+        // user actually asks to export MDX, whose sandbox renderer is separate from Markdown.
+        void import("@rightkit/markdown-editor/documents/markdown/exportMarkdown").then(({ markdownToHtml, markdownToPlainText }) => {
+            const output = target === "html" ? markdownToHtml(activeText, stem) : markdownToPlainText(activeText);
+            void saveFileDialog(`${stem}.${target === "html" ? "html" : "txt"}`, target === "html" ? "html" : "txt").then((path) => {
+                if (!path)
+                    return;
+                writeDocument(path, output)
+                    .then(() => toast(`Exported ${baseName(path)}`, "success"))
+                    .catch((e) => toast(`Export failed: ${errorMessage(e)}`, "error"));
+            });
+        });
+    };
+}
+/** Command-palette "Copy rendered" action for md/mdx, or null for other formats. */
+export function buildCopyRendered(active, markdownExport, activeText) {
+    if (!isMarkdownLike(active))
+        return null;
+    return () => {
+        const copy = (html, text) => {
+            const clip = navigator.clipboard;
+            const ok = () => toast("Rendered Markdown copied", "success");
+            const fail = () => toast("Couldn't copy to clipboard", "error");
+            if (clip?.write && typeof ClipboardItem !== "undefined") {
+                void clip
+                    .write([
+                    new ClipboardItem({
+                        "text/html": new Blob([html], { type: "text/html" }),
+                        "text/plain": new Blob([text], { type: "text/plain" }),
+                    }),
+                ])
+                    .then(ok)
+                    .catch(() => void clip.writeText(text).then(ok).catch(fail));
+            }
+            else {
+                void clip?.writeText(text).then(ok).catch(fail);
+            }
+        };
+        if (active.format === "md") {
+            if (markdownExport?.documentPath !== active.path) {
+                toast("Markdown renderer is still loading", "info");
+                return;
+            }
+            void markdownExport
+                .createSnapshot()
+                .then((snapshot) => copy(snapshot.htmlFragment, snapshot.plainText))
+                .catch(() => toast("Couldn't copy to clipboard", "error"));
+            return;
+        }
+        void import("@rightkit/markdown-editor/documents/markdown/exportMarkdown").then(({ markdownToHtmlFragment, markdownToPlainText }) => {
+            copy(markdownToHtmlFragment(activeText), markdownToPlainText(activeText));
+        });
+    };
+}
+/** Command-palette "Copy as Markdown" for PDF and DOCX (converted from document text/model). */
+export function buildCopyAsMarkdown(active) {
+    if (!active || (active.format !== "pdf" && active.format !== "docx"))
+        return null;
+    const { format, assetUrl, content } = active;
+    // DOCX without an asset URL carries its bytes as base64 content (DocumentRouter's initialBase64).
+    if (!assetUrl && (format === "pdf" || !content))
+        return null;
+    return () => {
+        const convert = format === "pdf"
+            ? import("@rightkit/document-core/documents/pdf/pdfToMarkdown").then((m) => m.pdfUrlToMarkdown(assetUrl))
+            : (assetUrl
+                ? fetch(assetUrl).then((r) => r.arrayBuffer())
+                : import("@rightkit/docx-editor/documents/docx/blankDocx").then((m) => m.base64ToBuffer(content)))
+                .then((buf) => import("@rightkit/docx-editor/documents/docx/docxToMarkdown").then((m) => m.docxBytesToMarkdown(buf)));
+        void convert
+            .then((md) => writeClipboardText(md))
+            .then(() => toast("Markdown copied", "success"))
+            .catch((e) => toast(`Couldn't copy as Markdown: ${errorMessage(e)}`, "error"));
+    };
+}