@rightkit/document-workspace 0.0.0-stage → 0.1.1

package/dist/documents/html/HtmlDocumentLayout.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { HtmlDocumentView } from "@rightkit/html-editor/documents/html/HtmlDocumentView";
+import { HtmlDocumentSource } from "./HtmlDocumentSource.js";
+import { HtmlDocumentEdit } from "@rightkit/html-editor/documents/html/HtmlDocumentEdit";
+import { HtmlAddressRow, HtmlLinkStatus, HtmlRichEditRow, HtmlSiteRootNotice, } from "@rightkit/html-editor/documents/html/HtmlDocumentToolbars";
+import { HtmlSafeBlockEditor } from "@rightkit/html-editor/documents/html/HtmlSafeBlockEditor";
+import { BlockedLinkPrompt } from "@rightkit/html-editor/documents/html/HtmlDocumentChrome";
+/** Pure render tree for the HTML document: toolbars, preview split, source drawer, and overlays. */
+export function HtmlDocumentLayout({ flags, address, rich, preview, source, overlays }) {
+    const { readOnly, active, drawer, sourceFullscreen, mode } = flags;
+    const { safeTarget, blockSnapshot, blockIdentity, hasChangeView, richEditRef, richFormatting, setRichFormatting, runBlockRichOp, runBlockStructuralOp, canRunRichOp, canRunStructuralOp, propertyAttributes, editRichSource, closeInlineEditor, inframeTarget, setInframeTarget, iframeGeneration, } = rich;
+    const { splitRef, hoveredLink, pickingRoot, onChooseSiteRoot, showSiteRootNotice, ...viewProps } = preview;
+    const overlay = !readOnly && safeTarget && blockSnapshot && (inframeTarget || !hasChangeView) ? (_jsx(HtmlSafeBlockEditor, { ref: richEditRef, identity: blockIdentity, snapshot: blockSnapshot, visualStyle: safeTarget.style, onClose: closeInlineEditor, onRichOp: (op) => void runBlockRichOp(op), onToolbarStateChange: setRichFormatting, propertyTargetTag: safeTarget.src !== undefined ? "img" : undefined, propertyAttributes: propertyAttributes, onEditSource: editRichSource, iframeTarget: inframeTarget, mountMode: inframeTarget ? "inframe" : undefined, iframeGeneration: iframeGeneration, onIframeTargetChange: setInframeTarget })) : null;
+    return (_jsxs("div", { className: "relative flex h-full min-h-0 flex-col bg-ink", children: [!(!readOnly && safeTarget && blockSnapshot) && (_jsx(HtmlAddressRow, { address: address.activePath, dirty: address.activeDirty, subpageStale: address.subpageStale, viewport: address.viewport, canGoBack: address.canGoBack, canGoForward: address.canGoForward, onBack: () => address.goHistory(-1), onForward: () => address.goHistory(1), onViewport: (next) => address.setViewportMode(next === "desktop" ? "auto" : next), onReload: address.onReload, findBar: drawer ? undefined : address.findBar, findMode: drawer ? undefined : address.findMode, onRequestFind: address.onRequestFind, onRequestReplace: drawer ? undefined : address.onRequestReplace, trailing: readOnly
+                    ? undefined
+                    : {
+                        label: "source",
+                        ariaLabel: "Toggle source",
+                        active: drawer,
+                        onClick: address.onToggleSource,
+                    } })), !readOnly && safeTarget && blockSnapshot && (_jsx(HtmlRichEditRow, { handleRef: richEditRef, snapshot: blockSnapshot, anchorHref: safeTarget.href, anchorSrc: safeTarget.src, formatting: richFormatting, onRichOp: (op) => void runBlockRichOp(op), onStructuralOp: (surface, action) => void runBlockStructuralOp(surface, action), canRichOp: canRunRichOp, canStructuralOp: canRunStructuralOp, onEditSource: editRichSource })), _jsxs("div", { ref: splitRef, "data-html-preview-split": true, className: "relative flex min-h-0 min-w-0 flex-1", children: [hoveredLink && _jsx(HtmlLinkStatus, { href: hoveredLink }), !sourceFullscreen && showSiteRootNotice && (_jsx(HtmlSiteRootNotice, { pickingRoot: pickingRoot, onChoose: onChooseSiteRoot })), !sourceFullscreen && (_jsx(HtmlDocumentView, { ...viewProps, mode: mode, drawerOpen: drawer, active: active, overlay: overlay })), drawer && (_jsx(HtmlDocumentSource, { ...source, active: active, sourceFullscreen: sourceFullscreen }))] }), overlays.inspectMenu && (_jsx(HtmlDocumentEdit, { inspectMenu: overlays.inspectMenu, onClose: () => overlays.setInspectMenu(null), onCopyValue: overlays.copyMenuValue, onOpenLinkNewTab: (href) => {
+                    overlays.setInspectMenu(null);
+                    void overlays.handleHref(href, true);
+                }, onViewSource: overlays.inspectFromMenu })), overlays.blocked && (_jsx(BlockedLinkPrompt, { href: overlays.blocked.href, reason: overlays.blocked.reason, onLocate: () => void overlays.locateBlocked(), onCopy: () => void overlays.copyBlocked(), onDismiss: () => overlays.setBlocked(null) }))] }));
+}

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

@@ -0,0 +1,60 @@
+import type { ReactNode, RefObject } from "react";
+import type { SearchProvider, ViewMode } from "@rightkit/document-core/documents/types";
+import type { SourceEditorViewState } from "../txt/TxtEditor.js";
+import type { HtmlPageBuffer } from "@rightkit/html-editor/documents/html/sessionTypes";
+export interface HtmlDocumentProps {
+    /** The originally-opened file. Its folder is the trusted site root; never changes as you navigate. */
+    entryPath: string;
+    /** Shared ViewMode; for HTML only interactive (default) / preview (Safe) apply now — Code is gone,
+     *  replaced by the in-place source drawer below. A stale persisted "source" falls back to interactive.
+     *  Flipped between interactive (scripts ON) and preview/Safe (scripts OFF) by the scripts switch in
+     *  the action bar above — HtmlDocument only READS it (drives `mode`); it doesn't own the toggle. */
+    view: ViewMode;
+    /** Live, editable source of the ENTRY doc (owned by App via the shared edits buffer). */
+    text: string;
+    onChange: (text: string) => void;
+    registerSearchProvider: (provider: SearchProvider | null) => void;
+    findBar?: ReactNode;
+    findMode?: "find" | "replace";
+    onRequestFind?: () => void;
+    onRequestReplace?: () => void;
+    /** Close the shared find bar. The drawer and the preview search DIFFERENT surfaces, so an open
+     *  find must not silently survive the switch between them. */
+    onCloseFind?: () => void;
+    /** Open a linked doc as its own the host app tab. `background` (new-tab gesture) adds it without
+     *  switching away from the current document. */
+    onOpenPath?: (path: string, opts?: {
+        background?: boolean;
+    }) => void;
+    /** Switch Interactive edit requests into Safe before creating a rich-edit draft. */
+    onChangeView?: (view: ViewMode) => void;
+    /** Inactive keep-alive panes stay mounted but must not own global shortcut events. */
+    active?: boolean;
+    /** Wave 2 Read mode: the source drawer, block editing, and inspect-to-source all stay closed —
+     *  Interactive/Safe `view` and every viewing control are unaffected. */
+    readOnly?: boolean;
+    /** Editable buffers for navigated (non-entry) pages in this session, keyed by absolute path. */
+    pageBuffers: Record<string, HtmlPageBuffer>;
+    /** Absolute paths of every dirty page in this session (entry + subs) — drives the page dirty marker. */
+    dirtyPagePaths: string[];
+    /** Seed a sub-page buffer from disk on first visit (no-op for the entry / already-loaded page). */
+    onEnsurePage: (entryPath: string, pagePath: string) => void;
+    /** Edit a page's buffer (entry routes to onChange; subs to App's per-page buffer). */
+    onPageChange: (entryPath: string, pagePath: string, text: string) => void;
+    /** Report the in-site page currently shown (App needs it for Ctrl+S targeting). */
+    onSetActivePage: (entryPath: string, pagePath: string) => void;
+    /** Save one page to disk (entry or sub). */
+    onSavePage: (entryPath: string, pagePath: string) => void;
+    /** Revert one page's buffer to its on-disk content. */
+    onDiscardPage: (entryPath: string, pagePath: string) => void;
+    /** Re-read a page from disk (refresh, browser-style). Prompts if the page has unsaved edits. */
+    onReloadFromDisk: (path: string, options?: {
+        force?: boolean;
+    }) => void;
+    /** Durable preview scroll: seeded on mount so scroll survives a tab-switch unmount. */
+    initialPreviewScrollY?: number;
+    /** Report the live preview scroll up to App's per-tab store (so it's restored on return). */
+    onPreviewScroll?: (y: number) => void;
+    /** App-owned source selection/scroll, retained if this dirty session is shelled. */
+    sourceViewStateRef?: RefObject<Record<string, SourceEditorViewState>>;
+}

package/dist/documents/html/HtmlDocumentProps.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,34 @@
+import type { EditorView } from "@codemirror/view";
+import type { RefObject, ReactNode } from "react";
+import { type SourceEditorViewState } from "../txt/TxtEditor.js";
+import type { SearchProvider } from "@rightkit/document-core/documents/types";
+import type { SourceRange } from "@rightkit/html-editor/documents/html/sourceMap";
+/**
+ * The in-place HTML source drawer: a resizable pane (splitter + optional fullscreen) hosting the
+ * editable CodeMirror source for the active page (entry or a navigated sub-page). Extracted verbatim
+ * from HtmlDocument — no behavior change.
+ */
+export declare function HtmlDocumentSource({ active, subLoaded, activePath, activeBuffer, activeName, activeDirty, drawerWidth, sourceFullscreen, onToggleFullscreen, onStartResize, onActiveSourceChange, onActiveSave, onDiscardPage, registerSearchProvider, findBar, findMode, onRequestFind, onRequestReplace, sourceViewStateRef, sourceEditorRef, pendingInspectRangeRef, revealSourceRange, }: {
+    active: boolean;
+    subLoaded: boolean;
+    activePath: string;
+    activeBuffer: string;
+    activeName: string;
+    activeDirty: boolean;
+    drawerWidth: number;
+    sourceFullscreen: boolean;
+    onToggleFullscreen: () => void;
+    onStartResize: (e: import("react").PointerEvent<HTMLDivElement>) => void;
+    onActiveSourceChange: (next: string) => void;
+    onActiveSave: () => void;
+    onDiscardPage: () => void;
+    registerSearchProvider: (provider: SearchProvider | null) => void;
+    findBar?: ReactNode;
+    findMode?: "find" | "replace";
+    onRequestFind?: () => void;
+    onRequestReplace?: () => void;
+    sourceViewStateRef: RefObject<Record<string, SourceEditorViewState>>;
+    sourceEditorRef: RefObject<EditorView | null>;
+    pendingInspectRangeRef: RefObject<SourceRange | null>;
+    revealSourceRange: (range: SourceRange) => boolean;
+}): import("react").JSX.Element;

package/dist/documents/html/HtmlDocumentSource.js

@@ -0,0 +1,28 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { FullscreenIcon } from "@rightkit/document-core/documents/FullscreenIcon";
+import { TextEditor } from "../txt/TxtEditor.js";
+/**
+ * The in-place HTML source drawer: a resizable pane (splitter + optional fullscreen) hosting the
+ * editable CodeMirror source for the active page (entry or a navigated sub-page). Extracted verbatim
+ * from HtmlDocument — no behavior change.
+ */
+export function HtmlDocumentSource({ active, subLoaded, activePath, activeBuffer, activeName, activeDirty, drawerWidth, sourceFullscreen, onToggleFullscreen, onStartResize, onActiveSourceChange, onActiveSave, onDiscardPage, registerSearchProvider, findBar, findMode, onRequestFind, onRequestReplace, sourceViewStateRef, sourceEditorRef, pendingInspectRangeRef, revealSourceRange, }) {
+    return (_jsxs(_Fragment, { children: [!sourceFullscreen && (_jsx("div", { onPointerDown: onStartResize, role: "separator", tabIndex: 0, "aria-orientation": "vertical", "aria-label": "Resize source drawer", "aria-valuemin": 280, "aria-valuenow": Math.round(drawerWidth), className: "w-1.5 shrink-0 cursor-col-resize bg-line transition-colors hover:bg-copper/60" })), _jsx("div", { className: `flex min-w-0 flex-col bg-panel ${sourceFullscreen ? "flex-1" : "shrink-0"}`, style: sourceFullscreen ? undefined : { width: drawerWidth, maxWidth: "calc(100% - 6px)" }, children: _jsx("div", { className: "min-h-0 flex-1", children: subLoaded ? (_jsx(TextEditor, { dockToolbar: false, active: active, documentPath: activePath, mono: true, language: "html", text: activeBuffer, onChange: onActiveSourceChange, onSave: onActiveSave, registerSearchProvider: registerSearchProvider, findBar: findBar, findMode: findMode, onRequestFind: onRequestFind, onRequestReplace: onRequestReplace, sourceToolbarActions: _jsxs(_Fragment, { children: [_jsx("button", { type: "button", onClick: onToggleFullscreen, className: "vr-press vr-focus flex h-6 w-6 items-center justify-center rounded text-muted hover:bg-panel-2 hover:text-paper", "aria-label": sourceFullscreen ? "Restore HTML split" : "Expand HTML source", title: sourceFullscreen ? "Restore split" : "Expand source", children: _jsx(FullscreenIcon, { restore: sourceFullscreen }) }), _jsx("button", { type: "button", onClick: onActiveSave, title: `Save ${activeName}`, className: `vr-press vr-focus rounded px-2 py-1 ${activeDirty ? "text-copper-hi" : "text-muted hover:bg-panel-2 hover:text-paper"}`, children: "save" }), _jsx("button", { type: "button", onClick: onDiscardPage, disabled: !activeDirty, title: `Discard ${activeName}`, className: "vr-press vr-focus rounded px-2 py-1 text-muted hover:bg-panel-2 hover:text-paper disabled:cursor-not-allowed disabled:opacity-40", children: "discard" })] }), initialViewState: sourceViewStateRef.current[activePath] ?? null, onViewStateChange: (state) => {
+                            sourceViewStateRef.current[activePath] = state;
+                        }, onEditorReady: (view) => {
+                            sourceEditorRef.current = view;
+                            if (!view)
+                                return;
+                            const pending = pendingInspectRangeRef.current;
+                            if (!pending)
+                                return;
+                            // The editor restores its saved scroll in a rAF right after this fires (see
+                            // TextEditor mount). Reveal on a LATER frame so our scroll-to-match isn't undone —
+                            // otherwise inspecting from a freshly-opened drawer selects the range off-screen.
+                            window.requestAnimationFrame(() => window.requestAnimationFrame(() => {
+                                const range = pendingInspectRangeRef.current;
+                                if (range && revealSourceRange(range))
+                                    pendingInspectRangeRef.current = null;
+                            }));
+                        } }, activePath)) : (_jsx("div", { className: "flex h-full items-center justify-center text-xs text-muted-2", children: "Loading source\u2026" })) }) })] }));
+}

package/dist/documents/markdown/MarkdownSplitPane.d.ts

@@ -0,0 +1,115 @@
+import { type ReactNode, type RefObject, type UIEventHandler } from "react";
+import type { EditorView } from "@codemirror/view";
+import type { SearchProvider, ViewMode } from "@rightkit/document-core/documents/types";
+import type { SourceEditorViewState } from "../txt/TxtEditor.js";
+import type { MarkdownSourceRange } from "@rightkit/markdown-editor/documents/markdown/MarkdownProtectedBlock";
+import { collectMarkdownHeadings, type MarkdownHeading } from "@rightkit/markdown-editor/documents/markdown/markdownTools";
+import type { MarkdownExportApi } from "@rightkit/markdown-editor/documents/markdown/export/markdownExportTypes";
+export declare function MarkdownSourceFallback({ text }: {
+    text: string;
+}): import("react").JSX.Element;
+export declare function selectAndScrollSourceLine(view: EditorView, lineNumber: number): void;
+export declare function selectAndScrollSourceRange(view: EditorView, range: MarkdownSourceRange): void;
+interface Props {
+    text: string;
+    documentPath?: string;
+    subscribeEdits?: (path: string, cb: () => void) => () => void;
+    getEditSnapshot?: (path: string) => string | undefined;
+    devMode?: boolean;
+    /** Source drawer open. The preview stays MOUNTED across this toggle (drawer-style, like HTML) — no
+     *  remount, so opening source no longer flashes a loading skeleton / re-renders / resets scroll. */
+    showSource: boolean;
+    /** Wave 2 Read mode: hybrid view becomes non-editable and the source drawer stays closed —
+     *  editing is only ever reachable in Edit. */
+    readOnly?: boolean;
+    /** Close the shared find bar when the rendered/source surface switches. */
+    onCloseFind?: () => void;
+    onChange: (text: string) => void;
+    onSave: () => void;
+    registerSearchProvider: (provider: SearchProvider | null) => void;
+    findBar?: ReactNode;
+    findMode?: "find" | "replace";
+    onRequestFind?: () => void;
+    onRequestReplace?: () => void;
+    onOpenPath?: (path: string) => void;
+    onChangeView?: (view: ViewMode) => void;
+    active?: boolean;
+    registerMarkdownExport?: (api: MarkdownExportApi | null) => void;
+    /** App-owned raw-source selection/scroll, retained across a shelled dirty tab. */
+    sourceViewStateRef?: RefObject<Record<string, SourceEditorViewState>>;
+    scrollContainerRef?: RefObject<HTMLDivElement | null>;
+    onScroll?: UIEventHandler<HTMLDivElement>;
+    /**
+     * Optional: Markdown document core to wire edits through. When
+     * supplied, the source editor applies edits via the core instead
+     * of the legacy `subscribeEdits`/`onChange` pipeline. Off by
+     * default to preserve existing behavior.
+     */
+    markdownCore?: import("@rightkit/markdown-editor/documents/markdown/core/MarkdownDocumentCore").MarkdownDocumentCore;
+}
+export declare function MarkdownSourceDrawer({ documentPath, text, onChange, onSave, registerSourceProvider, findBar, findMode, onRequestFind, onRequestReplace, headings, sourceFocusMode, sourceTypewriterMode, sourceFullscreen, sourceWidth, initialViewState, onJumpLine, onToggleFocus, onToggleTypewriter, onToggleFullscreen, onViewStateChange, onEditorReady, externalHistory, markdownCore, restoreTitle, expandTitle, showFullscreenToggle, className, }: {
+    documentPath?: string;
+    text: string;
+    onChange: (text: string) => void;
+    onSave: () => void;
+    registerSourceProvider: (provider: SearchProvider | null) => void;
+    findBar?: ReactNode;
+    findMode?: "find" | "replace";
+    onRequestFind?: () => void;
+    onRequestReplace?: () => void;
+    headings: ReturnType<typeof collectMarkdownHeadings>;
+    sourceFocusMode: boolean;
+    sourceTypewriterMode: boolean;
+    sourceFullscreen: boolean;
+    sourceWidth: number;
+    initialViewState: SourceEditorViewState | null;
+    onJumpLine: (line: number) => void;
+    onToggleFocus: () => void;
+    onToggleTypewriter: () => void;
+    onToggleFullscreen: () => void;
+    onViewStateChange: (state: SourceEditorViewState) => void;
+    onEditorReady: (view: EditorView | null) => void;
+    externalHistory?: boolean;
+    markdownCore?: import("@rightkit/markdown-editor/documents/markdown/core/MarkdownDocumentCore").MarkdownDocumentCore;
+    restoreTitle?: string;
+    expandTitle?: string;
+    showFullscreenToggle?: boolean;
+    className?: string;
+}): import("react").JSX.Element;
+export declare function useMarkdownSourceDrawer(text: string, onEditorReady?: (view: EditorView | null, jumpSourceToLine: (lineNumber: number) => void, jumpSourceToRange: (range: MarkdownSourceRange) => void) => void, onCaretOffsetChange?: (offset: number) => void, mappedHeadings?: MarkdownHeading[], documentPath?: string, externalSourceViewStateRef?: RefObject<Record<string, SourceEditorViewState>>): {
+    sourceWidth: number;
+    setSourceWidth: import("react").Dispatch<import("react").SetStateAction<number>>;
+    sourceFullscreen: boolean;
+    sourceEditorRef: RefObject<EditorView | null>;
+    jumpSourceToLine: (lineNumber: number) => void;
+    jumpSourceToRange: (range: MarkdownSourceRange) => void;
+    drawerProps: {
+        headings: MarkdownHeading[];
+        sourceFocusMode: boolean;
+        sourceTypewriterMode: boolean;
+        sourceFullscreen: boolean;
+        sourceWidth: number;
+        initialViewState: SourceEditorViewState | null;
+        onJumpLine: (lineNumber: number) => void;
+        onToggleFocus: () => void;
+        onToggleTypewriter: () => void;
+        onToggleFullscreen: () => void;
+        onViewStateChange: (state: SourceEditorViewState) => void;
+        onEditorReady: (view: EditorView | null) => void;
+    };
+};
+export declare function MarkdownSplitPane({ text, showSource, readOnly, onCloseFind, onChange, onSave, registerSearchProvider, findBar, findMode, onRequestFind, onRequestReplace, documentPath, subscribeEdits, getEditSnapshot, onOpenPath, onChangeView, active, registerMarkdownExport, sourceViewStateRef, scrollContainerRef, onScroll, markdownCore, }: Props): import("react").JSX.Element;
+export declare function MarkdownSourceActions({ headings, focusMode, typewriterMode, sourceFullscreen, onJumpLine, onToggleFocus, onToggleTypewriter, onToggleFullscreen, restoreTitle, expandTitle, showFullscreenToggle, }: {
+    headings: ReturnType<typeof collectMarkdownHeadings>;
+    focusMode: boolean;
+    typewriterMode: boolean;
+    sourceFullscreen: boolean;
+    onJumpLine: (line: number) => void;
+    onToggleFocus: () => void;
+    onToggleTypewriter: () => void;
+    onToggleFullscreen: () => void;
+    restoreTitle?: string;
+    expandTitle?: string;
+    showFullscreenToggle?: boolean;
+}): import("react").JSX.Element;
+export {};

package/dist/documents/markdown/MarkdownSplitPane.js

@@ -0,0 +1,352 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCloseFindOnSurfaceChange } from "@rightkit/document-core/app/useCloseFindOnSurfaceChange";
+import { lazy, Suspense, useCallback, useEffect, useMemo, useRef, useState, } from "react";
+import { useEditText } from "@rightkit/document-core/app/useEditText";
+import { useMirroredEditText } from "@rightkit/document-core/documents/useMirroredEditText";
+import { FullscreenIcon } from "@rightkit/document-core/documents/FullscreenIcon";
+import { TextSelection } from "prosemirror-state";
+import { scrollPosIntoView } from "@rightkit/document-core/documents/txt/cmScroll";
+import { MarkdownEditor } from "@rightkit/markdown-editor/documents/markdown/MarkdownEditor";
+import { collectMarkdownHeadings, collectSourceMapHeadings, } from "@rightkit/markdown-editor/documents/markdown/markdownTools";
+import { Dropdown, Item, Sep, TBtn } from "@rightkit/document-core/documents/toolbarPrimitives";
+import { useMarkdownCoreSubscription } from "@rightkit/markdown-editor/documents/markdown/core/useMarkdownCoreSubscription";
+import { useMarkdownCoreOptional } from "@rightkit/markdown-editor/documents/markdown/MarkdownCoreProvider";
+import { MarkdownWorkspacePanel } from "@rightkit/markdown-editor/documents/markdown/properties/MarkdownWorkspacePanel";
+import { useSettings } from "@rightkit/document-core/settings/settings";
+import { logicalSourceToPmPosition, postPmSelectionToCore } from "@rightkit/markdown-editor/documents/markdown/projection/pmSelectionBridge";
+import { publishMarkdownDocumentActivity } from "@rightkit/markdown-editor/documents/markdown/markdownDocumentActivity";
+// Source editor (CodeMirror) is lazy so md OPEN stays light — only the preview loads. DocumentRouter
+// prefetches this chunk when a md doc opens, so by the time the drawer is opened it's already warm
+// (the drawer shows readable source while the chunk resolves). The preview never unmounts, so the
+// Suspense fallback only ever covers the drawer.
+const TextEditor = lazy(() => import("../txt/TxtEditor.js").then((m) => ({ default: m.TextEditor })));
+const noopSubscribeEdits = (_path, _cb) => () => { };
+const noopEditSnapshot = (_path) => undefined;
+export function MarkdownSourceFallback({ text }) {
+    return (_jsx("div", { className: "h-full overflow-auto bg-panel px-8 py-6", children: _jsx("pre", { "data-vr-markdown-source-fallback": "", className: "min-h-full whitespace-pre-wrap rounded-lg px-8 py-7 font-mono text-sm leading-relaxed", style: { background: "var(--reader-surface)", color: "var(--doc-fg)" }, children: text }) }));
+}
+export function selectAndScrollSourceLine(view, lineNumber) {
+    const line = view.state.doc.line(Math.max(1, Math.min(lineNumber, view.state.doc.lines)));
+    view.dispatch({
+        selection: { anchor: line.from, head: line.to },
+        scrollIntoView: true,
+        userEvent: "select.pointer",
+    });
+    scrollPosIntoView(view, line.from);
+    view.focus();
+}
+export function selectAndScrollSourceRange(view, range) {
+    const from = Math.max(0, Math.min(range.from, view.state.doc.length));
+    const to = Math.max(from, Math.min(range.to, view.state.doc.length));
+    view.dispatch({
+        selection: { anchor: from, head: to },
+        scrollIntoView: true,
+        userEvent: "select.pointer",
+    });
+    scrollPosIntoView(view, from);
+    view.focus();
+}
+export function MarkdownSourceDrawer({ documentPath, text, onChange, onSave, registerSourceProvider, findBar, findMode, onRequestFind, onRequestReplace, headings, sourceFocusMode, sourceTypewriterMode, sourceFullscreen, sourceWidth, initialViewState, onJumpLine, onToggleFocus, onToggleTypewriter, onToggleFullscreen, onViewStateChange, onEditorReady, externalHistory = false, markdownCore, restoreTitle, expandTitle, showFullscreenToggle = true, className = `relative flex min-h-0 min-w-0 flex-col bg-panel ${sourceFullscreen ? "-ml-px flex-1" : "shrink-0 border-l border-line"}`, }) {
+    return (_jsx("section", { className: className, style: sourceFullscreen ? undefined : { width: `${sourceWidth}%` }, children: _jsx("div", { className: "min-h-0 flex-1", children: _jsx(Suspense, { fallback: _jsx(MarkdownSourceFallback, { text: text }), children: _jsx(TextEditor, { documentPath: documentPath, mono: true, markdownToolbar: true, text: text, onChange: onChange, onSave: onSave, registerSearchProvider: registerSourceProvider, findBar: findBar, findMode: findMode, onRequestFind: onRequestFind, onRequestReplace: onRequestReplace, sourceToolbarActions: _jsx(MarkdownSourceActions, { headings: headings, focusMode: sourceFocusMode, typewriterMode: sourceTypewriterMode, sourceFullscreen: sourceFullscreen, onJumpLine: onJumpLine, onToggleFocus: onToggleFocus, onToggleTypewriter: onToggleTypewriter, onToggleFullscreen: onToggleFullscreen, restoreTitle: restoreTitle, expandTitle: expandTitle, showFullscreenToggle: showFullscreenToggle }), initialViewState: initialViewState, onViewStateChange: onViewStateChange, onEditorReady: onEditorReady, autoFocus: true, sourceFocusMode: sourceFocusMode, sourceTypewriterMode: sourceTypewriterMode, externalHistory: externalHistory, markdownCore: markdownCore }) }) }) }));
+}
+export function useMarkdownSourceDrawer(text, onEditorReady, onCaretOffsetChange, mappedHeadings, documentPath, externalSourceViewStateRef) {
+    const localSourceViewStateRef = useRef(null);
+    const sourceEditorRef = useRef(null);
+    const [sourceWidth, setSourceWidth] = useState(42); // % — wide enough for Markdown tools while keeping preview visible
+    const [sourceFullscreen, setSourceFullscreen] = useState(false);
+    const [sourceFocusMode, setSourceFocusMode] = useState(false);
+    const [sourceTypewriterMode, setSourceTypewriterMode] = useState(false);
+    const headings = useMemo(() => mappedHeadings ?? collectMarkdownHeadings(text), [mappedHeadings, text]);
+    const jumpSourceToLine = useCallback((lineNumber) => {
+        const view = sourceEditorRef.current;
+        if (!view)
+            return;
+        selectAndScrollSourceLine(view, lineNumber);
+        requestAnimationFrame(() => selectAndScrollSourceLine(view, lineNumber));
+        window.setTimeout(() => selectAndScrollSourceLine(view, lineNumber), 80);
+        window.setTimeout(() => selectAndScrollSourceLine(view, lineNumber), 250);
+    }, []);
+    const jumpSourceToRange = useCallback((range) => {
+        const jump = () => {
+            const view = sourceEditorRef.current;
+            if (view)
+                selectAndScrollSourceRange(view, range);
+        };
+        jump();
+        requestAnimationFrame(jump);
+        window.setTimeout(jump, 80);
+        window.setTimeout(jump, 250);
+    }, []);
+    const drawerProps = {
+        headings,
+        sourceFocusMode,
+        sourceTypewriterMode,
+        sourceFullscreen,
+        sourceWidth,
+        initialViewState: (documentPath ? externalSourceViewStateRef?.current[documentPath] : undefined) ??
+            localSourceViewStateRef.current,
+        onJumpLine: jumpSourceToLine,
+        onToggleFocus: () => setSourceFocusMode((value) => !value),
+        onToggleTypewriter: () => setSourceTypewriterMode((value) => !value),
+        onToggleFullscreen: () => setSourceFullscreen((value) => !value),
+        onViewStateChange: (state) => {
+            if (documentPath && externalSourceViewStateRef)
+                externalSourceViewStateRef.current[documentPath] = state;
+            else
+                localSourceViewStateRef.current = state;
+            onCaretOffsetChange?.(state.head);
+        },
+        onEditorReady: (view) => {
+            sourceEditorRef.current = view;
+            onEditorReady?.(view, jumpSourceToLine, jumpSourceToRange);
+        },
+    };
+    return {
+        sourceWidth,
+        setSourceWidth,
+        sourceFullscreen,
+        sourceEditorRef,
+        jumpSourceToLine,
+        jumpSourceToRange,
+        drawerProps,
+    };
+}
+export function MarkdownSplitPane({ text, showSource, readOnly = false, onCloseFind, onChange, onSave, registerSearchProvider, findBar, findMode, onRequestFind, onRequestReplace, documentPath, subscribeEdits, getEditSnapshot, onOpenPath, onChangeView, active = true, registerMarkdownExport, sourceViewStateRef, scrollContainerRef, onScroll, markdownCore, }) {
+    const { settings } = useSettings();
+    // When the core is supplied, mirror its snapshot into local state
+    // so the rest of the component works without further changes. The
+    // source editor's own updates route back through the core via the
+    // legacy `onChange` path; the core is the source of truth.
+    const contextCore = useMarkdownCoreOptional();
+    const resolvedCore = markdownCore ?? contextCore;
+    const coreSnapshot = useMarkdownCoreSubscription(resolvedCore ?? undefined);
+    const liveText = useEditText(subscribeEdits ?? noopSubscribeEdits, getEditSnapshot ?? noopEditSnapshot, documentPath ?? "");
+    // Core mode: MarkdownCoreProvider owns external ingress (origin-tagged); no mirror into the core.
+    const [legacyText, setLegacyText] = useMirroredEditText(liveText, text);
+    // Legacy fallback for non-core mode. In core mode the hot path is
+    // direct: CodeMirror feeds update.changes and ProseMirror feeds
+    // local block patches without whole-string LCS. This callback is
+    // retained only for external reconciliation (bounded diff).
+    const commitSurfaceChange = useCallback((next, origin) => {
+        if (!resolvedCore) {
+            setLegacyText(next);
+            onChange(next);
+            return;
+        }
+        const current = resolvedCore.snapshot();
+        if (current.logicalSource === next)
+            return;
+        // Complete-source callbacks are reconciliation-only. Keep this path
+        // bounded and deterministic; local core surfaces feed native ranges.
+        const edits = [
+            {
+                from: 0,
+                to: current.logicalSource.length,
+                insert: next,
+                inheritMode: "preserve",
+            },
+        ];
+        resolvedCore.applyCommand({
+            edits,
+            expectedRevision: current.revision,
+            origin,
+            label: "Typing",
+            coalesceKey: `${origin}:typing`,
+        });
+    }, [onChange, resolvedCore, setLegacyText]);
+    const handleHybridChange = useCallback((next) => commitSurfaceChange(next, "hybrid"), [commitSurfaceChange]);
+    const handleSourceChange = useCallback((next) => commitSurfaceChange(next, "source"), [commitSurfaceChange]);
+    const renderedText = coreSnapshot?.logicalSource ?? legacyText;
+    const mappedHeadings = useMemo(() => coreSnapshot
+        ? collectSourceMapHeadings(coreSnapshot.logicalSource, coreSnapshot.sourceMap)
+        : undefined, [coreSnapshot]);
+    const [caretOffset, setCaretOffset] = useState(0);
+    const [tableContext, setTableContext] = useState(null);
+    const [toolbarState, setToolbarState] = useState({
+        headingLevel: null,
+        bold: false,
+        italic: false,
+        strike: false,
+        code: false,
+        highlight: false,
+    });
+    const [imageDialogRequest, setImageDialogRequest] = useState(0);
+    const hybridEditorRef = useRef(null);
+    const selectionRangeRef = useRef({ anchor: 0, head: 0 });
+    const captureHybridSelection = useCallback(() => {
+        const view = hybridEditorRef.current;
+        if (!view || !resolvedCore)
+            return undefined;
+        // Keyboard focus may leave the browser range in this editor before ProseMirror's
+        // selection observer catches up. Reconcile that owned range before formatting.
+        const domSelection = view.dom.ownerDocument.getSelection();
+        if (domSelection?.anchorNode &&
+            domSelection.focusNode &&
+            view.dom.contains(domSelection.anchorNode) &&
+            view.dom.contains(domSelection.focusNode)) {
+            try {
+                const anchor = view.posAtDOM(domSelection.anchorNode, domSelection.anchorOffset);
+                const head = view.posAtDOM(domSelection.focusNode, domSelection.focusOffset);
+                const selection = TextSelection.between(view.state.doc.resolve(anchor), view.state.doc.resolve(head));
+                if (!selection.eq(view.state.selection))
+                    view.dispatch(view.state.tr.setSelection(selection));
+            }
+            catch {
+                // Detached ranges use the editor's last owned selection.
+            }
+        }
+        const snapshot = resolvedCore.snapshot();
+        const hint = postPmSelectionToCore(resolvedCore, view.state.doc, view.state.selection, snapshot);
+        if (!hint)
+            return undefined;
+        const range = { anchor: hint.anchor, head: hint.head };
+        selectionRangeRef.current = range;
+        return range;
+    }, [resolvedCore]);
+    useEffect(() => {
+        if (!active || !resolvedCore || !registerMarkdownExport)
+            return;
+        const fallbackTitle = (documentPath?.split(/[\\/]/).pop() ?? "Untitled").replace(/\.(md|markdown)$/i, "");
+        const api = {
+            documentPath,
+            getRevision: () => resolvedCore.snapshot().revision,
+            // Export pipeline (DOM render, standalone HTML) is loaded on first export, not on open.
+            createSnapshot: async (options) => {
+                const { renderMarkdownExport } = await import("@rightkit/markdown-editor/documents/markdown/export/renderMarkdownExport");
+                return renderMarkdownExport({
+                    snapshot: resolvedCore.snapshot(),
+                    documentPath,
+                    fallbackTitle,
+                    theme: options?.theme ?? "current",
+                    remoteImages: options?.remoteImages ?? "preserve",
+                    safeHtmlEnabled: settings.markdownSafeHtml,
+                });
+            },
+        };
+        registerMarkdownExport(api);
+        return () => registerMarkdownExport(null);
+    }, [active, documentPath, registerMarkdownExport, resolvedCore, settings.markdownSafeHtml]);
+    const pendingSourceRangeRef = useRef(null);
+    const { sourceEditorRef, jumpSourceToRange, drawerProps } = useMarkdownSourceDrawer(renderedText, (view, _jumpLine, jumpRange) => {
+        if (view && pendingSourceRangeRef.current) {
+            const range = pendingSourceRangeRef.current;
+            pendingSourceRangeRef.current = null;
+            jumpRange(range);
+        }
+    }, setCaretOffset, mappedHeadings, documentPath, sourceViewStateRef);
+    // The active surface owns find: Hybrid when rendered, Source while the drawer is open.
+    const hybridProviderRef = useRef(null);
+    const sourceProviderRef = useRef(null);
+    // Read mode keeps the drawer closed even if a persisted view asks for "source" — the drawer is
+    // the editing surface, and Read never exposes one.
+    const drawer = showSource && !readOnly;
+    useCloseFindOnSurfaceChange(drawer, !!findMode, onCloseFind);
+    const showSourceRef = useRef(drawer);
+    showSourceRef.current = drawer;
+    const publish = useCallback(() => {
+        registerSearchProvider(showSourceRef.current ? sourceProviderRef.current : hybridProviderRef.current);
+    }, [registerSearchProvider]);
+    const registerHybridProvider = useCallback((p) => {
+        hybridProviderRef.current = p;
+        publish();
+    }, [publish]);
+    const registerSourceProvider = useCallback((p) => {
+        sourceProviderRef.current = p;
+        publish();
+    }, [publish]);
+    useEffect(() => {
+        publish();
+    }, [publish]); // re-expose the active surface when the drawer toggles
+    useEffect(() => () => registerSearchProvider(null), [registerSearchProvider]);
+    const openSourceAtRange = useCallback((range) => {
+        const from = Math.max(0, Math.min(range.from, renderedText.length));
+        const to = Math.max(from, Math.min(range.to, renderedText.length));
+        pendingSourceRangeRef.current = { from, to };
+        if (!showSourceRef.current) {
+            onChangeView?.("source");
+            return;
+        }
+        jumpSourceToRange({ from, to });
+        pendingSourceRangeRef.current = null;
+    }, [jumpSourceToRange, onChangeView, renderedText]);
+    // Read-mode outline/issue jump: the source drawer is unavailable, so select the range inside the
+    // hybrid view instead — same "jump to the thing" intent, never an edit surface.
+    const revealInHybrid = useCallback((range) => {
+        const view = hybridEditorRef.current;
+        if (!view || view.isDestroyed || !resolvedCore)
+            return;
+        const pos = logicalSourceToPmPosition(view.state.doc, range.from, resolvedCore.snapshot());
+        const clamped = Math.max(0, Math.min(pos, view.state.doc.content.size));
+        try {
+            const sel = TextSelection.near(view.state.doc.resolve(clamped));
+            view.dispatch(view.state.tr.setSelection(sel).scrollIntoView());
+            view.focus();
+        }
+        catch {
+            // Positions inside protected/atom blocks have no text cursor — leave the doc as-is.
+        }
+    }, [resolvedCore]);
+    useEffect(() => {
+        publishMarkdownDocumentActivity(documentPath, active ?? true);
+        return () => publishMarkdownDocumentActivity(documentPath, false);
+    }, [active, documentPath]);
+    // Read mode: undo/redo mutate the doc — the listeners stay off entirely (the Edit menu that
+    // fires these events is hidden too, so nothing is lost).
+    useEffect(() => {
+        if (!active || !resolvedCore || readOnly)
+            return;
+        const onUndo = () => {
+            if (!drawer)
+                captureHybridSelection();
+            resolvedCore.undo();
+        };
+        const onRedo = () => {
+            if (!drawer)
+                captureHybridSelection();
+            resolvedCore.redo();
+        };
+        window.addEventListener("viewright:undo", onUndo);
+        window.addEventListener("viewright:redo", onRedo);
+        return () => {
+            window.removeEventListener("viewright:undo", onUndo);
+            window.removeEventListener("viewright:redo", onRedo);
+        };
+    }, [active, resolvedCore, readOnly, drawer, captureHybridSelection]);
+    useEffect(() => {
+        if (!drawer || !sourceEditorRef.current)
+            return;
+        if (pendingSourceRangeRef.current) {
+            const range = pendingSourceRangeRef.current;
+            pendingSourceRangeRef.current = null;
+            jumpSourceToRange(range);
+            return;
+        }
+    }, [drawer, jumpSourceToRange, sourceEditorRef.current]);
+    const getInsertAt = useCallback(() => {
+        return (sourceEditorRef.current?.state.selection.main.head ??
+            selectionRangeRef.current.head ??
+            caretOffset);
+    }, [caretOffset, sourceEditorRef]);
+    return (_jsxs("div", { className: "flex h-full min-h-0 min-w-0 bg-ink", children: [_jsx("section", { className: drawer ? "hidden" : "min-h-0 min-w-0 flex-1", "aria-hidden": drawer ? true : undefined, children: resolvedCore ? (_jsx(MarkdownWorkspacePanel, { core: resolvedCore, caretOffset: caretOffset, documentPath: documentPath, safeHtml: settings.markdownSafeHtml, onJumpToRange: readOnly ? revealInHybrid : openSourceAtRange, getInsertAt: getInsertAt, selection: selectionRangeRef.current, getEditorView: () => hybridEditorRef.current, tableContext: tableContext, toolbarState: toolbarState, onInsertImage: () => setImageDialogRequest((request) => request + 1), chromeHidden: drawer, readOnly: readOnly, onToggleSource: () => onChangeView?.("source"), captureSelection: captureHybridSelection, scrollContainerRef: scrollContainerRef, onScroll: onScroll, findBar: findBar, findMode: findMode, onRequestFind: onRequestFind, onRequestReplace: onRequestReplace, children: _jsx(MarkdownEditor, { text: renderedText, onChange: handleHybridChange, onSave: onSave, documentPath: documentPath, onOpenPath: onOpenPath, onSourceJump: readOnly ? revealInHybrid : openSourceAtRange, onCaretOffsetChange: setCaretOffset, onSelectionRangeChange: (selection) => {
+                            selectionRangeRef.current = selection;
+                        }, onEditorReady: (view) => {
+                            hybridEditorRef.current = view;
+                        }, onTableContextChange: setTableContext, onToolbarStateChange: (next) => setToolbarState((current) => current.headingLevel === next.headingLevel &&
+                            current.bold === next.bold &&
+                            current.italic === next.italic &&
+                            current.strike === next.strike &&
+                            current.code === next.code &&
+                            current.highlight === next.highlight
+                            ? current
+                            : next), registerSearchProvider: registerHybridProvider, core: resolvedCore, mappedHeadings: mappedHeadings, requestImageDialog: imageDialogRequest, surfaceHidden: drawer || !active, active: active, readOnly: readOnly }) })) : (_jsx(MarkdownEditor, { text: renderedText, onChange: handleHybridChange, onSave: onSave, documentPath: documentPath, onOpenPath: onOpenPath, onSourceJump: readOnly ? revealInHybrid : openSourceAtRange, onCaretOffsetChange: setCaretOffset, onSelectionRangeChange: (selection) => {
+                        selectionRangeRef.current = selection;
+                    }, onEditorReady: (view) => {
+                        hybridEditorRef.current = view;
+                    }, registerSearchProvider: registerHybridProvider, core: resolvedCore, surfaceHidden: !active, active: active, readOnly: readOnly })) }), drawer && (_jsx(MarkdownSourceDrawer, { documentPath: documentPath, text: renderedText, onChange: handleSourceChange, externalHistory: Boolean(resolvedCore), onSave: onSave, registerSourceProvider: registerSourceProvider, findBar: findBar, findMode: findMode, onRequestFind: onRequestFind, onRequestReplace: onRequestReplace, ...drawerProps, sourceFullscreen: true, showFullscreenToggle: false, markdownCore: resolvedCore ?? undefined }))] }));
+}
+export function MarkdownSourceActions({ headings, focusMode, typewriterMode, sourceFullscreen, onJumpLine, onToggleFocus, onToggleTypewriter, onToggleFullscreen, restoreTitle = "Restore markdown split", expandTitle = "Expand markdown source", showFullscreenToggle = true, }) {
+    return (_jsxs(_Fragment, { children: [headings.length > 0 && (_jsx(Dropdown, { label: "outline", title: "Jump to heading", minWidth: 72, panelWidth: 220, children: (close) => headings.map((heading) => (_jsx(Item, { onRun: () => {
+                        onJumpLine(heading.line);
+                        close();
+                    }, children: _jsx("span", { style: { paddingLeft: (heading.depth - 1) * 10 }, children: heading.text || `Line ${heading.line}` }) }, `${heading.line}-${heading.text}`))) })), _jsx(Sep, {}), _jsx(TBtn, { label: "focus", title: "Focus current source line", active: focusMode, onRun: onToggleFocus, width: 50 }), _jsx(TBtn, { label: "type", title: "Typewriter source mode", active: typewriterMode, onRun: onToggleTypewriter, width: 42 }), showFullscreenToggle && (_jsx(TBtn, { label: _jsx(FullscreenIcon, { restore: sourceFullscreen }), title: sourceFullscreen ? restoreTitle : expandTitle, onRun: onToggleFullscreen }))] }));
+}