zidane-ui 9.0.4 → 9.1.3

package/src/git/headless/labels.ts

@@ -1,230 +0,0 @@
-/**
- * The git components' strings (the desktop app's wording). One flat
- * dictionary an app overrides with `<LabelsProvider>` or the `labels` prop of
- * `GitProvider`. Keys you leave out keep the default English label.
- */
-import type { GitPullRequest } from './host';
-
-type Checks = NonNullable<GitPullRequest['checks']>;
-
-const CHECKS: Record<Checks, string> = { pass: 'passing', fail: 'failing', pending: 'running' };
-
-const plural = (n: number, one: string) => `${n} ${one}${n === 1 ? '' : 's'}`;
-
-/** The default English strings of the git components. */
-export const DEFAULT_GIT_LABELS = {
-  /** A host call the host cannot make here. */
-  gitUnavailable: 'Not available here.',
-
-  // The git bar
-  gitBranchButton: (branch: string) => `Branch ${branch}`,
-  gitBranchDetached: (commit: string) => `Detached at ${commit}`,
-  gitBranchSwitch: 'Switch branch',
-  gitBranchSwitchLater: 'Branches switch once the agent is done',
-  gitPrTooltip: (pr: { number: number; title: string; draft: boolean }) =>
-    `${pr.draft ? 'Draft: ' : ''}${pr.title || `Pull request #${pr.number}`}`,
-  gitPrDraft: 'draft',
-  gitChangesTooltip: 'Uncommitted changes. Open in Diffs',
-  gitFilesUnit: (count: number) => (count === 1 ? ' file' : ' files'),
-
-  // Sync (the ahead / behind chip)
-  gitAhead: (count: number) => `${count} ahead`,
-  gitBehind: (count: number) => `${count} behind`,
-  gitSyncing: 'Syncing…',
-  gitPublishing: 'Publishing…',
-  gitToPush: (count: number) => `${count} to push`,
-  gitToPull: (count: number) => `${count} to pull`,
-  gitCommitsAhead: (count: number, base: string | null) => `${plural(count, 'commit')} ahead of ${base}`,
-  gitCommitsBehind: (count: number) => `${plural(count, 'commit')} behind`,
-  gitUpToDate: (upstream: string) => `Up to date with ${upstream}`,
-  gitSyncLater: 'Sync once the agent is done',
-  gitPublishLater: 'Publish once the agent is done',
-  gitSyncWith: (upstream: string | null) => `Sync with ${upstream}`,
-  gitPublishTo: (remote: string | null) => `Publish to ${remote}`,
-  gitFactsThen: (facts: string, action: string) => `${facts}. ${action}`,
-  gitPublishSummary: (branch: string, ahead: number, remote: string | null) =>
-    `Push ${branch}${ahead > 0 ? ` and its ${plural(ahead, 'commit')}` : ''} to ${remote}, and keep them in sync from now on.`,
-  gitSyncSummary: (behind: number, ahead: number, upstream: string) =>
-    behind > 0 && ahead > 0
-      ? `Pull ${plural(behind, 'commit')} from ${upstream} and push ${plural(ahead, 'commit')}.`
-      : behind > 0
-        ? `Pull ${plural(behind, 'commit')} from ${upstream}.`
-        : ahead > 0
-          ? `Push ${plural(ahead, 'commit')} to ${upstream}.`
-          : `Bring in anything new on ${upstream}.`,
-  gitSyncKeepsChanges: ' Your uncommitted changes stay as they are.',
-  gitPublishBranch: (branch: string) => `Publish ${branch}`,
-  gitPublishDialog: 'Publish branch',
-  gitSyncDialog: 'Sync branch',
-  gitDontAskAgain: "Don't ask again",
-  gitSyncCancel: 'Cancel',
-  gitPublish: 'Publish',
-  gitSync: 'Sync',
-
-  // Import repository
-  gitImportTitle: 'Import repository',
-  gitImportHintBefore: 'Paste a GitHub or git URL, or ',
-  gitImportHintCode: 'owner/repo',
-  gitImportHintAfter: '.',
-  gitImportField: 'Repository',
-  gitImportPlaceholder: 'https://github.com/owner/repo',
-  gitImportInvalid: 'Not a repository URL.',
-  gitImportPreview: (label: string, branch: string | undefined, destination: string) =>
-    `${label}${branch ? ` @ ${branch}` : ''} → ${destination}`,
-  gitImportInto: 'Clone into',
-  gitImportChange: 'Change…',
-  gitImportConnecting: 'Connecting…',
-  gitImportProgress: (phase: string, percent: number) => `${phase} ${percent}%`,
-  gitImportStop: 'Stop',
-  gitImportCancel: 'Cancel',
-  gitImportCloning: 'Cloning…',
-  gitImportClone: 'Clone',
-  gitImportStars: (stars: number) => `${stars.toLocaleString('en-US')} star${stars === 1 ? '' : 's'}`,
-  gitImportViewOnGithub: 'View on GitHub',
-  gitImportPrivate: 'Private',
-  gitImportArchived: 'Archived',
-
-  // The branch menu
-  gitMenuLabel: 'Switch branch or pull request',
-  gitSearchPlaceholder: 'Search pull requests and branches…',
-  gitSearchLabel: 'Search pull requests and branches',
-  gitListLabel: 'Pull requests and branches',
-  gitSectionReview: 'Waiting on you',
-  gitSectionMine: 'Yours',
-  gitSectionOther: 'Other pull requests',
-  gitSectionBranches: 'Branches',
-  gitSectionPullRequests: 'Pull requests',
-  gitMore: (count: number) => `${count} more`,
-  gitMoreSearchHint: 'search for the rest',
-  gitSearching: 'Searching open pull requests…',
-  gitNoGh: 'To see pull requests, install the GitHub CLI (gh) and sign in.',
-  gitRateLimited: (clock: string) => `GitHub rate limit, back at ${clock}.`,
-  gitLoadingBranches: 'Loading branches…',
-  gitNoMatches: 'No matches',
-  gitCheckedOutElsewhere: (branch: string, worktree: string) => `${branch} is checked out in ${worktree}`,
-  gitOpenWorktreeChat: 'Open its chat',
-  gitRowSwitching: 'switching',
-  gitRowCurrent: 'current',
-  gitChecksText: (checks: Checks) => CHECKS[checks],
-  gitChecksLabel: (checks: Checks) => `Checks ${CHECKS[checks]}`,
-  gitApproved: 'approved',
-  gitChangesRequested: 'changes',
-  gitAuthorLabel: (author: string) => `By ${author}`,
-  gitBranchChipLabel: (branch: string) => `Branch ${branch}`,
-  /** A pull request's age chip: "Updated 5m ago", but "Updated now" and "Updated Mar 4" (only a duration takes "ago"). */
-  gitUpdatedAge: (age: string, duration: boolean) => (duration ? `Updated ${age} ago` : `Updated ${age}`),
-  /** A branch's age chip, the same way. */
-  gitLastCommitAge: (age: string, duration: boolean) => (duration ? `Last commit ${age} ago` : `Last commit ${age}`),
-  gitDraft: 'draft',
-  gitFork: 'fork',
-  gitLocal: 'local',
-  gitLocalLabel: 'Branch is local',
-  gitDefaultBranch: 'default',
-  gitDriftLabel: (ahead: number, behind: number) => `${ahead} ahead, ${behind} behind the default branch`,
-  gitOpenOnGitHub: 'Open on GitHub',
-  gitOpenPullRequest: (number: number) => `Open #${number} on GitHub`,
-  gitCopyBranch: 'Copy branch name',
-  gitStartBranchLabel: (name: string) => `Start branch ${name}`,
-  gitStartWorktreeLabel: (name: string) => `Start ${name} as a worktree`,
-  gitStartBranch: 'Start branch',
-  gitStartAsWorktree: 'Start as worktree',
-  gitMovesThisChat: 'moves this chat',
-  gitFromHere: 'from here, changes kept',
-  gitStartWorktree: 'Start a worktree…',
-  gitWorktreeBranchPlaceholder: 'branch name',
-  gitWorktreeBranchLabel: 'New worktree branch',
-  gitStartingWorktree: 'starting worktree',
-  gitStartTheWorktree: 'Start the worktree',
-
-  // Move to… (another environment of the session's host)
-  gitMoveTitle: 'Move this session',
-  gitMoveWhere: 'Where should it run?',
-  gitMoveLoading: 'Loading where it can run…',
-  gitMoveNone: 'There is nowhere else to move it.',
-  gitMoveOffline: 'offline',
-  gitMoveCurrent: 'now',
-  gitMovePickFolder: (name: string) => `Pick a folder on ${name}.`,
-  gitMoveFolder: 'Folder',
-  gitMoveKeepFolder: 'Same folder',
-  gitMoveChangeFolder: 'Change…',
-  gitMoveBranch: 'Branch',
-  gitMoveConfirm: (name: string) => `Move to ${name}?`,
-  gitMoveConfirmDetail:
-    'Files are not copied. Its background tasks and terminals stop. The agent is told and keeps its history.',
-  gitMoveSubmit: 'Move',
-  gitMoveMoving: 'Moving…',
-  gitMoveBack: 'Back',
-  gitMoveCancel: 'Cancel',
-  gitMoveRemoveWorktree: 'Remove the old worktree if it has no uncommitted changes',
-  gitMoveMainCheckout: 'Main checkout',
-  gitMoveWorktreeKept: (reason: string | undefined) => `The session moved. ${reason ?? 'The old worktree was kept.'}`,
-  gitMoveDone: 'Done',
-
-  // The where picker
-  gitWhereLabel: 'Choose where the session runs',
-  gitWhereTitle: (place: string, isolation: string | undefined, branch: string | undefined) =>
-    `Runs on ${place}${isolation ? `, ${isolation.toLowerCase()}` : ''}${branch ? ` (${branch})` : ''}`,
-  gitRunsOn: 'Runs on',
-  gitRunsOnHelpLabel: 'What Runs on means',
-  gitRunsOnLocal: 'This computer',
-  gitRunsOnLocalFact: 'Stops when the app quits.',
-  gitRunsOnServer: 'Server',
-  gitRunsOnServerFact: 'Keeps running when you close the app.',
-  gitRunsOnMachine: 'Shared machine',
-  gitRunsOnMachineFact: 'Agent here. Files and commands there.',
-  gitHostLocalDescription: 'Agent runs on your computer',
-  gitHostServerDescription: 'Agent runs on the server, even when closed',
-  gitMachineStatus: (status: string) => status,
-  gitMachineDescription: (name: string) => `Agent here, files and commands on ${name}`,
-  gitMachineOffline: (name: string) => `${name} is offline.`,
-  gitIsolation: 'Isolation',
-  gitIsolationDefault: 'default',
-  gitWorktreeShort: 'Worktree',
-  gitBranch: 'Branch',
-  gitBranchPlaceholder: 'Branch name',
-  gitBranchHint: 'Empty uses the suggested name.',
-  gitEnvironmentSettings: 'Environment settings…',
-
-  // The remote folder picker
-  gitFolderPickerLabel: (host: string) => `Choose a folder on ${host}`,
-  gitFolderTitle: (folder: string, host: string) => `${folder} on ${host}`,
-  gitFolderDefaultTitle: (host: string) => `The first workspace root on ${host}`,
-  gitFolderDefault: 'Default folder',
-  gitFolderBackToRoots: 'Back to the workspace roots',
-  gitFolderReading: 'Reading folders…',
-  gitFolderRoots: 'Workspace roots',
-  gitFolderEmpty: 'No folders here.',
-  gitFolderUse: (name: string) => `Use ${name}`,
-  gitFolderFilter: 'Filter or type a path',
-  gitFolderPathLabel: 'Folder path',
-  gitFolderFilterLabel: 'Filter the folders, or type a path to open it',
-  gitFolderOpenPath: (path: string) => `Open ${path}`,
-  gitFolderNoMatch: 'No folder here matches.',
-  gitFolderSearchDeeper: (query: string) => `Search "${query}" in all folders below`,
-  gitFolderSearching: 'Searching…',
-  gitFolderSearchResults: 'Found below',
-  gitFolderSearchNone: 'No folder below matches.',
-  gitFolderSearchTruncated: 'More folders match. Type more of the name.',
-  gitFolderNew: 'New folder',
-  gitFolderNewName: 'Folder name',
-  gitFolderNewNameLabel: (parent: string) => `Name of the new folder in ${parent}`,
-  gitFolderCreating: 'Creating…',
-  gitFolderCreate: 'Create',
-  gitFolderCancel: 'Cancel',
-};
-
-/** The shape of the git label dictionary. */
-export type GitLabels = typeof DEFAULT_GIT_LABELS;
-
-/**
- * A host error in words: the host's own message, or {@link DEFAULT_GIT_LABELS.gitUnavailable}.
- *
- * @param error - The host's error.
- * @param labels - The labels in effect.
- */
-export function gitErrorText(
-  error: { code: 'unavailable' } | { code: 'failed'; message: string },
-  labels: Pick<GitLabels, 'gitUnavailable'>,
-): string {
-  return error.code === 'failed' ? error.message : labels.gitUnavailable;
-}

package/src/git/headless/move.ts

@@ -1,101 +0,0 @@
-/**
- * Moving a session to another environment of its host ("Move to…"): which
- * kinds it can go to, whether it needs a folder picked there, and what the
- * confirmation names. The dialog (`MoveSessionDialog`) renders this.
- */
-import type { EnvironmentDescriptor } from 'zidane/chat';
-import { parseMachineKind } from 'zidane/chat/pure';
-
-import { withMachines } from './environment';
-
-/** The session being moved. */
-export interface MoveSessionSubject {
-  /** The session's key. */
-  sessionId: string;
-  /** Its folder (`''` for a chat without one). */
-  cwd: string;
-  /** The saved server it is on; absent: this computer. */
-  hostId?: string;
-  /** Its environment kind now; absent: `local`. */
-  kind?: string;
-  /** It has turns: the move is confirmed first (the agent keeps its history). Default: `true`. */
-  hasTurns?: boolean;
-}
-
-/**
- * The subject of a move, from a session row (a sidebar row, the header's session).
- *
- * @param session - The session's key, folder, host, environment and turn count (absent: it has turns).
- */
-export function moveSubject(session: {
-  id: string;
-  cwd?: string;
-  hostId?: string;
-  environment?: { kind: string };
-  turnCount?: number;
-}): MoveSessionSubject {
-  return {
-    sessionId: session.id,
-    cwd: session.cwd ?? '',
-    ...(session.hostId ? { hostId: session.hostId } : {}),
-    ...(session.environment ? { kind: session.environment.kind } : {}),
-    ...(session.turnCount !== undefined ? { hasTurns: session.turnCount > 0 } : {}),
-  };
-}
-
-/** One kind a session can move to. */
-export interface MoveChoice {
-  /** The descriptor the host listed. */
-  descriptor: EnvironmentDescriptor;
-  /** What the menu and the confirmation call it: the machine's name for a machine's kind, else the kind's label. */
-  name: string;
-  /** It can be picked now. */
-  pickable: boolean;
-  /** Why it cannot (an offline machine, an unavailable kind). */
-  reason?: string;
-  /** A folder must be picked on the target: a machine's kind, or the session's folder is on a machine. */
-  needsFolder: boolean;
-}
-
-/**
- * The kinds a session can move to, this host's first, then each machine's. Disabled kinds never show; an offline
- * machine's kinds and unavailable kinds show, not pickable, with the reason.
- *
- * @param descriptors - The kinds the session's host lists.
- * @param subject - The session.
- */
-export function moveChoices(descriptors: readonly EnvironmentDescriptor[], subject: MoveSessionSubject): MoveChoice[] {
-  const fromMachine = parseMachineKind(subject.kind ?? 'local') !== null;
-  return withMachines(descriptors)
-    .filter((descriptor) => descriptor.enabled)
-    .map((descriptor) => {
-      const machine = descriptor.machine;
-      return {
-        descriptor,
-        name: machine ? machine.name : descriptor.label,
-        pickable: descriptor.available,
-        ...(descriptor.available || !descriptor.reason ? {} : { reason: descriptor.reason }),
-        needsFolder: machine !== undefined || fromMachine || !subject.cwd,
-      };
-    });
-}
-
-/**
- * The session runs in a worktree (`worktree`, `worktree@<machine>`): any move leaves it, and the move can remove it.
- *
- * @param subject - The session.
- */
-export function leavesWorktree(subject: MoveSessionSubject): boolean {
-  const kind = subject.kind ?? 'local';
-  return kind === 'worktree' || parseMachineKind(kind)?.base === 'worktree';
-}
-
-/**
- * The folder query the kinds are listed for: the session's folder when it is this host's (a machine's folder would
- * make every kind of this host unavailable).
- *
- * @param subject - The session.
- */
-export function moveListingCwd(subject: MoveSessionSubject): string | undefined {
-  return subject.cwd && parseMachineKind(subject.kind ?? 'local') === null ? subject.cwd : undefined;
-}

package/src/git/headless/remote-clone.ts

@@ -1,44 +0,0 @@
-/**
- * Clone on send: a new session on a saved server, started from a project on
- * this computer, runs in a clone of that project's repository on the server.
- * The server clones this computer's `origin` (as written) into
- * `<first workspace root>/<repository name>` when the first message is sent.
- * A folder already there that holds the same repository is reused; one that
- * holds something else makes the send fail with the server's message. A
- * server that takes no clones (`allowClone` off) is shown as such, and the
- * send uses its first root; an older server, which says nothing about clones,
- * offers none.
- */
-import { parseRepoInput } from 'zidane/chat/pure';
-
-import type { GitFolderListing } from './host';
-
-/** The local project's repository, as a new session on a server would clone it. */
-export interface DraftRemoteClone {
-  /** What the server clones: this computer's `origin` URL, as written. */
-  input: string;
-  /** The folder it lands in: the repository's name. */
-  name: string;
-  /** Where that folder goes: the server's first workspace root. */
-  parent: string;
-  /**
-   * `clone`: the server clones it on send. `exists`: a folder of that name is already there (used as it is when
-   * it holds the same repository). `off`: the server takes no clones: nothing is cloned, the send uses its first root.
-   */
-  state: 'clone' | 'exists' | 'off';
-}
-
-/**
- * What a send would clone, from the local project's `origin` and the listing of the server's first root.
- *
- * @param origin - The `origin` URL of the local project, `null` without one.
- * @param root - The listing of the server's first workspace root.
- * @returns `null` when there is nothing to clone (no `origin`, not a repository URL, or a server that says nothing
- * about clones).
- */
-export function resolveRemoteClone(origin: string | null, root: GitFolderListing): DraftRemoteClone | null {
-  const spec = origin ? parseRepoInput(origin) : null;
-  if (!origin || !spec || !root.allows) return null;
-  const state = !root.allows.clone ? 'off' : root.dirs.some((dir) => dir.name === spec.name) ? 'exists' : 'clone';
-  return { input: origin, name: spec.name, parent: root.path, state };
-}

package/src/git/headless/status-reads.ts

@@ -1,77 +0,0 @@
-/**
- * Status reads shared per folder: every git bar showing a folder (split
- * panes, another conversation in it) rides the same read, and a trigger that
- * doesn't need a new answer reuses one that started recently.
- *
- * A read is asked with how old an answer may be: `0` (the default) when
- * something may have just moved (a commit, a tool's edit, a switch), more
- * for a poll or a focus. A read already running answers anyone who accepts
- * its age; a caller that needs a newer one gets the single follow-up read
- * queued after it, shared by everyone who asks meanwhile, so a slow
- * repository never has an older answer overwrite a newer one.
- */
-import type { GitStatus } from './host';
-
-/** Reads of each folder's status, see the module comment. */
-export interface GitStatusReads {
-  /**
-   * Reads the folder's status, unless a read started within `maxAgeMs`.
-   * Resolves once the read that answers the call has landed.
-   */
-  refresh(cwd: string, maxAgeMs?: number): Promise<void>;
-}
-
-interface FolderReads {
-  /** When the last read started; `-Infinity` before the first. */
-  startedAt: number;
-  running: Promise<void> | null;
-  next: Promise<void> | null;
-}
-
-/**
- * A new {@link GitStatusReads}.
- *
- * @param read - The host's status read; a rejection answers `null`.
- * @param onAnswer - Called with each read's answer.
- * @param now - The clock. Default `Date.now`.
- */
-export function createGitStatusReads(
-  read: (cwd: string) => Promise<GitStatus | null>,
-  onAnswer: (cwd: string, status: GitStatus | null) => void,
-  now: () => number = Date.now,
-): GitStatusReads {
-  const folders = new Map<string, FolderReads>();
-
-  const start = (cwd: string, folder: FolderReads): Promise<void> => {
-    folder.startedAt = now();
-    const running = read(cwd)
-      .catch(() => null)
-      .then((status) => onAnswer(cwd, status))
-      .finally(() => {
-        folder.running = null;
-      });
-    folder.running = running;
-    return running;
-  };
-
-  return {
-    refresh(cwd, maxAgeMs = 0) {
-      let folder = folders.get(cwd);
-      if (!folder) folders.set(cwd, (folder = { startedAt: -Infinity, running: null, next: null }));
-      const f = folder;
-      // Already queued after the running read: that one answers every caller.
-      if (f.next) return f.next;
-      const fresh = now() - f.startedAt < maxAgeMs;
-      if (f.running) {
-        if (fresh) return f.running;
-        // The running read may have started before whatever this caller is asking about.
-        f.next = f.running.then(() => {
-          f.next = null;
-          return start(cwd, f);
-        });
-        return f.next;
-      }
-      return fresh ? Promise.resolve() : start(cwd, f);
-    },
-  };
-}

package/src/git/headless/switcher.ts

@@ -1,215 +0,0 @@
-/**
- * The branch menu's model, React-free: which rows it lists in which section,
- * what a typed name offers to start, the age and size words of a row, and the
- * per-folder cache that makes a reopened menu instant while it refreshes.
- */
-import { ageStep, formatCount } from 'zidane/chat/pure';
-
-import { RELATIVE_TIME_DATE_AFTER_DAYS } from '../../chat/headless/session-list';
-import type { GitBranch, GitHost, GitPullRequest, GitPullRequestList } from './host';
-
-/** A row of the branch menu. */
-export type SwitcherEntry =
-  | { kind: 'pr'; pr: GitPullRequest }
-  | { kind: 'branch'; row: GitBranch }
-  | { kind: 'create'; name: string; worktree: boolean };
-
-/** A section of the branch menu. */
-export type SwitcherSectionId = GitPullRequest['group'] | 'branches';
-
-/** The sections in order, and how many rows each shows until searched or expanded. */
-export const SWITCHER_SECTIONS: readonly { id: SwitcherSectionId; cap: number }[] = [
-  { id: 'review', cap: 5 },
-  { id: 'mine', cap: 5 },
-  { id: 'other', cap: 3 },
-  { id: 'branches', cap: 6 },
-];
-
-/** A section as shown: every row it holds, the ones shown, and how many wait behind "more". */
-export interface SwitcherSection {
-  /** Which section. */
-  id: SwitcherSectionId;
-  /** Rows shown until searched or expanded. */
-  cap: number;
-  /** Every row it holds for the query. */
-  all: SwitcherEntry[];
-  /** The rows shown. */
-  shown: SwitcherEntry[];
-  /** Rows behind "more". */
-  hidden: number;
-}
-
-/**
- * What a pull request search matches: `#12` or `12` (a number prefix), or the title, branch or
- * author (case-insensitive).
- *
- * @param pr - The pull request.
- * @param query - What was typed.
- */
-export function prMatches(pr: Pick<GitPullRequest, 'number' | 'title' | 'branch' | 'author'>, query: string): boolean {
-  const q = query.trim().toLowerCase();
-  if (!q) return true;
-  const bare = q.replace(/^#/, '');
-  return (
-    (bare !== '' && String(pr.number).startsWith(bare)) ||
-    pr.title.toLowerCase().includes(q) ||
-    pr.branch.toLowerCase().includes(q) ||
-    pr.author.toLowerCase().includes(q)
-  );
-}
-
-/**
- * A pull request list as the menu holds it: the list (`null` when the host cannot reach pull
- * requests) and, when GitHub rate-limited it, when it resumes.
- *
- * @param result - The host's answer.
- */
-export function readPullRequests(result: GitPullRequestList): {
-  list: readonly GitPullRequest[] | null;
-  retryAt: number | null;
-} {
-  if (result.kind === 'rate-limited') return { list: [], retryAt: result.retryAt };
-  if (result.kind === 'unavailable') return { list: null, retryAt: null };
-  return { list: result.items, retryAt: null };
-}
-
-/**
- * The sections in order for a query, each capped unless searching or expanded; empty ones left
- * out. A branch with an open pull request (any known) is listed once, under the pull request.
- *
- * @param input - The loaded pull requests and branches, the search's answer, the query (trimmed,
- *   lower case) and the expanded sections.
- */
-export function switcherSections(input: {
-  prs: readonly GitPullRequest[] | null | undefined;
-  branches: readonly GitBranch[] | null;
-  /** GitHub's answer for the query, when it is for this query. */
-  searched: readonly GitPullRequest[] | null;
-  query: string;
-  expanded: ReadonlySet<SwitcherSectionId>;
-}): SwitcherSection[] {
-  const { prs, branches, searched, query: q, expanded } = input;
-  const base = prs ?? [];
-  const prList = q ? (searched ?? base.filter((p) => prMatches(p, q))) : base;
-  const underPr = new Set([...base, ...prList].filter((p) => !p.fork).map((p) => p.branch));
-  const branchList = (branches ?? []).filter((b) => !underPr.has(b.name) && (!q || b.name.toLowerCase().includes(q)));
-  return SWITCHER_SECTIONS.map((sec) => {
-    const all: SwitcherEntry[] =
-      sec.id === 'branches'
-        ? branchList.map((row) => ({ kind: 'branch', row }))
-        : prList.filter((p) => p.group === sec.id).map((pr) => ({ kind: 'pr', pr }));
-    const capped = !q && !expanded.has(sec.id);
-    const shown = capped ? all.slice(0, sec.cap) : all;
-    return { ...sec, all, shown, hidden: all.length - shown.length };
-  }).filter((sec) => sec.all.length > 0);
-}
-
-/**
- * A typed name no branch here or pull request carries, offered to start: as a branch, and as a
- * worktree when one can be started.
- *
- * @param input - The typed name (trimmed), the current branch, what is loaded, and what can be started.
- */
-export function switcherCreates(input: {
-  typed: string;
-  current: string | null;
-  branches: readonly GitBranch[] | null;
-  prs: readonly GitPullRequest[] | null | undefined;
-  searched: readonly GitPullRequest[] | null | undefined;
-  canCreateBranch: boolean;
-  canStartWorktree: boolean;
-}): SwitcherEntry[] {
-  const { typed, current, branches, prs, searched, canCreateBranch, canStartWorktree } = input;
-  if (!typed || branches === null || typed === current) return [];
-  const known = (p: GitPullRequest) => !p.fork && p.branch === typed;
-  if (branches.some((b) => b.name === typed) || (prs ?? []).some(known) || searched?.some(known)) return [];
-  return [
-    ...(canCreateBranch ? [{ kind: 'create' as const, name: typed, worktree: false }] : []),
-    ...(canStartWorktree ? [{ kind: 'create' as const, name: typed, worktree: true }] : []),
-  ];
-}
-
-/**
- * A row's stable key (and the busy marker of its action).
- *
- * @param entry - The row.
- */
-export function switcherKey(entry: SwitcherEntry): string {
-  return entry.kind === 'pr'
-    ? `pr:${entry.pr.number}`
-    : entry.kind === 'branch'
-      ? `branch:${entry.row.name}`
-      : `create:${entry.worktree}`;
-}
-
-/**
- * A diff size at a glance: 1234 → `1.2k`.
- *
- * @param n - The count.
- */
-export function compactCount(n: number): string {
-  return formatCount(n, 10);
-}
-
-/**
- * Whether an age reads as a duration (`5m`, takes "ago") rather than `now` or a date.
- *
- * @param at - Epoch ms of the event.
- * @param now - Epoch ms of the current time.
- */
-export function ageIsDuration(at: number, now: number): boolean {
-  return ageStep(at, now, RELATIVE_TIME_DATE_AFTER_DAYS).kind === 'duration';
-}
-
-/**
- * A clock time, `14:05`.
- *
- * @param ms - Epoch ms.
- */
-export function clockTime(ms: number): string {
-  const d = new Date(ms);
-  return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
-}
-
-/** The branch menu's last lists per folder, so a reopened menu shows them while it refreshes. */
-export interface SwitcherCache {
-  /** The branches last listed for `cwd`. */
-  branches(cwd: string): readonly GitBranch[] | undefined;
-  /** Keeps the branches listed for `cwd`. */
-  setBranches(cwd: string, list: readonly GitBranch[]): void;
-  /** Whether pull requests were listed for `cwd`. */
-  hasPullRequests(cwd: string): boolean;
-  /** The pull requests last listed for `cwd`, `null` when the host could not reach them. */
-  pullRequests(cwd: string): readonly GitPullRequest[] | null | undefined;
-  /** Keeps the pull requests listed for `cwd`. */
-  setPullRequests(cwd: string, list: readonly GitPullRequest[] | null): void;
-}
-
-/** Creates an empty {@link SwitcherCache}. */
-export function createSwitcherCache(): SwitcherCache {
-  const branches = new Map<string, readonly GitBranch[]>();
-  const prs = new Map<string, readonly GitPullRequest[] | null>();
-  return {
-    branches: (cwd) => branches.get(cwd),
-    setBranches: (cwd, list) => void branches.set(cwd, list),
-    hasPullRequests: (cwd) => prs.has(cwd),
-    pullRequests: (cwd) => prs.get(cwd),
-    setPullRequests: (cwd, list) => void prs.set(cwd, list),
-  };
-}
-
-const caches = new WeakMap<GitHost, SwitcherCache>();
-
-/**
- * The {@link SwitcherCache} of a host: one per host, kept as long as the host is.
- *
- * @param host - The git host.
- */
-export function switcherCacheOf(host: GitHost): SwitcherCache {
-  let cache = caches.get(host);
-  if (!cache) {
-    cache = createSwitcherCache();
-    caches.set(host, cache);
-  }
-  return cache;
-}