dsh-remote-vs 0.8.8 → 0.9.0

package/src/client/CodeEditor.tsx

@@ -60,7 +60,18 @@ export interface CodeEditorViewState {
 export interface CodeEditorHandle {
   getContent: () => string
   isDirty: () => boolean
-  markSaved: () => void
+  /**
+   * Advance the dirty baseline to the bytes a save just wrote to the remote
+   * file, and re-derive the dirty flag from the LIVE buffer against them.
+   *
+   * Takes the saved text explicitly because the user may have typed while the
+   * remote write was in flight: the buffer is then NEWER than the file, and
+   * declaring it saved would be the same silent-loss bug in the other
+   * direction. `tabId` guards against the pane having switched to another tab
+   * while the save awaited — marking that editor saved would corrupt ITS
+   * baseline.
+   */
+  markSaved: (savedText: string, tabId: string) => void
   /** Snapshot scroll + selection, for restoring after a remount. */
   getViewState: () => CodeEditorViewState | undefined
   /** Scroll back and put the caret where it was. */
@@ -190,6 +201,21 @@ export const CodeEditor = forwardRef<CodeEditorHandle, {
    * where a file was when its tab is re-selected.
    */
   viewState?: CodeEditorViewState
+  /**
+   * The text as it was last LOADED from / SAVED to the remote file — the dirty
+   * baseline.
+   *
+   * Separate from `initial` because a tab switch or a surface flip remounts the
+   * editor with the LIVE buffer as `initial` (that is how unsaved edits survive
+   * the remount), while the file on disk is still the older `savedText`. Using
+   * `initial` as the baseline would declare the unsaved text clean: the dirty
+   * dot and status would lie, the close guard would stop prompting and Save
+   * would disable — a silent way to lose the very edits the handoff preserved.
+   *
+   * Absent (diff panes, older callers): the mount's own document is the
+   * baseline, which is the historical behaviour.
+   */
+  savedText?: string
   onSave: () => void
   onDirty: (dirty: boolean) => void
 }>(function CodeEditor(props, ref) {
@@ -402,14 +428,23 @@ export const CodeEditor = forwardRef<CodeEditorHandle, {
   useImperativeHandle(ref, () => ({
     getContent: () => viewRef.current?.state.doc.toString() ?? savedRef.current,
     isDirty: () => dirtyRef.current,
-    markSaved: () => {
+    markSaved: (savedText, tabId) => {
       const view = viewRef.current
-      if (view !== undefined) {
-        savedRef.current = view.state.doc.toString()
-        savedDocRef.current = view.state.doc
+      if (view === undefined) return
+      // The pane may have switched tabs while the save was in flight; this
+      // editor is then a different file and must not adopt the other tab's
+      // baseline.
+      if (propsRef.current.tabId !== tabId) return
+      // The written bytes themselves: no document copy needed (this string came
+      // from the caller's own `getContent`, or from the tab's baseline).
+      savedRef.current = savedText
+      const saved = EditorState.create({ doc: savedText }).doc
+      savedDocRef.current = saved
+      const dirty = view.state.doc !== saved && !view.state.doc.eq(saved)
+      if (dirty !== dirtyRef.current) {
+        dirtyRef.current = dirty
+        propsRef.current.onDirty(dirty)
       }
-      dirtyRef.current = false
-      propsRef.current.onDirty(false)
     },
     getViewState: () => {
       const view = viewRef.current
@@ -459,6 +494,34 @@ export const CodeEditor = forwardRef<CodeEditorHandle, {
     viewRef.current?.requestMeasure()
   }, [props.visible])
 
+  /**
+   * A save that landed AFTER this editor mounted.
+   *
+   * The save path moves the tab's `baseline` (the bytes now on disk) and asks
+   * the live editor to re-derive its dirty flag. That works while the same
+   * instance is mounted, but the pane can be remounted while the remote write
+   * is in flight (a surface flip, a dock, a tab switch): the replacement
+   * derives against the baseline it saw at MOUNT, and the corrected value only
+   * arrives later as a prop. Without this effect the tab keeps the `dirty:false`
+   * the save optimistically wrote, while the buffer holds newer text — dot off,
+   * Save disabled, close guard silent. Re-derive, never touch the document.
+   */
+  useEffect(() => {
+    const view = viewRef.current
+    const savedText = props.savedText
+    if (view === undefined || savedText === undefined) return
+    const baseline = EditorState.create({ doc: savedText }).doc
+    const previous = savedDocRef.current
+    if (previous !== undefined && previous.eq(baseline)) return
+    savedDocRef.current = baseline
+    savedRef.current = savedText
+    const dirty = view.state.doc !== baseline && !view.state.doc.eq(baseline)
+    if (dirty !== dirtyRef.current) {
+      dirtyRef.current = dirty
+      propsRef.current.onDirty(dirty)
+    }
+  }, [props.savedText])
+
   // The chat gate may flip while a popup is open (session switched away):
   // never commit into a session the file no longer belongs to.
   const chatGate = props.chatEnabled === true && props.sessionId !== undefined && props.remoteRoot !== undefined
@@ -670,7 +733,31 @@ export const CodeEditor = forwardRef<CodeEditorHandle, {
     viewRef.current = view
     // Baseline for the dirty check, kept as a `Text` so comparing on a
     // keystroke does not have to materialize the document as a string.
-    savedDocRef.current = view.state.doc
+    //
+    // `savedText` (the last loaded/saved bytes) wins over the mounted document:
+    // a remount can carry the UNSAVED buffer as `initial` (see the prop's doc),
+    // and that text must never become the "clean" reference.
+    const savedText = propsRef.current.savedText
+    const baseline = savedText !== undefined
+      ? EditorState.create({ doc: savedText }).doc
+      : view.state.doc
+    savedDocRef.current = baseline
+    if (savedText !== undefined) {
+      savedRef.current = savedText
+      // Report the dirty state AT MOUNT: the buffer can already be newer than
+      // the disk bytes (a handoff remount). Waiting for the first keystroke
+      // left exactly such a file shown as clean — dot off, Save disabled,
+      // close guard silent — which is the failure this baseline exists to
+      // prevent.
+      const dirty = view.state.doc !== baseline && !view.state.doc.eq(baseline)
+      // Only a CHANGE is worth a store write: this runs on every mount, and a
+      // clean tab reporting `false` would cost every subscriber a re-render for
+      // nothing.
+      if (dirty !== dirtyRef.current) {
+        dirtyRef.current = dirty
+        propsRef.current.onDirty(dirty)
+      }
+    }
     setView(view)
     /**
      * Come back to where this file was left.

package/src/client/EditorPane.tsx

@@ -11,6 +11,7 @@ import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } fro
 import { api } from './api.ts'
 import { CodeEditor, type CodeEditorHandle, type CodeEditorViewState } from './CodeEditor.tsx'
 import { sameLocalDir } from './composer.ts'
+import { editorViewStateOf, pruneEditorViewStates, registerLiveEditor, rememberEditorViewState } from './live-editor.ts'
 import { useRemoteChatTarget } from './use-remote-chat-target.ts'
 import { useExplorer, gotoChange, markChangeStale, undoChange, type EditorTab } from './store.tsx'
 import { DiffView } from './scm/DiffView.tsx'
@@ -229,23 +230,26 @@ export function EditorPane(props: { visible: boolean }): ReactNode {
    * buffer rather than the previous file's undo stack, which is what we want,
    * but it also reset the scroll and the caret.
    *
-   * The editor REPORTS its position (see `CodeEditor`'s `onViewState`) instead
-   * of this component reading it back through `editorRef`, because the ref is
-   * already `null` by the time any cleanup here could run: React clears a
-   * child's ref before running the parent's cleanup. Both earlier attempts
-   * failed on exactly that — a `useEffect` keyed on the active tab captured the
-   * INCOMING tab's editor (always scrollTop 0), and a `useLayoutEffect` cleanup
-   * found `editorRef.current === null`. `.spike/tabswitch-check.mjs` reproduces
-   * both failures and pins the working wiring.
+   * The map lives in `live-editor.ts`, NOT in a `useRef` here, because the pane
+   * is unmounted when the editor floats out (and again when it docks back): a
+   * per-component map would lose the position on the one surface swap that
+   * most needs it. It survives there for the same reason the store does.
    *
    * Keyed by tab id alone, which is safe because only ONE `EditorPane` is ever
    * mounted: the centre surface when the host has a `conversation.view` slot,
-   * otherwise the sidebar fallback. With two live editors for the same tab the
-   * hidden one would report its untouched scrollTop 0 and overwrite the visible
-   * one's, snapping every switch back to the top — so `RemoteRoot` gates both
-   * mounts on `editorSurface` and must keep doing so.
+   * the floating window while the editor floats, otherwise the sidebar
+   * fallback. With two live editors for the same tab the hidden one would
+   * report its untouched scrollTop 0 and overwrite the visible one's, snapping
+   * every switch back to the top — so `RemoteRoot`, `RemoteEditorView` and the
+   * floating window all gate their mounts on `editorSurface` and must keep
+   * doing so.
+   *
+   * The editor REPORTS its position (see `CodeEditor`'s `onViewState`) instead
+   * of this component reading it back through `editorRef`, because the ref is
+   * already `null` by the time any cleanup here could run: React clears a
+   * child's ref before running the parent's cleanup. `.spike/tabswitch-check.mjs`
+   * reproduces the failed variants and pins the working wiring.
    */
-  const viewStates = useRef(new Map<string, CodeEditorViewState>())
   /**
    * Store a reading under the tab that produced it.
    *
@@ -261,20 +265,17 @@ export function EditorPane(props: { visible: boolean }): ReactNode {
    * accept a report for any tab.
    */
   const rememberViewState = useCallback((tabId: string, state: CodeEditorViewState): void => {
-    viewStates.current.set(tabId, state)
+    rememberEditorViewState(tabId, state)
   }, [])
 
   /**
-   * Closed tabs may not keep their scroll + caret. This map is keyed by tab id
-   * and was only ever written, and the pane is mounted for the life of the
-   * page: a session that opened a few hundred files held a state object for
-   * every one of them, long after the tab was gone.
+   * Closed tabs may not keep their scroll + caret. The map is keyed by tab id
+   * and is only ever written: a session that opened a few hundred files would
+   * otherwise hold a state object for every one of them, long after the tab is
+   * gone.
    */
   useEffect(() => {
-    const live = new Set(tabs.map(tab => tab.id))
-    for (const id of [...viewStates.current.keys()]) {
-      if (!live.has(id)) viewStates.current.delete(id)
-    }
+    pruneEditorViewStates(new Set(tabs.map(tab => tab.id)))
   }, [tabs])
 
   /**
@@ -295,6 +296,20 @@ export function EditorPane(props: { visible: boolean }): ReactNode {
     && !activeTab.loading
     && activeTab.error === undefined
 
+  /**
+   * Advertise the live editor so the store can snapshot it before a surface
+   * flip (see `captureLiveEditor`): the floating window is a different mount of
+   * the SAME pane, so switching to it unmounts this component.
+   *
+   * The getter is `() => editorRef.current`, not the handle itself: the handle
+   * only exists after `CodeEditor` mounts, and it is cleared before the
+   * cleanup that would otherwise run here.
+   */
+  useEffect(() => {
+    if (!editorMounted || activeTab === undefined) return
+    return registerLiveEditor(activeTab.id, () => editorRef.current)
+  }, [editorMounted, activeTab?.id])
+
   const saveActive = async (): Promise<void> => {
     const tab = activeTab
     if (tab === undefined) return
@@ -304,6 +319,11 @@ export function EditorPane(props: { visible: boolean }): ReactNode {
       toast(t('editor.needSource'), true)
       return
     }
+    // The store advances the disk baseline and re-derives the dirty flag on the
+    // MOUNTED editor through the module-level registration (see
+    // `markLiveEditorSaved`), so this works even when the pane is remounted
+    // while the write is in flight. Nothing is left to do here beyond handing
+    // it the live buffer.
     await store.saveTab(tab.id, text)
   }
 
@@ -474,6 +494,7 @@ export function EditorPane(props: { visible: boolean }): ReactNode {
                       key={editorKey(activeTab)}
                       ref={editorRef}
                       initial={activeTab.text}
+                      savedText={activeTab.baseline}
                       path={activeTab.fullPath}
                       tabId={activeTab.id}
                       readOnly={activeTab.truncated}
@@ -488,9 +509,9 @@ export function EditorPane(props: { visible: boolean }): ReactNode {
                       {...(activeTab.changeSet === undefined ? {} : { changeSet: activeTab.changeSet })}
                       {...(activeTab.revealHunkLine === undefined ? {} : { revealHunkLine: activeTab.revealHunkLine })}
                       {...(activeTab.revealHunkNonce === undefined ? {} : { revealHunkNonce: activeTab.revealHunkNonce })}
-                      {...(viewStates.current.get(activeTab.id) === undefined
+                      {...(editorViewStateOf(activeTab.id) === undefined
                         ? {}
-                        : { viewState: viewStates.current.get(activeTab.id) })}
+                        : { viewState: editorViewStateOf(activeTab.id) })}
                       onTokens={setTokenCount}
                       onViewState={rememberViewState}
                       onStepHunk={(dir) => { gotoChange(activeTab.id, dir) }}