dsh-remote-vs 0.8.8 → 0.9.0

package/src/client/store.tsx

@@ -33,6 +33,8 @@ import { loadCommitFileDiff, findRepos, loadDiff, loadHead, loadStatusDetail, pr
 import { StageCoordinator } from './scm/stage-queue.ts'
 import { collapseDir, dropExpandedRows, expandDir, pruneDirExpansions, type DirExpansions } from './scm/untracked-dirs.ts'
 import { detectLang, makeT, type Lang } from './i18n.ts'
+import { effectiveEditorSurface, type EditorSurface } from './float-editor.ts'
+import { captureLiveEditorPosition, captureLiveEditorText, isLiveEditorDirty, isLiveEditorFor, markLiveEditorSaved } from './live-editor.ts'
 import { planWorkspaceFollow, selectionIsSessionBinding, type WorkspaceFollowDecision } from './remote-file-open-target.ts'
 import { revealViewTab } from './reveal.ts'
 import { isHtmlFile, isImageFile, isMarkdownFile, toast } from './vsc/kit.tsx'
@@ -49,6 +51,16 @@ export interface EditorTab {
   error: string | undefined
   /** File payload. */
   text: string
+  /**
+   * The text as last LOADED from / SAVED to the remote file.
+   *
+   * `text` is the live-buffer handoff copy (see `captureLiveBuffer`) and may
+   * therefore hold unsaved edits; this is the disk-side reference the editor
+   * uses as its dirty baseline. Without the split, a remount with the handoff
+   * text would label unsaved edits "clean" (dirty dot off, Save disabled, close
+   * guard silent) — the exact silent-loss path the handoff exists to avoid.
+   */
+  baseline?: string
   dirty: boolean
   saving: boolean
   binary: boolean
@@ -127,10 +139,22 @@ interface State {
   revision: number
   /** Where the editor pane is mounted ('center' = conversation view). */
   editorSurface: 'center' | 'sidebar'
+  /** True while the editor is popped out into the floating window. */
+  floatOpen: boolean
+  /**
+   * True once the host's frame-wide overlay slot actually rendered the
+   * floating window host. Until then the menu entry stays disabled: a surface
+   * that can never paint is worse than a missing entry.
+   */
+  floatAvailable: boolean
   /** The active sidebar panel (shared so any surface can switch it). */
   view: RailView
   /** A pending search request raised by the explorer's context menu. */
   searchRequest: SearchRequest | undefined
+  /** A pending "show this folder in the tree" request (search-result menu). */
+  revealRequest: RevealRequest | undefined
+  /** A pending "open a terminal in this folder" request (search-result menu). */
+  terminalRequest: TerminalRequest | undefined
   /**
    * Expanded untracked DIRECTORY rows (`-u normal` collapses a directory into
    * one row, so the panel asks for its contents on demand — see
@@ -154,6 +178,32 @@ export interface SearchRequest {
   scope: string
 }
 
+/** One "show this folder in the explorer tree" request. */
+export interface RevealRequest {
+  /** Monotonic id so asking for the same folder twice still re-triggers. */
+  id: number
+  /** Absolute remote DIRECTORY to expand and scroll to. */
+  path: string
+}
+
+/** One "open a terminal here" request. */
+export interface TerminalRequest {
+  /** Monotonic id so the same folder can be opened twice. */
+  id: number
+  /**
+   * Host alias the directory lives on.
+   *
+   * Carried explicitly, and NOT taken from the terminal panel's own last-used
+   * host: the panel remembers whatever host the user ran a shell on last, so a
+   * menu action on a workspace bound elsewhere opened the shell on the WRONG
+   * machine — the `cd` then failed with "No such file or directory" for a path
+   * that exists perfectly well on its own host.
+   */
+  alias: string
+  /** Absolute remote directory the fresh shell should `cd` into. */
+  dir: string
+}
+
 const WS_KEY = 'dsh-remote-vs.files.ws'
 const VIEW_KEY = 'dsh-remote-vs.view'
 /** Per-workspace repository sub-directory, keyed by workspace id. */
@@ -293,8 +343,12 @@ const state: State = {
   activeTabId: undefined,
   revision: 0,
   editorSurface: 'sidebar',
+  floatOpen: false,
+  floatAvailable: false,
   view: readStoredView(),
   searchRequest: undefined,
+  revealRequest: undefined,
+  terminalRequest: undefined,
   untrackedDirs: new Map(),
 }
 
@@ -334,13 +388,31 @@ export interface ExplorerValue {
   activeTab: EditorTab | undefined
   activeTabId: string | undefined
   revision: number
-  editorSurface: 'center' | 'sidebar'
+  /** Effective editor mount: the floating window wins over the base surface. */
+  editorSurface: EditorSurface
+  floatOpen: boolean
+  floatAvailable: boolean
   view: RailView
   searchRequest: SearchRequest | undefined
+  /** Pending "show this folder in the tree" request (consumed by the explorer). */
+  revealRequest: RevealRequest | undefined
+  /** Pending "open a terminal here" request (consumed by the terminal panel). */
+  terminalRequest: TerminalRequest | undefined
   setView: (view: RailView) => void
   /** Switch to the search panel (optionally scoped to a folder) — the tree's
       "find in folder" entry point. */
   requestSearch: (request: { mode: 'name' | 'content'; query?: string; scope: string }) => void
+  /**
+   * Show one remote directory in the explorer: switch to it, expand the folder
+   * and its ancestors, then scroll its row into view. Raised by the search
+   * results' "open containing folder" entry.
+   */
+  revealInExplorer: (dir: string) => void
+  /**
+   * Open a fresh terminal tab whose shell `cd`s into `dir`. Raised by the
+   * search results' "open in terminal" entry.
+   */
+  openTerminalAt: (dir: string) => void
   /**
    * The USER's pick — the workspace dropdowns and the wizard's "open files".
    *
@@ -368,6 +440,19 @@ export interface ExplorerValue {
   /** Expand / collapse one untracked directory row (one path-limited status). */
   toggleUntrackedDir: (dirPath: string) => Promise<void>
   openFile: (fullPath: string, options?: { line?: number }) => void
+  /**
+   * 「在悬浮编辑器中打开」：把编辑器整体浮出，再打开这个文件。
+   *
+   * 先捕获当前编辑器缓冲区再切表面（见 `captureLiveBuffer`）：主界面里没保存
+   * 的编辑不会因为这次切换丢掉。
+   */
+  openInFloatEditor: (fullPath: string, options?: { line?: number }) => void
+  /** 同上，只是打开的是工作区 diff（SCM 更改列表的悬浮入口）。 */
+  openDiffInFloatEditor: (rel: string, staged: boolean, untracked?: boolean) => void
+  /** 把当前编辑器整体浮出（双击会话视图的「远程编辑器」标签）。 */
+  openFloatingEditor: () => void
+  /** 停靠回主界面（底层的中心视图或侧栏表面）。 */
+  dockFloatingEditor: () => void
   openDiff: (rel: string, staged: boolean, untracked?: boolean) => void
   openCommitFile: (hash: string, rel: string) => void
   activateTab: (id: string) => void
@@ -384,7 +469,12 @@ export interface ExplorerValue {
    * `changeSet.marks`，`hunk` 是 `patches` 的下标）。
    */
   undoChange: (tabId: string, mark: ChangeMark) => Promise<void>
-  saveTab: (id: string, content: string) => Promise<void>
+  /**
+   * Write one file tab back to the remote host.
+   * @returns true only when the write really succeeded — the caller uses it to
+   *   advance the editor's dirty baseline (see `CodeEditorHandle.markSaved`).
+   */
+  saveTab: (id: string, content: string) => Promise<boolean>
   reloadTab: (id: string) => Promise<void>
   info: (text: string) => void
   fail: (text: string) => void
@@ -460,11 +550,17 @@ function build(): ExplorerValue {
     activeTab: state.tabs.find(item => item.id === state.activeTabId),
     activeTabId: state.activeTabId,
     revision: state.revision,
-    editorSurface: state.editorSurface,
+    editorSurface: effectiveEditorSurface(state.editorSurface, state.floatOpen),
+    floatOpen: state.floatOpen,
+    floatAvailable: state.floatAvailable,
     view: state.view,
     searchRequest: state.searchRequest,
+    revealRequest: state.revealRequest,
+    terminalRequest: state.terminalRequest,
     setView,
     requestSearch,
+    revealInExplorer,
+    openTerminalAt,
     selectWorkspace,
     setRepoSubdir,
     discoverRepos,
@@ -475,6 +571,10 @@ function build(): ExplorerValue {
     untrackedDirs: state.untrackedDirs,
     toggleUntrackedDir,
     openFile,
+    openInFloatEditor,
+    openDiffInFloatEditor,
+    openFloatingEditor,
+    dockFloatingEditor,
     openDiff,
     openCommitFile,
     activateTab,
@@ -622,6 +722,48 @@ export function requestSearch(request: { mode: 'name' | 'content'; query?: strin
   setView('search')
 }
 
+/** Monotonic ticket for "show this folder" requests (0 = none yet). */
+let revealSeq = 0
+
+/**
+ * Show one remote directory in the explorer.
+ *
+ * Two stages, because the tree is lazily loaded: this raises the request and
+ * switches the panel, and the explorer itself expands the ancestors (loading
+ * each level) and scrolls the row into view — it is the only place that knows
+ * which directories are currently expanded.
+ *
+ * @param dir - absolute remote DIRECTORY (a file's parent for a file hit).
+ */
+export function revealInExplorer(dir: string): void {
+  revealSeq += 1
+  patch({ revealRequest: { id: revealSeq, path: dir } })
+  setView('explorer')
+}
+
+/** Monotonic ticket for "open a terminal here" requests. */
+let terminalSeq = 0
+
+/**
+ * Open a fresh terminal tab whose shell lands in `dir` — on the CURRENT
+ * workspace's host.
+ *
+ * The terminal panel consumes the request (it owns the tabs) and the shell gets
+ * a quoted `cd` once its PTY reports ready — the host's terminal route has no
+ * "start in this directory" parameter, so a typed command is the honest way.
+ *
+ * The alias travels IN the request. The panel otherwise opens new tabs on the
+ * host it last used, which put the shell on a different machine than the path
+ * belongs to and made the `cd` fail with "No such file or directory".
+ *
+ * @param dir - absolute remote directory.
+ */
+export function openTerminalAt(dir: string): void {
+  terminalSeq += 1
+  patch({ terminalRequest: { id: terminalSeq, alias: currentWorkspace()?.alias ?? '', dir } })
+  setView('terminal')
+}
+
 /**
  * Select the binding every view works against — the USER's choice.
  *
@@ -1153,7 +1295,9 @@ let revealRetry: ReturnType<typeof setTimeout> | undefined
  * is told where the file opened instead of being left guessing.
  */
 function revealEditor(): void {
-  if (state.editorSurface !== 'center') return
+  // While the editor floats, the shell tab has no editor to reveal: the file
+  // just went into the floating window (which is already on screen).
+  if (effectiveEditorSurface(state.editorSurface, state.floatOpen) !== 'center') return
   const label = t('view.editor')
   // A newer open supersedes the pending retry: arming a second one left the
   // timers piling up one per opened file (each doing its own full-document tab
@@ -1176,6 +1320,63 @@ function patchTab(id: string, next: Partial<EditorTab>): void {
   patch({ tabs: state.tabs.map(tab => (tab.id === id ? { ...tab, ...next } : tab)) })
 }
 
+/**
+ * Copy the live editor buffer onto its tab before the editor is remounted.
+ *
+ * Why this exists: `CodeEditor` reads its `initial` text ONCE, on mount
+ * (`src/client/CodeEditor.tsx`), and the tab's stored text is only ever written
+ * by a load/reload/handoff — typing lives exclusively in CodeMirror. Every tab
+ * switch (a normal file click, another tab in the strip, a diff) and every
+ * editor-surface flip therefore unmounts and remounts the editor, and without
+ * this handoff the edits typed since the load would silently disappear (and a
+ * later Ctrl+S would write the pre-edit text back).
+ *
+ * The text is written into the tab, which is exactly the input the replacement
+ * mount reads: no extra channel exists or is needed. The DISK-side baseline is
+ * deliberately left alone (`EditorTab.baseline`), so the remount still knows
+ * the text is unsaved. The scroll + caret half of the handoff lives in
+ * `live-editor.ts`.
+ */
+function captureLiveBuffer(): void {
+  // The position is cheap and is needed even for a CLEAN tab: a surface flip
+  // remounts the very same tab, and the replacement's render happens before
+  // the old view's unmount report.
+  captureLiveEditorPosition()
+  const active = state.tabs.find(item => item.id === state.activeTabId)
+  // The whole document is only materialized when the tab may hold something the
+  // store does not: the buffer is edited, or a previous handoff already copied
+  // unsaved text into `text` (so undoing back to the disk bytes must still be
+  // carried). A clean, already-synced tab skips the O(file) copy.
+  const synced = active !== undefined
+    && active.kind === 'file'
+    && active.text === (active.baseline ?? active.text)
+  if (synced && !isLiveEditorDirty()) return
+  const captured = captureLiveEditorText()
+  if (captured === undefined) return
+  const tab = state.tabs.find(item => item.id === captured.tabId)
+  // Diffs and previews have no CodeMirror buffer; and an unchanged buffer
+  // would just hand the same string back, so neither case touches the store.
+  if (tab === undefined || tab.kind !== 'file' || tab.text === captured.text) return
+  patchTab(captured.tabId, { text: captured.text })
+}
+
+/**
+ * Flip the editor into the floating surface, capturing the live buffer first.
+ *
+ * A no-op while already floating (the editor is not remounted then), and a
+ * toast-only refusal on a host that cannot host the window — the caller still
+ * opens the file, just on the normal surface.
+ */
+function enterFloatSurface(): void {
+  if (!state.floatAvailable) {
+    toast(t('float.unavailable'), true)
+    return
+  }
+  if (state.floatOpen) return
+  captureLiveBuffer()
+  patch({ floatOpen: true })
+}
+
 /**
  * Deadline for one git round trip.
  *
@@ -1217,6 +1418,7 @@ function withDeadline<T>(promise: Promise<T>, ms: number, label: string): Promis
 
 /** Open (or focus) a remote file in the editor tab strip. */
 export function openFile(fullPath: string, options: { line?: number } = {}): void {
+  captureLiveBuffer()
   const workspace = currentWorkspace()
   if (workspace === undefined || fullPath === '') return
   const id = `file:${workspace.alias}:${fullPath}`
@@ -1266,6 +1468,8 @@ export function openFile(fullPath: string, options: { line?: number } = {}): voi
         binary: read.binary,
         truncated: read.truncated,
         text: read.binary ? '' : (read.text ?? ''),
+        // The disk side of the dirty comparison (see EditorTab.baseline).
+        ...(read.binary ? {} : { baseline: read.text ?? '' }),
       })
     } catch (error) {
       patchTab(id, { loading: false, error: error instanceof Error ? error.message : String(error) })
@@ -1309,13 +1513,22 @@ export function openRemoteFileInBinding(
   return true
 }
 
-/** Whether the editor tab is mounted in the centre conversation view. */
-export function isEditorCentered(): boolean {
-  return state.editorSurface === 'center'
+/**
+ * Whether the plugin's own rich editor is the place a remote file click should
+ * land (the click interceptor's gate, see `remote-file-open.ts`).
+ *
+ * The centre conversation view is the normal case; while the editor floats it
+ * is the floating window instead — the file still belongs in OUR editor, not in
+ * the host's native preview. On the sidebar-fallback layout (`sidebar`) the
+ * interceptor stays off, exactly as before this feature.
+ */
+export function isEditorTakeoverActive(): boolean {
+  return effectiveEditorSurface(state.editorSurface, state.floatOpen) !== 'sidebar'
 }
 
 /** Open (or focus) a working-tree diff of one repository path. */
 export function openDiff(rel: string, staged: boolean, untracked = false): void {
+  captureLiveBuffer()
   const workspace = currentWorkspace()
   if (workspace === undefined || state.repoRoot === undefined || rel === '') {
     toast(t('git.notARepo'), true)
@@ -1362,6 +1575,7 @@ export function openDiff(rel: string, staged: boolean, untracked = false): void
 
 /** Open (or focus) one file of one commit (`ref^` against `ref`). */
 export function openCommitFile(hash: string, rel: string): void {
+  captureLiveBuffer()
   const workspace = currentWorkspace()
   const root = state.repoRoot
   if (workspace === undefined || root === undefined || rel === '') return
@@ -1405,6 +1619,12 @@ export function openCommitFile(hash: string, rel: string): void {
 }
 
 export function activateTab(id: string): void {
+  // Switching away from a file tab remounts the editor, so the outgoing live
+  // buffer has to be captured first — otherwise every tab click silently
+  // discards edits typed since that tab was loaded (the tab's `text` is only
+  // the last load/handoff copy). Same protection for the pre-existing paths
+  // that switch tabs below (`openFile`/`openDiff`/`openCommitFile`).
+  captureLiveBuffer()
   patch({ activeTabId: id })
 }
 
@@ -1421,30 +1641,57 @@ export function updateTab(id: string, next: Partial<EditorTab>): void {
   patchTab(id, next)
 }
 
-/** Write one tab back to the remote host. */
-export async function saveTab(id: string, content: string): Promise<void> {
+/** Write one tab back to the remote host. @returns true when the write landed. */
+export async function saveTab(id: string, content: string): Promise<boolean> {
   const workspace = currentWorkspace()
   const tab = state.tabs.find(item => item.id === id)
-  if (workspace === undefined || tab === undefined || tab.kind !== 'file' || tab.binary || tab.truncated) return
+  if (workspace === undefined || tab === undefined || tab.kind !== 'file' || tab.binary || tab.truncated) return false
   // Never fall back to the tab's loaded text. `tab.text` is only ever written
-  // by a load/reload, never by typing, so substituting it here would push the
-  // PRE-EDIT bytes to the remote file and report success — destroying the
-  // user's edit with a confirmation. A caller without a live buffer must
-  // refuse to save instead (see EditorPane.saveActive).
+  // by a load/reload or by the surface handoff (`captureLiveBuffer`), never as
+  // a fallback for a caller without a live buffer, so substituting it here
+  // would push the PRE-EDIT (or the lost-buffer) bytes to the remote file and
+  // report success — destroying the user's edit with a confirmation. A caller
+  // without a live buffer must refuse to save instead (see EditorPane.saveActive).
   if (typeof content !== 'string') {
     toast(t('editor.needSource'), true)
-    return
+    return false
   }
   const text = content
   patchTab(id, { saving: true, text })
   try {
     await api.fileOp.write(workspace.alias, tab.fullPath, text)
-    patchTab(id, { saving: false, dirty: false })
+    /**
+     * The remote file now holds `text`, so that becomes the disk-side dirty
+     * baseline (a later remount compares against it).
+     *
+     * The dirty FLAG is deliberately NOT cleared while the tab may still hold
+     * something newer than what was written. Two ways that happens, and both
+     * must keep the flag:
+     *
+     *  - a live editor is mounted for this tab: the user may have typed while
+     *    the write was in flight, and only the editor can tell (it re-derives
+     *    through `markLiveEditorSaved` below);
+     *  - the tab was switched away from mid-write: its stored `text` is then the
+     *    handoff copy of that newer buffer, so comparing it with what was
+     *    written detects the difference without an editor.
+     *
+     * Only a tab whose stored text IS the written text, with no mounted editor,
+     * has nothing newer — there the flag is cleared directly. (Clearing it
+     * otherwise is how a tab read "saved" while its buffer was not: dot off,
+     * Save disabled, close guard silent.)
+     */
+    const liveEditor = isLiveEditorFor(id)
+    const current = state.tabs.find(item => item.id === id)
+    const newer = current !== undefined && current.text !== text
+    patchTab(id, { saving: false, baseline: text, ...(liveEditor || newer ? {} : { dirty: false }) })
+    markLiveEditorSaved(id, text)
     toast(`${t('editor.saved')} · ${tab.rel}`, false)
     await afterWrite()
+    return true
   } catch (error) {
     patchTab(id, { saving: false })
     toast(error instanceof Error ? error.message : String(error), true)
+    return false
   }
 }
 
@@ -1480,6 +1727,7 @@ export async function reloadTab(id: string): Promise<void> {
         binary: read.binary,
         truncated: read.truncated,
         dirty: false,
+        ...(read.binary ? {} : { baseline: read.text ?? '' }),
       })
       // Only now: the new text must already be in the tab when the editor remounts.
       patchTab(id, { reloadNonce: (tab.reloadNonce ?? 0) + 1 })
@@ -1512,6 +1760,109 @@ export function setEditorSurface(surface: 'center' | 'sidebar'): void {
   patch({ editorSurface: surface })
 }
 
+/**
+ * Record that the host's frame-wide overlay slot actually rendered the
+ * floating window host (see `FloatingEditorWindow`).
+ *
+ * This is a runtime handshake, not a configuration flag: on a host whose
+ * `shell.overlay` slot is missing, the entry never mounts and the menu entries
+ * stay disabled instead of opening a surface that cannot paint.
+ */
+export function setFloatEditorAvailable(available: boolean): void {
+  if (available) {
+    if (state.floatAvailable) return
+    patch({ floatAvailable: true })
+    return
+  }
+  // The host went away while the editor floated (plugin unmount / host swap).
+  // Keeping `floatOpen` would leave the main surfaces showing the "docked
+  // elsewhere" placeholder with no window to dock from, so the flag has to go.
+  //
+  // The capture below is BEST EFFORT and usually cannot carry the text: React
+  // detaches a child's ref before the parent's passive cleanup runs, so the
+  // editor handle is already gone by the time the overlay entry unmounts. The
+  // tab therefore keeps whatever the last switch captured — this call must not
+  // be read as a guarantee.
+  if (!state.floatAvailable && !state.floatOpen) return
+  captureLiveBuffer()
+  patch({ floatAvailable: false, floatOpen: false })
+}
+
+/**
+ * Float the editor in its current state, without opening anything.
+ *
+ * The entry is a double-click on the shell's 「远程编辑器」 tab (see
+ * `float-tab-trigger.ts`): the user is already looking at the editor and wants
+ * it out of the layout — no file, no diff, same tabs and buffers.
+ *
+ * Idempotent: while the editor already floats this does nothing (the window is
+ * on screen; a second trigger must not restart it).
+ */
+export function openFloatingEditor(): void {
+  if (state.floatOpen) return
+  captureLiveBuffer()
+  enterFloatSurface()
+  // A fresh open must not come back as a 34px bar: the ball is the minimized
+  // state, and the store carries no knowledge of the window's local collapse
+  // flag, so the window resets it when `floatOpen` flips (see its `wasOpenRef`).
+}
+
+/**
+ * Open one file in the floating editor (file-tree / search / SCM menu action).
+ *
+ * Order matters twice:
+ *   1. the live buffer is captured BEFORE the surface flips (the flip unmounts
+ *      the editor that owns it);
+ *   2. a second capture runs even when already floating, because opening
+ *      another file is a tab switch — the very action that remounts the editor
+ *      and would otherwise drop the edits typed in the tab being left.
+ * A host whose overlay slot is unavailable gets the file in the normal surface
+ * instead (with the reason toasted), so the click is never a dead end.
+ */
+export function openInFloatEditor(fullPath: string, options: { line?: number } = {}): void {
+  // Mirror `openFile`'s precondition: with no binding or no path there is no tab
+  // to show, and floating an empty editor is worse than not floating at all.
+  if (currentWorkspace() === undefined || fullPath === '') {
+    openFile(fullPath, options)
+    return
+  }
+  captureLiveBuffer()
+  enterFloatSurface()
+  openFile(fullPath, options)
+}
+
+/**
+ * The floating variant of `openDiff` — the SCM change list's entry.
+ *
+ * Same handoff order as `openInFloatEditor`; a diff tab has no text buffer of
+ * its own, but the file editor that WAS on screen still does.
+ */
+export function openDiffInFloatEditor(rel: string, staged: boolean, untracked = false): void {
+  // `openDiff` refuses (with its own toast) without a repository or a path;
+  // floating the editor onto a tab that will never open is worse than not
+  // floating at all.
+  if (currentWorkspace() === undefined || state.repoRoot === undefined || rel === '') {
+    openDiff(rel, staged, untracked)
+    return
+  }
+  captureLiveBuffer()
+  enterFloatSurface()
+  openDiff(rel, staged, untracked)
+}
+
+/**
+ * Dock the editor back onto its base surface (centre conversation view or the
+ * sidebar fallback), carrying the live buffer with it.
+ */
+export function dockFloatingEditor(): void {
+  if (!state.floatOpen) return
+  captureLiveBuffer()
+  patch({ floatOpen: false })
+  // The shell renders only the selected conversation view; a docked editor
+  // behind another tab would look like the window simply vanished.
+  revealEditor()
+}
+
 /**
  * 换一份「本会话改了什么」的标记。
  *

package/src/client/vsc/editor-theme.ts

@@ -29,7 +29,12 @@ function chrome(p: Palette, dark: boolean): Extension {
     '&': {
       backgroundColor: p.bg,
       color: p.fg,
-      fontSize: '13px',
+      // The floating window changes ONLY its own editor's type size (Ctrl+wheel,
+      // see FloatingEditorWindow); the variable is unset everywhere else, so the
+      // normal editor keeps 13px. A plain literal here would freeze the size and
+      // make the zoom silently do nothing. The zoom is a property of the window,
+      // so a docked editor always renders at the default size.
+      fontSize: 'var(--rvs-editor-font-size, 13px)',
       height: '100%',
     },
     '.cm-content': {