@rightkit/document-workspace 0.0.0-stage → 0.1.0

package/dist/app/useSetupRecovery.d.ts

@@ -0,0 +1,41 @@
+import { type Dispatch, type MutableRefObject, type SetStateAction } from "react";
+import type { LoadedDocument, ViewMode } from "@rightkit/document-core/documents/types";
+import type { ImageSaveFunction } from "@rightkit/media-ui";
+import type { DocumentTabs } from "./useDocumentTabs.js";
+import type { BlockDraftRegistry } from "@rightkit/document-core/app/blockDrafts";
+interface SetupRecoveryDeps {
+    blockDrafts: BlockDraftRegistry;
+    setError: Dispatch<SetStateAction<string | null>>;
+    openDocsRef: MutableRefObject<LoadedDocument[]>;
+    activePathRef: MutableRefObject<string | null>;
+    viewsRef: MutableRefObject<Record<string, ViewMode>>;
+    isDirty: (doc: LoadedDocument) => boolean;
+    editsRef: DocumentTabs["editsRef"];
+    htmlPagesRef: DocumentTabs["htmlPagesRef"];
+    docxSaversRef: MutableRefObject<Map<string, () => Promise<ArrayBuffer | null>>>;
+    imageSaversRef: MutableRefObject<Map<string, ImageSaveFunction>>;
+    setOpenDocs: DocumentTabs["setOpenDocs"];
+    writeEdits: DocumentTabs["writeEdits"];
+    writeHtmlPages: DocumentTabs["writeHtmlPages"];
+    setViews: Dispatch<SetStateAction<Record<string, ViewMode>>>;
+    setDocxDirty: DocumentTabs["setDocxDirty"];
+    restoreImageDirty: (path: string) => void;
+    fingerprints: MutableRefObject<Map<string, {
+        mtimeMs: number;
+        size: number;
+    }>>;
+    withTabKey: <T extends LoadedDocument>(doc: T, existingKey?: string) => T;
+}
+/**
+ * Setup-replacement recovery: snapshot every open dirty document (committed sources only — open
+ * block drafts are resolved first so the snapshot never carries a half-typed draft) before the
+ * installer destroys the window, then rehydrate documents/edits/views/dirty flags on the next
+ * launch when the snapshot is present. The pure snapshot (de)serialization lives in
+ * setupRecovery.ts; this hook owns the refs/callbacks that feed it and the re-entrant guard.
+ * Extracted verbatim from useDocuments; bodies are unchanged.
+ */
+export declare function useSetupRecovery({ blockDrafts, setError, openDocsRef, activePathRef, viewsRef, isDirty, editsRef, htmlPagesRef, docxSaversRef, imageSaversRef, setOpenDocs, writeEdits, writeHtmlPages, setViews, setDocxDirty, restoreImageDirty, fingerprints, withTabKey, }: SetupRecoveryDeps): {
+    prepareSetupRecovery: () => Promise<void>;
+    restoreSetupRecovery: () => Promise<string | null>;
+};
+export {};

package/dist/app/useSetupRecovery.js

@@ -0,0 +1,153 @@
+import { useCallback, useRef, } from "react";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+import { errorMessage } from "@rightkit/document-core/state/errors";
+import { captureSetupRecovery, clearSetupRecoverySnapshot, loadSetupRecoverySnapshot, saveSetupRecoverySnapshot, } from "./setupRecovery.js";
+import { resolveAllDrafts } from "./draftResolution.js";
+/**
+ * Setup-replacement recovery: snapshot every open dirty document (committed sources only — open
+ * block drafts are resolved first so the snapshot never carries a half-typed draft) before the
+ * installer destroys the window, then rehydrate documents/edits/views/dirty flags on the next
+ * launch when the snapshot is present. The pure snapshot (de)serialization lives in
+ * setupRecovery.ts; this hook owns the refs/callbacks that feed it and the re-entrant guard.
+ * Extracted verbatim from useDocuments; bodies are unchanged.
+ */
+export function useSetupRecovery({ blockDrafts, setError, openDocsRef, activePathRef, viewsRef, isDirty, editsRef, htmlPagesRef, docxSaversRef, imageSaversRef, setOpenDocs, writeEdits, writeHtmlPages, setViews, setDocxDirty, restoreImageDirty, fingerprints, withTabKey, }) {
+    const setupPreparingRef = useRef(false);
+    const prepareSetupRecovery = useCallback(async () => {
+        if (setupPreparingRef.current)
+            return;
+        setupPreparingRef.current = true;
+        try {
+            // Setup replacement resolves every open block draft before snapshotting, so the recovery
+            // snapshot carries committed source — never a half-typed draft.
+            const outcome = await resolveAllDrafts(blockDrafts, "setup-replacement", "done");
+            if (outcome !== "resolved") {
+                setupPreparingRef.current = false;
+                setError("Setup could not preserve an open block edit.");
+                return;
+            }
+            const snapshot = await captureSetupRecovery({
+                openDocs: openDocsRef.current,
+                activePath: activePathRef.current,
+                views: viewsRef.current,
+                isDirty,
+                editsRef,
+                htmlPagesRef,
+                docxSaversRef,
+                imageSaversRef,
+            });
+            await saveSetupRecoverySnapshot(snapshot);
+            await getCurrentWindow().destroy();
+        }
+        catch (e) {
+            setupPreparingRef.current = false;
+            setError(`Setup could not preserve unsaved changes: ${errorMessage(e)}`);
+        }
+    }, [
+        docxSaversRef,
+        editsRef,
+        htmlPagesRef,
+        imageSaversRef,
+        isDirty,
+        viewsRef,
+        blockDrafts,
+        openDocsRef,
+        activePathRef,
+        setError,
+    ]);
+    const restoreSetupRecovery = useCallback(async () => {
+        const snapshot = await loadSetupRecoverySnapshot();
+        if (!snapshot)
+            return null;
+        try {
+            const restored = snapshot.documents.map((entry) => {
+                const document = { ...entry.document };
+                if (entry.document.format === "docx") {
+                    if (!entry.binary?.base64)
+                        throw new Error(`Recovery data is missing for ${entry.document.displayName}.`);
+                    document.content = entry.binary.base64;
+                }
+                else if (entry.document.format === "image") {
+                    if (!entry.binary?.base64 || !entry.binary.mime)
+                        throw new Error(`Recovery data is missing for ${entry.document.displayName}.`);
+                    document.content = `data:${entry.binary.mime};base64,${entry.binary.base64}`;
+                }
+                return { entry, document };
+            });
+            setOpenDocs((prev) => {
+                let next = prev;
+                for (const { document } of restored) {
+                    const existing = next.find((candidate) => candidate.path === document.path);
+                    const recovered = withTabKey(document, existing?.tabKey);
+                    next = existing
+                        ? next.map((candidate) => (candidate.path === document.path ? recovered : candidate))
+                        : [...next, recovered];
+                }
+                return next;
+            });
+            writeEdits((prev) => {
+                const next = { ...prev };
+                for (const { entry, document } of restored) {
+                    if (entry.editedText !== undefined)
+                        next[document.path] = entry.editedText;
+                }
+                return next;
+            });
+            writeHtmlPages((prev) => {
+                const next = { ...prev };
+                for (const { entry, document } of restored) {
+                    if (entry.htmlPages)
+                        next[document.path] = entry.htmlPages;
+                }
+                return next;
+            });
+            setViews((prev) => {
+                const next = { ...prev };
+                for (const { entry, document } of restored) {
+                    if (entry.view)
+                        next[document.path] = entry.view;
+                }
+                viewsRef.current = next;
+                return next;
+            });
+            setDocxDirty((prev) => {
+                const next = new Set(prev);
+                for (const { document } of restored)
+                    if (document.format === "docx")
+                        next.add(document.path);
+                return next;
+            });
+            for (const { document } of restored) {
+                if (document.format === "image")
+                    restoreImageDirty(document.path);
+                if (document.fingerprint)
+                    fingerprints.current.set(document.path, document.fingerprint);
+            }
+            const restoredPaths = new Set(restored.map(({ document }) => document.path));
+            const active = snapshot.activePath && restoredPaths.has(snapshot.activePath)
+                ? snapshot.activePath
+                : activePathRef.current
+                    ? null
+                    : (restored[0]?.document.path ?? null);
+            await clearSetupRecoverySnapshot();
+            return active;
+        }
+        catch (e) {
+            setError(`Setup recovery could not be restored: ${errorMessage(e)}`);
+            return null;
+        }
+    }, [
+        restoreImageDirty,
+        setDocxDirty,
+        setOpenDocs,
+        setViews,
+        viewsRef,
+        withTabKey,
+        writeEdits,
+        writeHtmlPages,
+        activePathRef,
+        fingerprints,
+        setError,
+    ]);
+    return { prepareSetupRecovery, restoreSetupRecovery };
+}

package/dist/app/useTabChrome.d.ts

@@ -0,0 +1,40 @@
+import type { TabStripProps } from "./tabs/TabStrip.js";
+import type { LoadedDocument } from "@rightkit/document-core/documents/types";
+type DocsApi = {
+    activate: (path: string) => unknown;
+    open: (path: string, opts?: {
+        background?: boolean;
+    }) => unknown;
+    requestClose: TabStripProps["onRequestClose"];
+    closeAll: TabStripProps["onCloseAll"];
+    closeMany: TabStripProps["onClosePaths"];
+    newDocument: (format: "txt") => unknown;
+    isDirty: TabStripProps["isDirty"];
+};
+/** Tab-strip props + tab actions (reorder, bulk close, explorer open, cycle/jump), extracted from
+ * App.tsx. Tab order == openDocs order. */
+export declare function useTabChrome({ tabs, docs, activePath, sidebarCollapsed, tabOverviewOpen, setTabOverviewOpen, pinnedPaths, onTogglePin, titleBarTitleFor, dirtyPaths, subscribeDirty, }: {
+    tabs: {
+        openDocs: LoadedDocument[];
+        setOpenDocs: React.Dispatch<React.SetStateAction<LoadedDocument[]>>;
+        subscribeEdits: TabStripProps["subscribeEdits"];
+        getEditSnapshot: TabStripProps["getEditSnapshot"];
+    };
+    docs: DocsApi;
+    activePath: string | null;
+    sidebarCollapsed: boolean;
+    tabOverviewOpen: boolean;
+    setTabOverviewOpen: (open: boolean) => void;
+    pinnedPaths: TabStripProps["pinnedPaths"];
+    onTogglePin: (path: string) => unknown;
+    titleBarTitleFor: (d: LoadedDocument) => string;
+    dirtyPaths: TabStripProps["dirtyPaths"];
+    subscribeDirty: TabStripProps["subscribeDirty"];
+}): {
+    tabStripProps: TabStripProps;
+    openPathsSet: Set<string>;
+    openExplorerPath: (path: string) => void;
+    cycleTab: (dir: 1 | -1) => void;
+    jumpToTab: (index: number) => void;
+};
+export {};

package/dist/app/useTabChrome.js

@@ -0,0 +1,115 @@
+import { useCallback, useMemo } from "react";
+import { isLocalFileDoc } from "./sidebar/SidebarPathUtils.js";
+/** Tab-strip props + tab actions (reorder, bulk close, explorer open, cycle/jump), extracted from
+ * App.tsx. Tab order == openDocs order. */
+export function useTabChrome({ tabs, docs, activePath, sidebarCollapsed, tabOverviewOpen, setTabOverviewOpen, pinnedPaths, onTogglePin, titleBarTitleFor, dirtyPaths, subscribeDirty, }) {
+    const { openDocs, subscribeEdits, getEditSnapshot } = tabs;
+    const { activate, open, requestClose, closeAll, closeMany, newDocument, isDirty } = docs;
+    const reorderTabs = useCallback((fromPath, toPath, position = "before") => {
+        tabs.setOpenDocs((prev) => {
+            const from = prev.findIndex((doc) => doc.path === fromPath);
+            const to = prev.findIndex((doc) => doc.path === toPath);
+            if (from < 0 || to < 0 || from === to)
+                return prev;
+            const next = [...prev];
+            const [moved] = next.splice(from, 1);
+            const targetAfterRemoval = from < to ? to - 1 : to;
+            const insertAt = position === "after" ? targetAfterRemoval + 1 : targetAfterRemoval;
+            next.splice(insertAt, 0, moved);
+            return next;
+        });
+    }, [tabs]);
+    // Tab-strip bulk closes: the same Save-All/Discard-All chooser Close All uses, driven by closeMany
+    // with the chosen subset. Order = openDocs order so "to the right" means spatial, not sorted.
+    const closeOthers = useCallback((path) => {
+        closeMany(openDocs.filter((d) => d.path !== path).map((d) => d.path));
+    }, [closeMany, openDocs]);
+    const closeToRight = useCallback((path) => {
+        const at = openDocs.findIndex((d) => d.path === path);
+        if (at < 0)
+            return;
+        closeMany(openDocs.slice(at + 1).map((d) => d.path));
+    }, [closeMany, openDocs]);
+    // Explorer row click: the entry's path is already broker-granted by explorer_list_dir, so this is
+    // the same open-or-activate flow recents use (minus the token grant step).
+    const openExplorerPath = useCallback((path) => {
+        if (openDocs.some((d) => d.path === path)) {
+            void activate(path);
+        }
+        else {
+            void open(path);
+        }
+    }, [openDocs, activate, open]);
+    // Tab navigation operates on the visible open-tab order; Ctrl+9 maps to the last tab (browser-style).
+    const cycleTab = (dir) => {
+        if (openDocs.length < 2)
+            return;
+        const i = openDocs.findIndex((d) => d.path === activePath);
+        const n = openDocs.length;
+        activate(openDocs[((((i < 0 ? 0 : i) + dir) % n) + n) % n].path);
+    };
+    const jumpToTab = (index) => {
+        if (!openDocs.length)
+            return;
+        const target = index === 8 ? openDocs.length - 1 : index;
+        const doc = openDocs[target];
+        if (doc)
+            activate(doc.path);
+    };
+    // Tab-strip props for the titlebar — memoized so the memoized TabStrip skips per-keystroke App
+    // re-renders the same way Sidebar/Toolbar do. openDocs order IS the tab order (single source).
+    const toggleSidebarEvent = useCallback(() => window.dispatchEvent(new CustomEvent("viewright:toggle-sidebar")), []);
+    const openLocalPaths = useMemo(() => openDocs.filter(isLocalFileDoc).map((d) => d.path), [openDocs]);
+    const openPathsSet = useMemo(() => new Set(openDocs.map((d) => d.path)), [openDocs]);
+    const tabStripProps = useMemo(() => ({
+        docs: openDocs,
+        activePath,
+        sidebarCollapsed,
+        onToggleSidebar: toggleSidebarEvent,
+        onActivate: (path) => void activate(path),
+        onRequestClose: requestClose,
+        onCloseAll: closeAll,
+        onCloseOthers: closeOthers,
+        onCloseRight: closeToRight,
+        onClosePaths: closeMany,
+        onReorderTabs: reorderTabs,
+        onNewDocument: () => newDocument("txt"),
+        onTogglePin: (path) => void onTogglePin(path),
+        pinnedPaths,
+        openLocalPaths,
+        titleFor: titleBarTitleFor,
+        isDirty,
+        dirtyPaths,
+        subscribeDirty,
+        subscribeEdits,
+        getEditSnapshot,
+        computeTitle: titleBarTitleFor,
+        overviewOpen: tabOverviewOpen,
+        onOverviewOpenChange: setTabOverviewOpen,
+    }), [
+        openDocs,
+        activePath,
+        sidebarCollapsed,
+        toggleSidebarEvent,
+        activate,
+        requestClose,
+        closeAll,
+        closeOthers,
+        closeToRight,
+        closeMany,
+        reorderTabs,
+        newDocument,
+        onTogglePin,
+        pinnedPaths,
+        openLocalPaths,
+        titleBarTitleFor,
+        isDirty,
+        dirtyPaths,
+        subscribeDirty,
+        subscribeEdits,
+        getEditSnapshot,
+        tabOverviewOpen,
+        setTabOverviewOpen,
+    ]);
+    return { tabStripProps, openPathsSet, openExplorerPath, cycleTab, jumpToTab };
+}

package/dist/app/useViewState.d.ts

@@ -0,0 +1,27 @@
+import { type LoadedDocument, type ViewMeta, type ViewMode } from "@rightkit/document-core/documents/types";
+import type { BlockDraftRegistry } from "@rightkit/document-core/app/blockDrafts";
+/**
+ * Per-format view state: preview/source mode per doc, plus the persisted visible location
+ * (text/html scroll via the document pane, Markdown via its editor scroller; PDF page/zoom/fit
+ * reported by the
+ * viewer). Persisted per file (debounced) so reopening restores where you were. Returns the state
+ * setter + refs so the document-IO flows can seed view state when a file opens/saves.
+ */
+export declare function useViewState(activePath: string | null, openDocs: LoadedDocument[], blockDrafts?: BlockDraftRegistry): {
+    views: Record<string, ViewMode>;
+    setViews: import("react").Dispatch<import("react").SetStateAction<Record<string, ViewMode>>>;
+    viewsRef: import("react").RefObject<Record<string, ViewMode>>;
+    viewMetaRef: import("react").RefObject<Record<string, ViewMeta>>;
+    persistViewMeta: (path: string) => void;
+    contentScrollRef: import("react").RefObject<HTMLDivElement | null>;
+    requestViewChange: (next: ViewMode) => Promise<void>;
+    confirmViewChange: (decision: "done" | "discard" | "stay") => Promise<void>;
+    cancelViewChange: () => void;
+    pendingViewChange: {
+        next: ViewMode;
+        drafts: ReturnType<BlockDraftRegistry["snapshotModified"]>;
+    } | null;
+    onContentScroll: () => void;
+    onPdfViewState: (m: ViewMeta) => void;
+    dropViewState: (path: string) => void;
+};

package/dist/app/useViewState.js

@@ -0,0 +1,160 @@
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+import { saveViewState } from "../state/library.js";
+import { isUntitled } from "@rightkit/document-core/documents/types";
+import { resolveDocumentDrafts } from "./draftResolution.js";
+/**
+ * Per-format view state: preview/source mode per doc, plus the persisted visible location
+ * (text/html scroll via the document pane, Markdown via its editor scroller; PDF page/zoom/fit
+ * reported by the
+ * viewer). Persisted per file (debounced) so reopening restores where you were. Returns the state
+ * setter + refs so the document-IO flows can seed view state when a file opens/saves.
+ */
+export function useViewState(activePath, openDocs, blockDrafts) {
+    const [views, setViews] = useState({});
+    // Points at the active non-PDF viewer's actual scroller. Markdown owns an inner scroller so its
+    // fixed editing hero never overlaps content; other formats use the document pane itself.
+    const contentScrollRef = useRef(null);
+    const viewMetaRef = useRef({});
+    const viewsRef = useRef({});
+    const viewSaveTimer = useRef(null);
+    const persistViewMeta = useCallback((path) => {
+        if (isUntitled(path))
+            return;
+        if (viewSaveTimer.current)
+            window.clearTimeout(viewSaveTimer.current);
+        viewSaveTimer.current = window.setTimeout(() => {
+            void saveViewState(path, viewsRef.current[path] ?? "preview", viewMetaRef.current[path]);
+        }, 400);
+    }, []);
+    // Restore the saved scroll position for the active non-PDF doc once its scroller is in the DOM.
+    // Best-effort for tall async-rendered content (e.g. Markdown); PDF restores page/zoom internally.
+    useEffect(() => {
+        const el = contentScrollRef.current;
+        if (!el || !activePath)
+            return;
+        const doc = openDocs.find((d) => d.path === activePath);
+        if (!doc || doc.format === "pdf" || doc.format === "web")
+            return;
+        const target = viewMetaRef.current[activePath]?.scroll ?? 0;
+        const raf = requestAnimationFrame(() => {
+            el.scrollTop = target;
+        });
+        return () => cancelAnimationFrame(raf);
+    }, [activePath, openDocs]);
+    const [pendingViewChange, setPendingViewChange] = useState(null);
+    const applyViewFor = useCallback(async (path, next) => {
+        setViews((v) => ({ ...v, [path]: next }));
+        viewsRef.current[path] = next;
+        if (!isUntitled(path))
+            await saveViewState(path, next, viewMetaRef.current[path]);
+    }, []);
+    // requestViewChange is handed to every live DocumentRouter, whose memo comparator checks it by
+    // identity. Read the active path + draft registry through refs so the callback stays stable across
+    // tab switches; otherwise every warm pane (up to the live cap) re-renders on each switch.
+    const activePathRef = useRef(activePath);
+    const blockDraftsRef = useRef(blockDrafts);
+    useLayoutEffect(() => {
+        activePathRef.current = activePath;
+        blockDraftsRef.current = blockDrafts;
+    }, [activePath, blockDrafts]);
+    const requestViewChange = useCallback(async (next) => {
+        const path = activePathRef.current;
+        if (!path)
+            return;
+        const drafts = blockDraftsRef.current;
+        if (drafts) {
+            const modified = drafts.snapshotModified(path);
+            if (modified.length > 0) {
+                // Modified draft: offer Done / Discard / Stay instead of silently discarding.
+                setPendingViewChange({ next, drafts: modified });
+                return;
+            }
+            // Clean draft (not in snapshotModified but exists): close silently per contract.
+            // snapshotAll returns all drafts for this document (clean only at this point, since
+            // modified/stale/committing are already handled above).
+            const allForDoc = drafts.snapshotAll(path);
+            if (allForDoc.length > 0) {
+                for (const d of allForDoc)
+                    drafts.discard(d.identity);
+            }
+        }
+        await applyViewFor(path, next);
+    }, [applyViewFor]);
+    const confirmViewChange = useCallback(async (decision) => {
+        if (!pendingViewChange || !activePath || !blockDrafts) {
+            setPendingViewChange(null);
+            return;
+        }
+        if (decision === "stay") {
+            setPendingViewChange(null);
+            return;
+        }
+        const outcome = await resolveDocumentDrafts(blockDrafts, activePath, "view-change", decision);
+        if (outcome !== "resolved") {
+            // failed/cancelled: keep dialog open with fresh draft snapshot so error/reason stays visible
+            if (blockDrafts) {
+                setPendingViewChange({
+                    next: pendingViewChange.next,
+                    drafts: blockDrafts.snapshotModified(activePath),
+                });
+            }
+            return;
+        }
+        const next = pendingViewChange.next;
+        setPendingViewChange(null);
+        await applyViewFor(activePath, next);
+    }, [activePath, applyViewFor, blockDrafts, pendingViewChange]);
+    const cancelViewChange = useCallback(() => setPendingViewChange(null), []);
+    // Capture the non-PDF scroll position for the active doc (PDF reports its own page/zoom/fit).
+    const onContentScroll = useCallback(() => {
+        const el = contentScrollRef.current;
+        if (!el || !activePath || isUntitled(activePath))
+            return;
+        const doc = openDocs.find((d) => d.path === activePath);
+        if (!doc || doc.format === "pdf" || doc.format === "web")
+            return;
+        viewMetaRef.current[activePath] = {
+            ...(viewMetaRef.current[activePath] ?? {}),
+            scroll: el.scrollTop,
+        };
+        persistViewMeta(activePath);
+    }, [activePath, openDocs, persistViewMeta]);
+    // Merge PDF view state (page/zoom/fit) reported by the viewer, and persist it.
+    const onPdfViewState = useCallback((m) => {
+        if (!activePath)
+            return;
+        viewMetaRef.current[activePath] = { ...(viewMetaRef.current[activePath] ?? {}), ...m };
+        persistViewMeta(activePath);
+    }, [activePath, persistViewMeta]);
+    // Drop a closed tab's view state (mode + scroll/page/zoom meta) from all three stores. Without
+    // this, `views`/`viewsRef`/`viewMetaRef` only ever grow — every path that was ever opened stays
+    // keyed in these Records for the life of the app. Exposed for useDocumentWatcher's teardownDoc to
+    // call alongside its other per-close pruning (fingerprints, editsRef, etc.); this hook doesn't call
+    // it itself since it has no visibility into tab close.
+    const dropViewState = useCallback((path) => {
+        setViews((v) => {
+            if (!(path in v))
+                return v;
+            const n = { ...v };
+            delete n[path];
+            return n;
+        });
+        delete viewsRef.current[path];
+        delete viewMetaRef.current[path];
+    }, []);
+    return {
+        views,
+        setViews,
+        viewsRef,
+        viewMetaRef,
+        persistViewMeta,
+        contentScrollRef,
+        requestViewChange,
+        confirmViewChange,
+        cancelViewChange,
+        pendingViewChange,
+        onContentScroll,
+        onPdfViewState,
+        dropViewState,
+    };
+}

package/dist/appName.d.ts

@@ -0,0 +1,2 @@
+export declare function setHostAppName(name: string): void;
+export declare function hostAppName(): string;

package/dist/appName.js

@@ -0,0 +1,8 @@
+// Product name shown in user-facing copy. Hosts call setHostAppName() once at startup.
+let current = "App";
+export function setHostAppName(name) {
+    current = name;
+}
+export function hostAppName() {
+    return current;
+}

package/dist/documents/DocumentRouter.d.ts

@@ -0,0 +1,102 @@
+import { type ReactNode, type RefObject, type UIEventHandler } from "react";
+import type { LoadedDocument, ReadEditMode, ViewMode, ViewMeta, SearchProvider } from "@rightkit/document-core/documents/types";
+import type { DocxMenuApi } from "@rightkit/docx-editor/documents/docx/menuApi";
+import type { ImageSaveFunction } from "@rightkit/media-ui";
+import type { HtmlPageBuffer } from "@rightkit/html-editor/documents/html/sessionTypes";
+import type { MarkdownExportApi } from "@rightkit/markdown-editor/documents/markdown/export/markdownExportTypes";
+import type { SourceEditorViewState } from "./txt/TxtEditor.js";
+import type { PdfSaveFunction } from "@rightkit/document-core/documents/pdf/pdfEditor";
+import type { PdfSavePlan } from "@rightkit/document-core/documents/pdf/pdfEditModel";
+export declare const MarkdownTextFallback: ({ text }: {
+    text: string;
+}) => import("react").JSX.Element;
+interface Props {
+    doc: LoadedDocument;
+    view: ViewMode;
+    /** Wave 2 per-document Read/Edit (PDF: Markup) mode — "read" keeps viewers view-first,
+     *  "edit" exposes the format's existing editing surface as the floating format bar. */
+    readEdit?: ReadEditMode;
+    devMode?: boolean;
+    /** Live editable text (edits ?? content) + handlers, owned by App. */
+    text: string;
+    /** Per-document live edit subscription used by split panes without repainting App. */
+    subscribeEdits?: (path: string, cb: () => void) => () => void;
+    getEditSnapshot?: (path: string) => string | undefined;
+    getExternalSeq?: (path: string) => number;
+    /** App-level source selection/scroll store, retained when a dirty source pane shells. */
+    sourceViewStateRef?: RefObject<Record<string, SourceEditorViewState>>;
+    onChange: (text: string) => void;
+    onSave: () => void;
+    /** DOCX editor writes its bytes back to disk via its own File→Save. */
+    onDocxSave: (buffer: ArrayBuffer) => void;
+    /** DOCX edited (for unsaved-close warning). */
+    onDocxChange: () => void;
+    /** Register the DOCX editor's programmatic save (for the close dialog). */
+    registerDocxSave: (fn: (() => Promise<ArrayBuffer | null>) | null) => void;
+    /** Register the image editor export function for app-level Save / Save As / Ctrl+S. */
+    registerImageSave: (fn: ImageSaveFunction | null) => void;
+    /** Lift the DOCX command surface for the app's File/Format/Insert/Help menus. */
+    onDocxToolbar: (api: DocxMenuApi | null) => void;
+    onImageChange: () => void;
+    /** Page to a neighbouring image in the same folder, replacing this tab in place (image branch). */
+    onOpenImageSibling: (currentPath: string, targetPath: string) => void;
+    registerSearchProvider: (provider: SearchProvider | null) => void;
+    /** Keep-alive: whether this is the visible (active) pane. The real renderer doesn't branch on it
+     *  (inactive panes stay mounted, just CSS-hidden by the parent); it's a hook for test harnesses. */
+    active?: boolean;
+    /** Restored PDF view state (page/zoom/fit) and a callback to persist changes. */
+    pdfInitialView?: ViewMeta;
+    onPdfViewState?: (m: ViewMeta) => void;
+    /** Register the active PDF pane's print function (uses its own already-loaded document — see
+     *  documentPrinting.ts printPdfDocument for why re-fetching the stream URL is unreliable). */
+    registerPdfPrint?: (fn: (() => Promise<boolean>) | null) => void;
+    /** Register PDF annotation serialization for app-level Save / Save As / Ctrl+S. */
+    registerPdfSave?: (fn: PdfSaveFunction | null) => void;
+    /** Register PDF two-phase save plan for source/OCR edits plus annotations. */
+    registerPdfSavePlan?: (fn: (() => Promise<PdfSavePlan>) | null) => void;
+    /** Publish PDF annotation dirtiness to app-level close, quit, & autosave handling. */
+    onPdfDirtyChange?: (dirty: boolean) => void;
+    /** Register canonical rendered Markdown export for app-level print, export, & clipboard commands. */
+    registerMarkdownExport?: (api: MarkdownExportApi | null) => void;
+    /** Markdown live view owns its scroll below fixed authoring chrome. */
+    markdownScrollRef?: RefObject<HTMLDivElement | null>;
+    onMarkdownScroll?: UIEventHandler<HTMLDivElement>;
+    /** Shared FindBar element, placed by each searchable document toolbar. */
+    findBar?: ReactNode;
+    findMode?: "find" | "replace";
+    /** Shell-level preview/source toggle. */
+    onChangeView?: (view: ViewMode) => void;
+    /** Open the shared find UI — used by the HTML preview to intercept Ctrl+F inside its iframe. */
+    onRequestFind?: () => void;
+    /** Close the shared find bar — used when a surface that owns its own search goes away. */
+    onCloseFind?: () => void;
+    onRequestReplace?: () => void;
+    /** Open a brokered absolute path as a tab — used for HTML internal relative-link navigation.
+     *  `background` (new-tab gesture) adds the tab without switching to it. */
+    onOpenPath?: (path: string, opts?: {
+        background?: boolean;
+    }) => void;
+    /** MDX branch only: reports every grant minted for the document's compile-time imports + in-preview
+     *  link clicks, so the owning tab's close can revoke them. */
+    onMdxImportGranted?: (entryPath: string, grantedPath: string) => void;
+    /** HTML site-session state + handlers (consumed only by the html branch). */
+    html?: {
+        pageBuffers: Record<string, HtmlPageBuffer>;
+        dirtyPagePaths: string[];
+        onEnsurePage: (entryPath: string, pagePath: string) => void;
+        onPageChange: (entryPath: string, pagePath: string, text: string) => void;
+        onSetActivePage: (entryPath: string, pagePath: string) => void;
+        onSavePage: (entryPath: string, pagePath: string) => void;
+        onDiscardPage: (entryPath: string, pagePath: string) => void;
+        onReloadFromDisk: (path: string, options?: {
+            force?: boolean;
+        }) => void;
+        initialPreviewScrollY: number;
+        onPreviewScroll: (y: number) => void;
+    };
+}
+declare function DocumentRouterImpl({ doc, view, readEdit, devMode, text, subscribeEdits, getEditSnapshot, getExternalSeq, sourceViewStateRef, onChange, onSave, onDocxSave, onDocxChange, registerDocxSave, registerImageSave, onDocxToolbar, onImageChange, onOpenImageSibling, registerSearchProvider, active, pdfInitialView, onPdfViewState, registerPdfPrint, registerPdfSave, registerPdfSavePlan, onPdfDirtyChange, registerMarkdownExport, markdownScrollRef, onMarkdownScroll, findBar, findMode, onChangeView, onRequestFind, onCloseFind, onRequestReplace, onOpenPath, onMdxImportGranted, html, }: Props): import("react").JSX.Element;
+type MemoProps = Pick<Props, "doc" | "active" | "view" | "readEdit" | "text" | "findBar" | "findMode" | "onRequestReplace" | "onChangeView" | "html">;
+export declare function documentRouterPropsEqual(prev: MemoProps, next: MemoProps): boolean;
+export declare const DocumentRouter: import("react").MemoExoticComponent<typeof DocumentRouterImpl>;
+export {};