@young1lin/dsh-ui-gitworkbench 0.1.4 → 0.1.6

package/src/client/files-place.ts

@@ -0,0 +1,178 @@
+/**
+ * Where the reader is in the Files tab — the file they have open, the folders
+ * they have opened, the search they typed, whether blame is on.
+ *
+ * This is separate from the browser component because the component unmounts:
+ * switching to Changes and back used to lose the selection and every expanded
+ * folder, which is the difference between a tab you return to and a tab you
+ * start over in. Keeping the place one level up means the tab remembers, and
+ * the cached path list means returning renders the tree at once instead of
+ * blanking while the repository is re-read.
+ *
+ * Expanded folders are NOT pruned against the current file list. A directory
+ * can leave `ls-tree` because a branch was checked out or a rebase is halfway
+ * through, and re-opening the same six folders every time that happens is the
+ * annoyance this module exists to remove — a stale entry renders nothing and
+ * costs one string. A file that has genuinely gone IS dropped, because an
+ * editor over a file that is not there would show an empty buffer as if the
+ * file itself were empty. That case is reported rather than silently applied:
+ * a selection that clears itself with no explanation reads as a bug.
+ *
+ * Pure: no React, no DOM, no git. `tests/files-place.test.ts` loads it.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/client/files-place
+ */
+
+import { ancestorsOf } from './file-rows.ts'
+
+/** The reader's position in the Files tab. Serialisable — no Set, no Map. */
+export interface FilesPlace {
+  /** The open file's repo-relative path, or null for none. */
+  readonly open: string | null
+  /** Paths of the directories the reader has opened. */
+  readonly expanded: readonly string[]
+  /** The search box's text. */
+  readonly query: string
+  /** Whether the blame gutter is showing. */
+  readonly blameOn: boolean
+}
+
+/** Nothing open, nothing expanded — the tab before it is first used. */
+export const NO_PLACE: FilesPlace = { open: null, expanded: [], query: '', blameOn: false }
+
+/**
+ * Open a file: it becomes the selection, and every folder above it opens so
+ * that it is visible in the tree.
+ */
+export function openAt(place: FilesPlace, path: string): FilesPlace {
+  const expanded = new Set(place.expanded)
+  for (const dir of ancestorsOf(path)) expanded.add(dir)
+  return { ...place, open: path, expanded: [...expanded] }
+}
+
+/** Fold or unfold one directory. */
+export function toggleDir(place: FilesPlace, path: string): FilesPlace {
+  const expanded = new Set(place.expanded)
+  if (expanded.has(path)) expanded.delete(path)
+  else expanded.add(path)
+  return { ...place, expanded: [...expanded] }
+}
+
+/** What a reconciliation did, so the caller can say so. */
+export interface Reconciled {
+  readonly place: FilesPlace
+  /** The path that was open and is not in the repository any more, else null. */
+  readonly vanished: string | null
+}
+
+/**
+ * Settle the place against a freshly read file list.
+ *
+ * @param place - the reader's position as it stands.
+ * @param paths - every path the repository now has. An EMPTY list is treated
+ *                as "not read yet" rather than as "the repository is empty":
+ *                the fetch is in flight for most of the time this runs, and
+ *                blanking someone's selection on an in-flight fetch would
+ *                clear it every time the tab is opened.
+ */
+export function reconcilePlace(place: FilesPlace, paths: readonly string[]): Reconciled {
+  if (place.open === null || paths.length === 0) return { place, vanished: null }
+  if (paths.includes(place.open)) return { place, vanished: null }
+  return { place: { ...place, open: null }, vanished: place.open }
+}
+
+/**
+ * One place per worktree, because a worktree IS a different place: it holds
+ * different files, at different paths, and the file the reader had open may
+ * simply not exist in the one they switched to. Sharing a single place across
+ * sources also meant the tree kept rendering the PREVIOUS worktree's files
+ * until the new list arrived.
+ *
+ * Keyed by {@link pathKey}, so the same worktree is one entry however the path
+ * reached the drawer — `git worktree list` reports forward slashes and a
+ * session cwd arrives with the platform's own.
+ */
+export type FilesPlaces = ReadonlyMap<string, FilesPlace>
+
+/** This worktree's place, or a fresh one for a worktree not visited yet. */
+export function placeAt(places: FilesPlaces, key: string): FilesPlace {
+  return places.get(key) ?? NO_PLACE
+}
+
+/**
+ * Record this worktree's place, leaving every other worktree's alone.
+ *
+ * The key is re-inserted rather than overwritten, so iteration order is
+ * least-recent first. That is what makes {@link encodePlaces}'s cap mean
+ * "the worktrees you actually work in" instead of "the first twenty you
+ * happened to open".
+ */
+export function withPlace(places: FilesPlaces, key: string, place: FilesPlace): FilesPlaces {
+  const next = new Map(places)
+  next.delete(key)
+  next.set(key, place)
+  return next
+}
+
+/** Worktrees kept across restarts. Enough for the ones anybody actually works
+ *  in; a fixture repository alone can have forty. */
+export const PLACES_CAP = 20
+
+/** One worktree's place as it is stored. */
+interface StoredPlace {
+  readonly key: string
+  readonly open: string | null
+  readonly expanded: readonly string[]
+  readonly blame: boolean
+}
+
+/**
+ * The places, ready for storage: the most recent {@link PLACES_CAP}, without
+ * the search text.
+ *
+ * The search is deliberately dropped. Restoring it would filter the tree on a
+ * cold start, and a tree showing two rows out of nine hundred reads as broken
+ * when you do not remember typing anything — within one session you remember,
+ * a week later you do not.
+ */
+export function encodePlaces(places: FilesPlaces): readonly StoredPlace[] {
+  const all = [...places.entries()]
+  const kept = all.length > PLACES_CAP ? all.slice(all.length - PLACES_CAP) : all
+  return kept.map(([key, place]) => ({
+    key,
+    open: place.open,
+    expanded: [...place.expanded],
+    blame: place.blameOn,
+  }))
+}
+
+/** Whether a parsed value is one stored place this build can use. */
+function isStoredPlace(value: unknown): value is StoredPlace {
+  if (typeof value !== 'object' || value === null) return false
+  const entry = value as Record<string, unknown>
+  return typeof entry.key === 'string'
+    && (entry.open === null || typeof entry.open === 'string')
+    && Array.isArray(entry.expanded)
+    && entry.expanded.every(path => typeof path === 'string')
+    && typeof entry.blame === 'boolean'
+}
+
+/**
+ * Read places back. Anything unrecognisable is skipped rather than failing the
+ * whole list: a build that adds a field should cost the reader one worktree's
+ * memory, not all of them.
+ */
+export function decodePlaces(value: unknown): FilesPlaces {
+  if (!Array.isArray(value)) return new Map()
+  const out = new Map<string, FilesPlace>()
+  for (const entry of value) {
+    if (!isStoredPlace(entry)) continue
+    out.set(entry.key, {
+      open: entry.open,
+      expanded: entry.expanded,
+      query: '',
+      blameOn: entry.blame,
+    })
+  }
+  return out
+}

package/src/client/glyphs.tsx

@@ -0,0 +1,86 @@
+/**
+ * The drawer's two node glyphs, shared by every view that names a file or a
+ * directory: the changes tree behind all three file tabs, the history filter's
+ * path picker, and the Files tab's repository browser. They live in their own
+ * module because the browser needs them too, and importing a value out of the
+ * panel that imports the browser would be a cycle.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/client/glyphs
+ */
+
+import type { ReactNode } from 'react'
+
+import css from './GitWorkbenchPanel.module.css'
+import { fileIcon } from './file-icon.ts'
+
+/**
+ * The two node glyphs, in IntelliJ's New UI icon idiom: a 16px grid, 1px
+ * strokes, no fill, rounded joins — outlines, where the old UI shipped filled
+ * silhouettes. Hand-drawn here rather than imported, because the bundle purity
+ * gate forbids an icon package and the drawer needs exactly these two; they
+ * are shapes in that language, not JetBrains' own assets.
+ *
+ * `strokeWidth` is 1 against a viewBox that renders 1:1 at 16px, so every
+ * stroke lands on a whole pixel instead of straddling two.
+ *
+ * Every place the drawer names a file or a directory uses these: the path
+ * picker in the history filter, and the file tree behind all three tabs. The
+ * CLASS names keep their `path` prefix — `scripts/verify_history_feature.py`
+ * selects the picker's file rows by `label:has([class*="pathFileGlyph"])`.
+ */
+export function PathDirGlyph(): ReactNode {
+  return (
+    <svg
+      className={css.pathDirGlyph}
+      width="16" height="16" viewBox="0 0 16 16"
+      fill="none" stroke="currentColor" strokeWidth="1"
+      strokeLinejoin="round" strokeLinecap="round"
+      aria-hidden="true"
+    >
+      {/* Body, with the tab stepping up over the left third. The step is a
+          full 2px: at 1.3px it read as a rounded rectangle with a nick in it
+          rather than a folder. Every straight edge sits on a .5 coordinate so
+          a 1px stroke lands on one pixel instead of straddling two. */}
+      <path d="M2.5 12.75V4.25A.75.75 0 0 1 3.25 3.5H6l1.6 2h5.15A.75.75 0 0 1 13.5 6.25v6.5a.75.75 0 0 1-.75.75H3.25a.75.75 0 0 1-.75-.75Z" />
+    </svg>
+  )
+}
+
+/**
+ * @param path - the file's path, which decides its tint and monogram. Omitted
+ *               where the caller has no path to give, and the sheet then
+ *               paints in the row's own colour as it always did.
+ */
+export function PathFileGlyph({ path }: { path?: string } = {}): ReactNode {
+  const icon = path === undefined ? null : fileIcon(path)
+  const paint = icon === null || icon.mono === '' ? undefined : icon.color
+  return (
+    <svg
+      className={css.pathFileGlyph}
+      width="16" height="16" viewBox="0 0 16 16"
+      fill="none" stroke={paint ?? 'currentColor'} strokeWidth="1"
+      strokeLinejoin="round" strokeLinecap="round"
+      aria-hidden="true"
+    >
+      {/* Sheet, cut back at the top-right for the fold. Narrower and one step
+          taller than the folder, sharing its optical band, so the two never
+          look like different-sized icons in one column. */}
+      <path d="M3.5 12.75V3.25A.75.75 0 0 1 4.25 2.5H9l3.5 3.5v6.75a.75.75 0 0 1-.75.75H4.25a.75.75 0 0 1-.75-.75Z" />
+      {/* The fold itself — the corner turned back on the sheet. */}
+      <path d="M9 2.5v2.75a.75.75 0 0 0 .75.75h2.75" />
+      {/* The language's monogram, sitting on the sheet's lower half. Stroke is
+          off for the text: a 1px stroke on a 6px glyph fills it in solid. */}
+      {paint === undefined ? null : (
+        <text
+          x="8" y={icon !== null && icon.mono.length > 1 ? 11.4 : 11.8}
+          textAnchor="middle"
+          fill={paint} stroke="none"
+          fontSize={icon !== null && icon.mono.length > 1 ? 5.5 : 7.5}
+          fontWeight="700"
+          letterSpacing={icon !== null && icon.mono.length > 1 ? -0.3 : 0}
+          fontFamily="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace"
+        >{icon?.mono}</text>
+      )}
+    </svg>
+  )
+}

package/src/client/highlight.ts

@@ -198,6 +198,31 @@ export function highlightFile(
   })
 }
 
+/**
+ * Tokenize a file that really is one — the whole of it, in one pass.
+ *
+ * {@link highlightFile} re-lexes every non-comment line ON ITS OWN because a
+ * diff reconstruction is not a real file. That costs one Shiki call per line:
+ * measured on 1000 lines, the whole-file pass is 42ms and the thousand solo
+ * passes on top of it are another 644ms. It also throws away the only pass
+ * that knows about multi-line strings, block comments and template literals.
+ *
+ * When the lines ARE a complete file — the file browser's buffer, the diff
+ * pane's editor buffer — none of that applies: the file pass is both cheaper
+ * and more accurate, so it is the whole answer.
+ *
+ * @param lines - the file's lines, complete and in order.
+ * @param lang - from {@link shikiLangOf}.
+ * @param theme - from {@link shikiThemeOf}.
+ */
+export function highlightWholeFile(
+  lines: readonly string[],
+  lang: string | undefined,
+  theme = 'github-dark-default',
+): HighlightRun[][] | undefined {
+  return tokenizeLines(lines, lang, theme)
+}
+
 function looksLikeCommentLine(text: string): boolean {
   const t = text.trimStart()
   return t.startsWith('//') || t.startsWith('/*') || t.startsWith('*') || t.startsWith('#')

package/src/client/idle-value.ts

@@ -0,0 +1,53 @@
+/**
+ * A value that lags its source until the source stops changing.
+ *
+ * Syntax highlighting is the reason this exists. Recomputing it per keystroke
+ * costs 42ms on a thousand-line file and scales linearly, so a fast typist
+ * spends the whole session behind the main thread. CodeMirror maps its
+ * existing decorations through document changes, so the colours already ride
+ * along with the text while this waits — the repaint only has to be prompt
+ * enough that the reader never notices the last few characters were plain.
+ *
+ * Not a pure function, so no unit test: it is six lines of standard React and
+ * its behaviour is a timer. The rules it implements are stated above.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/client/idle-value
+ */
+
+import { useEffect, useState } from 'react'
+
+/**
+ * @param value - the live value.
+ * @param ms - how long the value must hold still before it is adopted.
+ * @returns the last value that stayed put for `ms`.
+ */
+export function useIdleValue<T>(value: T, ms: number): T {
+  const [held, setHeld] = useState(value)
+  useEffect(() => {
+    if (Object.is(held, value)) return
+    const timer = setTimeout(() => { setHeld(value) }, ms)
+    return () => { clearTimeout(timer) }
+  }, [value, ms, held])
+  return held
+}
+
+/** How long typing must pause before the highlight is recomputed. Long enough
+ *  that a burst of typing costs one repaint, short enough that the pause after
+ *  a word is already over by the time the eye gets back to the line. */
+export const HIGHLIGHT_IDLE_MS = 180
+
+/**
+ * Lines past which a file is shown uncoloured.
+ *
+ * Shiki costs about 0.3ms a line, and that is the whole-file pass alone — the
+ * floor, not an implementation detail we can tune away. Measured: 155ms at 500
+ * lines, 620ms at 2000, 1537ms at 5000. Debouncing keeps a burst of typing to
+ * one repaint, but it cannot make one repaint cheap, and a 1.5-second freeze
+ * every time the reader pauses is worse than plain text.
+ *
+ * So above this the file renders without colour and says so. The honest fix is
+ * to highlight only the viewport, which needs the tokens to be computed where
+ * the scroll position is known rather than in the pane; this cap is what holds
+ * until then.
+ */
+export const HIGHLIGHT_LINE_CAP = 2_000

package/src/client/image-view.ts

@@ -0,0 +1,106 @@
+/**
+ * The image preview's rules: when to ask the host for bytes, how to turn the
+ * answer into something an `<img>` can point at, and how to caption it.
+ *
+ * The gate here is deliberately weaker than the host's. The host decides what
+ * an image IS, by reading the signature; this only decides what is worth
+ * ASKING about, and getting that wrong costs a wasted round trip rather than a
+ * wrong render. So the extension is allowed to be the hint — in the one
+ * direction where a hint cannot hurt.
+ *
+ * Pure: no React, no DOM beyond the base64 decoder every browser and every
+ * supported node ship. `tests/image-view.test.ts` loads it directly.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/client/image-view
+ */
+
+/**
+ * Extensions worth one round trip.
+ *
+ * Exactly the formats the host's sniffer admits, because a name the sniffer
+ * would refuse anyway is a request with a known answer. Absent on purpose:
+ * `.tif` and `.heic` are images that browsers will not draw, so asking would
+ * end in "could not decode" where "binary file" is the more honest reply.
+ */
+const IMAGE_EXTS: ReadonlySet<string> = new Set([
+  'png', 'jpg', 'jpeg', 'jpe', 'gif', 'webp', 'bmp', 'dib', 'ico', 'cur', 'avif', 'svg',
+])
+
+/** Does this path's name suggest an image? A hint, never a verdict. */
+export function looksLikeImagePath(path: string): boolean {
+  const name = (path.split('/').pop() ?? '').toLowerCase()
+  const dot = name.lastIndexOf('.')
+  if (dot <= 0) return false
+  return IMAGE_EXTS.has(name.slice(dot + 1))
+}
+
+/**
+ * Should the view ask the host for image bytes, given what the text side said?
+ *
+ * Two different reasons, so two different rules:
+ *
+ *   - `binary` is asked about unconditionally. It is the case that matters —
+ *     the text path has already given up, so the round trip either produces a
+ *     picture or reproduces the same dead end. An extensionless PNG is found
+ *     here and nowhere else.
+ *   - `tooLarge` is asked about only when the NAME agrees, because the text
+ *     guard cuts at a smaller size than the image cap and a large file that is
+ *     not an image is usually a large file of text. Asking anyway would have
+ *     the host read a multi-megabyte log to conclude what its name already
+ *     said.
+ */
+export function shouldAskForImage(
+  path: string,
+  sides: { readonly binary: boolean; readonly tooLarge: boolean },
+): boolean {
+  if (sides.binary) return true
+  return sides.tooLarge && looksLikeImagePath(path)
+}
+
+/** base64 to bytes, for the Blob the `<img>` points at. */
+export function decodeBase64(base64: string): Uint8Array<ArrayBuffer> {
+  const binary = atob(base64)
+  // Backed by an explicit ArrayBuffer rather than the default: a Blob part
+  // must not be a view over a SharedArrayBuffer, and the default type is the
+  // union of both.
+  const out = new Uint8Array(new ArrayBuffer(binary.length))
+  for (let i = 0; i < binary.length; i += 1) out[i] = binary.charCodeAt(i)
+  return out
+}
+
+/**
+ * A byte count as a reader reads it.
+ *
+ * 1024-based with KB/MB labels — the convention every editor and browser
+ * devtools uses, so the number agrees with the one the reader would see
+ * anywhere else for the same file.
+ */
+export function formatBytes(bytes: number): string {
+  if (!Number.isFinite(bytes) || bytes < 0) return ''
+  if (bytes < 1024) return `${bytes} B`
+  const kb = bytes / 1024
+  if (kb < 1024) return `${kb < 10 ? kb.toFixed(1) : Math.round(kb)} KB`
+  const mb = kb / 1024
+  return `${mb < 10 ? mb.toFixed(1) : Math.round(mb)} MB`
+}
+
+/**
+ * The line under the picture: what it is, how big it is on screen, how big it
+ * is on disk.
+ *
+ * Dimensions are omitted rather than guessed when the browser reports none —
+ * an SVG with no intrinsic size is the ordinary case, and `0 × 0` under a
+ * picture that is plainly there reads as a bug.
+ */
+export function imageCaption(
+  kind: string,
+  bytes: number,
+  size: { readonly width: number; readonly height: number } | null,
+): string {
+  const parts: string[] = []
+  if (kind.length > 0) parts.push(kind)
+  if (size !== null && size.width > 0 && size.height > 0) parts.push(`${size.width} × ${size.height}`)
+  const weight = formatBytes(bytes)
+  if (weight.length > 0) parts.push(weight)
+  return parts.join(' · ')
+}

package/src/client/indent.ts

@@ -0,0 +1,74 @@
+/**
+ * The indentation unit a file uses, learned from the file itself.
+ *
+ * The editor's Tab key is CodeMirror's `indentWithTab`, which inserts and
+ * removes whatever `indentUnit` is configured with — so the only decision left
+ * is what that unit should be, and it is not a setting. This pane saves WHOLE
+ * files: indenting with two spaces inside a four-space project writes
+ * whitespace the project's own formatter will fight, and shows up in the next
+ * diff as a change to lines nobody edited.
+ *
+ * So the unit is detected: a tab-indented Go file gets a tab, four-space Java
+ * gets four.
+ *
+ * Pure: no React, no DOM, no git. `tests/indent.test.ts` loads it directly.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/client/indent
+ */
+
+/** Fallback unit for a file with no indentation to learn from. */
+export const DEFAULT_INDENT = '  '
+
+/**
+ * The file's own indentation unit, learned from its lines.
+ *
+ * Tabs win on count, because a single tab-indented line is unambiguous while
+ * spaces need a step to be inferred. For spaces the step is the most common
+ * NON-ZERO difference between the indents of consecutive lines — the same
+ * reasoning editors use, and the reason a file whose every line happens to sit
+ * at four spaces still reports four rather than its total depth.
+ *
+ * @param text - the whole buffer.
+ * @returns the unit to insert: a tab, N spaces, or {@link DEFAULT_INDENT}.
+ */
+export function detectIndent(text: string): string {
+  const lines = text.split('\n')
+  let tabs = 0
+  let spaced = 0
+  const widths: number[] = []
+  for (const line of lines) {
+    if (line.trim().length === 0) continue
+    if (line.startsWith('\t')) { tabs += 1; continue }
+    const width = line.length - line.trimStart().length
+    if (width > 0) spaced += 1
+    widths.push(width)
+  }
+  if (tabs > spaced) return '\t'
+
+  // The unit divides every level the file uses, so it is the GCD of the
+  // indents themselves — not the most common step between consecutive lines.
+  // A Java file with a text block indents its body by two levels at once, and
+  // counting steps makes that 8 the winner in a file indented by 4; 12 is not
+  // a multiple of 8, so a GCD cannot make that mistake.
+  //
+  // Widths seen only ONCE are set aside first: a single continuation line
+  // aligned under an open paren is at an arbitrary column, and one of those
+  // would drag the GCD down to 1. If nothing repeats there is no majority to
+  // protect, so the second pass reads them all.
+  const seen = new Map<number, number>()
+  for (const width of widths) {
+    if (width > 0) seen.set(width, (seen.get(width) ?? 0) + 1)
+  }
+  const repeated = [...seen].filter(([, count]) => count > 1).map(([width]) => width)
+  const unit = gcdOf(repeated.length > 0 ? repeated : [...seen.keys()])
+  return unit === 0 ? DEFAULT_INDENT : ' '.repeat(unit)
+}
+
+/** GCD of a list, 0 for an empty one. */
+function gcdOf(values: readonly number[]): number {
+  return values.reduce((a, b) => gcd(a, b), 0)
+}
+
+function gcd(a: number, b: number): number {
+  return b === 0 ? a : gcd(b, a % b)
+}

package/src/client/index.ts

@@ -19,8 +19,9 @@ import type {} from '@deepseek-ai/dsh-client-runtime' // informational inject ed
 import type {} from '@deepseek-ai/dsh-client-ui-slots' // SlotMap is reused, not extended
 import {
   GitWorkbenchPanel,
-  type DiscardPreview, type GitCommit, type GitOpName, type GitOpPayload, type GitOpResult,
+  type DiscardAnswer, type DiscardPreview, type GitCommit, type GitOpName, type GitOpPayload, type GitOpResult,
   type WorkbenchStats, type SyncStatus, type WorktreeStatus,
+  type BlameAnswer, type FileImage, type FileSides, type SideLayer, type WriteResult,
 } from './GitWorkbenchPanel.tsx'
 import type { StyleEntry, StyleScope, StyleSettings } from './themes.ts'
 import type { LogFilter } from '../log-filter.ts'
@@ -92,6 +93,64 @@ export function apply(ctx: ClientContext): void {
           ) as { ok: true; value: WorkbenchStats } | { ok: false; error: { message?: string } }
           return result.ok ? result.value : null
         },
+        // One layer of one file for the side-by-side diff pane: that layer's
+        // full-context diff, the right-hand text, and the shas block mutations
+        // will check against. Null (an older host half, a failed call) makes
+        // the pane fall back to the unified view rather than go blank.
+        fetchFileSides: async (worktreePath: string | undefined, path: string, layer: SideLayer, signal: AbortSignal): Promise<FileSides | null> => {
+          const result = await connection.rpc.call(
+            '/api',
+            'gitWorkbench/fileSides',
+            { args: { worktreePath: worktreePath ?? '', path, layer } },
+            signal,
+          ) as { ok: true; value: FileSides } | { ok: false; error: { message?: string } }
+          return result.ok ? result.value : null
+        },
+        // One file's blame for the side pane's gutter. Read-only, so a
+        // failure is simply no gutter: null makes the toggle report that
+        // blame is unavailable rather than leaving an empty column that
+        // looks like the file has no history.
+        fetchBlame: async (worktreePath: string | undefined, path: string, signal: AbortSignal): Promise<BlameAnswer | null> => {
+          const result = await connection.rpc.call(
+            '/api',
+            'gitWorkbench/blame',
+            { args: { worktreePath: worktreePath ?? '', path } },
+            signal,
+          ) as { ok: true; value: BlameAnswer } | { ok: false; error: { message?: string } }
+          return result.ok ? result.value : null
+        },
+        // One file's bytes, when the host's signature check confirms they are
+        // an image. Asked only for a file the text side has already declined,
+        // so null — an older host half with no such method, a failed call —
+        // simply leaves that decline standing.
+        fetchFileImage: async (worktreePath: string | undefined, path: string, signal: AbortSignal): Promise<FileImage | null> => {
+          const result = await connection.rpc.call(
+            '/api',
+            'gitWorkbench/fileImage',
+            { args: { worktreePath: worktreePath ?? '', path } },
+            signal,
+          ) as { ok: true; value: FileImage } | { ok: false; error: { message?: string } }
+          return result.ok ? result.value : null
+        },
+        // Save the side pane's editor buffer. The buffer travels with the blob
+        // sha it was opened with and the host re-derives that sha at the moment
+        // of the write, so a file that moved underneath the editor comes back
+        // `failure: 'stale'` with NOTHING written — null (transport failure, or
+        // a host half older than this client) reads as a failed save the same
+        // way every write op here folds its transport errors.
+        writeChecked: async (worktreePath: string | undefined, path: string, text: string, expectedSha: string, signal: AbortSignal): Promise<WriteResult | null> => {
+          try {
+            const result = await connection.rpc.call(
+              '/api',
+              'gitWorkbench/writeChecked',
+              { args: { worktreePath: worktreePath ?? '', path, text, expectedSha } },
+              signal,
+            ) as { ok: true; value: WriteResult } | { ok: false; error: { message?: string } }
+            return result.ok ? result.value : null
+          } catch {
+            return null
+          }
+        },
         // One page of the commit log past what `stats` bundles, so the history
         // list can grow instead of stopping at the first page. The filter is
         // compiled into git log arguments host-side (IDEA-style pushdown).
@@ -211,14 +270,22 @@ export function apply(ctx: ClientContext): void {
         // is the difference between "goes back to its committed content" and
         // "leaves the disk and cannot come back" — which is the entire question
         // the dialog exists to ask.
-        fetchDiscardPlan: async (worktreePath: string | undefined, path: string, signal: AbortSignal): Promise<DiscardPreview | null> => {
-          const result = await connection.rpc.call(
-            '/api',
-            'gitWorkbench/discardPlan',
-            { args: { worktreePath: worktreePath ?? '', path } },
-            signal,
-          ) as { ok: true; value: DiscardPreview } | { ok: false; error: { message?: string } }
-          return result.ok ? result.value : null
+        fetchDiscardPlan: async (worktreePath: string | undefined, path: string, signal: AbortSignal): Promise<DiscardAnswer> => {
+          // A throw here used to be nobody's: the click had already put the
+          // drawer into "asking the host", and an unhandled rejection left it
+          // there with no dialog and no way back except closing the drawer.
+          try {
+            const result = await connection.rpc.call(
+              '/api',
+              'gitWorkbench/discardPlan',
+              { args: { worktreePath: worktreePath ?? '', path } },
+              signal,
+            ) as { ok: boolean; value?: DiscardPreview; error?: { message?: string } }
+            if (result.ok && result.value !== undefined) return { kind: 'plan', plan: result.value }
+            return { kind: 'failed', error: result.error?.message ?? '' }
+          } catch (error) {
+            return { kind: 'failed', error: error instanceof Error ? error.message : String(error) }
+          }
         },
         runGitOp: async (op: GitOpName, worktreePath: string | undefined, payload: GitOpPayload, signal: AbortSignal): Promise<GitOpResult> => {
           const result = await connection.rpc.call(