@rightkit/document-workspace 0.0.0-stage → 0.1.0

package/dist/app/useAppTabChrome.js

@@ -0,0 +1,66 @@
+import { useCallback, useMemo } from "react";
+import { useTabChrome } from "./useTabChrome.js";
+import { useDocumentZoom } from "./useDocumentZoom.js";
+import { useAppLifecycle } from "./AppLifecycle.js";
+import { useOpenFromClipboard } from "./useOpenFromClipboard.js";
+import { baseName, isUntitled } from "@rightkit/document-core/documents/types";
+/**
+ * Titlebar title, tab strip, document zoom, the open-file watch set, the lifecycle effects, and the
+ * open-from-clipboard action. Extracted verbatim from useAppState; hook call order is unchanged.
+ */
+export function useAppTabChrome({ docs, tabs, activePath, sidebarCollapsed, tabOverviewOpen, setTabOverviewOpen, pinnedPaths, onTogglePin, dirtyPaths, subscribeDirty, active, view, settings, update, autoUpdateCheckRan, }) {
+    const { titleFor } = docs;
+    // Title bar carries the extension (e.g. "notes.md"); sidebar tabs stay stripped (the badge shows extension).
+    // As a function so the Toolbar's LiveTitle can recompute it live while typing an untitled doc.
+    const titleBarTitleFor = useCallback((d) => d.format === "web" || isUntitled(d.path) ? titleFor(d) : baseName(d.path), [titleFor]);
+    const { tabStripProps, openPathsSet, openExplorerPath, cycleTab, jumpToTab } = useTabChrome({
+        tabs,
+        docs,
+        activePath,
+        sidebarCollapsed,
+        tabOverviewOpen,
+        setTabOverviewOpen,
+        pinnedPaths,
+        onTogglePin,
+        titleBarTitleFor,
+        dirtyPaths,
+        subscribeDirty,
+    });
+    // Ctrl/Cmd+wheel document zoom + the zoom HUD/reset pill — extracted to useDocumentZoom.
+    const zoom = useDocumentZoom({ active, view, settings, update });
+    // Watch EVERY open file-backed tab plus each HTML session's visited sub-pages, in the one watcher.
+    // An external edit to ANY of them (active or background) arrives via the `file-changed` event and
+    // reloads that tab when it happens — so tab activation is a pure state change (no re-stat /
+    // reload-on-switch) and a background tab is already fresh by the time you click it. Keyed on the
+    // sorted path set so it re-arms only when a tab opens/closes/navigates, not on every keystroke.
+    const watchKey = useMemo(() => {
+        const files = tabs.openDocs
+            .filter((d) => d.format !== "web" && !isUntitled(d.path))
+            .map((d) => d.path);
+        const subPages = Object.values(tabs.htmlPages).flatMap((session) => Object.keys(session));
+        return [...new Set([...files, ...subPages])].sort().join("|");
+    }, [tabs.openDocs, tabs.htmlPages]);
+    // Ready-show, file watcher re-arm, background update check, and the "open URL as a tab" wiring.
+    useAppLifecycle({
+        watchKey,
+        autoCheckUpdates: settings.autoCheckUpdates,
+        autoUpdateCheckRan,
+        openLiveUrl: docs.openLiveUrl,
+    });
+    const openFromClipboard = useOpenFromClipboard({
+        open: docs.open,
+        openLiveUrl: docs.openLiveUrl,
+        duplicateAsDraft: docs.duplicateAsDraft,
+        setError: docs.setError,
+    });
+    return {
+        titleBarTitleFor,
+        tabStripProps,
+        openPathsSet,
+        openExplorerPath,
+        cycleTab,
+        jumpToTab,
+        zoom,
+        openFromClipboard,
+    };
+}

package/dist/app/useAutoSave.d.ts

@@ -0,0 +1,34 @@
+import { type MutableRefObject } from "react";
+import { type LoadedDocument } from "@rightkit/document-core/documents/types";
+interface AutoSaveDeps {
+    /** settings.autoSave — file-backed edits persist after a short idle delay. */
+    autoSave: boolean;
+    openDocs: LoadedDocument[];
+    openDocsRef: MutableRefObject<LoadedDocument[]>;
+    activePath: string | null;
+    activePathRef: MutableRefObject<string | null>;
+    isDirty: (doc: LoadedDocument) => boolean;
+    docxSaver: MutableRefObject<(() => Promise<ArrayBuffer | null>) | null>;
+    onDocxSave: (path: string, buffer: ArrayBuffer) => Promise<void>;
+    onSave: (doc: LoadedDocument, options?: {
+        silent?: boolean;
+        resolveDrafts?: boolean;
+    }) => Promise<string | null>;
+    saveAllHtmlPages: (entryPath: string, options?: {
+        silent?: boolean;
+    }) => Promise<boolean>;
+    /** Scheduler slot the orchestrator's stable `queueAutoSave` forwarder calls through — assigned
+     *  here each render (same ref-forward contract as before: the forwarder exists before this hook
+     *  can be constructed, so the ref bridges the gap). */
+    autoSaveSchedulerRef: MutableRefObject<(path: string) => void>;
+}
+/**
+ * Idle-delay autosave for file-backed tabs (txt/md via onSave, docx via the active bridge's
+ * exporter, image via the payload saver, html via the session's saveAllHtmlPages), plus the T2-1
+ * draft-flush guards on unload/hide. Extracted verbatim from useDocuments — bodies unchanged; the
+ * only edits are `settings.autoSave`/`htmlSession.saveAllHtmlPages` read through their narrower
+ * params. `autoSaveTimers` is owned here; `autoSaveSchedulerRef` stays owned by the orchestrator so
+ * `queueAutoSave` (needed earlier, before this hook's deps exist) keeps its stable identity.
+ */
+export declare function useAutoSave({ autoSave, openDocs, openDocsRef, activePath, activePathRef, isDirty, docxSaver, onDocxSave, onSave, saveAllHtmlPages, autoSaveSchedulerRef, }: AutoSaveDeps): void;
+export {};

package/dist/app/useAutoSave.js

@@ -0,0 +1,116 @@
+import { useCallback, useEffect, useRef } from "react";
+import { isUntitled } from "@rightkit/document-core/documents/types";
+import { editableImageOutputForPath } from "@rightkit/media-ui";
+import { flushDrafts } from "./documentDrafts.js";
+const AUTO_SAVE_DELAY_MS = 1000;
+/**
+ * Idle-delay autosave for file-backed tabs (txt/md via onSave, docx via the active bridge's
+ * exporter, image via the payload saver, html via the session's saveAllHtmlPages), plus the T2-1
+ * draft-flush guards on unload/hide. Extracted verbatim from useDocuments — bodies unchanged; the
+ * only edits are `settings.autoSave`/`htmlSession.saveAllHtmlPages` read through their narrower
+ * params. `autoSaveTimers` is owned here; `autoSaveSchedulerRef` stays owned by the orchestrator so
+ * `queueAutoSave` (needed earlier, before this hook's deps exist) keeps its stable identity.
+ */
+export function useAutoSave({ autoSave, openDocs, openDocsRef, activePath, activePathRef, isDirty, docxSaver, onDocxSave, onSave, saveAllHtmlPages, autoSaveSchedulerRef, }) {
+    const autoSaveTimers = useRef(new Map());
+    const scheduleAutoSave = useCallback((path) => {
+        const prior = autoSaveTimers.current.get(path);
+        if (prior)
+            clearTimeout(prior);
+        autoSaveTimers.current.delete(path);
+        if (!autoSave || isUntitled(path))
+            return;
+        const timer = setTimeout(() => {
+            autoSaveTimers.current.delete(path);
+            const doc = openDocsRef.current.find((candidate) => candidate.path === path);
+            if (!doc || !isDirty(doc))
+                return;
+            if (doc.format === "docx") {
+                // The imperative DOCX saver belongs to the active mounted bridge. Never risk using another
+                // tab's bridge if the user switched tabs during the idle delay.
+                if (activePathRef.current !== path)
+                    return;
+                void docxSaver.current?.().then((buffer) => {
+                    if (buffer)
+                        void onDocxSave(path, buffer);
+                });
+                return;
+            }
+            if (doc.format === "image") {
+                if (activePathRef.current !== path || !editableImageOutputForPath(path))
+                    return;
+                void onSave(doc, { silent: true, resolveDrafts: false });
+                return;
+            }
+            if (doc.format === "html") {
+                void saveAllHtmlPages(path, { silent: true });
+                return;
+            }
+            void onSave(doc, { silent: true, resolveDrafts: false });
+        }, AUTO_SAVE_DELAY_MS);
+        autoSaveTimers.current.set(path, timer);
+    }, [
+        docxSaver,
+        saveAllHtmlPages,
+        isDirty,
+        onDocxSave,
+        onSave,
+        autoSave,
+        activePathRef,
+        openDocsRef,
+    ]);
+    autoSaveSchedulerRef.current = scheduleAutoSave;
+    useEffect(() => {
+        if (autoSave) {
+            for (const doc of openDocs)
+                if (isDirty(doc))
+                    scheduleAutoSave(doc.path);
+            return;
+        }
+        for (const timer of autoSaveTimers.current.values())
+            clearTimeout(timer);
+        autoSaveTimers.current.clear();
+    }, [isDirty, openDocs, scheduleAutoSave, autoSave]);
+    // DOCX and image exporters are registered by their active viewer. If a user switches tabs during
+    // the idle delay, their timer intentionally skips that unsafe save; retry when the tab becomes
+    // active again so autosave does not remain stranded behind the active-viewer guard.
+    useEffect(() => {
+        if (!autoSave || !activePath)
+            return;
+        const active = openDocs.find((doc) => doc.path === activePath);
+        if (active && isDirty(active))
+            scheduleAutoSave(active.path);
+    }, [activePath, isDirty, openDocs, scheduleAutoSave, autoSave]);
+    useEffect(() => () => {
+        for (const timer of autoSaveTimers.current.values())
+            clearTimeout(timer);
+        autoSaveTimers.current.clear();
+    }, []);
+    // T2-1 data-loss guard: onTxtChange's draft writes are debounced (~400ms). If the window/process goes
+    // away before a pending write's timer fires, that in-flight edit would be lost from the recovery
+    // draft (the live in-memory editsRef is what save/close actually use, so this only protects the
+    // startup-restore draft, not save correctness). Flush synchronously on both signals — beforeunload
+    // covers window close/reload, visibilitychange-hidden also covers OS-level app switch/minimize/quit
+    // paths that don't reliably fire beforeunload in a Tauri webview.
+    useEffect(() => {
+        const onBeforeUnload = (event) => {
+            flushDrafts();
+            // Browser close guard: block navigation if any file-backed dirty doc or modified block draft exists.
+            const hasUnsavedWork = openDocsRef.current.some((doc) => isDirty(doc));
+            if (hasUnsavedWork) {
+                event.preventDefault();
+                event.returnValue = "";
+            }
+        };
+        const onVisibilityChange = () => {
+            if (document.visibilityState === "hidden")
+                flushDrafts();
+        };
+        window.addEventListener("beforeunload", onBeforeUnload);
+        document.addEventListener("visibilitychange", onVisibilityChange);
+        return () => {
+            window.removeEventListener("beforeunload", onBeforeUnload);
+            document.removeEventListener("visibilitychange", onVisibilityChange);
+        };
+    }, [isDirty, openDocsRef]);
+}

package/dist/app/useCloseAll.d.ts

@@ -0,0 +1,52 @@
+import { type MutableRefObject } from "react";
+import { type LoadedDocument } from "@rightkit/document-core/documents/types";
+import type { DocumentTabs } from "./useDocumentTabs.js";
+import type { BlockDraftRegistry } from "@rightkit/document-core/app/blockDrafts";
+import type { useHtmlSession } from "./useHtmlSession.js";
+interface CloseAllDeps {
+    openDocsRef: MutableRefObject<LoadedDocument[]>;
+    isDirty: (doc: LoadedDocument) => boolean;
+    setOpenDocs: DocumentTabs["setOpenDocs"];
+    setActivePath: DocumentTabs["setActivePath"];
+    teardownDoc: (path: string, closingDoc: LoadedDocument | undefined) => void;
+    blockDrafts: BlockDraftRegistry;
+    /** Whole session object (same as the original deps-array entries): only saveAllHtmlPages is
+     *  used, but passing the session keeps both call sites' dep expressions identical to inline. */
+    htmlSession: ReturnType<typeof useHtmlSession>;
+    onSaveFlushed: (doc: LoadedDocument, options?: {
+        silent?: boolean;
+    }) => Promise<string | null>;
+    docxSaver: MutableRefObject<(() => Promise<ArrayBuffer | null>) | null>;
+    docxSaversRef: MutableRefObject<Map<string, () => Promise<ArrayBuffer | null>>>;
+    onDocxSave: (path: string, buffer: ArrayBuffer) => Promise<void>;
+    onDocxSaveAs: (doc: LoadedDocument, buffer?: ArrayBuffer) => Promise<string | null>;
+}
+/**
+ * Bulk close + quit flows. Close All snapshots ordered affected paths (sorted dirty tabs) plus the
+ * full ordered snapshot so Save All/Don't Save can close clean tabs only after the dirty queue
+ * succeeds; the quit flow runs the same Save-All/Discard-All choice before destroying the window.
+ * Owns the confirmQuit/confirmCloseAll dialog state (not needed until after requestClose is
+ * constructed, so unlike the close/conflict/html dialog state it can live in this hook).
+ * Extracted verbatim from useDocuments; bodies are unchanged.
+ */
+export declare function useCloseAll({ openDocsRef, isDirty, setOpenDocs, setActivePath, teardownDoc, blockDrafts, htmlSession, onSaveFlushed, docxSaver, docxSaversRef, onDocxSave, onDocxSaveAs, }: CloseAllDeps): {
+    confirmQuit: boolean;
+    setConfirmQuit: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    confirmCloseAll: {
+        orderedPaths: string[];
+        affectedPaths: string[];
+    } | null;
+    setConfirmCloseAll: import("react").Dispatch<import("react").SetStateAction<{
+        orderedPaths: string[];
+        affectedPaths: string[];
+    } | null>>;
+    closeAll: () => void;
+    closeMany: (paths: string[]) => void;
+    confirmCloseAllSaveAll: () => Promise<void>;
+    confirmCloseAllDontSave: () => Promise<void>;
+    confirmCloseAllCancel: () => void;
+    quitNow: () => Promise<void>;
+    quitSaveAll: () => Promise<void>;
+    quitDiscardAll: () => Promise<void>;
+};
+export {};

package/dist/app/useCloseAll.js

@@ -0,0 +1,295 @@
+import { useCallback, useRef, useState } from "react";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+import { isUntitled } from "@rightkit/document-core/documents/types";
+import { toast } from "@rightkit/platform-ui/headless";
+import { resolveDocumentDrafts } from "./draftResolution.js";
+/**
+ * Bulk close + quit flows. Close All snapshots ordered affected paths (sorted dirty tabs) plus the
+ * full ordered snapshot so Save All/Don't Save can close clean tabs only after the dirty queue
+ * succeeds; the quit flow runs the same Save-All/Discard-All choice before destroying the window.
+ * Owns the confirmQuit/confirmCloseAll dialog state (not needed until after requestClose is
+ * constructed, so unlike the close/conflict/html dialog state it can live in this hook).
+ * Extracted verbatim from useDocuments; bodies are unchanged.
+ */
+export function useCloseAll({ openDocsRef, isDirty, setOpenDocs, setActivePath, teardownDoc, blockDrafts, htmlSession, onSaveFlushed, docxSaver, docxSaversRef, onDocxSave, onDocxSaveAs, }) {
+    const [confirmQuit, setConfirmQuit] = useState(false);
+    // Close All bulk chooser: snapshots ordered affected paths (sorted dirty tabs) plus full ordered
+    // snapshot so Save All/Don't Save can close clean tabs only after the dirty queue succeeds.
+    const [confirmCloseAll, setConfirmCloseAll] = useState(null);
+    // Close All: one operation per spec. Snapshot ordered affected paths. If any dirty
+    // (isDirty includes modified block drafts), open the bulk Save/Don't Save/Cancel
+    // chooser instead of auto-saving. The dialog lists ordered dirty docs; Save All
+    // resolves each draft with Done then persists sequentially, stopping on first
+    // failure/cancel (no teardown for remaining). Don't Save discards drafts then
+    // closes all. Cancel stays. Clean tabs close only via the chooser's Save/Don't
+    // Save path — they are not torn down before the user decides.
+    const closeAllInProgress = useRef(false);
+    /** After `closedPaths` leave the tab list, keep the current active tab if it survives; otherwise
+     *  activate the first remaining tab (snapshot order). closeAll() gets remaining=[] → null, so the
+     *  old null-out behavior is preserved. */
+    const fixActiveAfterClose = useCallback((closedPaths) => {
+        const closed = new Set(closedPaths);
+        setActivePath((cur) => {
+            if (cur && !closed.has(cur))
+                return cur;
+            const remaining = openDocsRef.current.filter((d) => !closed.has(d.path));
+            return remaining[0]?.path ?? null;
+        });
+    }, [openDocsRef, setActivePath]);
+    /** Close a chosen subset of tabs — the engine behind Close All, Close Others, and Close to the
+     *  Right. Dirty docs route through the same Save All / Don't Save bulk chooser closeAll uses. */
+    const closeMany = useCallback((paths) => {
+        if (closeAllInProgress.current)
+            return;
+        if (confirmCloseAll)
+            return; // dialog already open
+        const wanted = new Set(paths);
+        const ordered = [...openDocsRef.current]
+            .filter((d) => wanted.has(d.path))
+            .sort((a, b) => a.path.localeCompare(b.path));
+        if (ordered.length === 0)
+            return;
+        const affected = ordered.filter((doc) => isDirty(doc));
+        if (affected.length === 0) {
+            for (const doc of ordered)
+                teardownDoc(doc.path, doc);
+            const orderedSet = new Set(ordered.map((d) => d.path));
+            setOpenDocs((prev) => prev.filter((d) => !orderedSet.has(d.path)));
+            fixActiveAfterClose(ordered.map((d) => d.path));
+            return;
+        }
+        setConfirmCloseAll({
+            orderedPaths: ordered.map((d) => d.path),
+            affectedPaths: affected.map((d) => d.path),
+        });
+    }, [isDirty, teardownDoc, setOpenDocs, fixActiveAfterClose, confirmCloseAll, openDocsRef]);
+    const closeAll = useCallback(() => {
+        closeMany(openDocsRef.current.map((d) => d.path));
+    }, [closeMany, openDocsRef]);
+    const confirmCloseAllSaveAll = useCallback(async () => {
+        const snapshot = confirmCloseAll;
+        if (!snapshot)
+            return;
+        if (closeAllInProgress.current)
+            return;
+        closeAllInProgress.current = true;
+        setConfirmCloseAll(null);
+        try {
+            const { orderedPaths, affectedPaths } = snapshot;
+            // Save each affected doc in snapshot order (already sorted)
+            for (const path of affectedPaths) {
+                const doc = openDocsRef.current.find((d) => d.path === path);
+                if (!doc)
+                    continue;
+                // Save = Done then persist. Resolve draft first; a stale/failed Done blocks the write.
+                if (blockDrafts.snapshotModified(path).length > 0) {
+                    const outcome = await resolveDocumentDrafts(blockDrafts, path, "close-all", "done");
+                    if (outcome !== "resolved") {
+                        toast(`Close All cancelled — could not save ${doc.displayName}`, "error");
+                        return;
+                    }
+                }
+                if (doc.format === "html") {
+                    const ok = await htmlSession.saveAllHtmlPages(path);
+                    if (!ok) {
+                        toast(`Close All cancelled — could not save ${doc.displayName}`, "error");
+                        return;
+                    }
+                }
+                else if (doc.format === "docx") {
+                    if (isUntitled(doc.path)) {
+                        const savedPath = await onDocxSaveAs(doc);
+                        if (!savedPath) {
+                            toast(`Close All cancelled — could not save ${doc.displayName}`, "error");
+                            return;
+                        }
+                        const newDoc = openDocsRef.current.find((d) => d.path === savedPath) ?? {
+                            ...doc,
+                            path: savedPath,
+                        };
+                        teardownDoc(savedPath, newDoc);
+                        // Remove both old untitled path (if still present) and new saved path in one update
+                        setOpenDocs((prev) => prev.filter((d) => d.path !== path && d.path !== savedPath));
+                        continue;
+                    }
+                    const ab = await (docxSaversRef.current.get(path) ?? docxSaver.current)?.();
+                    if (ab) {
+                        await onDocxSave(path, ab);
+                    }
+                    else {
+                        toast(`Close All cancelled — could not save ${doc.displayName}`, "error");
+                        return;
+                    }
+                }
+                else if (doc.format === "image") {
+                    const saved = await onSaveFlushed(doc);
+                    if (!saved) {
+                        toast(`Close All cancelled — could not save ${doc.displayName}`, "error");
+                        return;
+                    }
+                    if (isUntitled(doc.path) && typeof saved === "string" && saved !== path) {
+                        const newDoc = openDocsRef.current.find((d) => d.path === saved) ?? {
+                            ...doc,
+                            path: saved,
+                        };
+                        teardownDoc(saved, newDoc);
+                        setOpenDocs((prev) => prev.filter((d) => d.path !== path && d.path !== saved));
+                        continue;
+                    }
+                }
+                else {
+                    const saved = await onSaveFlushed(doc);
+                    if (!saved) {
+                        toast(`Close All cancelled — could not save ${doc.displayName}`, "error");
+                        return;
+                    }
+                    if (isUntitled(doc.path) && typeof saved === "string" && saved !== path) {
+                        const newDoc = openDocsRef.current.find((d) => d.path === saved) ?? {
+                            ...doc,
+                            path: saved,
+                        };
+                        teardownDoc(saved, newDoc);
+                        setOpenDocs((prev) => prev.filter((d) => d.path !== path && d.path !== saved));
+                        continue;
+                    }
+                }
+                teardownDoc(path, doc);
+                setOpenDocs((prev) => prev.filter((d) => d.path !== path));
+            }
+            // All affected saved; now close clean tabs in one batch
+            const cleanPaths = orderedPaths.filter((p) => !affectedPaths.includes(p));
+            for (const p of cleanPaths) {
+                const doc = openDocsRef.current.find((d) => d.path === p);
+                if (doc)
+                    teardownDoc(p, doc);
+            }
+            if (cleanPaths.length > 0) {
+                const cleanSet = new Set(cleanPaths);
+                setOpenDocs((prev) => prev.filter((d) => !cleanSet.has(d.path)));
+            }
+            fixActiveAfterClose(orderedPaths);
+        }
+        finally {
+            closeAllInProgress.current = false;
+        }
+    }, [
+        confirmCloseAll,
+        blockDrafts,
+        htmlSession,
+        onSaveFlushed,
+        docxSaver,
+        docxSaversRef,
+        onDocxSave,
+        onDocxSaveAs,
+        teardownDoc,
+        setOpenDocs,
+        fixActiveAfterClose,
+        openDocsRef,
+    ]);
+    const confirmCloseAllDontSave = useCallback(async () => {
+        const snapshot = confirmCloseAll;
+        if (!snapshot)
+            return;
+        if (closeAllInProgress.current)
+            return;
+        closeAllInProgress.current = true;
+        setConfirmCloseAll(null);
+        try {
+            const { orderedPaths, affectedPaths } = snapshot;
+            for (const path of affectedPaths) {
+                if (blockDrafts.snapshotModified(path).length > 0) {
+                    await resolveDocumentDrafts(blockDrafts, path, "close-all", "discard");
+                }
+            }
+            for (const p of orderedPaths) {
+                const doc = openDocsRef.current.find((d) => d.path === p);
+                if (doc)
+                    teardownDoc(p, doc);
+            }
+            const orderedSet = new Set(orderedPaths);
+            setOpenDocs((prev) => prev.filter((d) => !orderedSet.has(d.path)));
+            fixActiveAfterClose(orderedPaths);
+        }
+        finally {
+            closeAllInProgress.current = false;
+        }
+    }, [confirmCloseAll, blockDrafts, teardownDoc, setOpenDocs, fixActiveAfterClose, openDocsRef]);
+    const confirmCloseAllCancel = useCallback(() => {
+        setConfirmCloseAll(null);
+    }, []);
+    const quitNow = useCallback(async () => {
+        await getCurrentWindow().destroy();
+    }, []);
+    // Save All before quit: snapshot ordered affected paths, resolve/save every affected
+    // document+page in sequence; quit only after every Done + disk write succeeds. Any failure
+    // cancels the quit with the tab still open. Single sequential operation per spec.
+    const quitSaveAll = useCallback(async () => {
+        const ordered = [...openDocsRef.current]
+            .filter((doc) => isDirty(doc))
+            .sort((a, b) => a.path.localeCompare(b.path));
+        // Ensure block-draft ordering is respected: snapshotModified is already sorted by identity key,
+        // but ordering the doc list by path matches that deterministic order for the document-level loop.
+        for (const doc of ordered) {
+            if (doc.format === "html") {
+                const ok = await htmlSession.saveAllHtmlPages(doc.path);
+                if (!ok) {
+                    toast(`Quit cancelled — could not save ${doc.displayName}`, "error");
+                    return;
+                }
+            }
+            else if (doc.format === "docx") {
+                const buffer = await (docxSaversRef.current.get(doc.path) ?? docxSaver.current)?.();
+                let saved = null;
+                if (isUntitled(doc.path))
+                    saved = await onDocxSaveAs(doc, buffer ?? undefined);
+                else if (buffer) {
+                    await onDocxSave(doc.path, buffer);
+                    saved = doc.path;
+                }
+                if (!saved) {
+                    toast(`Quit cancelled — could not save ${doc.displayName}`, "error");
+                    return;
+                }
+            }
+            else {
+                const saved = await onSaveFlushed(doc);
+                if (!saved) {
+                    toast(`Quit cancelled — could not save ${doc.displayName}`, "error");
+                    return;
+                }
+            }
+        }
+        await quitNow();
+    }, [
+        htmlSession.saveAllHtmlPages,
+        isDirty,
+        onSaveFlushed,
+        quitNow,
+        docxSaversRef,
+        docxSaver,
+        onDocxSaveAs,
+        onDocxSave,
+        openDocsRef,
+    ]);
+    // Quit without saving: discard every open block draft, then quit (whole-document edits are
+    // dropped by the existing dirty-state semantics).
+    const quitDiscardAll = useCallback(async () => {
+        for (const draft of blockDrafts.snapshotModified())
+            await blockDrafts.resolve(draft.identity, "quit", "discard");
+        await quitNow();
+    }, [blockDrafts, quitNow]);
+    return {
+        confirmQuit,
+        setConfirmQuit,
+        confirmCloseAll,
+        setConfirmCloseAll,
+        closeAll,
+        closeMany,
+        confirmCloseAllSaveAll,
+        confirmCloseAllDontSave,
+        confirmCloseAllCancel,
+        quitNow,
+        quitSaveAll,
+        quitDiscardAll,
+    };
+}

package/dist/app/useClosedTabEviction.d.ts

@@ -0,0 +1,10 @@
+import type { LoadedDocument } from "@rightkit/document-core/documents/types";
+/** Auto-evict per-path caches when tabs close: compare previous openDocs to current and evict removed
+ * paths. Extracted verbatim from App.tsx. */
+export declare function useClosedTabEviction({ openDocs, onEvictPath, dropHtmlProps, sourceViewStateRef, pruneClosedPaths, }: {
+    openDocs: LoadedDocument[];
+    onEvictPath: (path: string) => void;
+    dropHtmlProps: (path: string) => void;
+    sourceViewStateRef: React.MutableRefObject<Record<string, unknown>>;
+    pruneClosedPaths: (paths: string[]) => void;
+}): void;

package/dist/app/useClosedTabEviction.js

@@ -0,0 +1,38 @@
+import { useEffect, useRef } from "react";
+import { clearImageEditSnapshot } from "@rightkit/media-ui";
+import { inTauri } from "@rightkit/document-core/state/tauriBridge";
+import { isMac } from "@rightkit/document-core/platform";
+/** Auto-evict per-path caches when tabs close: compare previous openDocs to current and evict removed
+ * paths. Extracted verbatim from App.tsx. */
+export function useClosedTabEviction({ openDocs, onEvictPath, dropHtmlProps, sourceViewStateRef, pruneClosedPaths, }) {
+    const prevOpenDocsRef = useRef(openDocs);
+    useEffect(() => {
+        const prev = prevOpenDocsRef.current;
+        if (prev !== openDocs) {
+            const current = new Set(openDocs.map((d) => d.path));
+            const closedPaths = [];
+            for (const doc of prev) {
+                if (!current.has(doc.path)) {
+                    onEvictPath(doc.path);
+                    dropHtmlProps(doc.path);
+                    clearImageEditSnapshot(doc.path);
+                    // A PDF pane can unmount merely because its router leaves the live-tab budget.
+                    // Only removal from openDocs is terminal for its parked native reader.
+                    if (doc.format === "pdf" && inTauri() && isMac()) {
+                        void import("@rightkit/document-core/documents/pdf/macPdfNativeBridge")
+                            .then(({ nativePdfClosePath }) => nativePdfClosePath(doc.path))
+                            .catch(() => undefined);
+                    }
+                    delete sourceViewStateRef.current[doc.path];
+                    closedPaths.push(doc.path);
+                }
+            }
+            // T5-2: drop closed tabs' rendered/live/recent keep-alive markers too — owned by
+            // usePaneLiveness (see the hook for why each set must be pruned).
+            if (closedPaths.length) {
+                pruneClosedPaths(closedPaths);
+            }
+            prevOpenDocsRef.current = openDocs;
+        }
+    }, [openDocs, pruneClosedPaths, dropHtmlProps, onEvictPath, sourceViewStateRef]);
+}

package/dist/app/useCommandPalette.d.ts

@@ -0,0 +1,44 @@
+import { type LoadedDocument, type ViewMode } from "@rightkit/document-core/documents/types";
+import type { FileEntry } from "../state/library.js";
+import type { Settings } from "@rightkit/document-core/settings/settings";
+import type { DocxMenuApi } from "@rightkit/docx-editor/documents/docx/menuApi";
+import type { PaletteItem } from "./CommandPalette.js";
+interface PaletteDeps {
+    openDocs: LoadedDocument[];
+    recents: FileEntry[];
+    active: LoadedDocument | null;
+    activeEditable: boolean;
+    titleFor: (doc: LoadedDocument) => string;
+    activate: (path: string) => void | Promise<void>;
+    openRecent: (entry: FileEntry) => undefined | Promise<unknown>;
+    newDocument: () => void;
+    onOpenDialog: () => void | Promise<void>;
+    onOpenUrl: () => void;
+    onSave: (doc: LoadedDocument) => undefined | Promise<unknown>;
+    onSaveAs: (doc: LoadedDocument) => undefined | Promise<unknown>;
+    onPrint: (doc: LoadedDocument | null) => void;
+    docxMenu: DocxMenuApi | null;
+    onChangeView: (next: ViewMode) => void | Promise<void>;
+    settings: Settings;
+    update: (patch: Partial<Settings>) => void;
+    openSettings: () => void;
+    reopenClosed: () => void;
+    showHelp: () => void;
+    /** Copy the active document's text (text-like formats only); null/undefined hides the command. */
+    copyContents: (() => void) | null;
+    /** Export the active Markdown doc to HTML / plain text; null hides the commands. */
+    exportMarkdown: ((target: "html" | "txt") => void) | null;
+    /** Copy the active Markdown's RENDERED output to the clipboard (rich HTML + text); null hides it. */
+    copyRendered: (() => void) | null;
+    /** Copy a PDF/DOCX converted to Markdown; null hides it. */
+    copyAsMarkdown: (() => void) | null;
+    /** Duplicate the active text doc into a new unsaved draft; null hides the command. */
+    duplicate: (() => void) | null;
+}
+/**
+ * Command-palette entries: open tabs + recents + context-aware commands. Routes through the
+ * existing document handlers — the palette is just a uniform, cross-format way to reach them.
+ * Format-specific commands (save/print/view) gate on `capabilitiesFor`, not ad-hoc format checks.
+ */
+export declare function useCommandPalette(d: PaletteDeps): PaletteItem[];
+export {};