@n-seiji/nuthatch 0.1.5 → 0.1.7

package/dist/cli-pick-w9qk71fy.js

@@ -0,0 +1,1533 @@
+import"./cli-qrxgkskr.js";
+import {
+  rm2
+} from "./cli-23z98dw1.js";
+import {
+  root2
+} from "./cli-ygt2w4e1.js";
+import {
+  graphemes,
+  displayWidth,
+  padToWidth,
+  truncateToWidth,
+  truncateToWidthKeepingTail
+} from "./cli-71jgs14h.js";
+import {
+  render,
+  reportResult
+} from "./cli-dbzx9nzg.js";
+import {
+  loadRepoContext,
+  worktreeDirtyState
+} from "./cli-7jg5qqs9.js";
+import {
+  EXIT_CANCELLED,
+  ok
+} from "./cli-2bhb9p0x.js";
+
+// src/domain/candidates.ts
+var buildPickCandidates = (worktrees, dirtyByPath, localBranches, remoteBranches) => {
+  const existingBranches = new Set(worktrees.map((worktree) => worktree.branch).filter((branch) => branch !== null));
+  const worktreeCandidates = worktrees.map((worktree) => ({
+    kind: "worktree",
+    worktree,
+    dirty: dirtyByPath.get(worktree.path) ?? null
+  }));
+  const localOnly = localBranches.filter((branch) => !existingBranches.has(branch));
+  const localSet = new Set(localBranches);
+  const remoteOnly = remoteBranches.filter((branch) => !existingBranches.has(branch) && !localSet.has(branch));
+  return [
+    ...worktreeCandidates,
+    ...localOnly.map((branch) => ({
+      kind: "creatable",
+      branch,
+      source: "local"
+    })),
+    ...remoteOnly.map((branch) => ({
+      kind: "creatable",
+      branch,
+      source: "remote"
+    }))
+  ];
+};
+var candidateBranchLabel = (candidate) => candidate.kind === "worktree" ? candidate.worktree.branch ?? "(detached)" : candidate.branch;
+var candidateBranchName = (candidate) => candidate.kind === "worktree" ? candidate.worktree.branch : candidate.branch;
+
+// src/commands/pick.ts
+var pick = async (git, fs, options) => {
+  const context = await loadRepoContext(git, fs, options.cwd);
+  const [localBranches, remoteBranches, dirtyEntries] = await Promise.all([
+    git.listBranches(context.rootPath),
+    git.listRemoteBranches(context.rootPath),
+    Promise.all(context.worktrees.map(async (worktree) => [
+      worktree.path,
+      await worktreeDirtyState(git, fs, context.worktrees, worktree)
+    ]))
+  ]);
+  const dirtyByPath = new Map(dirtyEntries);
+  const candidates = buildPickCandidates(context.worktrees, dirtyByPath, localBranches, remoteBranches);
+  return ok({ data: { candidates } });
+};
+
+// src/ui/picker-render.ts
+import { homedir } from "node:os";
+
+// src/ui/ansi.ts
+var ESC = "\x1B";
+
+// src/ui/picker-frame.ts
+var CURSOR_HOME = `${ESC}[H`;
+var CLEAR_TO_END = `${ESC}[J`;
+var SGR_RESET = `${ESC}[0m`;
+var SGR_CODES = {
+  plain: "",
+  cyan: `${ESC}[36m`,
+  dim: `${ESC}[2m`,
+  "bold-dim": `${ESC}[1m${ESC}[2m`,
+  inverse: `${ESC}[7m`,
+  red: `${ESC}[31m`,
+  green: `${ESC}[32m`,
+  yellow: `${ESC}[33m`,
+  magenta: `${ESC}[35m`
+};
+var renderSpan = (span, colorEnabled) => {
+  const style = span.style ?? "plain";
+  if (!colorEnabled || style === "plain") {
+    return span.text;
+  }
+  return `${SGR_CODES[style]}${span.text}${SGR_RESET}`;
+};
+var lineWidth = (line) => line.reduce((total, span) => total + displayWidth(span.text), 0);
+var renderLine = (line, colorEnabled) => line.map((span) => renderSpan(span, colorEnabled)).join("");
+var padRenderedLine = (line, rendered, width) => {
+  const gap = Math.max(0, width - lineWidth(line));
+  return gap === 0 ? rendered : rendered + " ".repeat(gap);
+};
+var GUTTER = "  ";
+var buildSideBySide = (left, right, colorEnabled) => {
+  const leftWidth = Math.max(0, ...left.map((line) => lineWidth(line)));
+  const rowCount = Math.max(left.length, right.length);
+  const rows = [];
+  for (let index = 0;index < rowCount; index += 1) {
+    const leftLine = left[index] ?? [];
+    const rightLine = right[index] ?? [];
+    const renderedLeft = padRenderedLine(leftLine, renderLine(leftLine, colorEnabled), leftWidth);
+    const renderedRight = renderLine(rightLine, colorEnabled);
+    rows.push(index < left.length ? `${renderedLeft}${GUTTER}${renderedRight}` : renderedRight);
+  }
+  return rows;
+};
+var BOX_TOP_LEFT = "╭";
+var BOX_TOP_RIGHT = "╮";
+var BOX_BOTTOM_LEFT = "╰";
+var BOX_BOTTOM_RIGHT = "╯";
+var BOX_HORIZONTAL = "─";
+var BOX_VERTICAL = "│";
+var BOX_PADDING = 1;
+var BOX_PADDING_TOTAL = BOX_PADDING + BOX_PADDING;
+var BOX_BORDER_WIDTH = 2;
+var flattenToGraphemes = (line) => line.flatMap((span) => graphemes(span.text).map((text) => ({ text, style: span.style })));
+var toStyledSpan = (char) => char.style === undefined ? { text: char.text } : { text: char.text, style: char.style };
+var groupIntoSpans = (chars) => {
+  const spans = [];
+  for (const char of chars) {
+    const last = spans.at(-1);
+    if (last !== undefined && last.style === char.style) {
+      spans[spans.length - 1] = toStyledSpan({
+        text: last.text + char.text,
+        style: last.style
+      });
+    } else {
+      spans.push(toStyledSpan(char));
+    }
+  }
+  return spans;
+};
+var wrapLineToWidth = (line, width) => {
+  if (width <= 0) {
+    return [line];
+  }
+  const rows = [];
+  let current = [];
+  let currentWidth = 0;
+  for (const char of flattenToGraphemes(line)) {
+    const charWidth = displayWidth(char.text);
+    if (currentWidth + charWidth > width && current.length > 0) {
+      rows.push(groupIntoSpans(current));
+      current = [];
+      currentWidth = 0;
+    }
+    current.push(char);
+    currentWidth += charWidth;
+  }
+  if (current.length > 0 || rows.length === 0) {
+    rows.push(groupIntoSpans(current));
+  }
+  return rows;
+};
+var wrapInBox = (content, width) => {
+  const innerWidth = Math.max(0, width - BOX_BORDER_WIDTH - BOX_PADDING_TOTAL);
+  const horizontal = BOX_HORIZONTAL.repeat(Math.max(0, width - BOX_BORDER_WIDTH));
+  const pad = " ".repeat(BOX_PADDING);
+  const top = [{ text: `${BOX_TOP_LEFT}${horizontal}${BOX_TOP_RIGHT}` }];
+  const bottom = [{ text: `${BOX_BOTTOM_LEFT}${horizontal}${BOX_BOTTOM_RIGHT}` }];
+  const boxRow = (row) => {
+    const gap = " ".repeat(Math.max(0, innerWidth - lineWidth(row)));
+    return [{ text: `${BOX_VERTICAL}${pad}` }, ...row, { text: `${gap}${pad}${BOX_VERTICAL}` }];
+  };
+  const middle = content.flatMap((line) => {
+    const rows = lineWidth(line) <= innerWidth ? [line] : wrapLineToWidth(line, innerWidth);
+    return rows.map((row) => boxRow(row));
+  });
+  return [top, ...middle, bottom];
+};
+var ELLIPSIS = "…";
+var truncateLineToWidth = (line, width) => {
+  if (lineWidth(line) <= width) {
+    return line;
+  }
+  const budget = Math.max(0, width - displayWidth(ELLIPSIS));
+  const kept = [];
+  let usedWidth = 0;
+  for (const char of flattenToGraphemes(line)) {
+    const charWidth = displayWidth(char.text);
+    if (usedWidth + charWidth > budget) {
+      break;
+    }
+    kept.push(char);
+    usedWidth += charWidth;
+  }
+  return [...groupIntoSpans(kept), { text: ELLIPSIS }];
+};
+var buildFrame = (input) => {
+  const { left, right, stacked, colorEnabled } = input;
+  const lines = buildFrameLines(left, right, stacked, colorEnabled);
+  return `${CURSOR_HOME}${CLEAR_TO_END}${lines.join(`\r
+`)}`;
+};
+var buildFrameLines = (left, right, stacked, colorEnabled) => {
+  if (right === null) {
+    return left.map((line) => renderLine(line, colorEnabled));
+  }
+  if (stacked) {
+    return [...left, ...right].map((line) => renderLine(line, colorEnabled));
+  }
+  return buildSideBySide(left, right, colorEnabled);
+};
+
+// src/ui/picker-layout.ts
+var MAX_PATH_LENGTH = 40;
+var MAX_BRANCH_COLUMN_WIDTH = 24;
+var LEGEND_TEXT = "●=dirty ○=clean +=not created";
+var WORKTREE_KIND_LABELS = {
+  root: "root",
+  managed: "managed",
+  external: "ext"
+};
+var CREATABLE_SOURCE_LABELS = {
+  local: "local",
+  remote: "remote"
+};
+var statusMarker = (candidate) => {
+  if (candidate.kind === "creatable") {
+    return "+";
+  }
+  if (candidate.dirty === null) {
+    return " ";
+  }
+  return candidate.dirty ? "●" : "○";
+};
+var candidateKindLabel = (candidate) => candidate.kind === "worktree" ? WORKTREE_KIND_LABELS[candidate.worktree.kind] : CREATABLE_SOURCE_LABELS[candidate.source];
+var isWorktreeCandidate = (candidate) => candidate.kind === "worktree";
+var isCreatableCandidate = (candidate) => candidate.kind === "creatable";
+var WORKTREE_KIND_ORDER = {
+  root: 0,
+  managed: 1,
+  external: 2
+};
+var CREATABLE_SOURCE_ORDER = {
+  local: 0,
+  remote: 1
+};
+var compareByBranchLabel = (a, b) => candidateBranchLabel(a).localeCompare(candidateBranchLabel(b));
+var detachedRank = (candidate) => candidate.worktree.branch === null ? 1 : 0;
+var compareWorktreeCandidates = (a, b) => {
+  const kindDiff = WORKTREE_KIND_ORDER[a.worktree.kind] - WORKTREE_KIND_ORDER[b.worktree.kind];
+  if (kindDiff !== 0) {
+    return kindDiff;
+  }
+  const detachedDiff = detachedRank(a) - detachedRank(b);
+  return detachedDiff === 0 ? compareByBranchLabel(a, b) : detachedDiff;
+};
+var compareCreatableCandidates = (a, b) => {
+  const sourceDiff = CREATABLE_SOURCE_ORDER[a.source] - CREATABLE_SOURCE_ORDER[b.source];
+  return sourceDiff === 0 ? compareByBranchLabel(a, b) : sourceDiff;
+};
+var sortCandidatesForDisplay = (candidates) => [
+  ...candidates.filter((candidate) => isWorktreeCandidate(candidate)).toSorted((a, b) => compareWorktreeCandidates(a, b)),
+  ...candidates.filter((candidate) => isCreatableCandidate(candidate)).toSorted((a, b) => compareCreatableCandidates(a, b))
+];
+var KIND_COLUMN_WIDTH = Math.max(...Object.values(WORKTREE_KIND_LABELS).map((label) => label.length), ...Object.values(CREATABLE_SOURCE_LABELS).map((label) => label.length));
+var shortenPath = (path, homeDir, maxLength = MAX_PATH_LENGTH) => {
+  const withTilde = homeDir.length > 0 && (path === homeDir || path.startsWith(`${homeDir}/`)) ? `~${path.slice(homeDir.length)}` : path;
+  return truncateToWidthKeepingTail(withTilde, maxLength);
+};
+var candidatePathLabel = (candidate, homeDir, maxLength) => candidate.kind === "worktree" ? shortenPath(candidate.worktree.path, homeDir, maxLength) : "";
+var rawBranchColumnWidth = (candidates) => candidates.reduce((max, candidate) => Math.max(max, displayWidth(candidateBranchLabel(candidate))), 0);
+var branchColumnWidth = (candidates) => Math.min(MAX_BRANCH_COLUMN_WIDTH, rawBranchColumnWidth(candidates));
+var padBranchLabel = (label, width) => padToWidth(label, width);
+var toCandidateRow = (candidate, options) => ({
+  kind: "candidate",
+  index: options.index,
+  section: options.section,
+  statusMarker: statusMarker(candidate),
+  branchLabel: padBranchLabel(truncateToWidth(candidateBranchLabel(candidate), options.branchWidth), options.branchWidth),
+  kindLabel: candidateKindLabel(candidate).padEnd(KIND_COLUMN_WIDTH, " "),
+  pathLabel: candidatePathLabel(candidate, options.homeDir, options.pathMaxLength)
+});
+var sectionRows = (label, section, entries, rowOptions) => {
+  if (entries.length === 0) {
+    return [];
+  }
+  return [
+    { kind: "header", label },
+    ...entries.map((entry) => toCandidateRow(entry.candidate, { ...rowOptions, index: entry.index, section }))
+  ];
+};
+var buildDisplayRows = (candidates, homeDir, indexOffset = 0, columnWidths) => {
+  const { branchWidth, pathMaxLength } = columnWidths ?? {
+    branchWidth: branchColumnWidth(candidates),
+    pathMaxLength: MAX_PATH_LENGTH
+  };
+  const indexed = candidates.map((candidate, index) => ({
+    candidate,
+    index: index + indexOffset
+  }));
+  const worktreeEntries = indexed.filter((entry) => isWorktreeCandidate(entry.candidate));
+  const branchEntries = indexed.filter((entry) => isCreatableCandidate(entry.candidate));
+  const rowOptions = { branchWidth, pathMaxLength, homeDir };
+  return [
+    ...sectionRows("WORKTREES", "worktree", worktreeEntries, rowOptions),
+    ...sectionRows("BRANCHES — Enter creates a worktree", "branch", branchEntries, rowOptions)
+  ];
+};
+
+// src/domain/actions.ts
+var availableActions = (candidate) => {
+  const actions = ["cd"];
+  if (candidate.kind !== "worktree") {
+    actions.push("switchRoot");
+    return actions;
+  }
+  if (candidate.worktree.branch === null) {
+    return actions;
+  }
+  if (candidate.worktree.kind === "managed" || candidate.worktree.kind === "external") {
+    actions.push("delete");
+  }
+  if (candidate.worktree.kind !== "root") {
+    actions.push("switchRoot");
+  }
+  return actions;
+};
+var requiresDeleteConfirmation = (candidate) => candidate.kind === "worktree" && (candidate.worktree.kind === "external" || candidate.worktree.prunable);
+var requiresSwitchRootConfirmation = (candidate) => candidate.kind === "worktree" && candidate.worktree.kind === "external";
+
+// src/ui/side-panel.ts
+var ACTION_LABELS = {
+  cd: "cd into this worktree",
+  delete: "delete worktree",
+  switchRoot: "switch root here"
+};
+var ACTION_LETTERS = {
+  cd: "c",
+  delete: "d",
+  switchRoot: "r"
+};
+var SIDE_PANEL_WIDTH = 34;
+var buildActionPanelRows = ({
+  candidate,
+  panelIndex,
+  error,
+  busy
+}) => {
+  const actions = availableActions(candidate);
+  const rows = [
+    [{ text: "Actions for " }, { text: candidateBranchLabel(candidate), style: "cyan" }],
+    ...actions.map((action, actionIndex) => {
+      const marker = actionIndex === panelIndex ? "> " : "  ";
+      const text = `${marker}[${ACTION_LETTERS[action]}] ${ACTION_LABELS[action]}`;
+      return [{ text, style: actionIndex === panelIndex ? "inverse" : "plain" }];
+    })
+  ];
+  if (busy) {
+    rows.push([{ text: "Working…", style: "dim" }]);
+  }
+  if (error !== null) {
+    rows.push([{ text: error, style: "red" }]);
+  }
+  return rows;
+};
+var CONFIRM_QUESTIONS = {
+  delete: "Delete worktree for",
+  switchRoot: "Switch root here for"
+};
+var buildConfirmPanelRows = ({
+  candidate,
+  action
+}) => {
+  const rows = [
+    [
+      { text: `${CONFIRM_QUESTIONS[action]} ` },
+      { text: candidateBranchName(candidate) ?? "", style: "cyan" },
+      { text: "?" }
+    ]
+  ];
+  if (action === "switchRoot") {
+    rows.push([{ text: "This will put it into detached HEAD.", style: "dim" }]);
+  }
+  if (action === "delete" && candidate.kind === "worktree" && candidate.worktree.prunable) {
+    rows.push([{ text: "Prunable, not dirty-checked:", style: "dim" }], [{ text: "removes just its registration.", style: "dim" }]);
+  }
+  rows.push([{ text: "(y/N)", style: "dim" }]);
+  return rows;
+};
+
+// src/ui/picker-side-by-side.ts
+var SELECTION_MARKER_WIDTH = 2;
+var STATUS_MARKER_WIDTH = 1;
+var STATUS_MARKER_GAP_WIDTH = 1;
+var BRANCH_KIND_GUTTER_WIDTH = 2;
+var KIND_PATH_GAP_WIDTH = 1;
+var CANDIDATE_ROW_CHROME_WIDTH = SELECTION_MARKER_WIDTH + STATUS_MARKER_WIDTH + STATUS_MARKER_GAP_WIDTH + BRANCH_KIND_GUTTER_WIDTH + KIND_PATH_GAP_WIDTH;
+var HALF_DIVISOR = 2;
+var MIN_PATH_DISPLAY_LENGTH = Math.ceil(MAX_PATH_LENGTH / HALF_DIVISOR);
+var MAX_CANDIDATE_ROW_WIDTH = CANDIDATE_ROW_CHROME_WIDTH + MAX_BRANCH_COLUMN_WIDTH + KIND_COLUMN_WIDTH + MAX_PATH_LENGTH;
+var MIN_SIDE_BY_SIDE_WIDTH = CANDIDATE_ROW_CHROME_WIDTH + MAX_BRANCH_COLUMN_WIDTH + KIND_COLUMN_WIDTH + MIN_PATH_DISPLAY_LENGTH + displayWidth(GUTTER) + SIDE_PANEL_WIDTH;
+var isNarrowTerminal = (columns) => columns < MIN_SIDE_BY_SIDE_WIDTH;
+var LIST_FOOTER_HINT = "Tab/→/Ctrl+L actions · Ctrl+X delete · Ctrl+R switch root · ↑↓/Ctrl+P,N,K,J move · Enter cd · Esc cancel";
+var PANEL_FOOTER_HINT = "↑↓/Ctrl+P,N,K,J move · Enter run · c/d/r shortcuts · Esc/Tab/←/Ctrl+H close";
+var constrainRowColumnWidths = (rawBranchWidth, maxRowWidth) => {
+  const availableForBranchAndPath = Math.max(0, maxRowWidth - CANDIDATE_ROW_CHROME_WIDTH - KIND_COLUMN_WIDTH);
+  const branchWidth = Math.min(rawBranchWidth, availableForBranchAndPath);
+  const pathMaxLength = Math.max(0, Math.min(MAX_PATH_LENGTH, availableForBranchAndPath - branchWidth));
+  return { branchWidth, pathMaxLength };
+};
+var SHORT_LIST_FOOTER_HINT = "↑↓ move · Enter cd · Esc cancel";
+var SHORT_PANEL_FOOTER_HINT = "↑↓ move · Enter run · Esc close";
+var footerHintForWidth = (kind, width) => {
+  const full = kind === "list" ? LIST_FOOTER_HINT : PANEL_FOOTER_HINT;
+  const short = kind === "list" ? SHORT_LIST_FOOTER_HINT : SHORT_PANEL_FOOTER_HINT;
+  if (displayWidth(full) <= width) {
+    return full;
+  }
+  if (displayWidth(short) <= width) {
+    return short;
+  }
+  return truncateToWidth(short, width);
+};
+
+// src/ui/picker-viewport.ts
+var DEFAULT_TERMINAL_HEIGHT = 24;
+var MIN_VISIBLE_CANDIDATE_ROWS = 3;
+var BASE_CHROME_ROWS = 3;
+var SECTION_HEADER_ROWS = 2;
+var HIDDEN_COUNT_INDICATOR_ROWS = 2;
+var rowBudget = ({ terminalHeight, stackedPanelRows }) => {
+  const reserved = BASE_CHROME_ROWS + SECTION_HEADER_ROWS + HIDDEN_COUNT_INDICATOR_ROWS + stackedPanelRows;
+  return Math.max(MIN_VISIBLE_CANDIDATE_ROWS, terminalHeight - reserved);
+};
+var computeViewport = (total, selectedIndex, budget) => {
+  if (total <= budget) {
+    return { start: 0, end: total, hiddenAbove: 0, hiddenBelow: 0 };
+  }
+  const HALF_DIVISOR = 2;
+  const half = Math.floor(budget / HALF_DIVISOR);
+  const maxStart = total - budget;
+  const start = Math.min(maxStart, Math.max(0, selectedIndex - half));
+  const end = start + budget;
+  return { start, end, hiddenAbove: start, hiddenBelow: total - end };
+};
+
+// src/ui/picker-render.ts
+var QUERY_PREFIX = "hop: ";
+var queryLine = (query, maxWidth) => {
+  const hint = query.length === 0 ? " (type to filter)" : "";
+  const budget = Math.max(0, maxWidth - QUERY_PREFIX.length - hint.length);
+  return [
+    { text: QUERY_PREFIX },
+    { text: truncateToWidthKeepingTail(query, budget), style: "cyan" },
+    { text: hint, style: "dim" }
+  ];
+};
+var hiddenCountLine = (count, direction) => {
+  if (count === 0) {
+    return null;
+  }
+  const arrow = direction === "above" ? "↑ " : "↓ ";
+  const word = direction === "above" ? "above" : "below";
+  return [
+    {
+      text: `${arrow}${count} more ${word} (keep typing to narrow down)`,
+      style: "dim"
+    }
+  ];
+};
+var STATUS_MARKER_STYLES = {
+  "●": "yellow",
+  "○": "green"
+};
+var KIND_LABEL_STYLES = {
+  root: "magenta",
+  managed: "cyan",
+  ext: "yellow"
+};
+var candidateRowLine = (row, selected) => {
+  if (selected) {
+    const text = `❯ ${row.statusMarker} ${row.branchLabel}  ${row.kindLabel} ${row.pathLabel}`;
+    return [{ text, style: "inverse" }];
+  }
+  if (row.section === "branch") {
+    return [
+      {
+        text: `  ${row.statusMarker} ${row.branchLabel}  ${row.kindLabel} ${row.pathLabel}`,
+        style: "dim"
+      }
+    ];
+  }
+  return [
+    { text: "  " },
+    { text: row.statusMarker, style: STATUS_MARKER_STYLES[row.statusMarker] ?? "plain" },
+    { text: ` ${row.branchLabel}  ` },
+    { text: row.kindLabel, style: KIND_LABEL_STYLES[row.kindLabel.trim()] ?? "plain" },
+    { text: ` ${row.pathLabel}`, style: "dim" }
+  ];
+};
+var displayRowLine = (row, clampedIndex) => row.kind === "header" ? [{ text: row.label, style: "bold-dim" }] : candidateRowLine(row, row.index === clampedIndex);
+var buildListLines = ({
+  query,
+  maxWidth,
+  rows,
+  clampedIndex,
+  hiddenAbove,
+  hiddenBelow,
+  footerHint
+}) => {
+  const lines = [queryLine(query, maxWidth)];
+  if (rows.length === 0) {
+    lines.push([{ text: "No matches.", style: "dim" }]);
+  }
+  const above = hiddenCountLine(hiddenAbove, "above");
+  if (above !== null) {
+    lines.push(above);
+  }
+  for (const row of rows) {
+    lines.push(displayRowLine(row, clampedIndex));
+  }
+  const below = hiddenCountLine(hiddenBelow, "below");
+  if (below !== null) {
+    lines.push(below);
+  }
+  lines.push([{ text: `(${LEGEND_TEXT})`, style: "dim" }], [{ text: footerHint, style: "dim" }]);
+  return lines;
+};
+var buildSidePanelLines = (mode, panelIndex, busy) => {
+  if (mode.kind === "panel") {
+    return wrapInBox(buildActionPanelRows({
+      candidate: mode.candidate,
+      panelIndex,
+      error: mode.error,
+      busy
+    }), SIDE_PANEL_WIDTH);
+  }
+  if (mode.kind === "confirm") {
+    return wrapInBox(buildConfirmPanelRows({ candidate: mode.candidate, action: mode.action }), SIDE_PANEL_WIDTH);
+  }
+  return null;
+};
+var renderPickerFrame = ({
+  snapshot,
+  width,
+  height,
+  colorEnabled: color
+}) => {
+  const { query, filtered, clampedIndex, mode, panelIndex, busy } = snapshot;
+  const narrow = isNarrowTerminal(width);
+  const right = buildSidePanelLines(mode, panelIndex, busy);
+  const stacked = right !== null && narrow;
+  const listColumnWidth = right !== null && !stacked ? width - GUTTER.length - SIDE_PANEL_WIDTH : width;
+  const stackedPanelRows = stacked && right !== null ? right.length : 0;
+  const budget = rowBudget({ terminalHeight: height, stackedPanelRows });
+  const viewport = computeViewport(filtered.length, clampedIndex, budget);
+  const visible = filtered.slice(viewport.start, viewport.end);
+  const columnWidths = constrainRowColumnWidths(rawBranchColumnWidth(visible), listColumnWidth);
+  const rows = buildDisplayRows(visible, homedir(), viewport.start, columnWidths);
+  const left = buildListLines({
+    query,
+    maxWidth: listColumnWidth,
+    rows,
+    clampedIndex,
+    hiddenAbove: viewport.hiddenAbove,
+    hiddenBelow: viewport.hiddenBelow,
+    footerHint: footerHintForWidth(right === null ? "list" : "panel", listColumnWidth)
+  }).map((line) => truncateLineToWidth(line, listColumnWidth));
+  return buildFrame({ left, right, stacked, colorEnabled: color });
+};
+
+// src/ui/picker-keys.ts
+var isCtrlJByte = (input) => input === `
+`;
+var resolvePickerKeyAction = (input, key) => {
+  if (key.escape) {
+    return { type: "cancel", reason: "esc" };
+  }
+  if (key.ctrl && input === "c") {
+    return { type: "cancel", reason: "ctrlC" };
+  }
+  if (key.return) {
+    return { type: "select" };
+  }
+  if (key.tab || key.rightArrow || key.ctrl && (input === "l" || input === "f")) {
+    return { type: "openPanel" };
+  }
+  if (key.ctrl && input === "x") {
+    return { type: "deleteShortcut" };
+  }
+  if (key.ctrl && input === "r") {
+    return { type: "rootSwitchShortcut" };
+  }
+  if (key.upArrow || key.ctrl && (input === "p" || input === "k")) {
+    return { type: "up" };
+  }
+  if (key.downArrow || key.ctrl && (input === "n" || input === "j") || isCtrlJByte(input)) {
+    return { type: "down" };
+  }
+  if (key.ctrl && input === "u") {
+    return { type: "clear" };
+  }
+  if (key.backspace || key.delete) {
+    return { type: "backspace" };
+  }
+  if (input.length > 0 && !key.ctrl && !key.meta) {
+    return { type: "char", char: input };
+  }
+  return { type: "ignore" };
+};
+var PANEL_LETTER_SHORTCUTS = ["c", "d", "r"];
+var resolvePanelKeyAction = (input, key) => {
+  if (key.escape || key.tab || key.leftArrow || key.backspace || key.ctrl && input === "h") {
+    return { type: "close" };
+  }
+  if (key.return) {
+    return { type: "confirm" };
+  }
+  if (key.upArrow || key.ctrl && (input === "p" || input === "k")) {
+    return { type: "up" };
+  }
+  if (key.downArrow || key.ctrl && (input === "n" || input === "j") || isCtrlJByte(input)) {
+    return { type: "down" };
+  }
+  if (!key.ctrl && !key.meta && isPanelLetterShortcut(input)) {
+    return { type: "letter", char: input };
+  }
+  return { type: "ignore" };
+};
+var isPanelLetterShortcut = (input) => PANEL_LETTER_SHORTCUTS.includes(input);
+var resolveConfirmKeyAction = (input, key) => {
+  if (!key.ctrl && !key.meta && (input === "y" || input === "Y")) {
+    return { type: "yes" };
+  }
+  return { type: "no" };
+};
+
+// src/ui/picker-input.ts
+var requiresConfirmation = (candidate, action) => {
+  if (action === "delete") {
+    return requiresDeleteConfirmation(candidate);
+  }
+  if (action === "switchRoot") {
+    return requiresSwitchRootConfirmation(candidate);
+  }
+  return false;
+};
+var handleConfirmInput = (input, key, confirmMode, ctx) => {
+  const confirmAction = resolveConfirmKeyAction(input, key);
+  if (confirmAction.type === "yes") {
+    ctx.runAction(confirmMode.candidate, confirmMode.action);
+  } else {
+    ctx.setMode({ kind: "list" });
+  }
+};
+var runOrConfirm = (candidate, action, ctx) => {
+  if ((action === "delete" || action === "switchRoot") && requiresConfirmation(candidate, action)) {
+    ctx.setMode({ kind: "confirm", action, candidate });
+    return;
+  }
+  ctx.runAction(candidate, action);
+};
+var handlePanelInput = (input, key, panelMode, ctx) => {
+  const actions = availableActions(panelMode.candidate);
+  const panelAction = resolvePanelKeyAction(input, key);
+  switch (panelAction.type) {
+    case "close": {
+      ctx.setMode({ kind: "list" });
+      break;
+    }
+    case "up": {
+      ctx.setPanelIndex((current) => Math.max(0, current - 1));
+      break;
+    }
+    case "down": {
+      ctx.setPanelIndex((current) => Math.min(actions.length - 1, current + 1));
+      break;
+    }
+    case "confirm": {
+      const chosen = actions[Math.min(ctx.panelIndex, actions.length - 1)];
+      if (chosen !== undefined) {
+        runOrConfirm(panelMode.candidate, chosen, ctx);
+      }
+      break;
+    }
+    case "letter": {
+      const chosen = actions.find((action) => ACTION_LETTERS[action] === panelAction.char);
+      if (chosen !== undefined) {
+        runOrConfirm(panelMode.candidate, chosen, ctx);
+      }
+      break;
+    }
+    case "ignore": {
+      break;
+    }
+  }
+};
+var handleListInput = (input, key, ctx) => {
+  const action = resolvePickerKeyAction(input, key);
+  switch (action.type) {
+    case "cancel": {
+      ctx.onCancel(action.reason);
+      break;
+    }
+    case "select": {
+      if (ctx.selectedCandidate !== undefined) {
+        ctx.runAction(ctx.selectedCandidate, "cd");
+      }
+      break;
+    }
+    case "up": {
+      ctx.setIndex((current) => Math.max(0, current - 1));
+      break;
+    }
+    case "down": {
+      ctx.setIndex((current) => Math.min(ctx.filteredLength - 1, current + 1));
+      break;
+    }
+    case "clear": {
+      ctx.setQuery(() => "");
+      ctx.setIndex(() => 0);
+      break;
+    }
+    case "backspace": {
+      ctx.setQuery((current) => current.slice(0, -1));
+      ctx.setIndex(() => 0);
+      break;
+    }
+    case "char": {
+      ctx.setQuery((current) => current + action.char);
+      ctx.setIndex(() => 0);
+      break;
+    }
+    case "openPanel": {
+      if (ctx.selectedCandidate !== undefined) {
+        ctx.setPanelIndex(() => 0);
+        ctx.setMode({
+          kind: "panel",
+          candidate: ctx.selectedCandidate,
+          error: null
+        });
+      }
+      break;
+    }
+    case "deleteShortcut": {
+      if (ctx.selectedCandidate !== undefined && availableActions(ctx.selectedCandidate).includes("delete")) {
+        ctx.setMode({
+          kind: "confirm",
+          action: "delete",
+          candidate: ctx.selectedCandidate
+        });
+      }
+      break;
+    }
+    case "rootSwitchShortcut": {
+      if (ctx.selectedCandidate !== undefined && availableActions(ctx.selectedCandidate).includes("switchRoot")) {
+        runOrConfirm(ctx.selectedCandidate, "switchRoot", ctx);
+      }
+      break;
+    }
+    case "ignore": {
+      break;
+    }
+  }
+};
+
+// src/ui/picker-store.ts
+var matchesQuery = (candidate, query) => query.length === 0 || candidateBranchLabel(candidate).toLowerCase().includes(query.toLowerCase());
+var panelErrorTransition = (candidate, error) => ({
+  mode: { kind: "panel", candidate, error },
+  panelIndex: 0
+});
+var createFilteredSelector = () => {
+  let cache = null;
+  return (state) => {
+    if (cache !== null && cache.candidates === state.candidates && cache.query === state.query) {
+      return cache.result;
+    }
+    const result = sortCandidatesForDisplay(state.candidates.filter((candidate) => matchesQuery(candidate, state.query)));
+    cache = { candidates: state.candidates, query: state.query, result };
+    return result;
+  };
+};
+var runMutation = async (callbacks, candidate, action) => {
+  if (action === "switchRoot") {
+    const result = await callbacks.switchRootHere(candidate);
+    if (!result.ok || result.path === undefined) {
+      return {
+        type: "patch",
+        patch: panelErrorTransition(candidate, result.message ?? "Failed to switch root.")
+      };
+    }
+    return { type: "exit", outcome: { type: "path", path: result.path } };
+  }
+  const result = await callbacks.deleteWorktree(candidate);
+  if (!result.ok) {
+    return {
+      type: "patch",
+      patch: panelErrorTransition(candidate, result.message ?? "Failed to delete worktree.")
+    };
+  }
+  const fresh = await callbacks.reloadCandidates();
+  return {
+    type: "patch",
+    patch: { candidates: fresh, mode: { kind: "list" }, index: 0 }
+  };
+};
+var createExitGuard = (onExit, onCancel) => {
+  let exited = false;
+  return {
+    isExited: () => exited,
+    guardedOnExit: (outcome) => {
+      exited = true;
+      onExit(outcome);
+    },
+    guardedOnCancel: (reason) => {
+      exited = true;
+      onCancel(reason);
+    }
+  };
+};
+var createPickerStore = (initialCandidates, callbacks, onExit, onCancel) => {
+  let state = {
+    candidates: initialCandidates,
+    query: "",
+    index: 0,
+    mode: { kind: "list" },
+    panelIndex: 0,
+    busy: false
+  };
+  const { isExited, guardedOnExit, guardedOnCancel } = createExitGuard(onExit, onCancel);
+  const listeners = new Set;
+  const getFiltered = createFilteredSelector();
+  let snapshotCache = null;
+  const notify = () => {
+    snapshotCache = null;
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const setState = (patch) => {
+    state = { ...state, ...patch };
+    notify();
+  };
+  const getSnapshot = () => {
+    if (snapshotCache !== null) {
+      return snapshotCache;
+    }
+    const filtered = getFiltered(state);
+    const clampedIndex = Math.min(state.index, Math.max(filtered.length - 1, 0));
+    snapshotCache = {
+      query: state.query,
+      filtered,
+      clampedIndex,
+      mode: state.mode,
+      panelIndex: state.panelIndex,
+      busy: state.busy
+    };
+    return snapshotCache;
+  };
+  const runAction = (candidate, action) => {
+    if (action === "cd") {
+      guardedOnExit({ type: "cd", candidate });
+      return;
+    }
+    if (state.busy) {
+      return;
+    }
+    setState({ busy: true });
+    (async () => {
+      const outcome = await runMutation(callbacks, candidate, action);
+      if (outcome.type === "exit") {
+        guardedOnExit(outcome.outcome);
+        return;
+      }
+      setState({ ...outcome.patch, busy: false });
+    })();
+  };
+  const setIndex = (updater) => {
+    setState({ index: updater(state.index) });
+  };
+  const setQuery = (updater) => {
+    setState({ query: updater(state.query) });
+  };
+  const setPanelIndex = (updater) => {
+    setState({ panelIndex: updater(state.panelIndex) });
+  };
+  const setMode = (mode) => {
+    setState({ mode });
+  };
+  const handleInput = (input, key) => {
+    if (isExited() || state.busy) {
+      return;
+    }
+    const { mode, panelIndex } = state;
+    if (mode.kind === "confirm") {
+      handleConfirmInput(input, key, mode, { runAction, setMode });
+      return;
+    }
+    if (mode.kind === "panel") {
+      handlePanelInput(input, key, mode, {
+        panelIndex,
+        runAction,
+        setPanelIndex,
+        setMode
+      });
+      return;
+    }
+    const { filtered, clampedIndex } = getSnapshot();
+    handleListInput(input, key, {
+      selectedCandidate: filtered[clampedIndex],
+      filteredLength: filtered.length,
+      runAction,
+      onCancel: guardedOnCancel,
+      setIndex,
+      setQuery,
+      setPanelIndex,
+      setMode
+    });
+  };
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  };
+  return { getSnapshot, subscribe, handleInput };
+};
+
+// src/ui/alt-screen.ts
+var ENTER_ALT_SCREEN = `${ESC}[?1049h`;
+var LEAVE_ALT_SCREEN = `${ESC}[?1049l`;
+var HIDE_CURSOR = `${ESC}[?25l`;
+var SHOW_CURSOR = `${ESC}[?25h`;
+var enterAltScreen = (target) => {
+  if (!target.isTTY) {
+    return;
+  }
+  target.write(ENTER_ALT_SCREEN + HIDE_CURSOR);
+};
+var leaveAltScreen = (target) => {
+  if (!target.isTTY) {
+    return;
+  }
+  target.write(SHOW_CURSOR + LEAVE_ALT_SCREEN);
+};
+
+// src/ui/picker-key-event.ts
+var NO_MODIFIERS = {
+  ctrl: false,
+  meta: false,
+  escape: false,
+  return: false,
+  tab: false,
+  upArrow: false,
+  downArrow: false,
+  leftArrow: false,
+  rightArrow: false,
+  backspace: false,
+  delete: false
+};
+var event = (input, key = {}) => ({
+  input,
+  key: { ...NO_MODIFIERS, ...key }
+});
+var withMeta = (keyEvent) => ({
+  input: keyEvent.input,
+  key: { ...keyEvent.key, meta: true }
+});
+
+// src/ui/picker-key-csi.ts
+var ARROW_FINAL_BYTE_A = "A".codePointAt(0);
+var ARROW_FINAL_BYTE_B = "B".codePointAt(0);
+var ARROW_FINAL_BYTE_C = "C".codePointAt(0);
+var ARROW_FINAL_BYTE_D = "D".codePointAt(0);
+var arrowModifierKey = (finalByte) => {
+  if (finalByte === ARROW_FINAL_BYTE_A) {
+    return "upArrow";
+  }
+  if (finalByte === ARROW_FINAL_BYTE_B) {
+    return "downArrow";
+  }
+  if (finalByte === ARROW_FINAL_BYTE_C) {
+    return "rightArrow";
+  }
+  if (finalByte === ARROW_FINAL_BYTE_D) {
+    return "leftArrow";
+  }
+  return null;
+};
+var modifierBitsFromParam = (param) => {
+  const bits = param - 1;
+  const CTRL_BIT = 4;
+  const ALT_BIT = 2;
+  return { ctrl: (bits & CTRL_BIT) !== 0, meta: (bits & ALT_BIT) !== 0 };
+};
+var CSI_FINAL_BYTE_MIN = 64;
+var CSI_FINAL_BYTE_MAX = 126;
+var isCsiFinalByte = (byte) => byte >= CSI_FINAL_BYTE_MIN && byte <= CSI_FINAL_BYTE_MAX;
+var CTRL_C_BYTE = 3;
+var BRACKETED_PASTE_START = "200~";
+var BRACKETED_PASTE_END = "201~";
+var modifiedArrowOrDelete = (paramText, finalByte) => {
+  const MODIFIED_PATTERN = /^\d+;\d+$/u;
+  const DELETE_PARAM = "3";
+  if (finalByte === "~" && (paramText === DELETE_PARAM || paramText.startsWith(`${DELETE_PARAM};`))) {
+    return event("", { delete: true });
+  }
+  const arrowKey = arrowModifierKey(finalByte.codePointAt(0));
+  if (arrowKey === null || !(paramText === "" || MODIFIED_PATTERN.test(paramText))) {
+    return null;
+  }
+  const [, modifierParam] = paramText.split(";");
+  const mods = modifierParam === undefined ? {} : modifierBitsFromParam(Number(modifierParam));
+  return event("", { [arrowKey]: true, ...mods });
+};
+var parseCsi = (buf) => {
+  const CSI_PREFIX_LENGTH = 2;
+  let index = CSI_PREFIX_LENGTH;
+  let paramText = "";
+  while (index < buf.length && !isCsiFinalByte(buf[index])) {
+    const paramByte = buf[index];
+    if (paramByte === CTRL_C_BYTE) {
+      return {
+        kind: "interrupted",
+        consumed: index + 1,
+        event: event("c", { ctrl: true })
+      };
+    }
+    paramText += String.fromCodePoint(paramByte);
+    index += 1;
+  }
+  if (index >= buf.length) {
+    return { kind: "incomplete" };
+  }
+  const finalByte = String.fromCodePoint(buf[index]);
+  const consumed = index + 1;
+  const full = paramText + finalByte;
+  if (full === BRACKETED_PASTE_START) {
+    return { kind: "resolved", consumed, event: null, pasteStarted: true };
+  }
+  if (full === BRACKETED_PASTE_END) {
+    return { kind: "resolved", consumed, event: null, pasteEnded: true };
+  }
+  return {
+    kind: "resolved",
+    consumed,
+    event: modifiedArrowOrDelete(paramText, finalByte)
+  };
+};
+var SS3_SEQUENCE_LENGTH = 3;
+var parseSs3 = (buf) => {
+  if (buf.length < SS3_SEQUENCE_LENGTH) {
+    return { kind: "incomplete" };
+  }
+  const finalByte = buf[2];
+  if (finalByte === CTRL_C_BYTE) {
+    return {
+      kind: "interrupted",
+      consumed: SS3_SEQUENCE_LENGTH,
+      event: event("c", { ctrl: true })
+    };
+  }
+  const arrowKey = arrowModifierKey(finalByte);
+  return {
+    kind: "resolved",
+    consumed: SS3_SEQUENCE_LENGTH,
+    event: arrowKey === null ? null : event("", { [arrowKey]: true })
+  };
+};
+
+// src/ui/picker-key-parser.ts
+var ESC2 = 27;
+var BACKSPACE_DEL = 127;
+var BACKSPACE_BS = 8;
+var TAB = 9;
+var LF = 10;
+var CR = 13;
+var CTRL_LETTER_START = 1;
+var CTRL_LETTER_END = 26;
+var CTRL_LETTER_OFFSET = "a".codePointAt(0);
+var ctrlLetterFromByte = (byte) => String.fromCodePoint(byte + CTRL_LETTER_OFFSET - 1);
+var ONE_BYTE_MAX = 127;
+var TWO_BYTE_MASK = 224;
+var TWO_BYTE_PREFIX = 192;
+var THREE_BYTE_MASK = 240;
+var THREE_BYTE_PREFIX = 224;
+var FOUR_BYTE_MASK = 248;
+var FOUR_BYTE_PREFIX = 240;
+var UTF8_ONE_BYTE_LENGTH = 1;
+var UTF8_TWO_BYTE_LENGTH = 2;
+var UTF8_THREE_BYTE_LENGTH = 3;
+var UTF8_FOUR_BYTE_LENGTH = 4;
+var utf8SequenceLength = (leadByte) => {
+  if (leadByte <= ONE_BYTE_MAX) {
+    return UTF8_ONE_BYTE_LENGTH;
+  }
+  if ((leadByte & TWO_BYTE_MASK) === TWO_BYTE_PREFIX) {
+    return UTF8_TWO_BYTE_LENGTH;
+  }
+  if ((leadByte & THREE_BYTE_MASK) === THREE_BYTE_PREFIX) {
+    return UTF8_THREE_BYTE_LENGTH;
+  }
+  if ((leadByte & FOUR_BYTE_MASK) === FOUR_BYTE_PREFIX) {
+    return UTF8_FOUR_BYTE_LENGTH;
+  }
+  return UTF8_ONE_BYTE_LENGTH;
+};
+var decodeUtf8 = (bytes) => new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+var CONTROL_CODEPOINT_MAX = 31;
+var DEL_CODEPOINT = 127;
+var C1_CONTROL_MIN = 128;
+var C1_CONTROL_MAX = 159;
+var isPrintableChar = (char) => {
+  const codePoint = char.codePointAt(0) ?? 0;
+  if (codePoint <= CONTROL_CODEPOINT_MAX || codePoint === DEL_CODEPOINT) {
+    return false;
+  }
+  return codePoint < C1_CONTROL_MIN || codePoint > C1_CONTROL_MAX;
+};
+var pastedTextToEvents = (text) => [...text].filter((char) => isPrintableChar(char)).map((char) => event(char));
+var CSI_INTRODUCER_CODE = "[".codePointAt(0);
+var SS3_INTRODUCER_CODE = "O".codePointAt(0);
+var MAX_PENDING_SEQUENCE_BYTES = 32;
+var PASTE_END_MARKER = Buffer.concat([
+  Buffer.from([ESC2]),
+  Buffer.from(`[${BRACKETED_PASTE_END}`)
+]);
+
+class PickerKeyParser {
+  buffer = Buffer.alloc(0);
+  inPaste = false;
+  hasPendingEscape() {
+    return !this.inPaste && this.buffer.length === 1 && this.buffer[0] === ESC2;
+  }
+  flushPendingEscape() {
+    if (!this.hasPendingEscape()) {
+      return null;
+    }
+    this.buffer = Buffer.alloc(0);
+    return event("", { escape: true });
+  }
+  feed(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    const results = [];
+    let step = this.inPaste ? this.stepPaste() : this.step();
+    while (step !== null) {
+      results.push(...step);
+      step = this.inPaste ? this.stepPaste() : this.step();
+    }
+    return results;
+  }
+  stepPaste() {
+    if (this.buffer.length === 0) {
+      return null;
+    }
+    const markerIndex = this.buffer.indexOf(PASTE_END_MARKER);
+    if (markerIndex !== -1) {
+      const text = decodeUtf8(this.buffer.subarray(0, markerIndex));
+      this.buffer = this.buffer.subarray(markerIndex + PASTE_END_MARKER.length);
+      this.inPaste = false;
+      return pastedTextToEvents(text);
+    }
+    const maxOverlap = Math.min(PASTE_END_MARKER.length - 1, this.buffer.length);
+    let overlap = 0;
+    for (let candidate = maxOverlap;candidate > 0; candidate -= 1) {
+      const tail = this.buffer.subarray(this.buffer.length - candidate);
+      if (tail.equals(PASTE_END_MARKER.subarray(0, candidate))) {
+        overlap = candidate;
+        break;
+      }
+    }
+    const safeLength = this.buffer.length - overlap;
+    if (safeLength === 0) {
+      return null;
+    }
+    const text = decodeUtf8(this.buffer.subarray(0, safeLength));
+    this.buffer = this.buffer.subarray(safeLength);
+    return text.length > 0 ? pastedTextToEvents(text) : null;
+  }
+  step() {
+    if (this.buffer.length === 0) {
+      return null;
+    }
+    const first = this.buffer[0];
+    if (first === ESC2) {
+      return this.stepEscape();
+    }
+    if (first === CR) {
+      this.buffer = this.buffer.subarray(1);
+      return [event("", { return: true })];
+    }
+    if (first === LF) {
+      this.buffer = this.buffer.subarray(1);
+      return [event(`
+`)];
+    }
+    if (first === TAB) {
+      this.buffer = this.buffer.subarray(1);
+      return [event("", { tab: true })];
+    }
+    if (first === BACKSPACE_DEL || first === BACKSPACE_BS) {
+      this.buffer = this.buffer.subarray(1);
+      return [event("", { backspace: true })];
+    }
+    if (first >= CTRL_LETTER_START && first <= CTRL_LETTER_END) {
+      this.buffer = this.buffer.subarray(1);
+      return [event(ctrlLetterFromByte(first), { ctrl: true })];
+    }
+    if (first <= CONTROL_CODEPOINT_MAX) {
+      this.buffer = this.buffer.subarray(1);
+      return [];
+    }
+    return this.stepUtf8Char();
+  }
+  stepEscape() {
+    if (this.buffer.length === 1) {
+      return null;
+    }
+    const second = this.buffer[1];
+    if (second === CSI_INTRODUCER_CODE) {
+      return this.applySequence(parseCsi(this.buffer));
+    }
+    if (second === SS3_INTRODUCER_CODE) {
+      return this.applySequence(parseSs3(this.buffer));
+    }
+    this.buffer = this.buffer.subarray(1);
+    const inner = this.stepUtf8Char();
+    return inner === null ? null : inner.map((keyEvent) => withMeta(keyEvent));
+  }
+  applySequence(result) {
+    if (result.kind === "incomplete") {
+      if (this.buffer.length > MAX_PENDING_SEQUENCE_BYTES) {
+        this.buffer = Buffer.alloc(0);
+      }
+      return null;
+    }
+    if (result.kind === "interrupted") {
+      this.buffer = this.buffer.subarray(result.consumed);
+      return [result.event];
+    }
+    this.buffer = this.buffer.subarray(result.consumed);
+    if (result.pasteStarted === true) {
+      this.inPaste = true;
+    }
+    if (result.pasteEnded === true) {
+      this.inPaste = false;
+    }
+    return result.event === null ? [] : [result.event];
+  }
+  stepUtf8Char() {
+    const leadByte = this.buffer[0];
+    const length = utf8SequenceLength(leadByte);
+    if (this.buffer.length < length) {
+      return null;
+    }
+    const bytes = this.buffer.subarray(0, length);
+    this.buffer = this.buffer.subarray(length);
+    const char = decodeUtf8(bytes);
+    return char.length > 0 ? [event(char)] : [];
+  }
+}
+
+// src/ui/terminal-session.ts
+var ENABLE_BRACKETED_PASTE = `${ESC}[?2004h`;
+var DISABLE_BRACKETED_PASTE = `${ESC}[?2004l`;
+var PENDING_ESCAPE_TIMEOUT_MS = 25;
+var EXIT_SIGTERM = 143;
+var EXIT_SIGHUP = 129;
+var defaultStreams = () => ({
+  stdin: process.stdin,
+  stderr: process.stderr
+});
+var runSafely = (step) => {
+  try {
+    step();
+  } catch {}
+};
+var createCleanup = (deps) => {
+  let hasCleanedUp = false;
+  return () => {
+    if (hasCleanedUp) {
+      return;
+    }
+    hasCleanedUp = true;
+    runSafely(deps.clearPendingEscapeTimer);
+    if (deps.isInteractive) {
+      runSafely(() => {
+        deps.stdin.off("data", deps.handleData);
+      });
+      runSafely(() => {
+        deps.stdin.setRawMode?.(false);
+      });
+      runSafely(() => {
+        deps.stdin.pause();
+      });
+      runSafely(() => {
+        deps.altScreenTarget.write(DISABLE_BRACKETED_PASTE);
+      });
+    }
+    runSafely(() => {
+      deps.stderr.off("resize", deps.handleResize);
+    });
+    runSafely(() => {
+      leaveAltScreen(deps.altScreenTarget);
+    });
+  };
+};
+var installExitSignalHandler = (signal, code, cleanup) => {
+  const handleSignal = () => {
+    cleanup();
+    process.exitCode = code;
+    process.exit(code);
+  };
+  process.once(signal, handleSignal);
+  return () => {
+    process.removeListener(signal, handleSignal);
+  };
+};
+var installExitSignalHandlers = (cleanup) => {
+  const removeSigint = installExitSignalHandler("SIGINT", EXIT_CANCELLED, cleanup);
+  const removeSigterm = installExitSignalHandler("SIGTERM", EXIT_SIGTERM, cleanup);
+  const removeSighup = installExitSignalHandler("SIGHUP", EXIT_SIGHUP, cleanup);
+  return () => {
+    removeSigint();
+    removeSigterm();
+    removeSighup();
+  };
+};
+var runTerminalSession = (createHandlers, streams = defaultStreams()) => new Promise((resolve) => {
+  const { stdin, stderr } = streams;
+  const altScreenTarget = {
+    isTTY: stderr.isTTY === true,
+    write: (data) => {
+      stderr.write(data);
+    }
+  };
+  const isInteractive = stdin.isTTY === true && altScreenTarget.isTTY;
+  const parser = new PickerKeyParser;
+  let pendingEscapeTimer = null;
+  let renderScheduled = false;
+  let finished = false;
+  let handlers = null;
+  const clearPendingEscapeTimer = () => {
+    if (pendingEscapeTimer !== null) {
+      clearTimeout(pendingEscapeTimer);
+      pendingEscapeTimer = null;
+    }
+  };
+  const paint = () => {
+    renderScheduled = false;
+    if (finished || handlers === null) {
+      return;
+    }
+    altScreenTarget.write(handlers.buildFrame());
+  };
+  const requestRender = () => {
+    if (finished || renderScheduled) {
+      return;
+    }
+    renderScheduled = true;
+    queueMicrotask(paint);
+  };
+  const finish = (result) => {
+    if (finished) {
+      return;
+    }
+    finished = true;
+    cleanup();
+    removeSignalListeners();
+    resolve(result);
+  };
+  const scheduleEscapeFlush = () => {
+    clearPendingEscapeTimer();
+    pendingEscapeTimer = setTimeout(() => {
+      pendingEscapeTimer = null;
+      const flushed = parser.flushPendingEscape();
+      if (flushed !== null) {
+        handlers?.onKey(flushed);
+      }
+    }, PENDING_ESCAPE_TIMEOUT_MS);
+  };
+  const handleData = (chunk) => {
+    for (const event of parser.feed(chunk)) {
+      if (finished) {
+        return;
+      }
+      handlers?.onKey(event);
+    }
+    if (finished) {
+      return;
+    }
+    if (parser.hasPendingEscape()) {
+      scheduleEscapeFlush();
+    } else {
+      clearPendingEscapeTimer();
+    }
+  };
+  const handleResize = () => {
+    requestRender();
+  };
+  const cleanup = createCleanup({
+    stdin,
+    stderr,
+    altScreenTarget,
+    isInteractive,
+    handleData,
+    handleResize,
+    clearPendingEscapeTimer
+  });
+  const removeSignalListeners = installExitSignalHandlers(cleanup);
+  process.once("exit", cleanup);
+  enterAltScreen(altScreenTarget);
+  if (isInteractive) {
+    altScreenTarget.write(ENABLE_BRACKETED_PASTE);
+    stdin.setRawMode?.(true);
+    stdin.resume();
+    stdin.on("data", handleData);
+  }
+  if (altScreenTarget.isTTY) {
+    stderr.on("resize", handleResize);
+  }
+  handlers = createHandlers({ requestRender, finish });
+  requestRender();
+});
+
+// src/ui/picker.ts
+var DEFAULT_TERMINAL_WIDTH = 80;
+var terminalDimension = (value, fallback) => value !== undefined && value > 0 ? value : fallback;
+var colorEnabled = (stderr) => stderr.isTTY === true && (process.env["NO_COLOR"] ?? "") === "";
+var isCtrlC = (event) => event.key.ctrl && event.input === "c";
+var runPicker = (candidates, callbacks) => runTerminalSession(({ requestRender, finish }) => {
+  const store = createPickerStore(candidates, callbacks, (outcome) => finish(outcome), (reason) => finish({ type: "cancelled", reason }));
+  store.subscribe(requestRender);
+  return {
+    onKey: (event) => {
+      if (isCtrlC(event)) {
+        finish({ type: "cancelled", reason: "ctrlC" });
+        return;
+      }
+      store.handleInput(event.input, event.key);
+    },
+    buildFrame: () => renderPickerFrame({
+      snapshot: store.getSnapshot(),
+      width: terminalDimension(process.stderr.columns, DEFAULT_TERMINAL_WIDTH),
+      height: terminalDimension(process.stderr.rows, DEFAULT_TERMINAL_HEIGHT),
+      colorEnabled: colorEnabled(process.stderr)
+    })
+  };
+});
+
+// src/cli-pick.ts
+var loadPickCandidates = async (git, fs, json) => {
+  const pickResult = await pick(git, fs, { cwd: process.cwd() });
+  if (!pickResult.ok) {
+    reportResult("pick", pickResult, json);
+    return null;
+  }
+  return pickResult.data?.candidates ?? [];
+};
+var deleteWorktree = async (git, fs, candidate) => {
+  const branch = candidateBranchName(candidate);
+  if (branch === null) {
+    return { ok: false, message: "This candidate has no branch to remove." };
+  }
+  const result = await rm2(git, fs, {
+    cwd: process.cwd(),
+    branch,
+    ...candidate.kind === "worktree" ? { expectedPath: candidate.worktree.path } : {},
+    allowPrunable: candidate.kind === "worktree" && candidate.worktree.prunable,
+    force: false,
+    ext: false
+  });
+  if (!result.ok) {
+    return {
+      ok: false,
+      message: result.errorMessage ?? "Failed to remove worktree."
+    };
+  }
+  return { ok: true };
+};
+var createPickerCallbacks = (git, fs, json, onSwitchedBranch) => ({
+  deleteWorktree: (candidate) => deleteWorktree(git, fs, candidate),
+  switchRootHere: async (candidate) => {
+    const branch = candidateBranchName(candidate);
+    if (branch === null) {
+      return {
+        ok: false,
+        message: "This candidate has no branch to switch to."
+      };
+    }
+    const result = await root2(git, fs, {
+      cwd: process.cwd(),
+      target: branch,
+      allowExternalHolderSwap: candidate.kind === "worktree" && candidate.worktree.kind === "external",
+      ...candidate.kind === "worktree" ? { expectedHolderPath: candidate.worktree.path } : {}
+    });
+    if (!result.ok) {
+      return {
+        ok: false,
+        message: result.errorMessage ?? "Failed to switch root."
+      };
+    }
+    onSwitchedBranch({
+      branch,
+      detachedHolder: result.data?.detachedHolder ?? null,
+      warnings: result.warnings ?? []
+    });
+    return {
+      ok: true,
+      ...result.path === undefined ? {} : { path: result.path }
+    };
+  },
+  reloadCandidates: async () => await loadPickCandidates(git, fs, json) ?? []
+});
+var runInteractivePicker = (candidates, callbacks) => runPicker(candidates, callbacks);
+var renderSwitchRootOutcome = (path, outcome, json) => {
+  const branch = outcome?.branch ?? null;
+  const detachedHolder = outcome?.detachedHolder ?? null;
+  const warnings = outcome?.warnings ?? [];
+  render("root", ok({ path, data: { branch, switched: true, detachedHolder }, warnings }), json);
+};
+export {
+  createPickerCallbacks,
+  loadPickCandidates,
+  renderSwitchRootOutcome,
+  runInteractivePicker
+};