dsh-remote-vs 0.8.9 → 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,6 +139,14 @@ 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. */
@@ -323,6 +343,8 @@ const state: State = {
   activeTabId: undefined,
   revision: 0,
   editorSurface: 'sidebar',
+  floatOpen: false,
+  floatAvailable: false,
   view: readStoredView(),
   searchRequest: undefined,
   revealRequest: undefined,
@@ -366,7 +388,10 @@ 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). */
@@ -415,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
@@ -431,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
@@ -507,7 +550,9 @@ 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,
@@ -526,6 +571,10 @@ function build(): ExplorerValue {
     untrackedDirs: state.untrackedDirs,
     toggleUntrackedDir,
     openFile,
+    openInFloatEditor,
+    openDiffInFloatEditor,
+    openFloatingEditor,
+    dockFloatingEditor,
     openDiff,
     openCommitFile,
     activateTab,
@@ -1246,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
@@ -1269,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.
  *
@@ -1310,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}`
@@ -1359,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) })
@@ -1402,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)
@@ -1455,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
@@ -1498,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 })
 }
 
@@ -1514,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
   }
 }
 
@@ -1573,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 })
@@ -1605,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': {

package/src/client/vsc/vsc.css

@@ -2065,6 +2065,241 @@ body:not([data-ds-dark-theme]) .rvs-undo-affordance:focus-visible {
   font-size: 11px;
 }
 
+/* ---------------------------------------------------- floating editor window */
+
+/**
+ * The floating editor lives in the host's frame-wide overlay layer
+ * (`position: absolute; inset: 0; z-index: 20`, click-through, children opt
+ * back into pointer events). It is placed with viewport coordinates, so it
+ * floats above every column without joining any of their stacking contexts.
+ *
+ * `.rvs-root` carries the whole design-system token set and is row-flex by
+ * default; this frame overrides the direction to a column and takes its size
+ * from the inline rect the component keeps.
+ */
+.rvs-float-window {
+  position: fixed;
+  flex-direction: column;
+  /* The rect maths (clamp/persist) is in border-box terms; without this the
+     painted border would sit one pixel outside the computed rectangle. */
+  box-sizing: border-box;
+  min-width: 360px;
+  min-height: 220px;
+  overflow: hidden;
+  border: 1px solid var(--rvs-border2);
+  border-radius: 10px;
+  background: var(--rvs-code-bg);
+  color: var(--rvs-code-fg);
+  box-shadow: 0 18px 60px rgba(0, 0, 0, .45), 0 2px 8px rgba(0, 0, 0, .28);
+  z-index: 30;
+  /* The overlay layer itself is click-through; the window opts back in even if
+     the host wraps each overlay entry in its own element. */
+  pointer-events: auto;
+}
+
+/* Minimized: the frame IS the ball (see `.rvs-float-mini`); the body stays
+   mounted but hidden, and it must not impose a minimum height. */
+.rvs-float-window[data-rvs-float="collapsed"] {
+  min-height: 0;
+}
+
+/**
+ * Minimized window = floating ball.
+ *
+ * A full-width 34px bar was too long: it read as a broken window and covered a
+ * whole strip. The ball is a small circle at the window's own corner, draggable
+ * anywhere, restored by a click (or Enter/Space). It keeps the dirty dot, so
+ * "the editor is out and has unsaved edits" is still one glance away.
+ */
+.rvs-float-window.rvs-float-mini {
+  min-width: 0;
+  min-height: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 50%;
+  cursor: move;
+  touch-action: none;
+}
+
+.rvs-float-ball {
+  flex: 1;
+  /* Stretch to the circle: the frame is a COLUMN flex box with centred items,
+     so without this the hit area (and the absolutely positioned dot) would be
+     sized by the 16px glyph instead of the 44px ball. */
+  width: 100%;
+  height: 100%;
+  box-sizing: border-box;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  position: relative;
+  border-radius: 50%;
+  color: var(--rvs-brand);
+  font-size: 16px;
+  line-height: 1;
+  cursor: move;
+  outline: none;
+}
+
+.rvs-float-ball:hover,
+.rvs-float-ball:focus-visible {
+  background: var(--rvs-hover);
+}
+
+.rvs-float-ball-glyph {
+  pointer-events: none;
+}
+
+/* Unsaved edits stay visible while minimized. */
+.rvs-float-ball-dot {
+  position: absolute;
+  top: 8px;
+  right: 8px;
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background: var(--rvs-git-m);
+  box-shadow: 0 0 0 2px var(--rvs-code-bg);
+  pointer-events: none;
+}
+
+/* While a drag/resize gesture runs the pointer must not select editor text. */
+.rvs-float-window.dragging {
+  user-select: none;
+}
+
+.rvs-float-titlebar {
+  flex: none;
+  display: flex;
+  align-items: center;
+  gap: 7px;
+  height: 34px;
+  padding: 0 6px 0 10px;
+  border-bottom: 1px solid var(--rvs-border);
+  background: var(--rvs-layer3);
+  cursor: move;
+  user-select: none;
+  touch-action: none;
+}
+
+.rvs-float-glyph {
+  color: var(--rvs-brand);
+  font-size: 11px;
+}
+
+.rvs-float-title {
+  flex: none;
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--rvs-fg2);
+}
+
+.rvs-float-file {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-size: 11.5px;
+  color: var(--rvs-fg3);
+  direction: rtl;
+  unicode-bidi: plaintext;
+  text-align: left;
+}
+
+.rvs-float-spacer {
+  flex: 1;
+}
+
+.rvs-float-btn {
+  flex: none;
+  width: 22px;
+  height: 22px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0;
+  border: none;
+  border-radius: 5px;
+  background: transparent;
+  color: var(--rvs-fg3);
+  font: inherit;
+  font-size: 12px;
+  line-height: 1;
+  cursor: pointer;
+}
+
+.rvs-float-btn:hover {
+  background: var(--rvs-hover);
+  color: var(--rvs-fg);
+}
+
+.rvs-float-close:hover {
+  background: rgba(241, 76, 76, .18);
+  color: var(--rvs-danger);
+}
+
+.rvs-float-body {
+  flex: 1 1 0;
+  min-height: 0;
+  min-width: 0;
+  display: flex;
+  overflow: hidden;
+  background: var(--rvs-code-bg);
+}
+
+/* Keep the height chain pinned: the editor pane grows inside this box. */
+.rvs-float-body > .rvs-pane {
+  flex: 1 1 0;
+  min-height: 0;
+  min-width: 0;
+}
+
+/* Eight grips, placed INSIDE the border box: the window clips overflow (rounded
+   corners), so grips hanging outside would lose half their hit area. Corners
+   are larger so they can actually be hit. */
+.rvs-float-resize {
+  position: absolute;
+  z-index: 3;
+}
+
+.rvs-float-resize-n { top: 0; left: 10px; right: 10px; height: 6px; cursor: ns-resize; }
+.rvs-float-resize-s { bottom: 0; left: 10px; right: 10px; height: 6px; cursor: ns-resize; }
+.rvs-float-resize-e { top: 10px; bottom: 10px; right: 0; width: 6px; cursor: ew-resize; }
+.rvs-float-resize-w { top: 10px; bottom: 10px; left: 0; width: 6px; cursor: ew-resize; }
+.rvs-float-resize-ne { top: 0; right: 0; width: 12px; height: 12px; cursor: nesw-resize; }
+.rvs-float-resize-nw { top: 0; left: 0; width: 12px; height: 12px; cursor: nwse-resize; }
+.rvs-float-resize-se { bottom: 0; right: 0; width: 12px; height: 12px; cursor: nwse-resize; }
+.rvs-float-resize-sw { bottom: 0; left: 0; width: 12px; height: 12px; cursor: nesw-resize; }
+
+/* Shown by whichever surface the single editor left behind (centre tab or the
+   sidebar's editor panel). */
+.rvs-float-placeholder {
+  flex: 1;
+  min-height: 0;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 10px;
+  padding: 24px;
+  text-align: center;
+  color: var(--rvs-fg3);
+  font-size: 12.5px;
+}
+
+.rvs-float-placeholder-title {
+  color: var(--rvs-fg2);
+  font-size: 13px;
+  font-weight: 600;
+}
+
+.rvs-float-placeholder-text {
+  max-width: 360px;
+  line-height: 1.6;
+}
+
 /* --------------------------------------------------------- context menu */
 
 .rvs-portal {