dsh-remote-vs 0.8.9 → 0.9.1

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')
 }

package/src/client/live-editor.ts

@@ -0,0 +1,155 @@
+/**
+ * Handoff for the ONE live editor buffer when its mount is replaced.
+ *
+ * The plugin mounts exactly one `EditorPane` at a time (centre conversation
+ * view, sidebar fallback, or the floating window), and `CodeEditor` reads its
+ * `initial` text once on mount. So moving the editor between surfaces is
+ * effectively a remount: without a handoff the buffer typed since the last
+ * load is gone and the tab's stored text is the pre-edit one.
+ *
+ * This module is the handoff, and it is module-level for the same reason the
+ * store is: `EditorPane` is unmounted before the replacement mounts, so no
+ * React state survives the swap.
+ *
+ * Two things travel, and they are captured SEPARATELY because their costs
+ * differ by orders of magnitude:
+ *   - the buffer text (the store copies it onto the tab before the surface
+ *     flips, so the replacement mounts with it as `initial`) — materializes the
+ *     whole document, so it is taken only when the tab may differ from disk;
+ *   - scroll + caret (kept here and read back by the replacement, which is how
+ *     a tab switch already restored its position — same storage, now shared by
+ *     every surface instead of one component's `useRef`) — cheap, taken on
+ *     every switch.
+ */
+import type { CodeEditorHandle, CodeEditorViewState } from './CodeEditor.tsx'
+
+interface LiveEditorRegistration {
+  tabId: string
+  getHandle: () => CodeEditorHandle | null
+}
+
+let registration: LiveEditorRegistration | undefined
+
+/** Scroll + caret per tab id, surviving an unmount (see the header). */
+const viewStates = new Map<string, CodeEditorViewState>()
+
+/**
+ * Register the editor that is on screen right now.
+ *
+ * The caller passes a getter, not a handle: `editorRef.current` is `null`
+ * during the first render and is cleared before the parent's cleanup runs, so
+ * a snapshot taken later must read through the getter.
+ * @returns disposer; only the registration that is still current is cleared.
+ */
+export function registerLiveEditor(
+  tabId: string,
+  getHandle: () => CodeEditorHandle | null,
+): () => void {
+  const entry: LiveEditorRegistration = { tabId, getHandle }
+  registration = entry
+  return () => {
+    if (registration === entry) registration = undefined
+  }
+}
+
+/**
+ * Snapshot the live position (scroll + caret) without touching the document.
+ *
+ * Cheap, so the store can call it on EVERY switch: a surface flip remounts the
+ * very same tab, and the replacement's render happens before the old view's
+ * unmount report — the position has to be in the map before that render.
+ */
+export function captureLiveEditorPosition(): void {
+  const entry = registration
+  if (entry === undefined) return
+  const handle = entry.getHandle()
+  if (handle === null) return
+  const viewState = handle.getViewState()
+  if (viewState !== undefined) viewStates.set(entry.tabId, viewState)
+}
+
+/**
+ * Whether the live buffer differs from its disk baseline.
+ *
+ * The store uses this to skip the O(document) text copy on clean tabs (see
+ * `captureLiveBuffer`): the boolean is cheap, `getContent()` materializes the
+ * whole file as a string.
+ */
+export function isLiveEditorDirty(): boolean {
+  return registration?.getHandle()?.isDirty() === true
+}
+
+/**
+ * Copy the live buffer's text, for a switch that would otherwise lose it.
+ *
+ * Called from the store BEFORE the tab switch / surface flip: at that moment
+ * the editor is still mounted and its CodeMirror view still owns the edits.
+ * @returns undefined when no file editor is live (a diff tab, or a view that
+ *   was never the selected one) — there is nothing to carry over then.
+ */
+export function captureLiveEditorText(): { tabId: string; text: string } | undefined {
+  const entry = registration
+  if (entry === undefined) return undefined
+  const handle = entry.getHandle()
+  if (handle === null) return undefined
+  try {
+    return { tabId: entry.tabId, text: handle.getContent() }
+  } catch {
+    // A destroyed view is one race away from throwing; the switch must never
+    // be blocked by the handoff itself.
+    return undefined
+  }
+}
+
+/**
+ * Whether one tab's file editor is the one registered right now.
+ *
+ * The save path asks this before it clears a tab's dirty flag: if an editor IS
+ * mounted for that tab, the flag belongs to the live buffer and only the
+ * editor may clear it (see `markLiveEditorSaved`).
+ */
+export function isLiveEditorFor(tabId: string): boolean {
+  return registration?.tabId === tabId
+}
+
+/**
+ * Advance the registered editor's dirty baseline to the bytes a save wrote.
+ *
+ * Routed through the MODULE-LEVEL registration rather than a React ref on
+ * purpose: the pane can be remounted while the remote write is in flight (a
+ * surface flip, a dock, a tab switch), and the ref the save started with is
+ * then detached — that is exactly how a tab ended up reported clean while its
+ * live buffer was newer than the file. The registration always names the editor
+ * mounted NOW, so the correction lands on whichever instance is on screen, and
+ * it is skipped (never misapplied) when that editor shows another tab: that tab
+ * heals on its next mount from `savedText` (see `CodeEditor`).
+ * @returns true when an editor for this tab took the new baseline.
+ */
+export function markLiveEditorSaved(tabId: string, savedText: string): boolean {
+  const entry = registration
+  if (entry === undefined || entry.tabId !== tabId) return false
+  entry.getHandle()?.markSaved(savedText, tabId)
+  return true
+}
+
+/** Remember one tab's scroll + caret (reported by the editor, see EditorPane). */
+export function rememberEditorViewState(tabId: string, state: CodeEditorViewState): void {
+  viewStates.set(tabId, state)
+}
+
+/** The stored position for one tab, or undefined when it was never seen. */
+export function editorViewStateOf(tabId: string): CodeEditorViewState | undefined {
+  return viewStates.get(tabId)
+}
+
+/**
+ * Drop positions of tabs that no longer exist.
+ *
+ * The map used to live in a component with the same cleanup: without it a
+ * long session accumulated one state object per file ever opened.
+ */
+export function pruneEditorViewStates(liveIds: ReadonlySet<string>): void {
+  for (const id of [...viewStates.keys()]) {
+    if (!liveIds.has(id)) viewStates.delete(id)
+  }
+}

package/src/client/remote-file-open.ts

@@ -31,7 +31,7 @@ import {
   type ParsedFileAddress,
   type RemoteOpenBinding,
 } from './remote-file-open-target.ts'
-import { isEditorCentered, openRemoteFileInBinding, remoteOpenBindings } from './store.tsx'
+import { isEditorTakeoverActive, openRemoteFileInBinding, remoteOpenBindings } from './store.tsx'
 import { workspacePathOf } from './use-remote-chat-target.ts'
 
 interface SidebarRightLike {
@@ -216,7 +216,7 @@ export function installRemoteFileOpen(ctx: Context): () => void {
         // Cheap, synchronous gate first: only a file address of a session in
         // one of our bindings is intercepted. Everything else keeps the native
         // call (and its synchronous throw semantics) untouched.
-        if (!isEditorCentered()) return original(address, options)
+        if (!isEditorTakeoverActive()) return original(address, options)
         const parsed = parseFileAddress(address)
         if (parsed === undefined) return original(address, options)
         return interceptSync(ctx, parsed, address, options) === true ? undefined : original(address, options)