@rightkit/document-workspace 0.0.0-stage → 0.1.1

package/dist/app/AppRoot.js

@@ -0,0 +1,159 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useMemo, useRef } from "react";
+import { Onboarding } from "@rightkit/onboarding";
+import { getCurrentWindow, LogicalSize } from "@tauri-apps/api/window";
+import { isTauri } from "@rightkit/platform-ui";
+import { useSettings } from "@rightkit/document-core/settings/settings";
+import { LEGAL_GATE_DOCUMENTS, LEGAL_MATERIAL_SHA256, REQUIRED_LEGAL_ACCEPTANCE_VERSION, createOnboardingSettingsBackend, legalAcceptanceCurrent, legalReceiptFields, legalReceiptRecord, legalRecordCurrent, } from "../state/legal.js";
+import { App } from "./App.js";
+import { useReadyShow } from "./useReadyShow.js";
+import { logError } from "@rightkit/document-core/state/diagnostics";
+import { getShell, isBrowserQaMode } from "@rightkit/document-core/state/tauriBridge";
+import { hostAppName } from "../appName.js";
+// Locked (Adrian, 2026-07-17): the gate is its own fixed 960x560 window, independent of whatever
+// size the user last left the main 1100x750 workspace at. See memory
+// "legal-gate-fixed-960x560-own-window".
+const GATE_WIDTH = 960;
+const GATE_HEIGHT = 560;
+const TRUST_LINE = `${hostAppName()} works on the documents already on your disk. Nothing is uploaded to open or edit them.`;
+const AGREEMENT_STATEMENT = `I have read and agree to the ${hostAppName()} License, End User License Agreement, Acceptable Use Policy, and Product Schedule.`;
+// Transcribed from .claude/rules/brands.md (Right Suite — App Identities — the host app) LIGHT tokens.
+// The legal gate is locked to light mode for every app regardless of the app's own theme setting.
+const RIGHTKIT_LEGAL_GATE_THEME = {
+    bg: "#F7F3EC",
+    surface: "#FFFDF8",
+    border: "#E2DAD1",
+    text: "#211C18",
+    muted: "#6E665F",
+    accent: "#0C6AA5",
+    accentContrast: "#FFFFFF",
+    fontDisplay: "Tanker, 'Arial Narrow', sans-serif",
+    fontBody: "Geist, 'Hanken Grotesk', sans-serif",
+};
+const LEGAL_STEP = {
+    theme: RIGHTKIT_LEGAL_GATE_THEME,
+    appName: hostAppName(),
+    trustLine: TRUST_LINE,
+    documents: LEGAL_GATE_DOCUMENTS,
+    agreementStatement: AGREEMENT_STATEMENT,
+    onQuit: () => void destroyWindow(),
+    wordmarkFontUrl: "/fonts/Tanker-400.woff2",
+};
+async function resizeWindow(width, height) {
+    if (!isTauri())
+        return;
+    try {
+        const win = getCurrentWindow();
+        await win.setSize(new LogicalSize(width, height));
+        await win.center();
+    }
+    catch (error) {
+        // Never swallow this silently. Tauri rejects setSize/center unless the capability grants
+        // core:window:allow-set-size and allow-center — and a swallowed rejection is invisible: every
+        // test passes while the real app ignores the resize and renders the gate at the full workspace
+        // size. That is exactly how this shipped wrong once (2026-07-17). The reveal must still proceed,
+        // so log rather than throw. logError, NOT logEvent: an event reaches the exported diagnostics
+        // bundle as an anonymous info-level `renderer_event`, which is its own kind of silence.
+        try {
+            logError("legal-gate:resize-failed");
+        }
+        catch {
+            console.error("legal-gate: window resize failed", error);
+        }
+    }
+}
+// The shell's `fullscreen` action only toggles, so leave fullscreen through the window API.
+const exitFullscreen = () => getCurrentWindow().setFullscreen(false);
+async function tryWindowAction(label, action) {
+    try {
+        await action();
+    }
+    catch (error) {
+        try {
+            logError(label);
+        }
+        catch {
+            console.error(`${label}: ${String(error)}`);
+        }
+    }
+}
+/** Put the first-run gate into its exact, fixed-size state before revealing the hidden window. */
+async function prepareLegalGateWindow() {
+    if (!isTauri())
+        return;
+    const win = getShell().window;
+    // A prior native state (including macOS fullscreen) must not survive into the legal gate.
+    await tryWindowAction("legal-gate:fullscreen-exit-failed", exitFullscreen);
+    await tryWindowAction("legal-gate:unmaximize-failed", () => win.do("unmaximize"));
+    await tryWindowAction("legal-gate:resizable-failed", () => getCurrentWindow().setResizable(false));
+    await tryWindowAction("legal-gate:maximizable-failed", () => getCurrentWindow().setMaximizable(false));
+    await resizeWindow(GATE_WIDTH, GATE_HEIGHT);
+}
+/** Restore normal controls & maximize workspace before the accepted app shell mounts. */
+async function prepareWorkspaceWindow() {
+    if (!isTauri())
+        return;
+    const win = getShell().window;
+    await tryWindowAction("workspace:fullscreen-exit-failed", exitFullscreen);
+    await tryWindowAction("workspace:resizable-failed", () => getCurrentWindow().setResizable(true));
+    await tryWindowAction("workspace:maximizable-failed", () => getCurrentWindow().setMaximizable(true));
+    await tryWindowAction("workspace:maximize-failed", () => win.do("maximize"));
+}
+async function destroyWindow() {
+    if (!isTauri())
+        return;
+    try {
+        await getCurrentWindow().destroy();
+    }
+    catch {
+        // Outside Tauri there is no window to destroy.
+    }
+}
+/**
+ * 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 function AppRoot() {
+    const { settings, update, updateAsync } = useSettings();
+    // Browser QA runs against a fresh profile every launch, so the legal gate would otherwise block
+    // every automated run behind a manual click. QA mode is a deterministic harness, never a shipped
+    // build (isBrowserQaMode is false in production), so skip the gate there — mirrors how dev-native
+    // bypasses the license gate. Real users always see the gate until they accept.
+    // Browser QA normally bypasses the first-run gate so unattended document journeys can mount.
+    // The explicit qaLegal switch exercises the shipped gate itself with the same browser fixtures;
+    // it is only honored in QA/dev builds because isBrowserQaMode() is false in production.
+    const qaLegalGate = isBrowserQaMode() &&
+        typeof window !== "undefined" &&
+        new URLSearchParams(window.location.search).get("qaLegal") === "1";
+    const needsGate = (!isBrowserQaMode() || qaLegalGate) && !legalAcceptanceCurrent(settings);
+    // Configure native state before reveal. The gate is exact 960x560 and fixed; accepted/current
+    // workspace launches with normal controls and maximized geometry.
+    const beforeShow = useCallback(() => (needsGate ? prepareLegalGateWindow() : prepareWorkspaceWindow()), [needsGate]);
+    useReadyShow(beforeShow);
+    // Stable ports: onboarding reloads when either identity changes, so they read the live settings
+    // through refs instead of closing over each render's values.
+    const settingsRef = useRef(settings);
+    settingsRef.current = settings;
+    const updateRef = useRef(update);
+    updateRef.current = update;
+    const updateAsyncRef = useRef(updateAsync);
+    updateAsyncRef.current = updateAsync;
+    const onboardingSettings = useMemo(() => createOnboardingSettingsBackend(), []);
+    const legalReceipt = useMemo(() => ({
+        read: () => legalReceiptRecord(settingsRef.current),
+        write: async (record) => {
+            // Restore native controls & maximize BEFORE settings swaps in <App/>, so app never mounts in
+            // fixed legal-gate state even for a single frame.
+            await prepareWorkspaceWindow();
+            await updateAsyncRef.current(legalReceiptFields(record));
+        },
+    }), []);
+    if (!needsGate)
+        return _jsx(App, {});
+    // Onboarding's legal step comes first and wraps the shared LegalGate; with no further steps,
+    // accepting the receipt is the whole first run and the settings swap above mounts <App/>.
+    return (_jsx(Onboarding, { settings: onboardingSettings, legal: LEGAL_STEP, legalReceipt: legalReceipt, requiredVersion: REQUIRED_LEGAL_ACCEPTANCE_VERSION, requiredDocumentsHash: LEGAL_MATERIAL_SHA256, isAccepted: (state) => legalRecordCurrent(state.legalAcceptance), onComplete: () => { } }));
+}

package/dist/app/AppShell.d.ts

@@ -0,0 +1,2 @@
+/** Layout shell: renders the sidebar, toolbar, document pane, and dialogs from the composed app state. */
+export declare function AppShell(): import("react").JSX.Element;

package/dist/app/AppShell.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { AppFrame, Plane } from "@rightkit/react-shell/react";
+import { Sidebar } from "./Sidebar.js";
+import { Toolbar } from "./Toolbar.js";
+import { DocumentContextMenu } from "./DocumentContextMenu.js";
+import { ToastViewport } from "./ToastViewport.js";
+import { AppDialogsHost } from "./AppDialogsHost.js";
+import { DocumentPane } from "./DocumentPane.js";
+import { DropOverlay } from "./useFileDragOverlay.js";
+import { useAppContext } from "./AppProvider.js";
+/** Layout shell: renders the sidebar, toolbar, document pane, and dialogs from the composed app state. */
+export function AppShell() {
+    const { 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, docxMenu, settings, update, docContextMenu, closeDocContextMenu, copyContents, paletteItems, settingsOpen, setSettingsOpen, paletteOpen, setPaletteOpen, helpOpen, setHelpOpen, openUrlDialog, setOpenUrlDialog, quitDirtyDocs, open, openLiveUrl, fullscreenConfirm } = useAppContext();
+    return (_jsx(AppFrame, { children: _jsxs("div", { className: "vr-app-root flex h-full w-full bg-[var(--chrome)] text-paper", ...rootDragProps, children: [dragOver && _jsx(DropOverlay, {}), _jsx("a", { href: "#vr-doc-pane", className: "vr-skip-link", children: "Skip to content" }), !distractionFree && (_jsx(Sidebar, { activePath: activePath, openPaths: openPathsSet, recents: recents, pinnedPaths: pinnedPaths, pinnedEntries: pinnedEntries, onActivate: activate, onOpenRecent: openRecent, onOpenPath: openExplorerPath, onTogglePin: onTogglePin, onTogglePinDir: library.onTogglePinDir, onClearRecents: library.onClearRecents, onOpenDialog: onOpenDialog, onOpenUrl: openUrl, onOpenClipboard: openFromClipboard, onNew: newDocument, onOpenSettings: handleOpenSettings, onCollapsedChange: setSidebarCollapsed, titlebarSlot: menuSlot })), _jsx(Plane, { className: "min-w-0 flex-1 overflow-visible", children: _jsxs("main", { className: "flex min-h-0 min-w-0 flex-1 flex-col", children: [!distractionFree && (_jsx(Toolbar, { doc: active, title: titleBarTitle, compute: titleBarTitleFor, subscribeEdits: subscribeEdits, getEditSnapshot: getEditSnapshot, sidebarCollapsed: sidebarCollapsed, menuSlot: menuSlot, isDirty: isDirty, dirtyPaths: dirtyPaths, subscribeDirty: subscribeDirty, tabs: tabStripProps })), _jsx(DocumentPane, { active: active, activeIndex: activeIndex, activeEditable: activeEditable, view: view, distractionFree: distractionFree, docBarSlot: docBarSlot, setDocBarSlot: setDocBarSlot, modeSlot: modeSlot, inspectorOpen: inspectorOpen, toggleInspector: toggleInspector, closeInspector: closeInspector, findBarEl: findBarEl, zoom: zoom, openingPath: docs.openingPath, restoringSession: restoringSession, openDocs: openDocs, startPage: {
+                                    onNew: newDocument,
+                                    onOpenDialog,
+                                    onOpenUrl: openUrl,
+                                    onOpenClipboard: openFromClipboard,
+                                    recents,
+                                    onOpenRecent: openRecent,
+                                }, blockDrafts: blockDrafts, router: {
+                                    mountedDocs: openDocs,
+                                    activePath,
+                                    livePaths,
+                                    renderedPaths,
+                                    views,
+                                    contentScrollRef,
+                                    onContentScroll: viewState.onContentScroll,
+                                    onDocumentWheel: zoom.onDocumentWheel,
+                                    subscribeEdits,
+                                    getEditSnapshot,
+                                    getExternalSeq,
+                                    sourceViewStateRef,
+                                    onTxtChange: docs.onTxtChange,
+                                    onSave,
+                                    onDocxSaveAs: docs.onDocxSaveAs,
+                                    onDocxSave: docs.onDocxSave,
+                                    onDocxChange: docs.onDocxChange,
+                                    docxSaver: docs.docxSaver,
+                                    imageSaver: docs.imageSaver,
+                                    docxSaversRef: docs.docxSaversRef,
+                                    pdfSaversRef: docs.pdfSaversRef,
+                                    pdfSavePlansRef: docs.pdfSavePlansRef,
+                                    imageSaversRef: docs.imageSaversRef,
+                                    setDocxMenu,
+                                    setPdfPrint: registerPdfPrint,
+                                    setMarkdownExport: registerMarkdownExport,
+                                    onImageChange: docs.onImageChange,
+                                    onPdfDirtyChange: docs.onPdfDirtyChange,
+                                    openImageSibling: docs.openImageSibling,
+                                    registerSearchProviderFor,
+                                    onPdfViewState: viewState.onPdfViewState,
+                                    findBarEl: null,
+                                    findMode,
+                                    canReplaceSearch: !!searchProvider?.canReplace,
+                                    onChangeView,
+                                    toggleFind,
+                                    closeFind,
+                                    onOpenPath: onOpenPathForRouter,
+                                    trackMdxGrant: docs.trackMdxGrant,
+                                    htmlPropsFor,
+                                }, subscribeEdits: subscribeEdits, getEditSnapshot: getEditSnapshot, dirtyPaths: dirtyPaths, isDirty: isDirty, subscribeDirty: subscribeDirty, docxMenu: docxMenu, onHtmlSave: docs.onHtmlSaveShortcut, onSave: onSave, settings: settings, update: update })] }) }), docContextMenu && (_jsx(DocumentContextMenu, { menu: docContextMenu, onClose: closeDocContextMenu, onCopyContents: copyContents })), _jsx(ToastViewport, {}), _jsx(AppDialogsHost, { docs: docs, openDocs: openDocs, quitDirtyDocs: quitDirtyDocs, paletteItems: paletteItems, overlays: {
+                        settingsOpen,
+                        setSettingsOpen,
+                        paletteOpen,
+                        setPaletteOpen,
+                        helpOpen,
+                        setHelpOpen,
+                        openUrlDialog,
+                        setOpenUrlDialog,
+                    }, onHistoryPurged: library.onHistoryPurged, open: open, openLiveUrl: openLiveUrl, viewConfirm: viewState.pendingViewChange
+                        ? {
+                            onDone: () => void viewState.confirmViewChange("done"),
+                            onDiscard: () => void viewState.confirmViewChange("discard"),
+                            onStay: () => void viewState.confirmViewChange("stay"),
+                            error: viewState.pendingViewChange.drafts.find((d) => d.error)?.error ??
+                                viewState.pendingViewChange.drafts.find((d) => d.reason)?.reason ??
+                                null,
+                        }
+                        : null, fullscreenConfirm: fullscreenConfirm })] }) }));
+}

package/dist/app/CommandPalette.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode } from "react";
+export interface PaletteItem {
+    id: string;
+    label: string;
+    hint?: string;
+    icon?: ReactNode;
+    run: () => void;
+}
+/** Ctrl+Shift+P quick-open + command runner. Thin adapter over the shell's CommandPalette. */
+export declare function CommandPalette({ items, onClose }: {
+    items: PaletteItem[];
+    onClose: () => void;
+}): import("react").JSX.Element;

package/dist/app/CommandPalette.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo, useRef } from "react";
+import { MagnifyingGlass } from "@phosphor-icons/react/dist/icons/MagnifyingGlass";
+import { rankItems as rankByScore } from "@rightkit/platform-ui/headless";
+import { CommandPalette as ShellCommandPalette } from "@rightkit/react-shell/react";
+const isDocument = (it) => it.id.startsWith("tab:") || it.id.startsWith("recent:");
+// Keeps the app's ranking: subsequence score within each section, Documents (open tabs + recents)
+// ahead of Commands. The shell groups by first-seen order, so documents must come first here.
+function rankPaletteItems(commands, query, limit) {
+    const ranked = rankByScore(commands, query);
+    const documents = ranked.filter((c) => c.group === "Documents");
+    const rest = ranked.filter((c) => c.group !== "Documents");
+    return [...documents, ...rest].slice(0, limit);
+}
+/** Ctrl+Shift+P quick-open + command runner. Thin adapter over the shell's CommandPalette. */
+export function CommandPalette({ items, onClose }) {
+    // A command runs once per open palette: a second Enter or click during the exit animation is dropped.
+    const ran = useRef(false);
+    const commands = useMemo(() => items.map((it) => ({
+        id: it.id,
+        label: it.label,
+        hint: it.hint,
+        icon: it.icon,
+        group: isDocument(it) ? "Documents" : "Commands",
+        run: () => {
+            if (ran.current)
+                return;
+            ran.current = true;
+            it.run();
+        },
+    })), [items]);
+    return (_jsx(ShellCommandPalette, { commands: commands, onClose: onClose, rank: rankPaletteItems, limit: 50, paletteWidth: 680, enterDelayMs: 80, labels: {
+            placeholder: "Go to a file or run a command…",
+            inputAriaLabel: "Search files and commands",
+            title: "Command palette",
+            results: "Results",
+            empty: "No matches.",
+        }, className: "vr-pop vr-pop-modal vr-glass-panel max-w-[92vw] overflow-hidden rounded-[28px]", slots: {
+            field: "h-[62px] gap-3 border-b border-line px-5",
+            input: "vr-focus min-w-0 flex-1 bg-transparent font-sans text-[22px] text-paper placeholder:text-muted-2",
+            list: "max-h-[min(56vh,520px)] overflow-auto px-2.5 pb-2.5 pt-1.5",
+            group: "px-3 pb-1 pt-2.5 font-sans text-chrome-xs font-semibold text-muted-2",
+            option: "vr-palette-opt vr-focus h-[42px] w-full gap-3 rounded-xl px-3 font-sans text-paper/85 hover:bg-ink/30 [&.is-active]:bg-copper/[0.16] [&.is-active]:text-paper",
+            icon: "h-7 w-7 rounded-lg bg-ink/40 text-muted [.is-active_&]:bg-copper/20 [.is-active_&]:text-copper-hi",
+            empty: "px-4 py-3 font-sans text-xs text-muted-2",
+        }, searchIcon: _jsx(MagnifyingGlass, { size: 20, weight: "regular", "aria-hidden": "true", className: "shrink-0 text-muted" }) }));
+}

package/dist/app/DocActionBar.d.ts

@@ -0,0 +1,36 @@
+import type { LoadedDocument, ViewMode } from "@rightkit/document-core/documents/types";
+import type { DocxMenuApi } from "@rightkit/docx-editor/documents/docx/menuApi";
+import { type NativeMenuCommand } from "@rightkit/document-core/app/shell/nativeMenu";
+interface Props {
+    doc: LoadedDocument;
+    view: ViewMode;
+    onSave: () => void;
+    onSaveAs: () => void;
+    onPrint: () => void;
+    onClose: () => void;
+    onChangeView: (v: ViewMode) => void;
+    onEditImageExternal?: () => void;
+    /** Present once a DOCX editor is mounted — drives docx's menus + save/print. */
+    docxMenu?: DocxMenuApi | null;
+    /** Wave 2 Read mode — menu/view-switch editing affordances hide; file + viewing actions stay. */
+    readOnly?: boolean;
+}
+export declare const DocumentMenus: import("react").MemoExoticComponent<typeof DocumentMenusImpl>;
+declare function DocumentMenusImpl({ doc, view, onSave, onSaveAs, onPrint, onClose, onChangeView, onEditImageExternal, docxMenu, readOnly, }: Pick<Props, "doc" | "view" | "onSave" | "onSaveAs" | "onPrint" | "onClose" | "onChangeView" | "onEditImageExternal" | "docxMenu" | "readOnly">): import("react").JSX.Element | null;
+/** Commands the in-window menus offer for this document, for the macOS menu bar. Mirrors the
+ *  visibility rules of DocxMenus/TextMenus below so both platforms expose the same actions. */
+export declare function documentMenuCommands({ doc, view, onChangeView, onEditImageExternal, docxMenu, readOnly, spellcheck, wordWrap, toggleSpellcheck, toggleWordWrap, }: {
+    doc: LoadedDocument;
+    view: ViewMode;
+    onChangeView: (v: ViewMode) => void;
+    onEditImageExternal?: () => void;
+    docxMenu?: DocxMenuApi | null;
+    readOnly?: boolean;
+    spellcheck: boolean;
+    wordWrap: boolean;
+    toggleSpellcheck: () => void;
+    toggleWordWrap: () => void;
+}): NativeMenuCommand[];
+export declare const DocumentModeControls: import("react").MemoExoticComponent<typeof DocumentModeControlsImpl>;
+declare function DocumentModeControlsImpl({ doc, view, onChangeView, readOnly, }: Pick<Props, "doc" | "view" | "onChangeView" | "readOnly">): import("react").JSX.Element;
+export {};