dsh-remote-vs 0.0.0-stage → 0.8.3

package/src/client/scm/stage-queue.ts

@@ -0,0 +1,264 @@
+/**
+ * Stage / unstage coordinator: instant local feedback, ONE cheap verification.
+ *
+ * The reported problem: pressing `+` on a single file in a large repository
+ * (AOSP monorepo) fired FOUR repository-wide git commands — the `git add`
+ * itself, a full `git status` (through the panel's `refreshAll` →
+ * `store.afterWrite()`), and the three extras loaders (stash list, branches,
+ * remotes) — so one click cost minutes and locked the panel behind `gitBusy`.
+ * Nothing about staging one file needs any of them.
+ *
+ * What happens instead, per click:
+ *  1. the row moves between "changes" and "staged changes" IMMEDIATELY, in the
+ *     local status model (`sink.apply`), before anything leaves the browser;
+ *  2. the real `git add` / `git restore --staged` goes out, serialized per
+ *     repository so two clicks can never reorder each other;
+ *  3. clicks landing inside one window (250 ms) coalesce into ONE path-limited
+ *     `git status -- …` probe, whose cost tracks the touched paths rather than
+ *     the repository;
+ *  4. a path the probe contradicts is put back to what the repository actually
+ *     says — and the user is told. An optimistic update may be fast; it may
+ *     never quietly lie.
+ *
+ * No React, no fetch: the git verbs and the two local effects are injected, so
+ * the whole policy is drivable by `scripts/check-scm-stage.mjs` with a stubbed
+ * port and a fake clock.
+ */
+import { parseStatusDetail } from '../../git-ops.ts'
+import { stagedStateOf } from './status-map.ts'
+
+/** The repository a stage/unstage acts on. */
+export interface ScmTarget {
+  /** Host alias. */
+  alias: string
+  /** Absolute remote repository root (git runs here). */
+  root: string
+}
+
+/** The git verbs the coordinator drives. */
+export interface StagePort {
+  /** `git add -A -- <paths>`. */
+  stage: (target: ScmTarget, paths: readonly string[]) => Promise<void>
+  /** `git restore --staged -- <paths>`. */
+  unstage: (target: ScmTarget, paths: readonly string[]) => Promise<void>
+  /** Raw `-z` stdout of the path-limited status (`probeStatusPaths`). */
+  probe: (target: ScmTarget, paths: readonly string[]) => Promise<string>
+}
+
+/** A verification outcome the user has to know about. */
+export interface StageNotice {
+  /**
+   * `mismatch`: the repository disagreed with the local move, which was then
+   * corrected. `unverified`: the check itself could not run, so the local state
+   * stands unconfirmed.
+   */
+  kind: 'mismatch' | 'unverified'
+  /** Repo-relative paths the notice is about, in click order. */
+  paths: readonly string[]
+}
+
+/** The two local effects: the status model, and the user. */
+export interface StageSink {
+  /** Move paths between the index and worktree halves of the local model. */
+  apply: (paths: readonly string[], staged: boolean) => void
+  /**
+   * Report one verification outcome.
+   *
+   * A structured notice rather than a sentence: the wording belongs to the
+   * caller (its own i18n keys, which have to be literal `t()` calls in the
+   * source for the i18n check to see them), while this module stays free of
+   * React, fetch and copy.
+   */
+  report: (notice: StageNotice) => void
+}
+
+/** Timer injection, so a check can drive the debounce deterministically. */
+export interface StageClock {
+  set: (fn: () => void, ms: number) => unknown
+  clear: (handle: unknown) => void
+}
+
+/** The debounce window: how long clicks keep merging into one probe. */
+export const DEFAULT_STAGE_WINDOW_MS = 250
+
+/** One pending click. */
+interface Job {
+  target: ScmTarget
+  paths: readonly string[]
+  staged: boolean
+  /** The real verb, already in flight (ordered per repository). */
+  write: Promise<void>
+  resolve: () => void
+  reject: (error: unknown) => void
+}
+
+/** Repository identity for grouping (alias + root, one line each). */
+function targetKey(target: ScmTarget): string {
+  return `${target.alias}\n${target.root}`
+}
+
+/**
+ * Coordinates optimistic stage/unstage with a debounced, path-limited check.
+ *
+ * One instance per client: the panel's clicks, the store's status model and the
+ * user notifications all meet here.
+ */
+export class StageCoordinator {
+  private readonly port: StagePort
+  private readonly sink: StageSink
+  private readonly clock: StageClock
+  private readonly windowMs: number
+  /** Clicks waiting for the current window to close. */
+  private pending: Job[] = []
+  private timer: unknown
+  /** Per-repository write chain: the second click waits for the first. */
+  private readonly chains = new Map<string, Promise<void>>()
+
+  constructor(
+    port: StagePort,
+    sink: StageSink,
+    options: { clock?: StageClock; windowMs?: number } = {},
+  ) {
+    this.port = port
+    this.sink = sink
+    this.clock = options.clock ?? {
+      set: (fn, ms) => setTimeout(fn, ms),
+      clear: handle => { clearTimeout(handle as ReturnType<typeof setTimeout>) },
+    }
+    this.windowMs = options.windowMs ?? DEFAULT_STAGE_WINDOW_MS
+  }
+
+  /**
+   * Stage or unstage paths: local first, real verb in flight, verification once
+   * the window closes.
+   *
+   * @param target - repository the paths belong to.
+   * @param paths - repo-relative paths (a directory row may keep its `/`).
+   * @param staged - true to stage, false to unstage.
+   * @returns a promise that settles when this click's verification is in:
+   *   rejected when the git verb itself failed (the caller reports it), and
+   *   resolved when the verb landed — whether or not the probe agreed (a
+   *   disagreement is corrected and notified here, not thrown).
+   */
+  submit(target: ScmTarget, paths: readonly string[], staged: boolean): Promise<void> {
+    if (paths.length === 0) return Promise.resolve()
+    const list = [...paths]
+    // The write is queued BEFORE the local patch so the two orders cannot
+    // invert: the chain's first link runs on a microtask, after this frame.
+    const write = this.enqueue(target, () => (staged ? this.port.stage : this.port.unstage)(target, list))
+    let resolve: () => void = () => {}
+    let reject: (error: unknown) => void = () => {}
+    const settled = new Promise<void>((done, fail) => {
+      resolve = done
+      reject = fail
+    })
+    this.sink.apply(list, staged)
+    this.pending.push({ target, paths: list, staged, write, resolve, reject })
+    this.arm()
+    return settled
+  }
+
+  /**
+   * Verify everything submitted so far with ONE path-limited probe per
+   * repository. Called by the debounce timer; exposed so a caller (or a check)
+   * can force the window closed.
+   */
+  async flush(): Promise<void> {
+    if (this.timer !== undefined) {
+      this.clock.clear(this.timer)
+      this.timer = undefined
+    }
+    const batch = this.pending
+    this.pending = []
+    if (batch.length === 0) return
+    // The probe must never run before the writes it verifies have landed: on a
+    // slow repository a `git add` can outlast the debounce window by seconds.
+    const outcomes = await Promise.all(batch.map(job => job.write.then(() => undefined, (error: unknown) => error)))
+    batch.forEach((job, index) => {
+      const error = outcomes[index]
+      if (error === undefined) return
+      // The verb never landed: put the row back and let the caller report it.
+      this.sink.apply(job.paths, !job.staged)
+      job.reject(error)
+    })
+    const landed = batch.filter((_, index) => outcomes[index] === undefined)
+    if (landed.length > 0) await this.verify(landed)
+    for (const job of landed) job.resolve()
+  }
+
+  /** Drop the pending window (page teardown; the writes already went out). */
+  dispose(): void {
+    if (this.timer !== undefined) {
+      this.clock.clear(this.timer)
+      this.timer = undefined
+    }
+  }
+
+  /** Queue one write behind the previous one for the same repository. */
+  private enqueue(target: ScmTarget, run: () => Promise<void>): Promise<void> {
+    const key = targetKey(target)
+    const previous = this.chains.get(key) ?? Promise.resolve()
+    // A failed predecessor must not skip this write, hence the same handler on
+    // both sides; the stored chain swallows the failure so the next link runs.
+    const next = previous.then(run, run)
+    this.chains.set(key, next.then(() => undefined, () => undefined))
+    return next
+  }
+
+  /** (Re)start the debounce window. */
+  private arm(): void {
+    if (this.timer !== undefined) this.clock.clear(this.timer)
+    this.timer = this.clock.set(() => {
+      this.timer = undefined
+      void this.flush()
+    }, this.windowMs)
+  }
+
+  /**
+   * One probe per repository over every path the window touched, then correct
+   * whatever it contradicts.
+   */
+  private async verify(jobs: readonly Job[]): Promise<void> {
+    interface Group {
+      target: ScmTarget
+      paths: string[]
+      /** path → the staged-ness the local model now claims (last click wins). */
+      staged: Map<string, boolean>
+    }
+    const groups = new Map<string, Group>()
+    for (const job of jobs) {
+      const key = targetKey(job.target)
+      const group = groups.get(key) ?? { target: job.target, paths: [], staged: new Map<string, boolean>() }
+      for (const path of job.paths) {
+        if (!group.paths.includes(path)) group.paths.push(path)
+        // Two clicks on one path inside the window keep the LAST intent — that
+        // is the state the ordered writes left behind.
+        group.staged.set(path, job.staged)
+      }
+      groups.set(key, group)
+    }
+
+    for (const group of groups.values()) {
+      let stdout = ''
+      try {
+        stdout = await this.port.probe(group.target, group.paths)
+      } catch {
+        // A failed probe is not a failed operation: the writes landed, so the
+        // optimistic state stands. Say so rather than silently trusting it.
+        this.sink.report({ kind: 'unverified', paths: group.paths })
+        continue
+      }
+      const detail = parseStatusDetail(stdout)
+      const wrong: string[] = []
+      for (const path of group.paths) {
+        const expected = group.staged.get(path) === true
+        if (stagedStateOf(detail, path) !== expected) wrong.push(path)
+      }
+      if (wrong.length === 0) continue
+      // Staged-ness is binary, so the opposite of the optimistic value IS what
+      // the repository reports: apply the observation, not a guess.
+      for (const path of wrong) this.sink.apply([path], !(group.staged.get(path) === true))
+      this.sink.report({ kind: 'mismatch', paths: wrong })
+    }
+  }
+}

package/src/client/scm/status-map.ts

@@ -0,0 +1,381 @@
+/**
+ * Pure status model: buckets the detailed porcelain status into the SCM
+ * sections and derives the per-path / per-directory marks the file tree
+ * paints.
+ *
+ * Directory marks come from the STATUS PATH SET, never from materialized
+ * children: the remote tree is lazy (one SFTP listing per expanded folder),
+ * so a collapsed folder holding changes must still light up. Ignored state is
+ * inherited downward, because `git status --ignored=matching` reports an
+ * ignored directory once, unexpanded.
+ */
+import type { GitPathStatus, GitStatusDetail } from '../../protocol.ts'
+
+/** One changed path as the SCM panel shows it. */
+export interface ChangeEntry {
+  path: string
+  /** Single letter (`M`, `A`, `D`, `R`, `C`, `U`, `T`, `?`). */
+  status: string
+  /** Rename/copy source. */
+  oldPath?: string
+  /** True when this entry belongs to the staged (index) half. */
+  staged: boolean
+}
+
+/** The SCM sections: conflicts, changes (unstaged + untracked), staged. */
+export interface StatusBuckets {
+  conflicts: ChangeEntry[]
+  changes: ChangeEntry[]
+  staged: ChangeEntry[]
+  untracked: ChangeEntry[]
+  ignored: string[]
+  /** Badge count: staged + unstaged + untracked (conflicts excluded). */
+  total: number
+}
+
+/** True for a merge-conflict pair (UU/AA/DD/AU/UA/DU/UD). */
+export function isConflictStatus(x: string, y: string): boolean {
+  return x === 'U' || y === 'U' || (x === 'A' && y === 'A') || (x === 'D' && y === 'D')
+}
+
+/** The spelling the rest of this module reads (exported for the row projection). */
+const isConflict = isConflictStatus
+
+/** The most descriptive letter for a path that has both halves changed. */
+function pickLetter(staged: string, unstaged: string): string {
+  const rank = (letter: string): number => {
+    switch (letter) {
+      case 'D': return 60
+      case 'M': return 50
+      case 'T': return 45
+      case 'A': return 40
+      case 'R': return 30
+      case 'C': return 20
+      default: return 10
+    }
+  }
+  if (staged === '' || staged === ' ') return unstaged
+  if (unstaged === '' || unstaged === ' ') return staged
+  return rank(unstaged) >= rank(staged) ? unstaged : staged
+}
+
+/** Bucket the detailed status into the panel's sections. */
+export function bucketStatus(detail: GitStatusDetail): StatusBuckets {
+  const conflicts: ChangeEntry[] = []
+  const changes: ChangeEntry[] = []
+  const staged: ChangeEntry[] = []
+  const untracked: ChangeEntry[] = []
+  const stagedByPath = new Map<string, string>()
+  const worktreeByPath = new Map<string, string>()
+
+  for (const entry of detail.entries) {
+    const { path, x, y, origPath } = entry
+    if (x === '?' && y === '?') {
+      const item: ChangeEntry = { path, status: '?', staged: false }
+      untracked.push(item)
+      changes.push(item)
+      continue
+    }
+    if (isConflict(x, y)) {
+      conflicts.push({ path, status: 'U', staged: false, ...(origPath === undefined ? {} : { oldPath: origPath }) })
+      continue
+    }
+    if (x !== ' ' && x !== '?') {
+      staged.push({ path, status: x, staged: true, ...(origPath === undefined ? {} : { oldPath: origPath }) })
+      stagedByPath.set(path, x)
+    }
+    if (y !== ' ' && y !== '?') {
+      changes.push({ path, status: y, staged: false, ...(origPath === undefined ? {} : { oldPath: origPath }) })
+      worktreeByPath.set(path, y)
+    }
+  }
+
+  // The panel lists changes with the worktree letter (VS Code semantics); the
+  // tree uses the same precedence so both surfaces agree.
+  const merged = changes.map(entry => {
+    const stagedLetter = stagedByPath.get(entry.path)
+    if (stagedLetter === undefined) return entry
+    return { ...entry, status: pickLetter(stagedLetter, entry.status) }
+  })
+
+  return {
+    conflicts,
+    changes: merged,
+    staged,
+    untracked,
+    ignored: detail.ignored,
+    // `untracked` is a SUBSET view of `changes` (an untracked row is pushed to
+    // both, see above), so adding it double-counted every untracked file: one
+    // untracked file made the rail badge read 2 while the list showed 1. The
+    // badge counts entries, and every entry is either staged, changed or
+    // conflicted — exactly the three sections the panel renders.
+    total: staged.length + merged.length + conflicts.length,
+  }
+}
+
+/**
+ * Whether one porcelain record counts as STAGED for the panel.
+ *
+ * Mirrors `bucketStatus` exactly, because a verification that disagreed with
+ * the list would "correct" a change the user can see was applied: an untracked
+ * record is not in the index at all, and a conflict pair lives in its own
+ * section (never in "staged changes").
+ */
+export function isStagedStatus(x: string, y: string): boolean {
+  if (x === '?' || y === '?') return false
+  if (isConflict(x, y)) return false
+  return x !== ' '
+}
+
+/**
+ * The verb one row's action button issues.
+ *
+ * The button is the OPPOSITE of the section the row sits in: a row in "staged
+ * changes" offers unstage, a row in "changes" offers stage. This exists because
+ * the two are trivially confusable — the row already KNOWS which section it is
+ * in (`isStaged`), and passing that flag straight through as the verb's target
+ * inverts the action, which is silent: the optimistic model has nothing to move
+ * (`git add` on an already-staged path, `git restore --staged` on an unstaged
+ * one), the probe agrees with the row it never changed, so the click reports
+ * neither success nor failure. That is exactly what shipped in 0.8.0 for both
+ * directions (stage was a no-op AND unstage was a no-op) while the section-level
+ * buttons, which pass a literal, stayed correct.
+ *
+ * A named verb instead of a boolean, so the call site reads as the action rather
+ * than as a state (`applyStage(paths, rowVerb(isStaged))`).
+ */
+export function rowVerb(isStaged: boolean): 'stage' | 'unstage' {
+  return isStaged ? 'unstage' : 'stage'
+}
+
+/**
+ * The staged-ness of one path in a PATH-LIMITED status probe
+ * (`git status --porcelain -z -uno -- <paths>`).
+ *
+ * The probe runs with `--untracked-files=no`, so a path that is not in the
+ * index has no record at all: absence means "not staged" (measured against
+ * real git — untracked → no record, staged → `A `/`M `).
+ *
+ * A trailing slash is an untracked DIRECTORY row (`-u normal` reports the
+ * directory once): `git add -- dir/` puts every file inside into the index and
+ * the probe then reports those files individually, never `dir/` itself — so a
+ * directory path is answered by prefix (also measured).
+ */
+export function stagedStateOf(detail: GitStatusDetail, path: string): boolean {
+  if (path.endsWith('/')) {
+    return detail.entries.some(entry => entry.path.startsWith(path) && isStagedStatus(entry.x, entry.y))
+  }
+  const hit = detail.entries.find(entry => entry.path === path || entry.origPath === path)
+  return hit === undefined ? false : isStagedStatus(hit.x, hit.y)
+}
+
+/**
+ * The local (optimistic) projection of one stage/unstage: what the detailed
+ * status looks like the moment the user clicks, before the host answers.
+ *
+ * The transform mirrors what git does to the two halves of a porcelain record
+ * (`git add` clears the worktree half, `git restore --staged` clears the index
+ * half) and was checked against real git for the cases that are not obvious:
+ *   - staging an untracked path (`??`) makes it `A `;
+ *   - unstaging a staged NEW file returns it to `??` (untracked rows are listed
+ *     under "changes", so the record stays in the model);
+ *   - unstaging a staged RENAME leaves HEAD's path deleted in the INDEX — the
+ *     old path becomes `D ` and the new one untracked (measured, not assumed);
+ *   - staging a conflict resolves it into the index.
+ *
+ * Pure, so the panel's instant feedback is assertable without a host: the
+ * caller decides WHEN to apply it (and when to apply the inverse).
+ *
+ * @param detail - the status the panel is showing.
+ * @param paths - repo-relative paths that were just staged/unstaged.
+ * @param staged - true for a stage, false for an unstage.
+ * @returns the projected status (the same object when no path matched).
+ */
+export function optimisticStageDetail(
+  detail: GitStatusDetail,
+  paths: readonly string[],
+  staged: boolean,
+): GitStatusDetail {
+  if (paths.length === 0) return detail
+  const wanted = new Set(paths)
+  const entries: GitPathStatus[] = []
+  let touched = false
+  for (const entry of detail.entries) {
+    if (!wanted.has(entry.path)) {
+      entries.push(entry)
+      continue
+    }
+    touched = true
+    entries.push(...localStageEntry(entry, staged))
+  }
+  return touched ? { ...detail, entries } : detail
+}
+
+/** One record's local projection (a rename unstaged into two records). */
+function localStageEntry(entry: GitPathStatus, staged: boolean): GitPathStatus[] {
+  const { path, x, y, origPath } = entry
+  const keep = origPath === undefined ? {} : { origPath }
+  if (staged) {
+    // The index half takes the most descriptive letter it can keep: what is
+    // already staged, else what the worktree showed, else a plain add.
+    const letter = x !== ' ' && x !== '?' ? x : (y !== ' ' && y !== '?' ? y : 'M')
+    return [{ path, x: letter, y: ' ', ...keep }]
+  }
+  // Unmerged paths: `git restore --staged` refuses them, so the local model
+  // shows nothing until the verb reports the failure.
+  if (isConflict(x, y)) return [entry]
+  // Unstage puts the index half back to HEAD. A path HEAD does not have — an
+  // addition, a rename/copy destination, an untracked row — therefore has no
+  // index entry left at all and becomes untracked again (measured against real
+  // git: unstaging a staged rename leaves the new name untracked and HEAD's old
+  // path deleted in the INDEX).
+  if (x === '?' || x === 'A' || x === 'R' || x === 'C') {
+    const out: GitPathStatus[] = [{ path, x: '?', y: '?' }]
+    if (x === 'R' && origPath !== undefined) out.push({ path: origPath, x: 'D', y: ' ' })
+    return out
+  }
+  // HEAD has the path: what is left of the record is the worktree half.
+  const worktree = y !== ' ' && y !== '?' ? y : x
+  return [{ path, x: ' ', y: worktree, ...keep }]
+}
+
+/**
+ * Add a path the detailed status does not list yet as a STAGED ADDITION.
+ *
+ * The panel can stage a file that its own status call never reported: a file
+ * inside an expanded untracked DIRECTORY (`-u normal` collapses the directory
+ * into one `dir/` row, so the file has no record of its own). Without this the
+ * row would simply vanish — staged, yet shown nowhere until the next full
+ * refresh. A path that already has a record is left alone.
+ *
+ * @param detail - the status the panel is showing.
+ * @param path - repo-relative path that was just staged.
+ * @returns the status with the added record (the same object when it is known).
+ */
+export function insertStagedEntry(detail: GitStatusDetail, path: string): GitStatusDetail {
+  if (path === '' || detail.entries.some(entry => entry.path === path || entry.origPath === path)) return detail
+  return { ...detail, entries: [...detail.entries, { path, x: 'A', y: ' ' }] }
+}
+
+/** One local stage/unstage result a full status read may not have seen. */
+export interface StageOverride {
+  staged: boolean
+  /** Monotonic sequence number of the local change. */
+  at: number
+}
+
+/**
+ * Re-apply the local stage results a FULL status read could not have seen.
+ *
+ * Skipping the repository-wide refresh after a stage is what makes the click
+ * instant, but another verb (a save, a discard, a commit) can still have a full
+ * `git status` in flight — and on a large repository that read started minutes
+ * ago. Landing it as-is would flip the row the user just staged back into
+ * "changes", i.e. the panel would contradict itself for as long as it takes to
+ * run the next full read. A read that STARTED before a local change cannot have
+ * seen it, so those paths keep the local value; a read that started after them
+ * is authoritative and prunes them.
+ *
+ * @param detail - the freshly read status.
+ * @param overrides - repo-relative path → local stage result (one repository).
+ * @param startedAt - the sequence number when the read was issued.
+ * @returns the detail with the newer local results re-applied.
+ */
+export function applyStageOverrides(
+  detail: GitStatusDetail,
+  overrides: ReadonlyMap<string, StageOverride>,
+  startedAt: number,
+): GitStatusDetail {
+  let next = detail
+  for (const [path, override] of overrides) {
+    if (override.at <= startedAt) continue
+    next = optimisticStageDetail(next, [path], override.staged)
+  }
+  return next
+}
+
+/** Per-path marks the tree paints: file letter, directory roll-up, ignored. */
+export interface TreeMarks {
+  /** Repo-relative path → single status letter (`M`, `A`, `D`, `U`, `?`). */
+  files: Map<string, string>
+  /** Repo-relative directory → `M` when any descendant changed. */
+  dirs: Map<string, string>
+  /** Repo-relative paths (files and directories) git ignores. */
+  ignored: Set<string>
+  /** Directory prefixes implied by the ignored set, for deep paths. */
+  ignoredDirs: Set<string>
+}
+
+/** Strip a trailing slash and a leading `./` so status paths match tree paths. */
+function normalize(path: string): string {
+  return path.replace(/^\.\//, '').replace(/\/+$/, '')
+}
+
+/**
+ * Build tree marks from the detailed status.
+ *
+ * `buckets` may be supplied when the caller has already bucketed the same
+ * status. The marks need the same four lists, and recomputing them meant every
+ * store publish walked the whole change list twice.
+ */
+export function buildTreeMarks(detail: GitStatusDetail, buckets: StatusBuckets = bucketStatus(detail)): TreeMarks {
+  const files = new Map<string, string>()
+  const dirs = new Map<string, string>()
+  const stagedLetters = new Map<string, string>()
+  const worktreeLetters = new Map<string, string>()
+
+  const put = (rawPath: string, letter: string): void => {
+    const path = normalize(rawPath)
+    if (path === '') return
+    // `-u normal` reports an untracked DIRECTORY as one `dir/` record: strip
+    // the slash and it becomes a directory mark, not a phantom file.
+    if (rawPath.endsWith('/')) dirs.set(path, letter === '?' ? 'M' : letter)
+    else files.set(path, letter)
+  }
+  for (const entry of buckets.staged) stagedLetters.set(normalize(entry.path), entry.status)
+  for (const entry of buckets.changes) worktreeLetters.set(normalize(entry.path), entry.status)
+  for (const entry of buckets.untracked) put(entry.path, '?')
+  for (const entry of buckets.conflicts) put(entry.path, 'U')
+
+  const all = new Set<string>([...stagedLetters.keys(), ...worktreeLetters.keys()])
+  for (const path of all) {
+    const stagedLetter = stagedLetters.get(path)
+    const worktreeLetter = worktreeLetters.get(path)
+    if (files.has(path) || dirs.has(path)) continue
+    files.set(path, stagedLetter === undefined
+      ? (worktreeLetter as string)
+      : worktreeLetter === undefined
+        ? stagedLetter
+        : pickLetter(stagedLetter, worktreeLetter))
+  }
+
+  // Every directory on the way to a changed path is itself changed.
+  const markParents = (path: string): void => {
+    const segments = path.split('/')
+    let acc = ''
+    for (let i = 0; i < segments.length - 1; i++) {
+      acc = acc === '' ? (segments[i] as string) : `${acc}/${segments[i]}`
+      if (dirs.get(acc) === 'M') continue
+      dirs.set(acc, 'M')
+    }
+  }
+  for (const path of [...files.keys()]) markParents(path)
+  for (const path of [...dirs.keys()]) markParents(path)
+
+  const ignored = new Set<string>()
+  const ignoredDirs = new Set<string>()
+  for (const raw of buckets.ignored) {
+    const path = normalize(raw)
+    if (path === '') continue
+    if (raw.endsWith('/')) ignoredDirs.add(path)
+    else ignored.add(path)
+    const segments = path.split('/')
+    let acc = ''
+    for (let i = 0; i < segments.length - 1; i++) {
+      acc = acc === '' ? (segments[i] as string) : `${acc}/${segments[i]}`
+      ignoredDirs.add(acc)
+    }
+  }
+
+  return { files, dirs, ignored, ignoredDirs }
+}