@rightkit/document-workspace 0.0.0-stage → 0.1.1

package/dist/documents/DocumentRouter.js

@@ -0,0 +1,153 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { lazy, memo, Suspense, useEffect, } from "react";
+import { capabilitiesFor } from "./capabilities.js";
+import { ErrorBoundary } from "../app/ErrorBoundary.js";
+import { logEvent } from "@rightkit/document-core/state/diagnostics";
+// Heavy viewers — load only when their format is actually opened (keeps cold launch fast).
+// MarkdownSplitPane pulls the unified/remark engine (its preview) + lazies the CodeMirror source;
+// HtmlViewer pulls DOMPurify — all lazy so a cold launch or opening a plain TXT never pays for them.
+const MarkdownSplitPane = lazy(() => import("./markdown/MarkdownSplitPane.js").then((m) => ({ default: m.MarkdownSplitPane })));
+const MarkdownCoreProvider = lazy(() => import("@rightkit/markdown-editor/documents/markdown/MarkdownCoreProvider").then((m) => ({ default: m.MarkdownCoreProvider })));
+const MdxSplitPane = lazy(() => import("./mdx/MdxSplitPane.js").then((m) => ({ default: m.MdxSplitPane })));
+const HtmlDocument = lazy(() => import("./html/HtmlDocument.js").then((m) => ({ default: m.HtmlDocument })));
+const DocxPane = lazy(() => import("@rightkit/docx-editor/documents/docx/DocxPane").then((m) => ({ default: m.DocxPane })));
+const PdfViewer = lazy(() => import("@rightkit/document-core/documents/pdf/NativePdfDocument").then((m) => ({ default: m.NativePdfDocument })));
+const LivePreviewPane = lazy(() => import("./web/LivePreviewPane.js").then((m) => ({ default: m.LivePreviewPane })));
+const ImageViewer = lazy(() => import("./ImageDocument.js").then((m) => ({ default: m.ImageViewer })));
+const TextEditor = lazy(() => import("./txt/TxtEditor.js").then((m) => ({ default: m.TextEditor })));
+// The image viewer's React key: the containing folder, so same-folder paging reuses one instance
+// (seamless swap) while a different folder remounts. Falls back to the full path if it has no parent.
+const VIEWER_ROUTE_EVENTS = {
+    preview: "viewer:route:preview",
+    source: "viewer:route:source",
+    interactive: "viewer:route:interactive",
+};
+const imageInstanceKey = (path) => path.replace(/[\\/][^\\/]*$/, "") || path;
+const Loading = () => (_jsx("div", { className: "h-full bg-ink p-4", children: _jsxs("div", { className: "h-full animate-pulse rounded border border-line bg-panel/40 p-5", children: [_jsx("div", { className: "mb-5 h-6 w-40 rounded bg-panel-2" }), _jsxs("div", { className: "space-y-3", children: [_jsx("div", { className: "h-4 w-3/4 rounded bg-panel-2" }), _jsx("div", { className: "h-4 w-2/3 rounded bg-panel-2" }), _jsx("div", { className: "h-4 w-5/6 rounded bg-panel-2" })] })] }) }));
+export const MarkdownTextFallback = ({ text }) => (_jsx("div", { "data-vr-markdown-first-paint": "", className: "h-full overflow-auto bg-ink px-8 py-6", children: _jsx("pre", { className: "vr-markdown-document-geometry min-h-full whitespace-pre-wrap rounded-lg px-8 py-7 font-serif text-[length:var(--doc-size)] leading-[var(--doc-leading)]", style: { background: "var(--reader-surface)", color: "var(--doc-fg)" }, children: text }) }));
+function ViewerShell({ doc, children }) {
+    return (_jsx(ErrorBoundary, { label: `${doc.displayName || doc.format} viewer`, resetKey: `${doc.path}:${doc.format}`, closeTabPath: doc.path, children: _jsx(Suspense, { fallback: _jsx(Loading, {}), children: children }) }));
+}
+function DocumentRouterImpl({ doc, view, readEdit = "read", devMode, text, subscribeEdits, getEditSnapshot, getExternalSeq, sourceViewStateRef, onChange, onSave, onDocxSave, onDocxChange, registerDocxSave, registerImageSave, onDocxToolbar, onImageChange, onOpenImageSibling, registerSearchProvider, active = false, pdfInitialView, onPdfViewState, registerPdfPrint, registerPdfSave, registerPdfSavePlan, onPdfDirtyChange, registerMarkdownExport, markdownScrollRef, onMarkdownScroll, findBar, findMode, onChangeView, onRequestFind, onCloseFind, onRequestReplace, onOpenPath, onMdxImportGranted, html, }) {
+    useEffect(() => {
+        logEvent(VIEWER_ROUTE_EVENTS[view]);
+    }, [view]);
+    useEffect(() => {
+        if (doc.format === "md") {
+            void import("./markdown/MarkdownSplitPane.js");
+            void import("@rightkit/markdown-editor/documents/markdown/MarkdownCoreProvider");
+            // The source drawer (CodeMirror) is not needed for first paint: warm it after the preview
+            // has painted so it stays off the cold-mount critical path but is ready when opened.
+            const warmSource = () => {
+                void import("./txt/TxtEditor.js");
+            };
+            if (typeof window.requestIdleCallback === "function") {
+                window.requestIdleCallback(warmSource, { timeout: 2000 });
+            }
+            else {
+                window.setTimeout(warmSource, 300);
+            }
+        }
+        else if (doc.format === "mdx") {
+            // MDX preview is a separate subtree (sandboxed iframe). The compile path lives in mdxCompiler
+            // and the iframe runtime is bundled in mdxBridgeScript; the splitter + source editor are
+            // shared with the markdown side, so we prefetch both formats' chunks on first open.
+            void import("./mdx/MdxSplitPane.js");
+            void import("@rightkit/markdown-editor/documents/mdx/mdxCompiler");
+            void import("./markdown/MarkdownSplitPane.js"); // shared TxtEditor + outline code
+            void import("./txt/TxtEditor.js");
+        }
+        else if (doc.format === "html") {
+            void import("./txt/TxtEditor.js");
+        }
+    }, [doc.format]);
+    // Every viewer EXCEPT image is keyed by `doc.path` so switching documents REMOUNTS it. That makes
+    // the search provider register on mount and unregister on unmount through the normal lifecycle — no
+    // separate reset effect (which raced the lazy child's registration), and no "re-register on doc
+    // change" hacks inside the viewers. Same-format switches (html→html, pdf→pdf, txt→txt) previously
+    // reused one instance whose stable-deps registration effect never re-ran, so a leaving-doc reset
+    // left the provider null and Ctrl+F couldn't open. Keying fixes that whole class of bug. The key is
+    // stable while editing one doc (only switches remount), so the caret/scroll within a doc is intact.
+    // The IMAGE viewer is the deliberate exception: it's keyed by its FOLDER (imageInstanceKey), not the
+    // file, so same-folder paging reuses one mounted instance (seamless swap). That's safe because the
+    // image viewer registers NO search provider and resets its per-image edit/view state internally —
+    // do NOT "fix" it back to doc.path or you'll reintroduce the remount → blank → resize on paging.
+    switch (doc.format) {
+        case "web":
+            return (_jsx(ViewerShell, { doc: doc, children: _jsx(LivePreviewPane, { doc: doc }, doc.path) }));
+        case "pdf":
+            return (_jsx(ViewerShell, { doc: doc, children: _jsx(PdfViewer, { documentPath: doc.path, url: doc.assetUrl, active: active, readOnly: readEdit !== "edit", initialView: pdfInitialView, onViewState: onPdfViewState, registerPrint: registerPdfPrint, registerPdfSave: registerPdfSave, registerPdfSavePlan: registerPdfSavePlan, onDirtyChange: onPdfDirtyChange, registerSearchProvider: registerSearchProvider, findBar: findBar, findMode: findMode, onRequestFind: onRequestFind, onRequestReplace: onRequestReplace }, doc.path) }));
+        case "docx":
+            return (_jsx(ViewerShell, { doc: doc, children: _jsx(DocxPane, { documentPath: doc.path, url: doc.assetUrl, readOnly: readEdit !== "edit", initialBase64: doc.assetUrl ? undefined : doc.content, onSave: onDocxSave, onChange: onDocxChange, registerSave: registerDocxSave, registerMenu: onDocxToolbar, registerSearchProvider: registerSearchProvider, findBar: findBar, findMode: findMode, onRequestFind: onRequestFind, onRequestReplace: onRequestReplace }, doc.path) }));
+        case "image":
+            return (_jsx(ViewerShell, { doc: doc, children: _jsx(ImageViewer, { doc: doc, active: active, readOnly: readEdit !== "edit", onChange: onImageChange, registerSave: registerImageSave, onOpenSibling: onOpenImageSibling }, imageInstanceKey(doc.path)) }));
+        case "txt":
+            return (_jsx(ViewerShell, { doc: doc, children: _jsx(TextEditor, { documentPath: doc.path, language: "plain", text: text, onChange: onChange, onSave: onSave, registerSearchProvider: registerSearchProvider, findBar: findBar, findMode: findMode, onRequestFind: onRequestFind, onRequestReplace: onRequestReplace, active: active, readOnly: readEdit !== "edit", initialViewState: sourceViewStateRef?.current[doc.path] ?? null, onViewStateChange: (state) => {
+                        if (sourceViewStateRef)
+                            sourceViewStateRef.current[doc.path] = state;
+                    } }, doc.path) }));
+        case "html":
+            if (!html)
+                throw new Error("HTML router props are missing");
+            return (_jsx(ViewerShell, { doc: doc, children: _jsx(HtmlDocument, { entryPath: doc.path, view: view, text: text, onChange: onChange, registerSearchProvider: registerSearchProvider, findBar: findBar, findMode: findMode, onRequestFind: onRequestFind, onRequestReplace: onRequestReplace, onCloseFind: onCloseFind, onOpenPath: onOpenPath, onChangeView: onChangeView, active: active, readOnly: readEdit !== "edit", pageBuffers: html.pageBuffers, dirtyPagePaths: html.dirtyPagePaths, onEnsurePage: html.onEnsurePage, onPageChange: html.onPageChange, onSetActivePage: html.onSetActivePage, onSavePage: html.onSavePage, onDiscardPage: html.onDiscardPage, onReloadFromDisk: html.onReloadFromDisk, initialPreviewScrollY: html.initialPreviewScrollY, onPreviewScroll: html.onPreviewScroll, sourceViewStateRef: sourceViewStateRef }, doc.path) }));
+        case "mdx":
+            // MDX is JSX-execution content — it can NEVER mount in the app's React tree (it would
+            // share window/Tauri/localStorage with the shell). The MdxSplitPane owns a sandboxed
+            // iframe (`sandbox="allow-scripts"`, never `allow-same-origin`) and keeps the markdown
+            // source drawer verbatim. Compile + postMessage live in MdxPreviewFrame.
+            return (_jsx(ViewerShell, { doc: doc, children: _jsx(MdxSplitPane, { text: text, documentPath: doc.path, subscribeEdits: subscribeEdits, getEditSnapshot: getEditSnapshot, showSource: view === "source", onCloseFind: onCloseFind, devMode: devMode, readOnly: readEdit !== "edit", onChange: onChange, onSave: onSave, registerSearchProvider: registerSearchProvider, findBar: findBar, findMode: findMode, onRequestFind: onRequestFind, onRequestReplace: onRequestReplace, onOpenPath: onOpenPath, onImportGranted: onMdxImportGranted, active: active }, doc.path) }));
+        default:
+            // md — preview is ALWAYS mounted; the source drawer toggles via `showSource` (no
+            // component swap, so opening source no longer remounts/refreshes the preview, like HTML's drawer).
+            return (_jsx(ViewerShell, { doc: doc, children: _jsx(Suspense, { fallback: _jsx(MarkdownTextFallback, { text: text }), children: _jsx(MarkdownCoreProvider, { documentId: doc.path, initialText: text, onChange: onChange, subscribeEdits: subscribeEdits, getEditSnapshot: getEditSnapshot, getExternalSeq: getExternalSeq, children: _jsx(MarkdownSplitPane, { text: text, documentPath: doc.path, subscribeEdits: subscribeEdits, getEditSnapshot: getEditSnapshot, showSource: view === "source", onCloseFind: onCloseFind, devMode: devMode, readOnly: readEdit !== "edit", onChange: onChange, onSave: onSave, registerSearchProvider: registerSearchProvider, findBar: findBar, findMode: findMode, onRequestFind: onRequestFind, onRequestReplace: onRequestReplace, onOpenPath: onOpenPath, onChangeView: onChangeView, active: active, registerMarkdownExport: registerMarkdownExport, scrollContainerRef: markdownScrollRef, onScroll: onMarkdownScroll, sourceViewStateRef: sourceViewStateRef }, doc.path) }) }) }));
+    }
+}
+// Active + MRU + protected tabs may stay mounted (see App.tsx). Without this memo, shell updates
+// cascade into every live pane; with many tabs open that can make the main thread drop keystrokes.
+// Format-aware: PDF, Image, HTML, and DOCX viewers consume active ownership for side effects
+// (shortcut/scroll state, save state, active print ownership, or the global DOCX toolbar). Web can
+// stay isolated from an active-only wrapper change. Find placement is viewer-owned, so it is compared too.
+const formatUsesActive = (doc) => !!doc && capabilitiesFor(doc.format).canEdit;
+const formatUsesFindBar = (doc) => doc?.format !== "image" && doc?.format !== "web";
+// T5-1: `html` used to be entirely omitted from the memo comparison, so an HTML tab's session props
+// (pageBuffers/dirtyPagePaths) could change underneath the memo without ever re-rendering
+// the pane. Compare the fields
+// that actually drive its rendering. App.tsx's htmlPropsFor (T2-3) keeps this prop referentially
+// STABLE per entryPath unless that path's own slice changed, so the `prev === next` fast path is the
+// common case for every OTHER open html tab — this only forces a render when html truly changed for
+// THIS doc, it never widens re-renders beyond that.
+function htmlPropsEqual(prev, next) {
+    if (prev === next)
+        return true;
+    if (!prev || !next)
+        return false;
+    if (prev.pageBuffers !== next.pageBuffers)
+        return false;
+    if (prev.dirtyPagePaths !== next.dirtyPagePaths) {
+        if (prev.dirtyPagePaths.length !== next.dirtyPagePaths.length)
+            return false;
+        for (let i = 0; i < prev.dirtyPagePaths.length; i++) {
+            if (prev.dirtyPagePaths[i] !== next.dirtyPagePaths[i])
+                return false;
+        }
+    }
+    return true;
+}
+export function documentRouterPropsEqual(prev, next) {
+    if ((formatUsesActive(prev.doc) || formatUsesActive(next.doc)) && prev.active !== next.active) {
+        return false;
+    }
+    if ((prev.doc.format === "html" || next.doc.format === "html") &&
+        !htmlPropsEqual(prev.html, next.html)) {
+        return false;
+    }
+    return (prev.doc === next.doc &&
+        prev.view === next.view &&
+        prev.readEdit === next.readEdit &&
+        prev.text === next.text &&
+        prev.findMode === next.findMode &&
+        prev.onChangeView === next.onChangeView &&
+        !!prev.onRequestReplace === !!next.onRequestReplace &&
+        (!(formatUsesFindBar(prev.doc) || formatUsesFindBar(next.doc)) || prev.findBar === next.findBar));
+}
+export const DocumentRouter = memo(DocumentRouterImpl, documentRouterPropsEqual);

package/dist/documents/FileTypeIcon.d.ts

@@ -0,0 +1,6 @@
+import type { DocFormat } from "@rightkit/document-core/documents/types";
+export declare function FileTypeIcon({ format, path, size, }: {
+    format: DocFormat;
+    path?: string;
+    size?: number;
+}): import("react").JSX.Element;

package/dist/documents/FileTypeIcon.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// Format badge — a solid colored file chip with the visible extension stacked vertically, so it
+// stays legible at small sidebar sizes. Four-character labels use a deliberate 2x2 stack.
+// Colors are distinct per format and dark enough for white badge text at small task/sidebar sizes.
+const STYLE = {
+    pdf: { label: "PDF", color: "#B83A2F" },
+    md: { label: "MD", color: "#2F7D45" },
+    mdx: { label: "MDX", color: "#7A5CAE" },
+    html: { label: "HTML", color: "#B45424" },
+    docx: { label: "DOCX", color: "#1F5FAE" },
+    image: { label: "IMG", color: "#8A3B8E" },
+    web: { label: "WEB", color: "#0F737A" },
+    txt: { label: "TXT", color: "#68707A" },
+    unknown: { label: "?", color: "#68707A" },
+};
+const EXTENSION_LABEL_ALIASES = {
+    jpeg: "JPG",
+    markdown: "MD",
+    text: "TXT",
+};
+const EXTENSIONLESS_LABELS = {
+    dockerfile: "DOCK",
+    makefile: "MAKE",
+};
+const DOTFILE_LABELS = {
+    ".env": "ENV",
+    ".npmrc": "NPM",
+    ".gitignore": "GIT",
+    ".gitattributes": "GIT",
+    ".editorconfig": "EDIT",
+};
+function badgeLabelFor(format, path) {
+    if (!path || format === "web" || path.startsWith("untitled:"))
+        return STYLE[format]?.label ?? STYLE.txt.label;
+    const name = path.split(/[\\/]/).pop()?.toLowerCase() ?? "";
+    const dotfile = DOTFILE_LABELS[name];
+    if (dotfile)
+        return dotfile;
+    const extensionless = EXTENSIONLESS_LABELS[name];
+    if (extensionless)
+        return extensionless;
+    const ext = name.includes(".") ? (name.split(".").pop() ?? "") : "";
+    if (!ext)
+        return STYLE[format]?.label ?? STYLE.txt.label;
+    return (EXTENSION_LABEL_ALIASES[ext] ?? ext.toUpperCase()).slice(0, 4);
+}
+export function FileTypeIcon({ format, path, size = 18, }) {
+    const s = STYLE[format] ?? STYLE.txt;
+    const label = badgeLabelFor(format, path);
+    const letters = label.split("");
+    const w = size;
+    const h = Math.round(size * 1.3); // a touch taller than wide — reads as a file/spine
+    if (letters.length === 4) {
+        const fontSize = Math.max(5, Math.min(size * 0.42, 8));
+        return (_jsx("span", { "aria-label": `${label} file`, role: "img", style: {
+                display: "inline-grid",
+                gridTemplateColumns: "1fr 1fr",
+                alignItems: "center",
+                justifyItems: "center",
+                width: w,
+                height: h,
+                background: s.color,
+                borderRadius: Math.max(2, size * 0.16),
+                color: "#fff",
+                fontFamily: '"JetBrains Mono", ui-monospace, monospace',
+                fontWeight: 800,
+                lineHeight: 1,
+                letterSpacing: 0,
+                userSelect: "none",
+                flexShrink: 0,
+                padding: Math.max(1, Math.round(size * 0.12)),
+            }, children: letters.map((c, i) => (_jsx("span", { style: { fontSize }, children: c }, i))) }));
+    }
+    // Fit the stacked letters to the chip height, but never so big they crowd the width.
+    const fontSize = Math.max(5, Math.min(((h - 3) / letters.length) * 0.86, w * 0.66));
+    return (_jsx("span", { "aria-label": `${label} file`, role: "img", style: {
+            display: "inline-flex",
+            flexDirection: "column",
+            alignItems: "center",
+            justifyContent: "center",
+            width: w,
+            height: h,
+            background: s.color,
+            borderRadius: Math.max(2, size * 0.16),
+            color: "#fff",
+            fontFamily: '"JetBrains Mono", ui-monospace, monospace',
+            fontWeight: 700,
+            lineHeight: 1.02,
+            letterSpacing: 0,
+            userSelect: "none",
+            flexShrink: 0,
+        }, children: letters.map((c, i) => (_jsx("span", { style: { fontSize }, children: c }, i))) }));
+}

package/dist/documents/ImageDocument.d.ts

@@ -0,0 +1,14 @@
+import type { ImageSaveFunction } from "@rightkit/media-ui";
+import type { LoadedDocument } from "@rightkit/document-core/documents/types";
+interface Props {
+    doc: LoadedDocument;
+    active?: boolean;
+    onChange: () => void;
+    registerSave: (fn: ImageSaveFunction | null) => void;
+    /** Page to the previous/next image in the same folder, replacing this tab in place. */
+    onOpenSibling?: (currentPath: string, targetPath: string) => void;
+    /** Read mode: no edit tools — zoom/fit/paging stay, the stage is pure view. */
+    readOnly?: boolean;
+}
+export declare function ImageViewer({ doc, ...props }: Props): import("react").JSX.Element;
+export {};

package/dist/documents/ImageDocument.js

@@ -0,0 +1,61 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// the host app host for @rightkit/media-ui's image viewer/editor. Reproduces the former local
+// layout: tool panels in-flow above the stage inside the chrome toolbar, and only the capsule
+// docked into App's single document bar (via DocBar, which renders nothing for inactive panes).
+import { useState } from "react";
+import { CaretLeft } from "@phosphor-icons/react/dist/icons/CaretLeft";
+import { CaretRight } from "@phosphor-icons/react/dist/icons/CaretRight";
+import { ImageViewer as RightKitImageViewer } from "@rightkit/media-ui/image";
+import { DocBar } from "@rightkit/document-core/app/shell/docBar";
+import { BUNDLED_FONTS } from "@rightkit/document-core/settings/fonts";
+import { listSiblingImages, listSystemFonts } from "@rightkit/document-core/state/tauriBridge";
+import { printImageDataUrl } from "@rightkit/document-core/app/documentPrinting";
+import { logError } from "@rightkit/document-core/state/diagnostics";
+import { toast } from "@rightkit/platform-ui/headless";
+import { acquireResource, updateResource } from "@rightkit/document-core/app/resourceCensus";
+import { hostAppName } from "../appName.js";
+const ADAPTERS = {
+    icons: {
+        caretLeft: _jsx(CaretLeft, { size: 18, weight: "regular", "aria-hidden": "true" }),
+        caretRight: _jsx(CaretRight, { size: 18, weight: "regular", "aria-hidden": "true" }),
+    },
+    listImageSiblings: listSiblingImages,
+    listSystemFonts,
+    bundledFonts: BUNDLED_FONTS,
+    bundledFontsLabel: `${hostAppName()} fonts`,
+    bundledFontsEmptyOption: hostAppName(),
+    defaultFontId: "inter",
+    fallbackFontStack: "'Inter', system-ui, sans-serif",
+    printImage: printImageDataUrl,
+    acquireResource: ({ kind, documentPath, estimatedBytes, dirty, stateExternalized }) => {
+        const release = acquireResource({
+            kind: kind,
+            documentPath,
+            estimatedBytes,
+            dirty,
+            stateExternalized,
+            format: "image",
+        });
+        return {
+            release,
+            update: (next) => updateResource(release, {
+                ...(next.dirty === undefined ? {} : { dirty: next.dirty }),
+                ...(next.stateExternalized === undefined
+                    ? {}
+                    : { stateExternalized: next.stateExternalized }),
+            }),
+        };
+    },
+    notify: (message, severity) => toast(message, severity),
+    // media-ui reports only the "print:failed" tag; any other tag has no allowlisted label.
+    logError: (tag) => {
+        if (tag === "print:failed")
+            logError(tag);
+    },
+};
+export function ImageViewer({ doc, ...props }) {
+    const [panelsHost, setPanelsHost] = useState(null);
+    const [capsuleHost, setCapsuleHost] = useState(null);
+    const displaySrc = doc.assetUrl || doc.content;
+    return (_jsxs("div", { "data-vr-image-host": "", className: "flex h-full min-h-0 flex-col bg-ink", children: [_jsxs("div", { className: "no-print vr-chrome vr-document-toolbar relative flex flex-shrink-0 flex-col text-chrome-xs text-muted", children: [_jsx("div", { ref: setPanelsHost, className: "contents" }), _jsx("div", { className: "relative z-30 shrink-0", children: _jsx(DocBar, { children: _jsx("div", { ref: setCapsuleHost, className: "vr-capsule vr-image-capsule h-[42px] px-1" }) }) })] }), _jsx(RightKitImageViewer, { ...props, path: doc.path, displayName: doc.displayName, src: doc.content || displaySrc, displaySrc: displaySrc, printEventName: "viewright:print", toolbarContainer: capsuleHost, panelsContainer: panelsHost, adapters: ADAPTERS })] }));
+}

package/dist/documents/capabilities.d.ts

@@ -0,0 +1,17 @@
+import type { DocFormat } from "@rightkit/document-core/documents/types";
+export interface DocumentCapabilities {
+    /** Edited inside the host app, either through a source surface, the DOCX bridge, or the image shell. */
+    canEdit: boolean;
+    /** Offers Save As for editable local formats. */
+    canSaveAs: boolean;
+    /** Printable via the shell's print path. DOCX prints through its own editor bridge instead. */
+    canPrintInApp: boolean;
+    /** Has a shell-level preview/source view toggle. */
+    canSwitchView: boolean;
+    /** Find supports replace (text formats). */
+    canReplace: boolean;
+}
+/** Single entry point for format capabilities. Callers read `capabilitiesFor(format).canReplace`. */
+export declare function capabilitiesFor(format: DocFormat): DocumentCapabilities;
+/** md and mdx share one Markdown pipeline; use this instead of `format === "md" || format === "mdx"`. */
+export declare function isMarkdownFormat(format: DocFormat | undefined): boolean;

package/dist/documents/capabilities.js

@@ -0,0 +1,18 @@
+const EDITABLE = new Set(["txt", "md", "mdx", "html", "docx", "pdf", "image"]);
+// md/mdx (preview/source), html (interactive/safe + source drawer). Images edit inside the viewer shell.
+const VIEW_SWITCH = new Set(["md", "mdx", "html"]);
+const TEXT_REPLACE = new Set(["txt", "md", "mdx", "html"]);
+/** Single entry point for format capabilities. Callers read `capabilitiesFor(format).canReplace`. */
+export function capabilitiesFor(format) {
+    return {
+        canEdit: EDITABLE.has(format),
+        canSaveAs: EDITABLE.has(format),
+        canPrintInApp: format !== "docx" && format !== "web" && format !== "unknown",
+        canSwitchView: VIEW_SWITCH.has(format),
+        canReplace: TEXT_REPLACE.has(format),
+    };
+}
+/** md and mdx share one Markdown pipeline; use this instead of `format === "md" || format === "mdx"`. */
+export function isMarkdownFormat(format) {
+    return format === "md" || format === "mdx";
+}

package/dist/documents/html/HtmlDocument.d.ts

@@ -0,0 +1,15 @@
+import type { HtmlDocumentProps } from "./HtmlDocumentProps.js";
+export type { HtmlDocumentProps } from "./HtmlDocumentProps.js";
+/**
+ * One tab = one local-site session. The tab is identified by `entryPath`; `activePath` is the page
+ * currently shown and may roam to sub-pages as the user navigates (always under the entry folder —
+ * Rust enforces containment). Switching modes/opening the source drawer keeps this component mounted,
+ * so the nav stack and every page's edit buffer survive.
+ *
+ * This file is the mode-router shell: it owns the preview-build lifecycle (applied snapshot → srcDoc),
+ * the source drawer state, and layout. Behavior lives in focused hooks (useHtmlPreviewControls,
+ * useHtmlInspect, useHtmlBlockDrafts, useHtmlAutoViewport, plus the existing navigation/bridge/block
+ * hooks); rendering is delegated to HtmlDocumentView (preview surface), HtmlDocumentSource (source
+ * drawer), and HtmlDocumentEdit (inspect context menu).
+ */
+export declare function HtmlDocument({ entryPath, view, text, onChange, registerSearchProvider, findBar, findMode, onRequestFind, onRequestReplace, onCloseFind, onOpenPath, onChangeView, readOnly, active, pageBuffers, dirtyPagePaths, onEnsurePage, onPageChange, onSetActivePage, onSavePage, onDiscardPage, onReloadFromDisk, initialPreviewScrollY, onPreviewScroll, sourceViewStateRef: externalSourceViewStateRef, }: HtmlDocumentProps): import("react").JSX.Element;