@rightkit/document-workspace 0.0.0-stage → 0.1.0

package/dist/app/useAppDocumentCore.d.ts

@@ -0,0 +1,210 @@
+/**
+ * Document core: shared tab/edit state, view state, the recents/pins library, and the open/save/dirty/close
+ * owner. Extracted verbatim from useAppState; these are the first hook calls of the app shell.
+ */
+export declare function useAppDocumentCore(): {
+    blockDrafts: import("@rightkit/document-core/app/blockDrafts").BlockDraftRegistry;
+    tabs: {
+        openDocs: import("@rightkit/document-core/documents/types").LoadedDocument[];
+        setOpenDocs: import("react").Dispatch<import("react").SetStateAction<import("@rightkit/document-core/documents/types").LoadedDocument[]>>;
+        activePath: string | null;
+        setActivePath: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+        editsRef: import("react").RefObject<Record<string, string>>;
+        writeEdits: (updater: (prev: Record<string, string>) => Record<string, string>) => void;
+        writeEditsLive: (path: string, text: string) => void;
+        subscribeEdits: (path: string, cb: () => void) => () => void;
+        getEditSnapshot: (path: string) => string;
+        getExternalSeq: (path: string) => number;
+        docxDirty: Set<string>;
+        docxDirtyRef: import("react").RefObject<Set<string>>;
+        setDocxDirty: (next: import("react").SetStateAction<Set<string>>) => void;
+        pdfDirty: Set<string>;
+        pdfDirtyRef: import("react").RefObject<Set<string>>;
+        setPdfDirty: (next: import("react").SetStateAction<Set<string>>) => void;
+        imageDirty: Set<string>;
+        imageDirtyRef: import("react").RefObject<Set<string>>;
+        setImageDirty: (next: import("react").SetStateAction<Set<string>>) => void;
+        htmlPages: import("@rightkit/html-editor/documents/html/sessionTypes").HtmlSessionPages;
+        htmlPagesRef: import("react").RefObject<import("@rightkit/html-editor/documents/html/sessionTypes").HtmlSessionPages>;
+        writeHtmlPages: (updater: (prev: import("@rightkit/html-editor/documents/html/sessionTypes").HtmlSessionPages) => import("@rightkit/html-editor/documents/html/sessionTypes").HtmlSessionPages, options?: {
+            immediate?: boolean;
+        }) => void;
+        htmlActivePage: Record<string, string>;
+        setHtmlActivePage: import("react").Dispatch<import("react").SetStateAction<Record<string, string>>>;
+        mdxGrantsRef: import("react").RefObject<Record<string, Set<string>>>;
+        trackMdxGrant: (entryPath: string, grantedPath: string) => void;
+    };
+    docBarSlot: HTMLElement | null;
+    setDocBarSlot: import("react").Dispatch<import("react").SetStateAction<HTMLElement | null>>;
+    dirtyPaths: Set<string>;
+    subscribeDirty: (path: string, listener: () => void) => () => void;
+    viewState: {
+        views: Record<string, import("@rightkit/document-core/documents/types").ViewMode>;
+        setViews: import("react").Dispatch<import("react").SetStateAction<Record<string, import("@rightkit/document-core/documents/types").ViewMode>>>;
+        viewsRef: import("react").RefObject<Record<string, import("@rightkit/document-core/documents/types").ViewMode>>;
+        viewMetaRef: import("react").RefObject<Record<string, import("@rightkit/document-core/documents/types").ViewMeta>>;
+        persistViewMeta: (path: string) => void;
+        contentScrollRef: import("react").RefObject<HTMLDivElement | null>;
+        requestViewChange: (next: import("@rightkit/document-core/documents/types").ViewMode) => Promise<void>;
+        confirmViewChange: (decision: "done" | "discard" | "stay") => Promise<void>;
+        cancelViewChange: () => void;
+        pendingViewChange: {
+            next: import("@rightkit/document-core/documents/types").ViewMode;
+            drafts: ReturnType<import("@rightkit/document-core/app/blockDrafts").BlockDraftRegistry["snapshotModified"]>;
+        } | null;
+        onContentScroll: () => void;
+        onPdfViewState: (m: import("@rightkit/document-core/documents/types").ViewMeta) => void;
+        dropViewState: (path: string) => void;
+    };
+    library: {
+        onHistoryPurged: () => void;
+        recents: import("../index.js").FileEntry[];
+        pinnedPaths: Set<string>;
+        pinnedEntries: import("../index.js").PinEntry[];
+        refreshLibrary: () => Promise<void>;
+        syncPinned: (path: string) => Promise<void>;
+        onTogglePin: (path: string) => Promise<void>;
+        onTogglePinDir: (path: string, displayName: string) => Promise<void>;
+        onClearRecents: () => Promise<void>;
+    };
+    docs: {
+        ensureHtmlPage: (entryPath: string, pagePath: string) => Promise<void>;
+        setHtmlPageEdited: (entryPath: string, pagePath: string, edited: string) => void;
+        setHtmlActive: (entryPath: string, pagePath: string) => void;
+        discardHtmlPage: (entryPath: string, pagePath: string) => void;
+        saveHtmlPage: (entryPath: string, pagePath: string, options?: {
+            silent?: boolean;
+        }) => Promise<boolean>;
+        saveAllHtmlPages: (entryPath: string, options?: {
+            silent?: boolean;
+        }) => Promise<boolean>;
+        discardAllHtmlPages: (entryPath: string) => void;
+        onHtmlSaveShortcut: (entryPath: string) => void;
+        htmlDirtyPages: (entryPath: string) => {
+            path: string;
+            name: string;
+            isEntry: boolean;
+        }[];
+        htmlSaveCurrent: () => Promise<void>;
+        htmlSaveAll: () => Promise<void>;
+        htmlDiscardAll: () => void;
+        htmlConfirmCancel: () => void;
+        htmlConflictReload: () => Promise<void>;
+        htmlConflictKeep: () => Promise<void>;
+        reloadHtmlSubpage: (path: string) => void;
+        blockDrafts: import("@rightkit/document-core/app/blockDrafts").BlockDraftRegistry;
+        activate: (path: string) => Promise<void>;
+        open: (path: string, opts?: import("./useDocumentLoader.js").OpenDocumentOptions) => Promise<void>;
+        openLiveUrl: (input: string, opts?: {
+            background?: boolean;
+        }) => Promise<void>;
+        openRecent: (entry: import("../index.js").FileEntry) => Promise<void>;
+        onOpenDialog: () => Promise<void>;
+        newDocument: (format?: "txt" | "md" | "docx") => void;
+        duplicateAsDraft: (text: string, toastMsg?: string) => void;
+        requestClose: (path: string) => void;
+        closeAll: () => void;
+        closeMany: (paths: string[]) => void;
+        reopenLastClosed: () => void;
+        openImageSibling: (currentPath: string, targetPath: string) => Promise<void>;
+        onTxtChange: (path: string, content: string, text: string) => void;
+        onSave: (doc: import("@rightkit/document-core/documents/types").LoadedDocument, options?: {
+            silent?: boolean;
+        }) => Promise<string | null>;
+        onSaveAs: (doc: import("@rightkit/document-core/documents/types").LoadedDocument) => Promise<string | null>;
+        onDocxSaveAs: (doc: import("@rightkit/document-core/documents/types").LoadedDocument, buffer?: ArrayBuffer) => Promise<string | null>;
+        onPrint: (doc: import("@rightkit/document-core/documents/types").LoadedDocument | null) => void;
+        onDocxSave: (path: string, buffer: ArrayBuffer) => Promise<void>;
+        onDocxChange: (path: string) => void;
+        onPdfDirtyChange: (path: string, dirty: boolean) => void;
+        docxSaver: import("react").RefObject<(() => Promise<ArrayBuffer | null>) | null>;
+        docxSaversRef: import("react").RefObject<Map<string, () => Promise<ArrayBuffer | null>>>;
+        pdfSaversRef: import("react").RefObject<Map<string, import("@rightkit/document-core/documents/pdf/pdfEditor").PdfSaveFunction>>;
+        pdfSavePlansRef: import("react").RefObject<Map<string, () => Promise<import("@rightkit/document-core/documents/pdf/pdfEditModel").PdfSavePlan>>>;
+        onImageChange: (path: string) => void;
+        imageSaver: import("react").RefObject<import("@rightkit/media-ui").ImageSaveFunction | null>;
+        imageSaversRef: import("react").RefObject<Map<string, import("@rightkit/media-ui").ImageSaveFunction>>;
+        onEditImageExternal: (doc: import("@rightkit/document-core/documents/types").LoadedDocument | null) => void;
+        isDirty: (doc: import("@rightkit/document-core/documents/types").LoadedDocument) => boolean;
+        hasModifiedDraft: (path: string) => boolean;
+        snapshotModified: (path?: string) => Readonly<{
+            identity: import("@rightkit/document-core/app/blockDrafts").BlockDraftIdentity;
+            blockKind: string;
+            originalRevision: string | number;
+            sourceRange?: import("@rightkit/document-core/app/blockDrafts").BlockDraftSourceRange;
+            sourceChecksum?: string;
+            originalText: string;
+            currentText: string;
+            targetTag?: string;
+            selectionBookmark?: import("@rightkit/document-core/app/blockDrafts").BlockDraftSelectionBookmark;
+            status: import("@rightkit/document-core/app/blockDrafts").BlockDraftStatus;
+            reason?: string;
+            error?: string;
+        }>[];
+        snapshotAll: (path?: string) => Readonly<{
+            identity: import("@rightkit/document-core/app/blockDrafts").BlockDraftIdentity;
+            blockKind: string;
+            originalRevision: string | number;
+            sourceRange?: import("@rightkit/document-core/app/blockDrafts").BlockDraftSourceRange;
+            sourceChecksum?: string;
+            originalText: string;
+            currentText: string;
+            targetTag?: string;
+            selectionBookmark?: import("@rightkit/document-core/app/blockDrafts").BlockDraftSelectionBookmark;
+            status: import("@rightkit/document-core/app/blockDrafts").BlockDraftStatus;
+            reason?: string;
+            error?: string;
+        }>[];
+        pendingSavePaths: Set<string>;
+        titleFor: (doc: import("@rightkit/document-core/documents/types").LoadedDocument) => string;
+        error: string | null;
+        openingPath: string | null;
+        restoringSession: boolean;
+        setError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+        confirmClose: string | null;
+        setConfirmClose: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+        confirmCloseAll: {
+            orderedPaths: string[];
+            affectedPaths: string[];
+        } | null;
+        setConfirmCloseAll: import("react").Dispatch<import("react").SetStateAction<{
+            orderedPaths: string[];
+            affectedPaths: string[];
+        } | null>>;
+        confirmCloseAllSaveAll: () => Promise<void>;
+        confirmCloseAllDontSave: () => Promise<void>;
+        confirmCloseAllCancel: () => void;
+        confirmQuit: boolean;
+        setConfirmQuit: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+        conflict: string | null;
+        setConflict: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+        keepConflict: (path: string) => Promise<void>;
+        reload: (path: string, options?: {
+            force?: boolean;
+            replayDeferred?: boolean;
+        }) => void;
+        confirmSave: () => Promise<void>;
+        confirmDontSave: () => Promise<void>;
+        applyReload: (path: string) => void;
+        quitNow: () => Promise<void>;
+        quitSaveAll: () => Promise<void>;
+        quitDiscardAll: () => Promise<void>;
+        draftConfirm: {
+            documentPath: string;
+            intent: import("@rightkit/document-core/app/blockDrafts").BlockDraftIntent;
+            onResolved: () => void;
+        } | null;
+        setDraftConfirm: import("react").Dispatch<import("react").SetStateAction<{
+            documentPath: string;
+            intent: import("@rightkit/document-core/app/blockDrafts").BlockDraftIntent;
+            onResolved: () => void;
+        } | null>>;
+        confirmDraftDone: () => Promise<void>;
+        confirmDraftDiscard: () => Promise<void>;
+        confirmDraftCancel: () => void;
+        requestDraftAwareViewChange: (path: string, proceed: () => void) => void;
+        htmlConfirm: import("./useHtmlSession.js").HtmlConfirmState;
+        htmlConflict: import("./useHtmlSession.js").HtmlConflictState;
+        trackMdxGrant: (entryPath: string, grantedPath: string) => void;
+    };
+};

package/dist/app/useAppDocumentCore.js

@@ -0,0 +1,40 @@
+import { useCallback, useMemo, useState } from "react";
+import { createBlockDraftRegistry } from "@rightkit/document-core/app/blockDrafts";
+import { useDocumentTabs } from "./useDocumentTabs.js";
+import { useViewState } from "./useViewState.js";
+import { useLibrary } from "./useLibrary.js";
+import { useDocuments } from "./useDocuments.js";
+/**
+ * Document core: shared tab/edit state, view state, the recents/pins library, and the open/save/dirty/close
+ * owner. Extracted verbatim from useAppState; these are the first hook calls of the app shell.
+ */
+export function useAppDocumentCore() {
+    const [blockDrafts] = useState(() => createBlockDraftRegistry());
+    const tabs = useDocumentTabs();
+    // App's docked-bar centre slot; formats portal their tool capsule into it (shell/docBar).
+    const [docBarSlot, setDocBarSlot] = useState(null);
+    const { openDocs, activePath, subscribeEdits } = tabs;
+    const dirtyPaths = useMemo(() => new Set([...tabs.docxDirty, ...tabs.pdfDirty, ...tabs.imageDirty]), [tabs.docxDirty, tabs.pdfDirty, tabs.imageDirty]);
+    const subscribeDirty = useCallback((path, listener) => {
+        const unsubscribeEdits = subscribeEdits(path, listener);
+        const unsubscribeDrafts = blockDrafts.subscribe(listener);
+        return () => {
+            unsubscribeEdits();
+            unsubscribeDrafts();
+        };
+    }, [blockDrafts, subscribeEdits]);
+    const viewState = useViewState(activePath, openDocs, blockDrafts);
+    const library = useLibrary(openDocs);
+    const docs = useDocuments({ tabs, viewState, library, blockDrafts });
+    return {
+        blockDrafts,
+        tabs,
+        docBarSlot,
+        setDocBarSlot,
+        dirtyPaths,
+        subscribeDirty,
+        viewState,
+        library,
+        docs,
+    };
+}

package/dist/app/useAppEffects.d.ts

@@ -0,0 +1,18 @@
+import { syncActiveFormatSavers } from "./activeFormatSavers.js";
+type SyncArgs = Parameters<typeof syncActiveFormatSavers>;
+/** Small self-contained App effects, extracted verbatim: diagnostics toggle, startup persistence
+ * warning, pane-active paint marker, active-format saver sync, and the native-menu Settings event. */
+export declare function useAppEffects({ diagnosticsSetting, activePath, docxSaver, imageSaver, docxSaversRef, imageSaversRef, openSettings, }: {
+    diagnosticsSetting: boolean | undefined;
+    activePath: SyncArgs[0];
+    docxSaver: SyncArgs[1];
+    imageSaver: SyncArgs[2];
+    docxSaversRef: {
+        current: SyncArgs[3];
+    };
+    imageSaversRef: {
+        current: SyncArgs[4];
+    };
+    openSettings: () => void;
+}): void;
+export {};

package/dist/app/useAppEffects.js

@@ -0,0 +1,52 @@
+import { useEffect, useLayoutEffect } from "react";
+import { toast } from "@rightkit/platform-ui/headless";
+import { logEvent, setDiagnosticsEnabled } from "@rightkit/document-core/state/diagnostics";
+import { getPersistenceStatus } from "@rightkit/document-core/state/tauriBridge";
+import { scheduleAfterPaint } from "@rightkit/document-core/app/deferredMount";
+import { syncActiveFormatSavers } from "./activeFormatSavers.js";
+import { hostAppName } from "../appName.js";
+/** Small self-contained App effects, extracted verbatim: diagnostics toggle, startup persistence
+ * warning, pane-active paint marker, active-format saver sync, and the native-menu Settings event. */
+export function useAppEffects({ diagnosticsSetting, activePath, docxSaver, imageSaver, docxSaversRef, imageSaversRef, openSettings, }) {
+    // diagnostics.ts caches the privacy toggle instead of re-parsing settings per event; keep it current.
+    useEffect(() => {
+        setDiagnosticsEnabled(diagnosticsSetting !== false);
+    }, [diagnosticsSetting]);
+    // Startup: warn persistently when the local database was unreadable and had to be replaced.
+    useEffect(() => {
+        void (async () => {
+            try {
+                const status = await getPersistenceStatus();
+                if (status.degraded) {
+                    toast(status.quarantinedTo
+                        ? `${hostAppName()} couldn't read its local database, so recent files, pins and tabs start empty. The original was kept at ${status.quarantinedTo}.`
+                        : `${hostAppName()} couldn't open its local database; recent files, tabs and settings won't be saved this session.`, { kind: "warning", ttl: 0 });
+                }
+            }
+            catch {
+                // Status probe is best-effort; a failed probe must not block startup.
+            }
+        })();
+    }, []);
+    // Post-paint marker — independent of resource reconciliation. The marker effect's
+    // deps are [activePath] only so the cleanup-then-rerun pattern in the deferred-mount effect
+    // (which cancels its own rAFs when renderedPaths updates) does not also cancel this log.
+    // Fires for both cold & warm clicks as a "pane became active" latency marker.
+    useEffect(() => {
+        if (!activePath)
+            return;
+        return scheduleAfterPaint(() => {
+            logEvent("pane:active:paint");
+        });
+    }, [activePath]);
+    // Restore an already-mounted DOCX/image tab's registered saver before paint. Clearing both
+    // refs loses warm viewers because their registration effect correctly does not remount.
+    useLayoutEffect(() => {
+        syncActiveFormatSavers(activePath, docxSaver, imageSaver, docxSaversRef.current, imageSaversRef.current);
+    }, [activePath, docxSaver, docxSaversRef, imageSaver, imageSaversRef]);
+    // macOS app menu: the host app › Settings… (⌘,) fires this from the native menu bridge.
+    useEffect(() => {
+        window.addEventListener("viewright:open-settings", openSettings);
+        return () => window.removeEventListener("viewright:open-settings", openSettings);
+    }, [openSettings]);
+}

package/dist/app/useAppPaneSearch.d.ts

@@ -0,0 +1,37 @@
+import type { LoadedDocument, SearchProvider } from "@rightkit/document-core/documents/types";
+import type { createBlockDraftRegistry } from "@rightkit/document-core/app/blockDrafts";
+import type { useDocuments } from "./useDocuments.js";
+import type { useDocumentTabs } from "./useDocumentTabs.js";
+import type { useAppShellSetup } from "./useAppShellSetup.js";
+type Docs = ReturnType<typeof useDocuments>;
+type Tabs = ReturnType<typeof useDocumentTabs>;
+type Setup = ReturnType<typeof useAppShellSetup>;
+export interface AppPaneSearchInput {
+    docs: Docs;
+    tabs: Tabs;
+    openDocs: LoadedDocument[];
+    activePath: Tabs["activePath"];
+    active: LoadedDocument | null;
+    blockDrafts: ReturnType<typeof createBlockDraftRegistry>;
+    previewScrollStore: Setup["previewScrollStore"];
+    sourceViewStateRef: Setup["sourceViewStateRef"];
+}
+/**
+ * Warm-MRU pane liveness, search controller, stable per-path search registration, HTML session props,
+ * and closed-tab eviction. Extracted verbatim from useAppState; hook call order is unchanged.
+ */
+export declare function useAppPaneSearch({ docs, tabs, openDocs, activePath, active, blockDrafts, previewScrollStore, sourceViewStateRef, }: AppPaneSearchInput): {
+    livePaths: Set<string>;
+    renderedPaths: Set<string>;
+    searchProvider: SearchProvider | null;
+    openFind: (replace: boolean) => void;
+    toggleFind: (replace: boolean) => void;
+    closeFind: () => void;
+    findBarEl: import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | null;
+    canOpenFind: boolean;
+    findOpen: boolean;
+    findMode: "find" | "replace" | undefined;
+    registerSearchProviderFor: (path: string) => (provider: SearchProvider | null) => void;
+    htmlPropsFor: (entryPath: string) => NonNullable<import("react").ComponentProps<typeof import("../index.js").DocumentRouter>["html"]>;
+};
+export {};

package/dist/app/useAppPaneSearch.js

@@ -0,0 +1,74 @@
+import { useCallback, useRef } from "react";
+import { usePaneLiveness } from "./usePaneLiveness.js";
+import { useSearchController } from "./useSearchController.js";
+import { useHtmlSessionProps } from "./useHtmlSessionProps.js";
+import { useClosedTabEviction } from "./useClosedTabEviction.js";
+/**
+ * Warm-MRU pane liveness, search controller, stable per-path search registration, HTML session props,
+ * and closed-tab eviction. Extracted verbatim from useAppState; hook call order is unchanged.
+ */
+export function useAppPaneSearch({ docs, tabs, openDocs, activePath, active, blockDrafts, previewScrollStore, sourceViewStateRef, }) {
+    // Warm-MRU pane liveness (see usePaneLiveness); `pruneClosedPaths` drops a closed tab's markers.
+    const { livePaths, renderedPaths, pruneClosedPaths } = usePaneLiveness({
+        openDocs,
+        activePath,
+        isDirty: docs.isDirty,
+        pendingSavePaths: docs.pendingSavePaths,
+        restoringSession: docs.restoringSession,
+        blockDrafts,
+    });
+    const { searchProvider, registerSearchProvider, openFind, toggleFind, closeFind, findBarEl, canOpenFind, findOpen, findMode, } = useSearchController(activePath, active, openDocs, docs.activate);
+    // Per-path, STABLE binding of the controller's `registerSearchProvider`. Each doc pane is rendered
+    // inside a `.map`, so an inline `(p) => registerSearchProvider(doc.path, p)` would be a fresh
+    // function every render — and viewers (MarkdownView/MarkdownSplitPane, HTML, PDF) list their register
+    // callback in effect deps, so an unstable identity re-fires those effects every render, each minting a
+    // new provider object → setSearchProvider → re-render → infinite "Maximum update depth" loop. Caching
+    // one bound fn per path keeps the identity stable (the controller's registerSearchProvider already is).
+    const boundRegisterRef = useRef(new Map());
+    const registerSearchProviderFor = useCallback((path) => {
+        const cache = boundRegisterRef.current;
+        let fn = cache.get(path);
+        if (!fn) {
+            fn = (provider) => registerSearchProvider(path, provider);
+            cache.set(path, fn);
+        }
+        return fn;
+    }, [registerSearchProvider]);
+    // HTML site-session props for the router — extracted to useHtmlSessionProps. dropHtmlProps is
+    // what the shared closed-tab eviction effect below calls per closed path.
+    const { htmlPropsFor, dropHtmlProps } = useHtmlSessionProps({
+        htmlPages: tabs.htmlPages,
+        previewScrollStore,
+        ensureHtmlPage: docs.ensureHtmlPage,
+        setHtmlPageEdited: docs.setHtmlPageEdited,
+        setHtmlActive: docs.setHtmlActive,
+        saveHtmlPage: docs.saveHtmlPage,
+        discardHtmlPage: docs.discardHtmlPage,
+        htmlDirtyPages: docs.htmlDirtyPages,
+        reload: docs.reload,
+    });
+    const evictBoundRegister = useCallback((path) => {
+        boundRegisterRef.current.delete(path);
+    }, []);
+    useClosedTabEviction({
+        openDocs,
+        onEvictPath: evictBoundRegister,
+        dropHtmlProps,
+        sourceViewStateRef,
+        pruneClosedPaths,
+    });
+    return {
+        livePaths,
+        renderedPaths,
+        searchProvider,
+        openFind,
+        toggleFind,
+        closeFind,
+        findBarEl,
+        canOpenFind,
+        findOpen,
+        findMode,
+        registerSearchProviderFor,
+        htmlPropsFor,
+    };
+}

package/dist/app/useAppShellSetup.d.ts

@@ -0,0 +1,40 @@
+import { type Dispatch, type SetStateAction } from "react";
+import type { useDocuments } from "./useDocuments.js";
+import type { useDocumentTabs } from "./useDocumentTabs.js";
+import type { SourceEditorViewState } from "../documents/txt/TxtEditor.js";
+type Docs = ReturnType<typeof useDocuments>;
+type Tabs = ReturnType<typeof useDocumentTabs>;
+export interface AppShellSetupInput {
+    docs: Docs;
+    activePath: Tabs["activePath"];
+    setSettingsOpen: Dispatch<SetStateAction<boolean>>;
+}
+/**
+ * Settings, drag/drop overlay, format APIs, the document context menu, app-level effects, and the
+ * per-app refs (auto-update guard, preview scroll store, source view state). Extracted verbatim from
+ * useAppState; hook call order is unchanged.
+ */
+export declare function useAppShellSetup({ docs, activePath, setSettingsOpen }: AppShellSetupInput): {
+    settings: import("@rightkit/document-core/settings/settings").Settings;
+    update: (patch: Partial<import("@rightkit/document-core/settings/settings").Settings>) => void;
+    handleOpenSettings: () => void;
+    dragOver: boolean;
+    rootDragProps: {
+        onDragEnter: (e: import("react").DragEvent) => void;
+        onDragOver: (e: import("react").DragEvent) => void;
+        onDragLeave: (e: import("react").DragEvent) => void;
+        onDrop: () => void;
+    };
+    docxMenu: import("@rightkit/docx-editor/documents/docx/menuApi").DocxMenuApi | null;
+    setDocxMenu: Dispatch<SetStateAction<import("@rightkit/docx-editor/documents/docx/menuApi").DocxMenuApi | null>>;
+    markdownExport: import("@rightkit/markdown-editor/documents/markdown/export/markdownExportTypes").MarkdownExportApi | null;
+    registerPdfPrint: (fn: (() => Promise<boolean>) | null) => void;
+    registerMarkdownExport: (api: import("@rightkit/markdown-editor/documents/markdown/export/markdownExportTypes").MarkdownExportApi | null) => void;
+    handlePrint: (doc: import("@rightkit/document-core/documents/types").LoadedDocument | null) => void;
+    docContextMenu: import("./DocumentContextMenu.js").DocContextMenu | null;
+    closeDocContextMenu: () => void;
+    autoUpdateCheckRan: import("react").RefObject<boolean>;
+    previewScrollStore: import("react").RefObject<Map<string, number>>;
+    sourceViewStateRef: import("react").RefObject<Record<string, SourceEditorViewState>>;
+};
+export {};

package/dist/app/useAppShellSetup.js

@@ -0,0 +1,52 @@
+import { useCallback, useRef } from "react";
+import { useAppEffects } from "./useAppEffects.js";
+import { useFileDragOverlay } from "./useFileDragOverlay.js";
+import { useFormatApis } from "./useFormatApis.js";
+import { useDocumentContextMenu } from "./DocumentContextMenu.js";
+import { useSettings } from "@rightkit/document-core/settings/settings";
+/**
+ * Settings, drag/drop overlay, format APIs, the document context menu, app-level effects, and the
+ * per-app refs (auto-update guard, preview scroll store, source view state). Extracted verbatim from
+ * useAppState; hook call order is unchanged.
+ */
+export function useAppShellSetup({ docs, activePath, setSettingsOpen }) {
+    const { settings, update } = useSettings();
+    const handleOpenSettings = useCallback(() => setSettingsOpen(true), [setSettingsOpen]);
+    useAppEffects({
+        diagnosticsSetting: settings.diagnostics,
+        activePath,
+        docxSaver: docs.docxSaver,
+        imageSaver: docs.imageSaver,
+        docxSaversRef: docs.docxSaversRef,
+        imageSaversRef: docs.imageSaversRef,
+        openSettings: handleOpenSettings,
+    });
+    const { dragOver, rootDragProps } = useFileDragOverlay();
+    const { docxMenu, setDocxMenu, markdownExport, registerPdfPrint, registerMarkdownExport, handlePrint, } = useFormatApis(docs.onPrint);
+    const { menu: docContextMenu, close: closeDocContextMenu } = useDocumentContextMenu();
+    const autoUpdateCheckRan = useRef(false);
+    // Durable interactive-HTML preview scroll, keyed by the html tab's entry path. Lives here (not in
+    // HtmlDocument) so it survives the unmount on tab switch and is restored when you return.
+    const previewScrollStore = useRef(new Map());
+    // Source selection + scroll are view state, but must survive an eligible dirty-router eviction just
+    // like the source itself. One path-keyed owner covers TXT, Markdown's source drawer, and HTML pages.
+    const sourceViewStateRef = useRef({});
+    return {
+        settings,
+        update,
+        handleOpenSettings,
+        dragOver,
+        rootDragProps,
+        docxMenu,
+        setDocxMenu,
+        markdownExport,
+        registerPdfPrint,
+        registerMarkdownExport,
+        handlePrint,
+        docContextMenu,
+        closeDocContextMenu,
+        autoUpdateCheckRan,
+        previewScrollStore,
+        sourceViewStateRef,
+    };
+}

package/dist/app/useAppSlots.d.ts

@@ -0,0 +1,28 @@
+import { DocumentMenus } from "./DocActionBar.js";
+import type { LoadedDocument, ReadEditMode } from "@rightkit/document-core/documents/types";
+import type { useDocuments } from "./useDocuments.js";
+import type { useFormatApis } from "./useFormatApis.js";
+import type { useViewState } from "./useViewState.js";
+type Docs = ReturnType<typeof useDocuments>;
+type Formats = ReturnType<typeof useFormatApis>;
+export interface AppSlotsInput {
+    docs: Docs;
+    active: LoadedDocument | null;
+    view: Parameters<typeof DocumentMenus>[0]["view"];
+    onChangeView: ReturnType<typeof useViewState>["requestViewChange"];
+    handlePrint: Formats["handlePrint"];
+    docxMenu: Formats["docxMenu"];
+    activeReadEdit: ReadEditMode;
+}
+/**
+ * Stable close/edit/open callbacks and the docked-bar menu + mode slots. Extracted verbatim from
+ * useAppState; hook call order is unchanged.
+ */
+export declare function useAppSlots({ docs, active, view, onChangeView, handlePrint, docxMenu, activeReadEdit, }: AppSlotsInput): {
+    onOpenPathForRouter: (p: string, opts?: {
+        background?: boolean;
+    }) => void;
+    menuSlot: import("react").JSX.Element | null;
+    modeSlot: import("react").JSX.Element | null;
+};
+export {};

package/dist/app/useAppSlots.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useMemo } from "react";
+import { DocumentMenus, DocumentModeControls } from "./DocActionBar.js";
+import { capabilitiesFor } from "../documents/capabilities.js";
+/**
+ * Stable close/edit/open callbacks and the docked-bar menu + mode slots. Extracted verbatim from
+ * useAppState; hook call order is unchanged.
+ */
+export function useAppSlots({ docs, active, view, onChangeView, handlePrint, docxMenu, activeReadEdit, }) {
+    const { onSave, onSaveAs, requestClose, open } = docs;
+    // Stabilized chrome props so the memoized Sidebar/Toolbar/DocStatsPill skip the per-keystroke
+    // App re-render — slots are memoized on the data they actually read.
+    const closeActive = useCallback(() => {
+        if (active)
+            requestClose(active.path);
+    }, [active, requestClose]);
+    const editActiveImageExternal = useCallback(() => {
+        if (active)
+            docs.onEditImageExternal(active);
+    }, [active, docs]);
+    // T2-3: stable identity so the memoized DocumentRouterTable doesn't see a fresh function every render.
+    const onOpenPathForRouter = useCallback((p, opts) => {
+        void open(p, opts);
+    }, [open]);
+    const menuSlot = useMemo(() => active ? (_jsx(DocumentMenus, { doc: active, view: view, onSave: () => active.format === "html" ? docs.onHtmlSaveShortcut(active.path) : onSave(active), onSaveAs: () => onSaveAs(active), onPrint: () => handlePrint(active), onClose: closeActive, onEditImageExternal: editActiveImageExternal, onChangeView: onChangeView, docxMenu: active.format === "docx" ? docxMenu : null, readOnly: activeReadEdit === "read" })) : null, [
+        active,
+        view,
+        docxMenu,
+        onChangeView,
+        onSave,
+        onSaveAs,
+        handlePrint,
+        docs,
+        closeActive,
+        editActiveImageExternal,
+        activeReadEdit,
+    ]);
+    const modeSlot = useMemo(() => active && capabilitiesFor(active.format).canSwitchView ? (_jsx(DocumentModeControls, { doc: active, view: view, onChangeView: onChangeView, readOnly: activeReadEdit === "read" })) : null, [active, view, onChangeView, activeReadEdit]);
+    return { onOpenPathForRouter, menuSlot, modeSlot };
+}

package/dist/app/useAppTabChrome.d.ts

@@ -0,0 +1,51 @@
+import { type Dispatch, type SetStateAction } from "react";
+import { useDocumentZoom } from "./useDocumentZoom.js";
+import type { LoadedDocument } from "@rightkit/document-core/documents/types";
+import type { useDocuments } from "./useDocuments.js";
+import type { useDocumentTabs } from "./useDocumentTabs.js";
+import type { useAppDocumentCore } from "./useAppDocumentCore.js";
+import type { useAppShellSetup } from "./useAppShellSetup.js";
+import type { useLibrary } from "./useLibrary.js";
+type Docs = ReturnType<typeof useDocuments>;
+type Tabs = ReturnType<typeof useDocumentTabs>;
+type Core = ReturnType<typeof useAppDocumentCore>;
+type Setup = ReturnType<typeof useAppShellSetup>;
+type Library = ReturnType<typeof useLibrary>;
+export interface AppTabChromeInput {
+    docs: Docs;
+    tabs: Tabs;
+    activePath: Tabs["activePath"];
+    sidebarCollapsed: boolean;
+    tabOverviewOpen: boolean;
+    setTabOverviewOpen: Dispatch<SetStateAction<boolean>>;
+    pinnedPaths: Library["pinnedPaths"];
+    onTogglePin: Library["onTogglePin"];
+    dirtyPaths: Core["dirtyPaths"];
+    subscribeDirty: Core["subscribeDirty"];
+    active: LoadedDocument | null;
+    view: Parameters<typeof useDocumentZoom>[0]["view"];
+    settings: Setup["settings"];
+    update: Setup["update"];
+    autoUpdateCheckRan: Setup["autoUpdateCheckRan"];
+}
+/**
+ * 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 declare function useAppTabChrome({ docs, tabs, activePath, sidebarCollapsed, tabOverviewOpen, setTabOverviewOpen, pinnedPaths, onTogglePin, dirtyPaths, subscribeDirty, active, view, settings, update, autoUpdateCheckRan, }: AppTabChromeInput): {
+    titleBarTitleFor: (d: LoadedDocument) => string;
+    tabStripProps: import("./tabs/TabStrip.js").TabStripProps;
+    openPathsSet: Set<string>;
+    openExplorerPath: (path: string) => void;
+    cycleTab: (dir: 1 | -1) => void;
+    jumpToTab: (index: number) => void;
+    zoom: {
+        zoomHud: string | null;
+        zoomedAwayFromDefault: boolean;
+        zoomPercentLabel: string;
+        resetDocumentZoom: () => void;
+        onDocumentWheel: (e: import("react").WheelEvent<HTMLDivElement>) => void;
+    };
+    openFromClipboard: () => Promise<void>;
+};
+export {};