dsh-remote-vs 0.8.9 → 0.9.0

package/src/client/RemoteExplorer.tsx

@@ -1032,6 +1032,22 @@ export function RemoteExplorer(props: { showHidden: boolean; onToggleHidden: ()
     ]
     if (entry !== undefined) {
       entries.push({ label: t('files.open'), onSelect: () => openEntry(entry), separated: true })
+      if (!entry.isDir) {
+        // 「在悬浮编辑器中打开」: the editor surface floats above the app shell,
+        // above whatever conversation view is selected. Disabled only when the
+        // host has no frame-wide overlay slot to host the window (see
+        // `FloatingEditorWindow`'s availability handshake).
+        //
+        // Deliberately opens the FILE, not the working-tree diff the adjacent
+        // "Open" entry may choose for a changed file: this is the editor, and a
+        // diff is not an editing surface (SCM's own entry keeps the diff
+        // semantics because that list is about changes).
+        entries.push({
+          label: t('files.openInFloat'),
+          onSelect: () => { store.openInFloatEditor(entry.path) },
+          disabled: !store.floatAvailable,
+        })
+      }
       if (!entry.isDir && isPreviewOnlyFile(entry.path)) {
         entries.push({ label: t('files.openAsText'), onSelect: () => store.openFile(entry.path) })
       }

package/src/client/RemoteRoot.tsx

@@ -11,6 +11,7 @@
 import type { Context } from '@deepseek-ai/cordis'
 import { useCallback, useEffect, useRef, useState, type ReactNode } from 'react'
 import { EditorPane } from './EditorPane.tsx'
+import { FloatingEditorPlaceholder } from './FloatingPlaceholder.tsx'
 import { RemoteExplorer } from './RemoteExplorer.tsx'
 import { SearchView } from './SearchView.tsx'
 import { HistoryPanel } from './scm/HistoryPanel.tsx'
@@ -171,9 +172,14 @@ function Shell(props: { ctx: Context; visible: boolean }): ReactNode {
    * that owns it was gone AND the centre tab mounted a second EditorPane on
    * the same store tab — two live buffers with independent undo state, the one
    * state this file declares must never happen.
+   *
+   * Only the CENTRE pixel surface triggers this redirect. While the editor
+   * floats the sidebar keeps whatever view it had: the editor panel renders a
+   * "docked elsewhere" placeholder (see panelFor), and on docking the user
+   * lands back where they were.
    */
   useEffect(() => {
-    if (store.editorSurface !== 'sidebar' && view === 'editor') go('explorer')
+    if (store.editorSurface === 'center' && view === 'editor') go('explorer')
   }, [store.editorSurface, view, go])
 
   useEffect(() => {
@@ -264,11 +270,14 @@ function Shell(props: { ctx: Context; visible: boolean }): ReactNode {
         // The sidebar editor is the FALLBACK surface, used only when the host
         // has no `conversation.view` slot to mount the editor in (index.tsx
         // stays on 'sidebar' then). It must not render while the centre surface
-        // owns the editor: both read the same store, so two live editors for one
-        // tab fight over the scroll position and the hidden one — sitting at
-        // scrollTop 0 — wins, which is exactly why a tab switch kept snapping
-        // back to the top of the file.
-        return editorInSidebar ? <EditorPane visible={panelLive('editor')} /> : null
+        // or the floating window owns the editor: all of them read the same
+        // store, so two live editors for one tab fight over the scroll position
+        // and the hidden one — sitting at scrollTop 0 — wins, which is exactly
+        // why a tab switch kept snapping back to the top of the file.
+        if (editorInSidebar) return <EditorPane visible={panelLive('editor')} />
+        // Floating the editor away from the sidebar: the panel stays reachable
+        // (so docking returns here) but shows where the editor went.
+        return store.floatOpen ? <FloatingEditorPlaceholder /> : null
       default:
         return (
           <RemoteExplorer

package/src/client/SearchView.tsx

@@ -240,12 +240,13 @@ export function SearchView(): ReactNode {
   }
 
   /**
-   * Right-click on a name result: the four things one does with a found path.
+   * Right-click on a name result: what one does with a found path.
    *
    * "Relative" is relative to the REPOSITORY when the workspace sits inside one
    * (the same relative form the tree's own menu copies), else absolute — which
    * is what makes the copied value paste straight into a shell that already ran
-   * `cd` into the repo.
+   * `cd` into the repo. Directories only get the copy/reveal/terminal entries:
+   * there is no file to open in the editor.
    */
   const openHitMenu = (event: React.MouseEvent, hit: SearchHit): void => {
     event.preventDefault()
@@ -255,7 +256,13 @@ export function SearchView(): ReactNode {
     menu.open(event.clientX, event.clientY, [
       { label: t('files.copyAbs'), onSelect: () => { void copyText(abs); toast(t('files.copiedClipboard')) } },
       { label: t('files.copyRel'), onSelect: () => { void copyText(rel); toast(t('files.copiedClipboard')) } },
-      { label: t('search.revealInExplorer'), onSelect: () => { store.revealInExplorer(dir) }, separated: true },
+      {
+        label: t('files.openInFloat'),
+        onSelect: () => { store.openInFloatEditor(abs) },
+        disabled: !store.floatAvailable || hit.isDir,
+        separated: true,
+      },
+      { label: t('search.revealInExplorer'), onSelect: () => { store.revealInExplorer(dir) } },
       { label: t('search.openInTerminal'), onSelect: () => { store.openTerminalAt(dir) } },
     ])
   }

package/src/client/float-editor.ts

@@ -0,0 +1,271 @@
+/**
+ * Pure geometry and surface rules for the floating editor.
+ *
+ * Kept free of React and of the DOM on purpose: the drag / resize / zoom maths
+ * is the part that is easy to get subtly wrong (negative sizes, a window that
+ * escapes the viewport, a stale stored rect from a larger screen), and this
+ * module is what `scripts/check-float-editor.mjs` drives directly. The window
+ * component is then only wiring.
+ *
+ * The SURFACE rule lives here too: the plugin has exactly one live editor, and
+ * which mount owns it is a three-way decision (centre conversation view,
+ * sidebar fallback, floating window). Encoding it as a pure function keeps the
+ * invariant testable and out of three separate `=== 'center'` comparisons.
+ */
+
+/** Where the editor pane is mounted right now. */
+export type EditorSurface = 'center' | 'sidebar' | 'float'
+
+/** The persisted layout of the floating window, in viewport pixels. */
+export interface FloatRect {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+
+/** Viewport size the geometry is clamped to. */
+export interface FloatViewport {
+  width: number
+  height: number
+}
+
+/** A resize grip: the compass directions of the eight handles. */
+export type FloatResizeHandle = 'n' | 's' | 'e' | 'w' | 'ne' | 'nw' | 'se' | 'sw'
+
+/** Smallest window the editor can be squeezed into and stay usable. */
+export const FLOAT_MIN_WIDTH = 360
+export const FLOAT_MIN_HEIGHT = 220
+/** Height of the title bar; a minimized window keeps exactly this much. */
+export const FLOAT_TITLEBAR_HEIGHT = 34
+/** Gap a maximized window keeps from the viewport edges. */
+export const FLOAT_VIEWPORT_EDGE = 8
+
+/** Editor font-size range for Ctrl+wheel zoom (px). */
+export const FLOAT_FONT_MIN = 9
+export const FLOAT_FONT_MAX = 28
+export const FLOAT_FONT_DEFAULT = 13
+
+/** Diameter of the minimized ball, in pixels. */
+export const FLOAT_BALL_SIZE = 44
+/**
+ * How far a pointer may travel and still count as a CLICK: the minimized window
+ * is a single 44px ball, so "click restores / drag moves" has to be decided
+ * from one pointer gesture.
+ */
+export const FLOAT_BALL_CLICK_SLOP = 4
+
+/** A point in viewport coordinates (the minimized ball's origin). */
+export interface FloatPoint {
+  x: number
+  y: number
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value))
+}
+
+/** True when the stored value is a usable finite number (not NaN/Infinity). */
+function finite(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value)
+}
+
+/** The effective editor surface: floating wins, otherwise the base mount. */
+export function effectiveEditorSurface(base: 'center' | 'sidebar', floatOpen: boolean): EditorSurface {
+  return floatOpen ? 'float' : base
+}
+
+/**
+ * The rect a fresh floating window opens at: about two thirds of the frame,
+ * centred, with a hard size cap so a 4K monitor does not produce a 2600px
+ * editor for a 40-column file.
+ */
+export function defaultFloatRect(viewport: FloatViewport): FloatRect {
+  const maxWidth = Math.max(FLOAT_MIN_WIDTH, viewport.width - FLOAT_VIEWPORT_EDGE * 2)
+  const maxHeight = Math.max(FLOAT_MIN_HEIGHT, viewport.height - FLOAT_VIEWPORT_EDGE * 2)
+  const width = Math.min(maxWidth, Math.max(FLOAT_MIN_WIDTH, Math.round(viewport.width * 0.62)), 1180)
+  const height = Math.min(maxHeight, Math.max(FLOAT_MIN_HEIGHT, Math.round(viewport.height * 0.7)), 860)
+  const x = Math.round((viewport.width - width) / 2)
+  const y = Math.round((viewport.height - height) / 2) - 12
+  return clampFloatRect({ x, y, width, height }, viewport)
+}
+
+/**
+ * Bring a rect back inside the viewport and to a legal size.
+ *
+ * Used on every drag step, on restore, and whenever the browser window is
+ * resized: a rect persisted on a 2560px screen must not open a window whose
+ * title bar is off-screen on a 1366px laptop.
+ */
+export function clampFloatRect(rect: FloatRect, viewport: FloatViewport): FloatRect {
+  const width = clamp(rect.width, FLOAT_MIN_WIDTH, Math.max(FLOAT_MIN_WIDTH, viewport.width))
+  const height = clamp(rect.height, FLOAT_MIN_HEIGHT, Math.max(FLOAT_MIN_HEIGHT, viewport.height))
+  const x = clamp(rect.x, 0, Math.max(0, viewport.width - width))
+  const y = clamp(rect.y, 0, Math.max(0, viewport.height - height))
+  return { x: Math.round(x), y: Math.round(y), width: Math.round(width), height: Math.round(height) }
+}
+
+/** Move the window by a pointer delta, staying inside the viewport. */
+export function dragFloatRect(start: FloatRect, dx: number, dy: number, viewport: FloatViewport): FloatRect {
+  return clampFloatRect({ ...start, x: start.x + dx, y: start.y + dy }, viewport)
+}
+
+/**
+ * Resize from one grip.
+ *
+ * Each axis is adjusted from the edge that MOVED (west/north resize changes the
+ * origin too), then clamped: the minimum size is anchored at the opposite edge
+ * (so dragging the north grip past the bottom stops instead of flipping the
+ * rect) and no edge may leave the viewport.
+ */
+export function resizeFloatRect(
+  start: FloatRect,
+  handle: FloatResizeHandle,
+  dx: number,
+  dy: number,
+  viewport: FloatViewport,
+): FloatRect {
+  let left = start.x
+  let top = start.y
+  let right = start.x + start.width
+  let bottom = start.y + start.height
+  if (handle.includes('e')) right += dx
+  if (handle.includes('w')) left += dx
+  if (handle.includes('s')) bottom += dy
+  if (handle.includes('n')) top += dy
+
+  // Minimum size, anchored at the edge that did NOT move.
+  if (right - left < FLOAT_MIN_WIDTH) {
+    if (handle.includes('w')) left = right - FLOAT_MIN_WIDTH
+    else right = left + FLOAT_MIN_WIDTH
+  }
+  if (bottom - top < FLOAT_MIN_HEIGHT) {
+    if (handle.includes('n')) top = bottom - FLOAT_MIN_HEIGHT
+    else bottom = top + FLOAT_MIN_HEIGHT
+  }
+
+  // Viewport clamp: keep the rect (and every edge) on screen.
+  left = clamp(left, 0, Math.max(0, viewport.width - FLOAT_MIN_WIDTH))
+  top = clamp(top, 0, Math.max(0, viewport.height - FLOAT_MIN_HEIGHT))
+  right = clamp(right, left + FLOAT_MIN_WIDTH, viewport.width)
+  bottom = clamp(bottom, top + FLOAT_MIN_HEIGHT, viewport.height)
+  return {
+    x: Math.round(left),
+    y: Math.round(top),
+    width: Math.round(right - left),
+    height: Math.round(bottom - top),
+  }
+}
+
+/** The rect a maximized window occupies: the frame minus a small margin. */
+export function maximizeFloatRect(viewport: FloatViewport): FloatRect {
+  const edge = FLOAT_VIEWPORT_EDGE
+  return {
+    x: edge,
+    y: edge,
+    width: Math.max(FLOAT_MIN_WIDTH, viewport.width - edge * 2),
+    height: Math.max(FLOAT_MIN_HEIGHT, viewport.height - edge * 2),
+  }
+}
+
+/**
+ * Parse a persisted rect.
+ *
+ * Anything malformed is discarded rather than repaired into a guess: the
+ * caller then opens the default rect. Values that are merely STALE (a rect from
+ * another screen) are legal input and get clamped.
+ */
+export function parseFloatRect(raw: string | null | undefined, viewport: FloatViewport): FloatRect | undefined {
+  if (typeof raw !== 'string' || raw.trim() === '') return undefined
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    return undefined
+  }
+  if (typeof parsed !== 'object' || parsed === null) return undefined
+  const candidate = parsed as Record<string, unknown>
+  if (!finite(candidate.x) || !finite(candidate.y) || !finite(candidate.width) || !finite(candidate.height)) {
+    return undefined
+  }
+  return clampFloatRect(
+    { x: candidate.x, y: candidate.y, width: candidate.width, height: candidate.height },
+    viewport,
+  )
+}
+
+/** Serialize a rect for localStorage. */
+export function serializeFloatRect(rect: FloatRect): string {
+  return JSON.stringify({ x: rect.x, y: rect.y, width: rect.width, height: rect.height })
+}
+
+/**
+ * One Ctrl+wheel step: up (negative deltaY) grows the text, down shrinks it.
+ * Values are whole pixels so the stored size stays stable across sessions.
+ */
+export function stepFloatZoom(current: number, deltaY: number): number {
+  if (!finite(current)) return FLOAT_FONT_DEFAULT
+  if (deltaY === 0) return clamp(Math.round(current), FLOAT_FONT_MIN, FLOAT_FONT_MAX)
+  const direction = deltaY < 0 ? 1 : -1
+  return clamp(Math.round(current) + direction, FLOAT_FONT_MIN, FLOAT_FONT_MAX)
+}
+
+/** Parse the persisted editor font size (fallback = the default 13px). */
+export function parseFloatFontSize(raw: string | null | undefined): number {
+  if (typeof raw !== 'string') return FLOAT_FONT_DEFAULT
+  const value = Number(raw)
+  if (!finite(value)) return FLOAT_FONT_DEFAULT
+  return clamp(Math.round(value), FLOAT_FONT_MIN, FLOAT_FONT_MAX)
+}
+
+/**
+ * Where the minimized ball may sit: fully on screen, whatever position was
+ * asked for (a ball restored on a smaller monitor must stay clickable).
+ */
+export function clampBallPosition(pos: FloatPoint, viewport: FloatViewport): FloatPoint {
+  const maxX = Math.max(0, viewport.width - FLOAT_BALL_SIZE)
+  const maxY = Math.max(0, viewport.height - FLOAT_BALL_SIZE)
+  const x = finite(pos.x) ? pos.x : 0
+  const y = finite(pos.y) ? pos.y : 0
+  return { x: Math.round(clamp(x, 0, maxX)), y: Math.round(clamp(y, 0, maxY)) }
+}
+
+/**
+ * The ball's default spot when a window is minimized: its own top-left corner,
+ * so the ball appears where the window was instead of jumping to a corner.
+ */
+export function ballFromRect(rect: FloatRect, viewport: FloatViewport): FloatPoint {
+  return clampBallPosition({ x: rect.x, y: rect.y }, viewport)
+}
+
+/**
+ * Whether a finished gesture was a CLICK rather than a drag.
+ *
+ * The minimized window is one small target with two actions on the same
+ * pointer: a press that never really moved restores the window, a real drag
+ * moves the ball. Without this distinction every move-by-3px would also
+ * restore, and every click would be a zero-distance drag.
+ */
+export function isBallClick(dx: number, dy: number): boolean {
+  return Math.abs(dx) <= FLOAT_BALL_CLICK_SLOP && Math.abs(dy) <= FLOAT_BALL_CLICK_SLOP
+}
+
+/** Parse a persisted ball position (stale geometry is clamped, garbage dropped). */
+export function parseBallPosition(raw: string | null | undefined, viewport: FloatViewport): FloatPoint | undefined {
+  if (typeof raw !== 'string' || raw.trim() === '') return undefined
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    return undefined
+  }
+  if (typeof parsed !== 'object' || parsed === null) return undefined
+  const candidate = parsed as Record<string, unknown>
+  if (!finite(candidate.x) || !finite(candidate.y)) return undefined
+  return clampBallPosition({ x: candidate.x, y: candidate.y }, viewport)
+}
+
+/** Serialize a ball position for localStorage. */
+export function serializeBallPosition(pos: FloatPoint): string {
+  return JSON.stringify({ x: pos.x, y: pos.y })
+}

package/src/client/float-tab-trigger.ts

@@ -0,0 +1,51 @@
+/**
+ * Double-click on the shell's 「远程编辑器」 tab floats the editor.
+ *
+ * That tab belongs to the host's conversation-view header, not to us: the plugin
+ * registers a VIEW into the shell's tab strip and never sees the tab row's DOM.
+ * There is no public service for "the user double-clicked my tab" either, so the
+ * only way to honour the gesture is a document-level `dblclick` listener that
+ * recognises the tab the same way `reveal.ts` does for clicks — by its label,
+ * skipping our own surfaces.
+ *
+ * Fail-safe by construction: a miss (another host build, a renamed tab, a
+ * double-click somewhere else) simply does nothing. It never prevents the
+ * default action, never throws, and does not steal double-clicks from the
+ * plugin's own UI (`.rvs-root`) or from dialogs.
+ */
+
+/** Elements that behave like the shell's view tabs. */
+const TAB_SELECTOR = 'button, [role="tab"], [role="button"]'
+
+/**
+ * Install the double-click trigger.
+ *
+ * @param label - the tab's visible label (the same localized string the view
+ *   registered with); matched against the tab's trimmed text.
+ * @param onTrigger - called once per recognised double-click.
+ * @returns disposer removing the listener.
+ */
+export function installFloatTabTrigger(label: string, onTrigger: () => void): () => void {
+  if (typeof document === 'undefined' || label === '') return () => {}
+  const handler = (event: MouseEvent): void => {
+    if (event.button !== 0) return
+    const target = event.target
+    if (!(target instanceof Element)) return
+    // Our own surfaces (editor tabs, menus, the floating window) own their
+    // double-clicks — the window's title bar uses one to maximize.
+    if (target.closest('.rvs-root') !== null) return
+    const tab = target.closest<HTMLElement>(TAB_SELECTOR)
+    if (tab === null) return
+    if ((tab.textContent ?? '').trim() !== label) return
+    // A second click while the shell is mid-transition is harmless: the action
+    // is idempotent (an already-floating editor is left alone).
+    try {
+      onTrigger()
+    } catch {
+      // Never let a listener break the shell's own double-click handling.
+    }
+  }
+  // Capture phase: the shell's tab may stop propagation on its own handlers.
+  document.addEventListener('dblclick', handler, true)
+  return () => document.removeEventListener('dblclick', handler, true)
+}

package/src/client/i18n.ts

@@ -158,6 +158,20 @@ const zh: Record<string, string> = {
   'files.deleteConfirm': '确定删除 {target} 吗？此操作在远端不可撤销。',
   'files.open': '打开',
   'files.openAsText': '以文本打开',
+  'files.openInFloat': '在悬浮编辑器中打开',
+  // -- floating editor window
+  'float.title': '悬浮编辑器',
+  'float.dragHint': '拖动标题栏移动窗口；拖动边缘缩放；双击标题栏最大化或还原',
+  'float.minimize': '最小化',
+  'float.ballHint': '点击恢复悬浮编辑器，拖动可移动',
+  'float.dockViewHint': '双击「远程编辑器」标签可浮出编辑器',
+  'float.maximize': '最大化',
+  'float.restore': '还原窗口',
+  'float.dock': '停靠回主界面',
+  'float.placeholder': '远程编辑器正在悬浮窗口中',
+  'float.placeholderHint': '编辑器只有一份实例，已浮出到窗口中央；关闭悬浮窗或点「停靠」后回到这里。',
+  'float.dockBack': '停靠回主界面',
+  'float.unavailable': '当前宿主没有全帧悬浮层（shell.overlay），悬浮编辑器不可用。',
   'files.rename': '重命名',
   'files.copy': '复制',
   'files.cut': '剪切',
@@ -496,6 +510,20 @@ const en: Record<string, string> = {
   'files.deleteConfirm': 'Delete {target}? This cannot be undone on the remote host.',
   'files.open': 'Open',
   'files.openAsText': 'Open as text',
+  'files.openInFloat': 'Open in floating editor',
+  // -- floating editor window
+  'float.title': 'Floating editor',
+  'float.dragHint': 'Drag the title bar to move; drag an edge to resize; double-click the title bar to maximize or restore',
+  'float.minimize': 'Minimize',
+  'float.ballHint': 'Click to restore the floating editor, drag to move it',
+  'float.dockViewHint': 'Double-click the "remote editor" tab to float the editor',
+  'float.maximize': 'Maximize',
+  'float.restore': 'Restore window',
+  'float.dock': 'Dock back into the main layout',
+  'float.placeholder': 'The remote editor is floating over the app',
+  'float.placeholderHint': 'There is only one editor instance and it is out in the floating window; close that window or press Dock to bring it back here.',
+  'float.dockBack': 'Dock back',
+  'float.unavailable': 'This host has no frame-wide overlay slot (shell.overlay); the floating editor is unavailable.',
   'files.rename': 'Rename',
   'files.copy': 'Copy',
   'files.cut': 'Cut',

package/src/client/index.tsx

@@ -19,13 +19,15 @@ import type {} from '@deepseek-ai/dsh-client-ui-settings/client'
 import type {} from '@deepseek-ai/dsh-client-ui-workspace/client'
 import './vsc/vsc.css'
 import { RemoteDirectoryFlow } from './DirectoryFlow.tsx'
+import { FloatingEditorWindow } from './FloatingEditorWindow.tsx'
+import { installFloatTabTrigger } from './float-tab-trigger.ts'
 import { registerNativeExplorer } from './NativeExplorer.tsx'
 import { installRemoteFileOpen } from './remote-file-open.ts'
 import { RemoteEditorView } from './RemoteEditorView.tsx'
 import { RemoteRoot } from './RemoteRoot.tsx'
 import { ChangesDock, type ChangesDockProps } from './changes/ChangesDock.tsx'
 import { SettingsHostsSection, SettingsWorkspacesSection } from './SettingsHosts.tsx'
-import { setEditorSurface } from './store.tsx'
+import { openFloatingEditor, setEditorSurface } from './store.tsx'
 import { detectLang, makeT } from './i18n.ts'
 import { setIconService, type IconServiceLike } from './vsc/kit.tsx'
 
@@ -283,4 +285,49 @@ export function apply(ctx: Context): void {
       }
     }
   }, 'dsh-remote-vs: conversation view (editor + diff)')
+  // Double-click on the shell's 「远程编辑器」 tab floats the editor. The tab row
+  // belongs to the host's header (we only contribute a view), so the gesture is
+  // recognised by label — the same lookup `reveal.ts` already uses for clicks —
+  // and a miss is a silent no-op.
+  ctx.effect(
+    () => installFloatTabTrigger(viewT('view.editor'), () => { openFloatingEditor() }),
+    'dsh-remote-vs: float on tab double-click',
+  )
+  // The floating editor window: hosted by the host's FRAME-WIDE overlay slot,
+  // which is the only seat that survives every sidebar tab and conversation
+  // view being unmounted. Registering from a narrower surface (the explorer
+  // tab, the editor view) would take the window away with that surface — and
+  // the editor's live buffer with it.
+  //
+  // The slot is looked up behind a try/catch: an older host without
+  // `shell.overlay` simply keeps the floating feature off. Availability is NOT
+  // assumed here — `FloatingEditorWindow` reports it once it really mounts, so
+  // the menu entry can never point at a window that cannot paint.
+  ctx.effect(() => {
+    let dispose: (() => void) | undefined
+    try {
+      const slots = ctx.slots as unknown as {
+        inject(slot: string, register: () => () => void): () => void
+        register(
+          options: { name: string; id: string; order: number },
+          component: () => ReactNode,
+        ): () => void
+      }
+      dispose = slots.inject('shell.overlay', () => slots.register({
+        name: 'shell.overlay',
+        id: 'remote-vs:floating-editor',
+        order: 40,
+      }, () => <FloatingEditorWindow ctx={ctx} />))
+    } catch (error) {
+      console.warn('[dsh-remote-vs] shell.overlay registration failed (floating editor unavailable):', error)
+      return () => {}
+    }
+    return () => {
+      try {
+        dispose?.()
+      } catch {
+        // Ignore.
+      }
+    }
+  }, 'dsh-remote-vs: floating editor window')
 }