dsh-remote-vs 0.8.6 → 0.8.8

package/lib/index.js

@@ -1,4 +1,4 @@
-import { a as pushPipeline, c as require_lib, d as ensurePrivateDir, f as keysDir, i as probe, l as aliasRoot, o as seedHelperCache, p as storePath, r as helperAvailability, s as RemoteFiles, t as RemoteWorlds, u as dshHome } from "./worlds-C6W225o9.js";
+import { a as pushPipeline, c as require_lib, d as ensurePrivateDir, f as keysDir, i as probe, l as aliasRoot, o as seedHelperCache, p as storePath, r as helperAvailability, s as RemoteFiles, t as RemoteWorlds, u as dshHome } from "./worlds-DnzpX3Hv.js";
 import z from "@deepseek-ai/schemastery";
 import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, statSync, writeSync } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";

package/lib/p2-router-fs.js

@@ -1,4 +1,4 @@
-import { l as aliasRoot, n as isWindowsAbsolute } from "./worlds-C6W225o9.js";
+import { l as aliasRoot, n as isWindowsAbsolute } from "./worlds-DnzpX3Hv.js";
 import { FileSystem, FsError } from "@deepseek-ai/dsh-fs";
 //#region src/p2/router-fs.ts
 /**

package/lib/types/client/scm/diff-model.d.ts

@@ -26,4 +26,34 @@ export declare function diffCounts(model: DiffModel): {
     added: number;
     removed: number;
 };
+/**
+ * Where a prev/next jump lands, as an index into the ordered hunk list.
+ *
+ * Wraps at both ends (the last change's "next" is the first change, and the
+ * first one's "previous" is the last), because a diff toolbar button that does
+ * nothing at the end reads as broken. `cursor < 0` means "nothing jumped yet":
+ * the first `next` lands on the first hunk and the first `previous` on the last.
+ *
+ * Pure, so `scripts/check-diff-ui.mjs` can pin the wrapping without a browser.
+ *
+ * @param count - how many hunks the model has (0 → -1, i.e. nothing to jump to).
+ * @param cursor - the hunk the toolbar currently reports, or -1.
+ * @param direction - 1 for "next change", -1 for "previous change".
+ * @returns the hunk index to scroll to, or -1 when the model has no hunks.
+ */
+export declare function stepHunk(count: number, cursor: number, direction: 1 | -1): number;
+/**
+ * The hunk the viewport is sitting in, derived from the top visible row.
+ *
+ * "Sitting in" = the last change whose first row is at or ABOVE the top row, so
+ * scrolling into the middle of a change keeps reporting that change (and
+ * scrolling above the first one reports -1). This is what keeps the toolbar's
+ * `n / N` honest when the user scrolls by hand instead of using the buttons —
+ * the jump math alone would report the last button press, not the screen.
+ *
+ * @param startRows - first row index of each hunk, ASCENDING.
+ * @param topRow - the row index at the top of the viewport (may be fractional).
+ * @returns the hunk index, or -1 when the viewport is above the first hunk.
+ */
+export declare function hunkAtRow(startRows: readonly number[], topRow: number): number;
 export {};

package/lib/types/client/vsc/kit.d.ts

@@ -18,6 +18,8 @@ type IconProps = {
 };
 export declare function IconChevronRight(props: IconProps): ReactNode;
 export declare function IconChevronDown(props: IconProps): ReactNode;
+/** Mirror of `IconChevronDown`, for the diff's "previous change" button. */
+export declare function IconChevronUp(props: IconProps): ReactNode;
 export declare function IconFolder(props: IconProps & {
     open?: boolean;
 }): ReactNode;

package/lib/types/workspace-title.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The title one remote binding gets in DSH's own workspace sidebar.
+ *
+ * The sidebar (and the session grouping under it) is rendered by the shell from
+ * the workspace REGISTRY, so this string is the only label the user ever sees
+ * there. It used to be built from the remote PATH's last segment, which threw
+ * away the one name the user had chosen: a workspace created as
+ * "P710_userdebug" showed up as `… > P710`, and two bindings that differ only
+ * deeper down (`…/userdebug/P710` and `…/userdebug/P710_fac`) became
+ * indistinguishable.
+ *
+ * The alias stays in front: it is what tells two hosts apart, and the part after
+ * it is what takes the workspace name.
+ *
+ * DISPLAY ONLY. The registry resolves a workspace by its canonical PATH
+ * (`resolveByPath`) and its own documentation says the title is "used only when
+ * a new record is created" and that different paths may share one — so a title
+ * never decides routing, and none of the plugin's routing reads it.
+ *
+ * Pure and dependency-free, so `scripts/check-diff-ui.mjs` can pin it without a
+ * host (the host half imports cordis and cannot load outside DSH).
+ */
+/**
+ * The title this binding SHOULD have: `alias > workspace name`.
+ *
+ * @param binding - alias, the name the user typed, and the remote path.
+ * @returns `alias > name`, falling back to the path's last segment when no name
+ *   was given (bindings created before names existed, or an empty field).
+ */
+export declare function workspaceTitle(binding: {
+    alias: string;
+    name?: string;
+    remotePath: string;
+}): string;
+/**
+ * The title the OLD code produced: `alias > <last path segment>`, name ignored.
+ *
+ * Kept so an existing registration can be retitled ONLY when its current title
+ * is still exactly this. That is what keeps the upgrade from ever touching a
+ * title the user renamed by hand in the shell's workspace settings.
+ *
+ * @param binding - alias and remote path; the name is deliberately unused.
+ */
+export declare function legacyWorkspaceTitle(binding: {
+    alias: string;
+    remotePath: string;
+}): string;

package/lib/{worlds-C6W225o9.js → worlds-DnzpX3Hv.js}

@@ -18233,6 +18233,61 @@ var RpcConnection = class {
 	}
 };
 //#endregion
+//#region src/workspace-title.ts
+/**
+* The title one remote binding gets in DSH's own workspace sidebar.
+*
+* The sidebar (and the session grouping under it) is rendered by the shell from
+* the workspace REGISTRY, so this string is the only label the user ever sees
+* there. It used to be built from the remote PATH's last segment, which threw
+* away the one name the user had chosen: a workspace created as
+* "P710_userdebug" showed up as `… > P710`, and two bindings that differ only
+* deeper down (`…/userdebug/P710` and `…/userdebug/P710_fac`) became
+* indistinguishable.
+*
+* The alias stays in front: it is what tells two hosts apart, and the part after
+* it is what takes the workspace name.
+*
+* DISPLAY ONLY. The registry resolves a workspace by its canonical PATH
+* (`resolveByPath`) and its own documentation says the title is "used only when
+* a new record is created" and that different paths may share one — so a title
+* never decides routing, and none of the plugin's routing reads it.
+*
+* Pure and dependency-free, so `scripts/check-diff-ui.mjs` can pin it without a
+* host (the host half imports cordis and cannot load outside DSH).
+*/
+/** Last path segment of an absolute remote path ('' when the path is `/`). */
+function pathBase(remotePath) {
+	return remotePath.split("/").filter((part) => part !== "").pop() ?? remotePath;
+}
+/** The alias part of a title, with a readable fallback. */
+function aliasOf(alias) {
+	return alias.trim() === "" ? "remote" : alias.trim();
+}
+/**
+* The title this binding SHOULD have: `alias > workspace name`.
+*
+* @param binding - alias, the name the user typed, and the remote path.
+* @returns `alias > name`, falling back to the path's last segment when no name
+*   was given (bindings created before names existed, or an empty field).
+*/
+function workspaceTitle(binding) {
+	const named = (binding.name ?? "").trim();
+	return `${aliasOf(binding.alias)} > ${named !== "" ? named : pathBase(binding.remotePath)}`;
+}
+/**
+* The title the OLD code produced: `alias > <last path segment>`, name ignored.
+*
+* Kept so an existing registration can be retitled ONLY when its current title
+* is still exactly this. That is what keeps the upgrade from ever touching a
+* title the user renamed by hand in the shell's workspace settings.
+*
+* @param binding - alias and remote path; the name is deliberately unused.
+*/
+function legacyWorkspaceTitle(binding) {
+	return `${aliasOf(binding.alias)} > ${pathBase(binding.remotePath)}`;
+}
+//#endregion
 //#region src/p2/worlds.ts
 /**
 * Remote worlds: alias registry, tombstones, cwd-keyed routing decisions,
@@ -18522,9 +18577,13 @@ var RemoteWorlds = class {
 			}
 			if (registry === void 0) continue;
 			try {
-				if (await registry.resolveByPath(aliasPath) !== void 0) continue;
-				const base = binding.remotePath.split("/").filter(Boolean).pop() ?? binding.remotePath;
-				await registry.create(aliasPath, `${binding.alias} > ${base}`);
+				const existing = await registry.resolveByPath(aliasPath);
+				const desired = workspaceTitle(binding);
+				if (existing !== void 0) {
+					if (desired !== existing.title && existing.title === legacyWorkspaceTitle(binding) && typeof existing.setTitle === "function") await existing.setTitle(desired);
+					continue;
+				}
+				await registry.create(aliasPath, desired);
 			} catch (error) {
 				try {
 					this.ctx.logger.warn(`[remote-vs] workspace registration failed for ${aliasPath}: ${error instanceof Error ? error.message : String(error)}`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-remote-vs",
   "description": "VSCode-style remote development for DSH: SSH host manager (key/password), helper deploy pipeline with version check, remote file explorer + editor + terminal in dsh-better-sidebar.",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "icon": "icon.svg",
   "keywords": [
     "dsh",

package/src/client/SearchView.tsx

@@ -20,7 +20,7 @@ import {
   type ContentHit,
 } from '../search-ops.ts'
 import { searchFiles, type SearchHit } from './scm/actions.ts'
-import { repoRelative, useExplorer } from './store.tsx'
+import { useExplorer } from './store.tsx'
 import { api } from './api.ts'
 import {
   FileIcon,
@@ -77,7 +77,7 @@ function relativeTo(root: string, full: string): string {
 
 export function SearchView(): ReactNode {
   const store = useExplorer()
-  const { t, alias, root, repoRoot } = store
+  const { t, alias, root } = store
   const [mode, setModeState] = useState<Mode>(readMode)
   const [query, setQuery] = useState('')
   /** Absolute remote directory the search runs in ('' = workspace root). */
@@ -209,17 +209,19 @@ export function SearchView(): ReactNode {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [request?.id])
 
+  /**
+   * A hit ALWAYS opens the file.
+   *
+   * It used to open the diff instead whenever the file had a status mark, which
+   * is wrong for a search result: the user is looking for the file, not for its
+   * change, and for a path the index knows nothing about (untracked, or a mark
+   * that belongs to another repository root) that "diff" rendered EMPTY — the
+   * panel called it "no differences" and there was no way to see the content,
+   * not even by double-clicking. The diff has its own entry points (the source
+   * control panel and the change review dock).
+   */
   const openHit = (path: string, line?: number): void => {
-    if (line === undefined) {
-      const rel = repoRelative(repoRoot, path)
-      if (rel !== '' && store.marks.files.has(rel)) {
-        store.openDiff(rel, false, store.marks.files.get(rel) === '?')
-        return
-      }
-      store.openFile(path)
-      return
-    }
-    store.openFile(path, { line })
+    store.openFile(path, line === undefined ? undefined : { line })
   }
 
   const groups = useMemo(() => groupHits(contentHits), [contentHits])

package/src/client/i18n.ts

@@ -297,6 +297,10 @@ const zh: Record<string, string> = {
   'scm.afterEditable': '变更后（可编辑）',
   'scm.stagedReadonly': '已暂存（只读）',
   'scm.reloadDiff': '重新载入差异',
+  'scm.hScrollHint': '有比窗口更宽的行 —— 拖动这里左右滚动（或按住 Shift 滚滚轮）',
+  'scm.prevHunk': '上一处改动',
+  'scm.nextHunk': '下一处改动',
+  'scm.hunkNavHint': '在改动之间跳转（显示第 n 处 / 共 N 处）',
   'scm.stageHunk': '暂存该块',
   'scm.unstageHunk': '取消暂存该块',
   'scm.revertHunk': '还原该块',
@@ -629,6 +633,10 @@ const en: Record<string, string> = {
   'scm.afterEditable': 'After (editable)',
   'scm.stagedReadonly': 'staged (read-only)',
   'scm.reloadDiff': 'Reload diff',
+  'scm.hScrollHint': 'A line is wider than the view — drag here to scroll sideways (or hold Shift and wheel)',
+  'scm.prevHunk': 'Previous change',
+  'scm.nextHunk': 'Next change',
+  'scm.hunkNavHint': 'Jump between changes (shows change n of N)',
   'scm.stageHunk': 'Stage this hunk',
   'scm.unstageHunk': 'Unstage this hunk',
   'scm.revertHunk': 'Revert this hunk',

package/src/client/scm/DiffView.tsx

@@ -20,7 +20,7 @@ import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, typ
 import type { EditorTab } from '../store.tsx'
 import { useExplorer } from '../store.tsx'
 import { applyHunk, GitOpError } from './actions.ts'
-import { diffCounts } from './diff-model.ts'
+import { diffCounts, hunkAtRow, stepHunk } from './diff-model.ts'
 import type { DiffRow } from '../../protocol.ts'
 import { api } from '../api.ts'
 import { CodeEditor, type CodeEditorHandle } from '../CodeEditor.tsx'
@@ -29,6 +29,8 @@ import { useRemoteChatTarget } from '../use-remote-chat-target.ts'
 import { langFromPath, tokenizeDocument, type Token } from '../vsc/tokenize.ts'
 import {
   IconButton,
+  IconChevronDown,
+  IconChevronUp,
   IconRefresh,
   IconSave,
   MiniSpinner,
@@ -225,19 +227,24 @@ function Line(props: { tokens: Token[]; empty?: boolean }): ReactNode {
 
 /**
  * The top horizontal scrollbar: a scroll container whose only content is a
- * spacer as wide as the widest pane. Dragging it drives both panes, so the
- * user never has to scroll to the bottom of a file to reach a long line's
- * horizontal bar.
+ * spacer as wide as the widest line. Dragging it drives both panes, so a long
+ * line can be reached without scrolling to the bottom of the file first.
+ *
+ * Rendered only when a line really is wider than the grid (see `hscroll`), and
+ * styled tall enough to see and grab: as a permanently mounted 13 px band with
+ * a `thin`, low-contrast thumb it read as "there is no horizontal scrollbar".
  */
 function HScrollBar(props: {
   barRef: React.RefObject<HTMLDivElement>
   width: number
+  hint: string
   onScroll: (left: number) => void
 }): ReactNode {
   return (
     <div
       className="rvs-hbar"
       ref={props.barRef}
+      title={props.hint}
       onScroll={(e) => props.onScroll(e.currentTarget.scrollLeft)}
     >
       <div className="rvs-hbar-inner" style={{ width: props.width }} />
@@ -265,20 +272,68 @@ export function DiffView(props: { tab: EditorTab; visible: boolean }): ReactNode
   const leftRef = useRef<HTMLDivElement>(null)
   const rightRef = useRef<HTMLDivElement>(null)
   const hbarRef = useRef<HTMLDivElement>(null)
-  const [barWidth, setBarWidth] = useState(0)
+  const gridRef = useRef<HTMLDivElement | null>(null)
+  /**
+   * Widest rendered line vs the width the grid actually shows.
+   *
+   * Only the PAIR matters: the top bar exists for one reason — telling the user
+   * "this line continues past the edge, grab me" — so it is rendered only when
+   * `content > viewport`. A permanently mounted 13 px band was invisible in
+   * practice (a 1 px spacer, `thin` scrollbar, low-contrast thumb) and read as
+   * "there is no horizontal scrollbar at all".
+   */
+  const [hscroll, setHscroll] = useState({ content: 0, viewport: 0 })
   const rowsInView = useRowWindow(tab.model?.rows ?? [])
 
+  /** First row of every change, ascending — the prev/next jump targets. */
+  const hunkRows = useMemo(() => (tab.model === undefined ? [] : tab.model.hunks.map(hunk => hunk.startRow).sort((a, b) => a - b)), [tab.model])
   /**
-   * Measure the widest pane and size the top bar's spacer to it. Runs after
-   * every model change, on container resizes (a pane that is empty until
-   * its fonts settle would otherwise leave the bar too short) and whenever
-   * the window slides, since the widest line on screen changes with it.
+   * The change the toolbar's `n / N` reports.
+   *
+   * A jump sets it explicitly instead of re-deriving it from `scrollTop`: near
+   * the bottom of a file the browser CLAMPS the offset, so re-deriving would
+   * report the change above the one the button just went to and the next click
+   * would refuse to advance. A manual scroll does re-derive it (`hunkAtRow`),
+   * which is what keeps the counter honest when the user drags instead of
+   * clicking. `-1` = nothing jumped yet / the viewport is above the first
+   * change.
+   */
+  const [hunkCursor, setHunkCursor] = useState(-1)
+  /** The `scrollTop` a jump just wrote, so its own scroll event is not read as a manual scroll. */
+  const jumpedTopRef = useRef(-1)
+
+  /** Scroll to the next (1) or previous (-1) change, wrapping at both ends. */
+  const jumpHunk = (direction: 1 | -1): void => {
+    const grid = gridRef.current
+    if (grid === null) return
+    const target = stepHunk(hunkRows.length, hunkCursor, direction)
+    if (target < 0) return
+    const top = (hunkRows[target] as number) * ROW_HEIGHT
+    jumpedTopRef.current = top
+    grid.scrollTop = top
+    setHunkCursor(target)
+  }
+
+  /** Keep `n / N` in step with the viewport while the user scrolls by hand. */
+  const syncHunkCursor = (grid: HTMLDivElement): void => {
+    if (hunkRows.length === 0) return
+    if (Math.abs(grid.scrollTop - jumpedTopRef.current) < 1) return
+    const next = hunkAtRow(hunkRows, grid.scrollTop / ROW_HEIGHT)
+    setHunkCursor(previous => (previous === next ? previous : next))
+  }
+
+  /**
+   * Measure the widest pane and the grid's own width. Runs after every model
+   * change, on container resizes (a pane that is empty until its fonts settle
+   * would otherwise leave the bar too short) and whenever the window slides,
+   * since the widest line on screen changes with it.
    */
   useLayoutEffect(() => {
     if (mode !== 'split') return
     const measure = (): void => {
-      const widest = Math.max(leftRef.current?.scrollWidth ?? 0, rightRef.current?.scrollWidth ?? 0)
-      setBarWidth(widest)
+      const content = Math.max(leftRef.current?.scrollWidth ?? 0, rightRef.current?.scrollWidth ?? 0)
+      const viewport = gridRef.current?.clientWidth ?? 0
+      setHscroll(previous => (previous.content === content && previous.viewport === viewport ? previous : { content, viewport }))
     }
     measure()
     const timer = window.setTimeout(measure, 80)
@@ -419,6 +474,19 @@ export function DiffView(props: { tab: EditorTab; visible: boolean }): ReactNode
         <span style={{ color: 'var(--rvs-git-d)' }}>-{counts.removed}</span>
         {tab.staged && <span className="rvs-pill">{t('scm.stagedReadonly')}</span>}
         <span className="rvs-einfo-spacer" />
+        {/* Prev/next change: only the split view is windowed, so only it has a
+            row offset to jump to. The counter doubles as the "where am I" cue. */}
+        {mode === 'split' && hunkRows.length > 0 && (
+          <span className="rvs-hunknav" title={t('scm.hunkNavHint')}>
+            <IconButton title={t('scm.prevHunk')} onClick={() => jumpHunk(-1)}>
+              <IconChevronUp size={13} />
+            </IconButton>
+            <span className="rvs-hunknav-pos">{hunkCursor < 0 ? `-/${hunkRows.length}` : `${hunkCursor + 1}/${hunkRows.length}`}</span>
+            <IconButton title={t('scm.nextHunk')} onClick={() => jumpHunk(1)}>
+              <IconChevronDown size={13} />
+            </IconButton>
+          </span>
+        )}
         {busy && <MiniSpinner />}
         <IconButton title={t('scm.reloadDiff')} onClick={() => { void reload() }} disabled={busy}>
           <IconRefresh size={13} />
@@ -431,10 +499,24 @@ export function DiffView(props: { tab: EditorTab; visible: boolean }): ReactNode
       </div>
       {mode === 'split' && (
         <>
-          <HScrollBar barRef={hbarRef} width={barWidth} onScroll={syncFromBar} />
+          {hscroll.content > hscroll.viewport + 1 && (
+            <HScrollBar barRef={hbarRef} width={hscroll.content} hint={t('scm.hScrollHint')} onScroll={syncFromBar} />
+          )}
           {/* The grid owns the vertical scroll for all three columns, so the
               window below is shared and the panes cannot drift apart. */}
-          <div className="rvs-diff-grid" ref={rowsInView.attachGrid} onScroll={rowsInView.onScroll}>
+          <div
+            className="rvs-diff-grid"
+            ref={(element) => {
+              // Two consumers, one element: the row window's observer and the
+              // horizontal measurement above.
+              rowsInView.attachGrid(element)
+              gridRef.current = element
+            }}
+            onScroll={(event) => {
+              rowsInView.onScroll(event)
+              syncHunkCursor(event.currentTarget)
+            }}
+          >
             <div className="rvs-diff-cols">
               {/* Left pane: fixed 50% (see .rvs-diff-col) with its own hidden
                   horizontal scroll, driven from the bar above. */}

package/src/client/scm/diff-model.ts

@@ -204,3 +204,47 @@ export function diffCounts(model: DiffModel): { added: number; removed: number }
   }
   return { added, removed }
 }
+
+/**
+ * Where a prev/next jump lands, as an index into the ordered hunk list.
+ *
+ * Wraps at both ends (the last change's "next" is the first change, and the
+ * first one's "previous" is the last), because a diff toolbar button that does
+ * nothing at the end reads as broken. `cursor < 0` means "nothing jumped yet":
+ * the first `next` lands on the first hunk and the first `previous` on the last.
+ *
+ * Pure, so `scripts/check-diff-ui.mjs` can pin the wrapping without a browser.
+ *
+ * @param count - how many hunks the model has (0 → -1, i.e. nothing to jump to).
+ * @param cursor - the hunk the toolbar currently reports, or -1.
+ * @param direction - 1 for "next change", -1 for "previous change".
+ * @returns the hunk index to scroll to, or -1 when the model has no hunks.
+ */
+export function stepHunk(count: number, cursor: number, direction: 1 | -1): number {
+  if (count <= 0) return -1
+  if (cursor < 0 || cursor >= count) return direction === 1 ? 0 : count - 1
+  return (cursor + direction + count) % count
+}
+
+/**
+ * The hunk the viewport is sitting in, derived from the top visible row.
+ *
+ * "Sitting in" = the last change whose first row is at or ABOVE the top row, so
+ * scrolling into the middle of a change keeps reporting that change (and
+ * scrolling above the first one reports -1). This is what keeps the toolbar's
+ * `n / N` honest when the user scrolls by hand instead of using the buttons —
+ * the jump math alone would report the last button press, not the screen.
+ *
+ * @param startRows - first row index of each hunk, ASCENDING.
+ * @param topRow - the row index at the top of the viewport (may be fractional).
+ * @returns the hunk index, or -1 when the viewport is above the first hunk.
+ */
+export function hunkAtRow(startRows: readonly number[], topRow: number): number {
+  let found = -1
+  for (let index = 0; index < startRows.length; index += 1) {
+    const start = startRows[index] as number
+    if (start > topRow) break
+    found = index
+  }
+  return found
+}

package/src/client/vsc/kit.tsx

@@ -55,6 +55,11 @@ export function IconChevronDown(props: IconProps): ReactNode {
   return svg(props.size ?? 14, <path d="M3.5 6 L8 10.5 L12.5 6" />, props.className)
 }
 
+/** Mirror of `IconChevronDown`, for the diff's "previous change" button. */
+export function IconChevronUp(props: IconProps): ReactNode {
+  return svg(props.size ?? 14, <path d="M3.5 10 L8 5.5 L12.5 10" />, props.className)
+}
+
 export function IconFolder(props: IconProps & { open?: boolean }): ReactNode {
   return props.open === true
     ? svg(props.size ?? 16, <path d="M1.8 12.6V4.2a1 1 0 0 1 1-1h3l1.4 1.6h6a1 1 0 0 1 1 1v1H2.6l1 5.8a1 1 0 0 0 1 .8h7.6" />, props.className)

package/src/client/vsc/vsc.css

@@ -1073,6 +1073,29 @@ body[data-ds-dark-theme] .rvs-root {
   color: var(--rvs-fg3);
 }
 
+/**
+ * Prev/next change, in the toolbar's free space.
+ *
+ * Two chevrons around a tabular counter: the pair then reads as "jump to change
+ * n of N" instead of two anonymous arrows, and the counter doubles as the "where
+ * am I" cue while scrolling by hand.
+ */
+.rvs-hunknav {
+  display: inline-flex;
+  align-items: center;
+  gap: 1px;
+  margin-right: 2px;
+}
+
+.rvs-hunknav-pos {
+  min-width: 30px;
+  text-align: center;
+  font-size: 11px;
+  font-variant-numeric: tabular-nums;
+  color: var(--rvs-fg3);
+  user-select: none;
+}
+
 .rvs-seg {
   display: inline-flex;
   border: 1px solid var(--rvs-border2);
@@ -1118,15 +1141,19 @@ body[data-ds-dark-theme] .rvs-root {
  * The two panes scroll horizontally on their own — so a long line can never
  * widen the layout — and this proxy bar drives both of them from the TOP of
  * the view, instead of forcing a scroll to the bottom of the file to reach a
- * horizontal bar. Its inner spacer is sized to the widest pane.
+ * horizontal bar. Its inner spacer is sized to the widest line, and the
+ * component only renders it when a line really is wider than the grid.
+ *
+ * Sized and coloured to be SEEN: as a 13 px band with `scrollbar-width: thin`
+ * and a faint thumb, it read as "there is no horizontal scrollbar at all".
  */
 .rvs-hbar {
   flex: none;
-  height: 13px;
+  height: 15px;
   overflow-x: auto;
   overflow-y: hidden;
   border-bottom: 1px solid var(--rvs-border);
-  scrollbar-width: thin;
+  background: var(--rvs-hover);
 }
 
 .rvs-hbar-inner {
@@ -1134,16 +1161,19 @@ body[data-ds-dark-theme] .rvs-root {
 }
 
 .rvs-hbar::-webkit-scrollbar {
-  height: 9px;
+  height: 11px;
 }
 
 .rvs-hbar::-webkit-scrollbar-thumb {
-  background: var(--dsw-alias-scrollbar-bg-l2, rgba(127, 127, 127, .45));
-  border-radius: 5px;
+  background: var(--dsw-alias-scrollbar-bg-l2, rgba(150, 160, 180, .75));
+  border-radius: 6px;
+  border: 2px solid transparent;
+  background-clip: padding-box;
 }
 
 .rvs-hbar::-webkit-scrollbar-thumb:hover {
-  background: var(--dsw-alias-scrollbar-hover-l2, rgba(127, 127, 127, .65));
+  background: var(--dsw-alias-scrollbar-hover-l2, rgba(170, 180, 200, .95));
+  background-clip: padding-box;
 }
 
 .rvs-hbar::-webkit-scrollbar-track {
@@ -1159,8 +1189,10 @@ body[data-ds-dark-theme] .rvs-root {
 /**
  * One diff pane. `flex: 1 1 0` keeps the panes EXACTLY equal however long a
  * line is (the previous row markup let a long line widen its own pane, which
- * is what broke the symmetry), and each pane carries its own horizontal
- * scroll — hidden, because the top bar is the user-facing control.
+ * is what broke the symmetry). Each pane keeps its own horizontal scroll, and
+ * its scrollbar is now VISIBLE: the top proxy remains the convenient control,
+ * but the pane's own bar is what a user reaches for first, and it sits right
+ * under the content when the file is shorter than the view.
  */
 .rvs-diff-col {
   flex: 1 1 0;
@@ -1170,10 +1202,23 @@ body[data-ds-dark-theme] .rvs-root {
 }
 
 .rvs-diff-col::-webkit-scrollbar {
-  height: 0;
+  height: 9px;
   width: 0;
 }
 
+.rvs-diff-col::-webkit-scrollbar-thumb {
+  background: var(--dsw-alias-scrollbar-bg-l2, rgba(150, 160, 180, .6));
+  border-radius: 5px;
+}
+
+.rvs-diff-col::-webkit-scrollbar-thumb:hover {
+  background: var(--dsw-alias-scrollbar-hover-l2, rgba(170, 180, 200, .85));
+}
+
+.rvs-diff-col::-webkit-scrollbar-track {
+  background: transparent;
+}
+
 .rvs-dline {
   display: flex;
   align-items: flex-start;

package/src/p2/worlds.ts

@@ -23,6 +23,7 @@ import { aliasRoot } from '../paths.ts'
 import type { RemoteHostEntry, RemoteWorkspaceBinding } from '../protocol.ts'
 import { RpcConnection } from './helper-rpc.ts'
 import { SshProcRuntime } from './ssh-proc.ts'
+import { legacyWorkspaceTitle, workspaceTitle } from '../workspace-title.ts'
 
 export type RoutingMode = 'off' | 'shadow' | 'enforce'
 
@@ -395,10 +396,23 @@ export class RemoteWorlds {
       }
       if (registry === undefined) continue
       try {
-        const existing = await registry.resolveByPath(aliasPath)
-        if (existing !== undefined) continue
-        const base = binding.remotePath.split('/').filter(Boolean).pop() ?? binding.remotePath
-        await registry.create(aliasPath, `${binding.alias} > ${base}`)
+        const existing = await registry.resolveByPath(aliasPath) as
+          | { title?: string; setTitle?: (title: string) => Promise<unknown> }
+          | undefined
+        const desired = workspaceTitle(binding)
+        if (existing !== undefined) {
+          // DISPLAY ONLY: the registry resolves workspaces by canonical PATH
+          // (`resolveByPath`) and its own docs call the title "used only when a
+          // new record is created", so nothing here can move a route. The
+          // retitle is additionally gated on the current title still being
+          // EXACTLY what the old code produced (`alias > <last path segment>`),
+          // so a title the user renamed by hand is never overwritten.
+          if (desired !== existing.title && existing.title === legacyWorkspaceTitle(binding) && typeof existing.setTitle === 'function') {
+            await existing.setTitle(desired)
+          }
+          continue
+        }
+        await registry.create(aliasPath, desired)
       } catch (error) {
         try {
           this.ctx.logger.warn(`[remote-vs] workspace registration failed for ${aliasPath}: ${error instanceof Error ? error.message : String(error)}`)