@rightkit/document-workspace 0.0.0-stage → 0.1.1

package/dist/app/AppProvider.d.ts

@@ -0,0 +1,317 @@
+import { type ReactNode } from "react";
+/**
+ * Hook composition for the whole app shell. Hook call order matches the original useAppState exactly:
+ * document core → chrome state → shell setup → pane/search → tab chrome/zoom/lifecycle → commands &
+ * shortcuts → slots. Plain (non-hook) derivations stay between the same hook calls they originally did.
+ */
+declare function useAppState(): {
+    dragOver: boolean;
+    rootDragProps: {
+        onDragEnter: (e: import("react").DragEvent) => void;
+        onDragOver: (e: import("react").DragEvent) => void;
+        onDragLeave: (e: import("react").DragEvent) => void;
+        onDrop: () => void;
+    };
+    distractionFree: boolean;
+    activePath: string | null;
+    openPathsSet: Set<string>;
+    recents: import("../index.js").FileEntry[];
+    pinnedPaths: Set<string>;
+    pinnedEntries: import("../index.js").PinEntry[];
+    activate: (path: string) => Promise<void>;
+    openRecent: (entry: import("../index.js").FileEntry) => Promise<void>;
+    openExplorerPath: (path: string) => void;
+    onTogglePin: (path: string) => Promise<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>;
+    };
+    onOpenDialog: () => Promise<void>;
+    openUrl: () => void;
+    openFromClipboard: () => Promise<void>;
+    newDocument: (format?: "txt" | "md" | "docx") => void;
+    handleOpenSettings: () => void;
+    setSidebarCollapsed: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    menuSlot: import("react").JSX.Element | null;
+    modeSlot: import("react").JSX.Element | null;
+    active: import("@rightkit/document-core/documents/types").LoadedDocument | null;
+    activeIndex: number;
+    activeEditable: boolean;
+    titleBarTitle: string;
+    titleBarTitleFor: (d: import("@rightkit/document-core/documents/types").LoadedDocument) => string;
+    subscribeEdits: (path: string, cb: () => void) => () => void;
+    getEditSnapshot: (path: string) => string;
+    getExternalSeq: (path: string) => number;
+    sidebarCollapsed: boolean;
+    isDirty: (doc: import("@rightkit/document-core/documents/types").LoadedDocument) => boolean;
+    dirtyPaths: Set<string>;
+    subscribeDirty: (path: string, listener: () => void) => () => void;
+    tabStripProps: import("./tabs/TabStrip.js").TabStripProps;
+    view: import("@rightkit/document-core/documents/types").ViewMode;
+    docBarSlot: HTMLElement | null;
+    setDocBarSlot: import("react").Dispatch<import("react").SetStateAction<HTMLElement | null>>;
+    inspectorOpen: boolean;
+    toggleInspector: () => void;
+    closeInspector: () => void;
+    findBarEl: import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | null;
+    zoom: {
+        zoomHud: string | null;
+        zoomedAwayFromDefault: boolean;
+        zoomPercentLabel: string;
+        resetDocumentZoom: () => void;
+        onDocumentWheel: (e: import("react").WheelEvent<HTMLDivElement>) => 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;
+    };
+    restoringSession: boolean;
+    openDocs: import("@rightkit/document-core/documents/types").LoadedDocument[];
+    blockDrafts: import("@rightkit/document-core/app/blockDrafts").BlockDraftRegistry;
+    livePaths: Set<string>;
+    renderedPaths: Set<string>;
+    views: Record<string, import("@rightkit/document-core/documents/types").ViewMode>;
+    contentScrollRef: import("react").RefObject<HTMLDivElement | null>;
+    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;
+    };
+    onSave: (doc: import("@rightkit/document-core/documents/types").LoadedDocument, options?: {
+        silent?: boolean;
+    }) => Promise<string | null>;
+    setDocxMenu: import("react").Dispatch<import("react").SetStateAction<import("@rightkit/docx-editor/documents/docx/menuApi").DocxMenuApi | null>>;
+    registerPdfPrint: (fn: (() => Promise<boolean>) | null) => void;
+    registerMarkdownExport: (api: import("@rightkit/markdown-editor/documents/markdown/export/markdownExportTypes").MarkdownExportApi | null) => void;
+    findMode: "find" | "replace" | undefined;
+    searchProvider: import("@rightkit/document-core/documents/types").SearchProvider | null;
+    toggleFind: (replace: boolean) => void;
+    closeFind: () => void;
+    onChangeView: (next: import("@rightkit/document-core/documents/types").ViewMode) => Promise<void>;
+    registerSearchProviderFor: (path: string) => (provider: import("@rightkit/document-core/documents/types").SearchProvider | null) => void;
+    onOpenPathForRouter: (p: string, opts?: {
+        background?: boolean;
+    }) => void;
+    htmlPropsFor: (entryPath: string) => NonNullable<import("react").ComponentProps<typeof import("../index.js").DocumentRouter>["html"]>;
+    sourceViewStateRef: import("react").RefObject<Record<string, import("../index.js").SourceEditorViewState>>;
+    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;
+    };
+    docxMenu: import("@rightkit/docx-editor/documents/docx/menuApi").DocxMenuApi | null;
+    settings: import("@rightkit/document-core/settings/settings").Settings;
+    update: (patch: Partial<import("@rightkit/document-core/settings/settings").Settings>) => void;
+    docContextMenu: import("./DocumentContextMenu.js").DocContextMenu | null;
+    closeDocContextMenu: () => void;
+    copyContents: (() => undefined) | null;
+    paletteItems: import("./CommandPalette.js").PaletteItem[];
+    settingsOpen: boolean;
+    setSettingsOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    paletteOpen: boolean;
+    setPaletteOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    helpOpen: boolean;
+    setHelpOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    openUrlDialog: boolean;
+    setOpenUrlDialog: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    quitDirtyDocs: import("@rightkit/document-core/documents/types").LoadedDocument[];
+    open: (path: string, opts?: import("./useDocumentLoader.js").OpenDocumentOptions) => Promise<void>;
+    openLiveUrl: (input: string, opts?: {
+        background?: boolean;
+    }) => Promise<void>;
+    fullscreenConfirm: {
+        onDone: () => Promise<void>;
+        onDiscard: () => Promise<void>;
+        onStay: () => void;
+        error: string | null;
+    } | null;
+};
+export type AppState = ReturnType<typeof useAppState>;
+/** Read the composed app state inside AppProvider. */
+export declare function useAppContext(): AppState;
+/** Mounts the composed app state (all top-level hooks) for AppShell and its children. */
+export declare function AppProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export {};

package/dist/app/AppProvider.js

@@ -0,0 +1,217 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+import { capabilitiesFor } from "../documents/capabilities.js";
+import { effectiveReadEdit } from "./shell/readEdit.js";
+import { toast } from "@rightkit/platform-ui/headless";
+import { useAppDocumentCore } from "./useAppDocumentCore.js";
+import { useAppChromeState } from "./useAppChromeState.js";
+import { useAppShellSetup } from "./useAppShellSetup.js";
+import { useAppPaneSearch } from "./useAppPaneSearch.js";
+import { useAppTabChrome } from "./useAppTabChrome.js";
+import { useAppCommands } from "./useAppCommands.js";
+import { useAppSlots } from "./useAppSlots.js";
+import { writeClipboardText } from "@rightkit/document-core/state/tauriBridge";
+import { hostAppName } from "../appName.js";
+/**
+ * Hook composition for the whole app shell. Hook call order matches the original useAppState exactly:
+ * document core → chrome state → shell setup → pane/search → tab chrome/zoom/lifecycle → commands &
+ * shortcuts → slots. Plain (non-hook) derivations stay between the same hook calls they originally did.
+ */
+function useAppState() {
+    const { blockDrafts, tabs, docBarSlot, setDocBarSlot, dirtyPaths, subscribeDirty, viewState, library, docs, } = useAppDocumentCore();
+    const { openDocs, activePath, editsRef, subscribeEdits, getEditSnapshot, getExternalSeq } = tabs;
+    const { views, contentScrollRef, requestViewChange: onChangeView } = viewState;
+    const { recents, pinnedPaths, pinnedEntries, onTogglePin } = library;
+    const { activate, open, openLiveUrl, openRecent, onOpenDialog, newDocument, onSave } = docs;
+    const { isDirty, restoringSession } = docs;
+    const { settingsOpen, setSettingsOpen, paletteOpen, setPaletteOpen, helpOpen, setHelpOpen, openUrlDialog, setOpenUrlDialog, tabOverviewOpen, setTabOverviewOpen, sidebarCollapsed, setSidebarCollapsed, inspectorOpen, toggleInspector, closeInspector, } = useAppChromeState();
+    const { settings, update, handleOpenSettings, dragOver, rootDragProps, docxMenu, setDocxMenu, markdownExport, registerPdfPrint, registerMarkdownExport, handlePrint, docContextMenu, closeDocContextMenu, autoUpdateCheckRan, previewScrollStore, sourceViewStateRef, } = useAppShellSetup({ docs, activePath, setSettingsOpen });
+    const active = openDocs.find((d) => d.path === activePath) ?? null;
+    // Tab order == openDocs order (titlebar tabs use index-keyed ids for aria-controls/labelledby).
+    const activeIndex = openDocs.findIndex((d) => d.path === activePath);
+    const quitDirtyDocs = openDocs.filter((doc) => isDirty(doc));
+    const view = active ? (views[active.path] ?? "preview") : "preview";
+    const { livePaths, renderedPaths, searchProvider, openFind, toggleFind, closeFind, findBarEl, canOpenFind, findOpen, findMode, registerSearchProviderFor, htmlPropsFor, } = useAppPaneSearch({
+        docs,
+        tabs,
+        openDocs,
+        activePath,
+        active,
+        blockDrafts,
+        previewScrollStore,
+        sourceViewStateRef,
+    });
+    // Read the live editsRef (not the debounced `edits` state) so the controlled editor + command-palette
+    // text actions see the latest keystroke without App re-rendering on every keystroke.
+    const activeText = active ? (editsRef.current[active.path] ?? active.content) : "";
+    const activeEditable = active ? capabilitiesFor(active.format).canEdit : false;
+    const activeReadEdit = active ? effectiveReadEdit(active) : "read";
+    const activeTextLike = active ? capabilitiesFor(active.format).canReplace : false;
+    // Whole-document copy — shared by the command palette, the bottom-bar button, and the document
+    // context menu's "Copy contents". Null for non-text formats (pdf/image/docx binary surfaces).
+    const copyContents = activeTextLike && active
+        ? () => void writeClipboardText(activeText)
+            .then(() => toast("Document contents copied", "success"))
+            .catch(() => toast("Couldn't copy to clipboard", "error"))
+        : null;
+    const { titleBarTitleFor, tabStripProps, openPathsSet, openExplorerPath, cycleTab, jumpToTab, zoom, openFromClipboard, } = useAppTabChrome({
+        docs,
+        tabs,
+        activePath,
+        sidebarCollapsed,
+        tabOverviewOpen,
+        setTabOverviewOpen,
+        pinnedPaths,
+        onTogglePin,
+        dirtyPaths,
+        subscribeDirty,
+        active,
+        view,
+        settings,
+        update,
+        autoUpdateCheckRan,
+    });
+    const titleBarTitle = active ? titleBarTitleFor(active) : hostAppName();
+    const { paletteItems, distractionFree, fullscreenConfirm } = useAppCommands({
+        docs,
+        openDocs,
+        recents,
+        active,
+        activeEditable,
+        activeTextLike,
+        activeText,
+        copyContents,
+        settings,
+        update,
+        onChangeView,
+        docxMenu,
+        markdownExport,
+        handlePrint,
+        openFromClipboard,
+        cycleTab,
+        jumpToTab,
+        blockDrafts,
+        searchProvider,
+        canOpenFind,
+        findOpen,
+        openFind,
+        settingsOpen,
+        setSettingsOpen,
+        paletteOpen,
+        setPaletteOpen,
+        helpOpen,
+        setHelpOpen,
+        openUrlDialog,
+        setOpenUrlDialog,
+        setTabOverviewOpen,
+    });
+    const { onOpenPathForRouter, menuSlot, modeSlot } = useAppSlots({
+        docs,
+        active,
+        view,
+        onChangeView,
+        handlePrint,
+        docxMenu,
+        activeReadEdit,
+    });
+    const openUrl = () => setOpenUrlDialog(true);
+    return {
+        dragOver,
+        rootDragProps,
+        distractionFree,
+        activePath,
+        openPathsSet,
+        recents,
+        pinnedPaths,
+        pinnedEntries,
+        activate,
+        openRecent,
+        openExplorerPath,
+        onTogglePin,
+        library,
+        onOpenDialog,
+        openUrl,
+        openFromClipboard,
+        newDocument,
+        handleOpenSettings,
+        setSidebarCollapsed,
+        menuSlot,
+        modeSlot,
+        active,
+        activeIndex,
+        activeEditable,
+        titleBarTitle,
+        titleBarTitleFor,
+        subscribeEdits,
+        getEditSnapshot,
+        getExternalSeq,
+        sidebarCollapsed,
+        isDirty,
+        dirtyPaths,
+        subscribeDirty,
+        tabStripProps,
+        view,
+        docBarSlot,
+        setDocBarSlot,
+        inspectorOpen,
+        toggleInspector,
+        closeInspector,
+        findBarEl,
+        zoom,
+        docs,
+        restoringSession,
+        openDocs,
+        blockDrafts,
+        livePaths,
+        renderedPaths,
+        views,
+        contentScrollRef,
+        viewState,
+        onSave,
+        setDocxMenu,
+        registerPdfPrint,
+        registerMarkdownExport,
+        findMode,
+        searchProvider,
+        toggleFind,
+        closeFind,
+        onChangeView,
+        registerSearchProviderFor,
+        onOpenPathForRouter,
+        htmlPropsFor,
+        sourceViewStateRef,
+        tabs,
+        docxMenu,
+        settings,
+        update,
+        docContextMenu,
+        closeDocContextMenu,
+        copyContents,
+        paletteItems,
+        settingsOpen,
+        setSettingsOpen,
+        paletteOpen,
+        setPaletteOpen,
+        helpOpen,
+        setHelpOpen,
+        openUrlDialog,
+        setOpenUrlDialog,
+        quitDirtyDocs,
+        open,
+        openLiveUrl,
+        fullscreenConfirm,
+    };
+}
+const AppContext = createContext(null);
+/** Read the composed app state inside AppProvider. */
+export function useAppContext() {
+    const app = useContext(AppContext);
+    if (!app)
+        throw new Error("useAppContext must be used inside AppProvider");
+    return app;
+}
+/** Mounts the composed app state (all top-level hooks) for AppShell and its children. */
+export function AppProvider({ children }) {
+    const app = useAppState();
+    return _jsx(AppContext.Provider, { value: app, children: children });
+}

package/dist/app/AppRoot.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Top-level shell: renders the shared Right Suite legal gate in place of the document workspace
+ * until the acceptance receipt in settings is current, then swaps to <App/>. Owns the one call to
+ * useReadyShow() for BOTH paths — the gate's own window (960x560, fixed) must reveal itself just
+ * like the main app window does, or a real first-run user launching the installer-hidden window
+ * sees nothing at all.
+ */
+export declare function AppRoot(): import("react").JSX.Element;