@n-seiji/nuthatch 0.1.7 → 0.2.1

package/README.ja.md

@@ -40,8 +40,8 @@ hop -- <branch>    # 予約コマンドと被る branch 名をエスケープ
 hop --help         # usage を表示 (-h / hop help でも同じ)
 
 hop --version          # hop の version を表示
-hop --update           # 最新リリースへ、インストールした方法のまま更新
-hop --update --check   # --update が何をするかを報告するだけ — 何も変更しない
+hop --update           # standalone バイナリを最新リリースへ置換 (それ以外は更新方法を表示)
+hop --update --check   # 更新があるかを報告するだけ — 何も変更しない
 ```
 
 同じ branch が複数の worktree で checkout されている場合、branch だけを指定する
@@ -92,7 +92,7 @@ action を選ぶ間も一覧が見え続ける。横に並べられない幅 (
 | `Tab`, `→`, `Ctrl+L`, `Ctrl+F` | 選択中の候補の action panel を開く (ここで cd / 削除 / root 切替) |
 | `Ctrl+X` | 選択中の worktree を削除 (常に先に y/N を確認) |
 | `Ctrl+R` | root clone を選択中の branch へ切替 (`external` は先に y/N を確認) |
-| `↑`/`↓`, `Ctrl+P`/`Ctrl+N`, `Ctrl+K`/`Ctrl+J` | 選択を移動 (矢印・emacs・vim キーがすべて併用可) |
+| `↑`/`↓`, `Ctrl+P`/`Ctrl+N`, `Ctrl+K` | 選択を移動 (矢印・emacs・vim キーがすべて併用可) |
 | `Esc` | 静かにキャンセル — exit 0、stdout は空のまま (shell wrapper は cd しない) |
 | `Ctrl+C` | 割り込みとしてキャンセル — exit 130、実際の SIGINT と同じ |
 
@@ -142,30 +142,40 @@ install script は `hop` を `~/.local/bin` に置き (`HOP_INSTALL_DIR` で
 には `HOP_VERSION=vX.Y.Z` を使う。Linux arm64 はビルド済みバイナリが
 まだないため、npm install を使う。
 
+v0.2.0 より後のリリースのバイナリにはビルド来歴 (build provenance) の attestation
+が付く。ダウンロードしたバイナリを手動で検証するには:
+
+```sh
+gh attestation verify ./hop-darwin-arm64 --repo n-seiji/nuthatch \
+  --signer-workflow github.com/n-seiji/nuthatch/.github/workflows/release.yml
+```
+
+`install.sh` は attestation を確認せず、SHA-256 だけを検証する。
+
 ### 更新
 
 ```sh
-hop --update          # 最新リリースへ、インストールした方法のまま更新
-hop --update --check  # 報告だけ: current / latest / method / 実行されるコマンド
+hop --update          # standalone バイナリを最新リリースへ置換
+hop --update --check  # 報告だけ: current / latest / インストール方法 / すべきこと
 hop --version         # 今どの version か
 ```
 
-`hop --update` は hop のインストール方法を判定する。`install.sh` で入れた
-バイナリは、置き場のディレクトリに書き込めて (バイナリと checksum の
-ダウンロードの前に確認する)、かつリリースに添付された `.sha256` と SHA-256 が
-一致した場合にだけその場で差し替える — 不一致なら何も置換しない。
-mise / npm / bun 経由の install は、そのツール自身の upgrade コマンド
-(`mise upgrade …`、
-`npm install -g --prefix <hop が入っている prefix> @n-seiji/nuthatch@latest`、
-`bun add -g @n-seiji/nuthatch@latest`) をホームディレクトリで実行して更新する
-ので、グローバルの mise 設定で固定した version が優先され (hop は先に mise へ
-問い合わせ、upgrade するものが無ければ警告する)、プロジェクトの `mise.toml`
-には左右されず、npm の更新は hop が今入っている prefix に入る。`npx` / `bunx`、
-ソースチェックアウト、Homebrew・Nix・aqua・proto など他のバージョン管理ツール
-が自分用にコピーを持っているバイナリ、hop が扱わない配置 (pnpm・yarn の
-global、プロジェクトの依存) は、代わりにどうすればよいかを示して拒否する。
-hop がネットワークに出るのはこれだけで、GitHub と npm の固定アドレスへの
-HTTPS リクエストのみ (タイムアウトとサイズ上限つき)。
+`hop --update` が置換するのは `install.sh` で入れたバイナリだけで、置き場の
+ディレクトリに書き込めて (バイナリと checksum のダウンロードの前に確認する)、
+かつリリースに添付された `.sha256` と SHA-256 が一致した場合に限る — 不一致なら
+何も置換しない (確認するのは SHA-256 のみで、attestation は見ない)。それ以外のインストールでは、何も実行せず、リクエストも送らず、
+更新方法を 1 行表示して終了する (exit 1):
+
+| インストール方法 | 更新方法 |
+|---|---|
+| `install.sh` (`~/.local/bin` のバイナリ) | `hop --update`、または `install.sh` を再実行 |
+| mise | `mise upgrade` |
+| npm / bun / pnpm / yarn の global | `npm i -g @n-seiji/nuthatch@latest` (または使っているパッケージマネージャの同等コマンド) |
+| Homebrew・Nix・aqua・proto・ソースチェックアウト・その他のツール | そのツール自身の upgrade コマンド |
+
+`hop --update --check` はどのインストール方法でも使え、同じ案内を報告する。
+hop がネットワークに出るのは GitHub の固定アドレスへの HTTPS リクエストだけで、
+タイムアウトとサイズ上限つき。
 
 ## トラブルシューティング
 

package/README.md

@@ -42,8 +42,8 @@ hop -- <branch>    # escape a branch name that collides with a reserved command
 hop --help         # print usage (also -h / hop help)
 
 hop --version          # print hop's version
-hop --update           # update hop to the latest release, the way it was installed
-hop --update --check   # only report what --update would do — changes nothing
+hop --update           # replace a standalone binary with the latest release (other installs: prints how to update)
+hop --update --check   # only report whether an update is available — changes nothing
 ```
 
 If Git reports the same branch checked out in multiple worktrees, the
@@ -100,7 +100,7 @@ below the list instead.
 | `Tab`, `→`, `Ctrl+L`, `Ctrl+F` | Open the action panel for the selected candidate (cd / delete / switch root here) |
 | `Ctrl+X` | Delete the selected worktree (always asks y/N first) |
 | `Ctrl+R` | Switch the root clone to the selected branch (asks y/N first for an `external` worktree) |
-| `↑`/`↓`, `Ctrl+P`/`Ctrl+N`, `Ctrl+K`/`Ctrl+J` | Move the selection (arrow, emacs, and vim keys all work side by side) |
+| `↑`/`↓`, `Ctrl+P`/`Ctrl+N`, `Ctrl+K` | Move the selection (arrow, emacs, and vim keys all work side by side) |
 | `Esc` | Cancel quietly — exit 0, stdout stays empty (the shell wrapper just doesn't cd) |
 | `Ctrl+C` | Cancel like an interrupt — exit 130, same as a real SIGINT |
 
@@ -148,30 +148,40 @@ The install script places `hop` in `~/.local/bin` (override with
 specific version with `HOP_VERSION=vX.Y.Z`. Linux arm64 has no prebuilt
 binary yet — use the npm install instead.
 
+Release binaries from releases after v0.2.0 carry a build-provenance
+attestation. To verify a downloaded binary by hand:
+
+```sh
+gh attestation verify ./hop-darwin-arm64 --repo n-seiji/nuthatch \
+  --signer-workflow github.com/n-seiji/nuthatch/.github/workflows/release.yml
+```
+
+`install.sh` does not check it; it verifies the SHA-256 only.
+
 ### Updating
 
 ```sh
-hop --update          # update to the latest release, the way hop was installed
-hop --update --check  # just report: current, latest, method, and the command it would run
+hop --update          # replace a standalone binary with the latest release
+hop --update --check  # just report: current, latest, how hop was installed, what to do
 hop --version         # which version do I have?
 ```
 
-`hop --update` detects how hop was installed. A binary from `install.sh` is
-replaced in place, but only if its directory is writable (checked before the
-binary or its checksum is downloaded) and only after its SHA-256 matches the
-`.sha256` attached to the release — on a mismatch nothing is replaced. A mise /
-npm / bun install is updated by running that tool's own upgrade command from
-your home directory (`mise upgrade …`,
-`npm install -g --prefix <the prefix hop lives in> @n-seiji/nuthatch@latest`,
-`bun add -g @n-seiji/nuthatch@latest`), so a version pinned in your global mise
-config still wins (hop asks mise first and warns when it has nothing to
-upgrade), a project's own `mise.toml` cannot interfere, and an npm update lands
-in the prefix hop is already in. `npx` / `bunx`, a source checkout, a binary
-that Homebrew, Nix, aqua, proto or another version manager keeps its own copy
-of, and layouts hop does not drive (a pnpm or yarn global, a project
-dependency) are refused with a note on what to do instead. This is the only
-thing hop does over the network: HTTPS requests to fixed GitHub and npm
-addresses, each with a timeout and a size cap.
+`hop --update` only replaces the binary that `install.sh` installs, and only if
+its directory is writable (checked before the binary or its checksum is
+downloaded) and its SHA-256 matches the `.sha256` attached to the release; on a
+mismatch nothing is replaced (SHA-256 only; attestations are not checked). For any other install it runs nothing, makes no
+request, and prints one line saying how to update it (exit 1):
+
+| Installed with | Update with |
+|---|---|
+| `install.sh` (binary in `~/.local/bin`) | `hop --update`, or re-run `install.sh` |
+| mise | `mise upgrade` |
+| npm / bun / pnpm / yarn global | `npm i -g @n-seiji/nuthatch@latest` (or your package manager's equivalent) |
+| Homebrew, Nix, aqua, proto, a source checkout, any other tool | that tool's own upgrade command |
+
+`hop --update --check` works for every install and reports the same hint. The
+only network traffic is HTTPS requests to fixed GitHub addresses, each with a
+timeout and a size cap.
 
 ## Troubleshooting
 

package/dist/{clean-n2f9z8n3.js → clean-rn2476my.js}

@@ -1,22 +1,23 @@
 import {
   messageOf
-} from "./cli-qrxgkskr.js";
+} from "./cli-ph0gp56k.js";
 import {
   upstreamStateOf
-} from "./cli-pqd2qe7v.js";
+} from "./cli-btqjpf1q.js";
 import {
   withRepoLock
-} from "./cli-rcw5adqd.js";
+} from "./cli-wcnyhk4w.js";
 import {
+  isOptionLikeRef,
   loadRepoContext,
   nestedWorktrees,
   worktreeDirtyState
-} from "./cli-7jg5qqs9.js";
+} from "./cli-y8vsqre6.js";
 import {
   EXIT_USAGE_ERROR,
   ok,
   fail
-} from "./cli-2bhb9p0x.js";
+} from "./cli-77yanq37.js";
 
 // src/domain/garbage.ts
 var classifyGarbage = (input) => {
@@ -41,9 +42,15 @@ var buildCleanCandidates = async (git, fs, context, ext) => {
     git.resolveDefaultBranchRef(context.rootPath),
     git.upstreamStates(context.rootPath)
   ]);
-  const targets = context.worktrees.filter((wt) => wt.kind === "managed" || ext && wt.kind === "external");
+  const targets = context.worktrees.filter((wt) => (wt.kind === "managed" || ext && wt.kind === "external") && !(wt.branch !== null && isOptionLikeRef(wt.branch)));
   const results = await Promise.all(targets.map(async (wt) => {
-    const reason = await classifyWorktree(wt, { git, fs, defaultRef, upstreams, context });
+    const reason = await classifyWorktree(wt, {
+      git,
+      fs,
+      defaultRef,
+      upstreams,
+      context
+    });
     if (reason === null) {
       return null;
     }
@@ -51,6 +58,17 @@ var buildCleanCandidates = async (git, fs, context, ext) => {
   }));
   return results.filter((candidate) => candidate !== null);
 };
+var branchMergeFacts = async (git, rootPath, branch, { defaultRef, upstreams }) => {
+  const upstreamGone = upstreamStateOf(upstreams, branch).kind === "gone";
+  const mergedIntoDefault = defaultRef === null ? "unknown" : await git.isAncestor(rootPath, branch, defaultRef);
+  const allCommitsReachableFromDefault = defaultRef === null || mergedIntoDefault === true || !upstreamGone ? "unknown" : await git.hasEquivalentCommits(rootPath, branch, defaultRef);
+  return {
+    prunable: false,
+    upstreamGone,
+    mergedIntoDefault,
+    allCommitsReachableFromDefault
+  };
+};
 var classifyWorktree = async (wt, { git, fs, defaultRef, upstreams, context }) => {
   if (wt.prunable) {
     return classifyGarbage({
@@ -65,15 +83,10 @@ var classifyWorktree = async (wt, { git, fs, defaultRef, upstreams, context }) =
     return null;
   }
   const { rootPath, worktrees } = context;
-  const upstreamGone = upstreamStateOf(upstreams, wt.branch).kind === "gone";
-  const mergedIntoDefault = defaultRef === null ? "unknown" : await git.isAncestor(rootPath, wt.branch, defaultRef);
-  const allCommitsReachableFromDefault = defaultRef === null || mergedIntoDefault === true || !upstreamGone ? "unknown" : await git.hasEquivalentCommits(rootPath, wt.branch, defaultRef);
-  const facts = {
-    prunable: false,
-    mergedIntoDefault,
-    upstreamGone,
-    allCommitsReachableFromDefault
-  };
+  const facts = await branchMergeFacts(git, rootPath, wt.branch, {
+    defaultRef,
+    upstreams
+  });
   if (classifyGarbage({ ...facts, clean: true }) === null) {
     return null;
   }
@@ -132,23 +145,19 @@ var removeCandidate = async ({
     return "failed";
   }
 };
-var canDeletePrunableBranch = async (git, rootPath, candidate, { defaultRef, upstreams }) => {
+var canDeletePrunableBranch = async (git, rootPath, candidate, facts) => {
   if (candidate.reason !== "prunable") {
     return true;
   }
-  if (candidate.branch.length === 0 || defaultRef === null) {
+  if (candidate.branch.length === 0) {
     return false;
   }
   try {
-    const mergedIntoDefault = await git.isAncestor(rootPath, candidate.branch, defaultRef);
-    if (mergedIntoDefault === true) {
-      return true;
-    }
-    if (upstreamStateOf(upstreams, candidate.branch).kind === "gone") {
-      return await git.hasEquivalentCommits(rootPath, candidate.branch, defaultRef) === true;
-    }
-  } catch {}
-  return false;
+    const branchFacts = await branchMergeFacts(git, rootPath, candidate.branch, facts);
+    return classifyGarbage({ ...branchFacts, clean: true }) !== null;
+  } catch {
+    return false;
+  }
 };
 var executeClean = ({
   git,

package/dist/cli-26d2drt6.js

@@ -0,0 +1,30 @@
+// src/infra/term.ts
+import { createInterface } from "node:readline";
+var colorEnabled = (stream) => stream.isTTY === true && (process.env["NO_COLOR"] ?? "") === "";
+var createTermPort = () => ({
+  isTTY() {
+    return process.stderr.isTTY === true && process.stdin.isTTY === true;
+  },
+  logStderr(message) {
+    process.stderr.write(`${message}
+`);
+  },
+  confirm(message) {
+    return new Promise((resolve) => {
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stderr,
+        terminal: false
+      });
+      rl.question(`${message} [y/N] `, (answer) => {
+        rl.close();
+        resolve(answer.trim().toLowerCase() === "y");
+      });
+      rl.once("close", () => {
+        resolve(false);
+      });
+    });
+  }
+});
+
+export { colorEnabled, createTermPort };

package/dist/{cli-2bhb9p0x.js → cli-77yanq37.js}

@@ -15,5 +15,7 @@ var fail = (exitCode, errorMessage, warnings) => ({
   errorMessage,
   ...warnings === undefined || warnings.length === 0 ? {} : { warnings }
 });
+var pass = (value) => ({ ok: true, value });
+var reject = (rejection) => ({ ok: false, rejection });
 
-export { EXIT_SUCCESS, EXIT_GENERAL_ERROR, EXIT_USAGE_ERROR, EXIT_SAFE_REJECTION, EXIT_CANCELLED, ok, fail };
+export { EXIT_SUCCESS, EXIT_GENERAL_ERROR, EXIT_USAGE_ERROR, EXIT_SAFE_REJECTION, EXIT_CANCELLED, ok, fail, pass, reject };

package/dist/{cli-23z98dw1.js → cli-9n04gsq1.js}

@@ -1,24 +1,26 @@
 import {
   messageOf
-} from "./cli-qrxgkskr.js";
+} from "./cli-ph0gp56k.js";
 import {
   withRepoLock
-} from "./cli-rcw5adqd.js";
+} from "./cli-wcnyhk4w.js";
 import {
+  optionLikeRefRejection,
   loadRepoContext,
   nestedWorktrees,
   worktreeDirtyState
-} from "./cli-7jg5qqs9.js";
+} from "./cli-y8vsqre6.js";
 import {
   EXIT_GENERAL_ERROR,
   EXIT_USAGE_ERROR,
   EXIT_SAFE_REJECTION,
   ok,
-  fail
-} from "./cli-2bhb9p0x.js";
+  fail,
+  pass,
+  reject
+} from "./cli-77yanq37.js";
 
 // src/commands/rm.ts
-var EXT_DEPRECATION_WARNING = "--ext is deprecated and no longer required: hop rm can now remove external worktrees without it.";
 var lockedRejection = (branch, lockReason) => fail(EXIT_SAFE_REJECTION, `Worktree for "${branch}" is locked by git${lockReason === null ? "" : ` (${lockReason})`}. hop never unlocks worktrees automatically — run "git worktree unlock" yourself first if you're sure.`);
 var turnedPrunableRejection = (branch) => fail(EXIT_SAFE_REJECTION, `The selected worktree for "${branch}" changed before removal (git now reports it prunable). Refresh the picker and retry.`);
 var stalePrunableWarning = ({ path, prunableReason }) => `Worktree at ${path} no longer exists${prunableReason === null ? "" : ` (${prunableReason})`}; removed its stale registration — if it had been moved by hand, the moved copy is no longer linked to this repository.`;
@@ -26,17 +28,13 @@ var resolveTarget = (worktrees, branch, expectedPath) => {
   const matches = worktrees.filter((wt) => wt.branch === branch);
   if (expectedPath !== undefined) {
     const target = matches.find((wt) => wt.path === expectedPath);
-    return target === undefined ? {
-      rejection: fail(EXIT_SAFE_REJECTION, `The selected worktree for "${branch}" changed before removal. Refresh the picker and retry.`)
-    } : { target };
+    return target === undefined ? reject(fail(EXIT_SAFE_REJECTION, `The selected worktree for "${branch}" changed before removal. Refresh the picker and retry.`)) : pass(target);
   }
   if (matches.length > 1) {
-    return {
-      rejection: fail(EXIT_SAFE_REJECTION, `Branch "${branch}" is checked out at ${matches.length} worktrees (${matches.map((wt) => wt.path).join(", ")}). Refusing to guess which one to remove.`)
-    };
+    return reject(fail(EXIT_SAFE_REJECTION, `Branch "${branch}" is checked out at ${matches.length} worktrees (${matches.map((wt) => wt.path).join(", ")}). Refusing to guess which one to remove.`));
   }
   const [target] = matches;
-  return target === undefined ? {} : { target };
+  return target === undefined ? reject(fail(EXIT_GENERAL_ERROR, `No worktree found for branch "${branch}".`)) : pass(target);
 };
 var nestedWorktreeRejection = (branch, targetPath, worktrees) => {
   const nested = nestedWorktrees(worktrees, targetPath);
@@ -67,27 +65,21 @@ var targetSafetyRejection = async ({ git, fs, context, options }, target) => {
 var validateRemoval = async (check) => {
   const { context, options } = check;
   const resolved = resolveTarget(context.worktrees, options.branch, options.expectedPath);
-  if (resolved.rejection !== undefined) {
-    return { ok: false, rejection: resolved.rejection };
-  }
-  const { target } = resolved;
-  if (target === undefined) {
-    return {
-      ok: false,
-      rejection: fail(EXIT_GENERAL_ERROR, `No worktree found for branch "${options.branch}".`)
-    };
+  if (!resolved.ok) {
+    return resolved;
   }
+  const target = resolved.value;
   if (target.kind === "root") {
-    return { ok: false, rejection: fail(EXIT_USAGE_ERROR, "Cannot remove the root clone.") };
+    return reject(fail(EXIT_USAGE_ERROR, "Cannot remove the root clone."));
   }
   const rejection = await targetSafetyRejection(check, target);
-  return rejection === null ? { ok: true, target } : { ok: false, rejection };
+  return rejection === null ? resolved : reject(rejection);
 };
-var withExtWarning = (ext, result) => ext ? {
-  ...result,
-  warnings: [...result.warnings ?? [], EXT_DEPRECATION_WARNING]
-} : result;
 var removeWorktree = async (git, fs, options) => {
+  const refRejection = optionLikeRefRejection("branch", options.branch);
+  if (refRejection !== null) {
+    return refRejection;
+  }
   const context = await loadRepoContext(git, fs, options.cwd);
   const validation = await validateRemoval({ git, fs, context, options });
   if (!validation.ok) {
@@ -100,7 +92,7 @@ var removeWorktree = async (git, fs, options) => {
       if (!freshValidation.ok) {
         return freshValidation.rejection;
       }
-      const { target } = freshValidation;
+      const target = freshValidation.value;
       await git.removeWorktree(context.rootPath, target.path, options.force);
       return ok({
         data: { branch: options.branch, path: target.path },
@@ -111,6 +103,6 @@ var removeWorktree = async (git, fs, options) => {
     }
   });
 };
-var rm2 = async (git, fs, options) => withExtWarning(options.ext, await removeWorktree(git, fs, options));
+var rm2 = (git, fs, options) => removeWorktree(git, fs, options);
 
 export { rm2 };

package/dist/cli-a56b2ar0.js

@@ -0,0 +1,20 @@
+// src/domain/classify.ts
+var isWithin = (parent, child) => {
+  if (parent === child) {
+    return false;
+  }
+  const parentWithSlash = parent.endsWith("/") ? parent : `${parent}/`;
+  return child.startsWith(parentWithSlash);
+};
+var isWithinOrSelf = (parent, child) => parent === child || isWithin(parent, child);
+var classifyWorktreePath = (path, rootPath, managedRoot) => {
+  if (path === rootPath) {
+    return "root";
+  }
+  if (path === managedRoot || isWithin(managedRoot, path)) {
+    return "managed";
+  }
+  return "external";
+};
+
+export { isWithin, isWithinOrSelf, classifyWorktreePath };

package/dist/{cli-g72ra4e5.js → cli-b0tk5wcx.js}

@@ -1,21 +1,3 @@
-// src/domain/classify.ts
-var isWithin = (parent, child) => {
-  if (parent === child) {
-    return false;
-  }
-  const parentWithSlash = parent.endsWith("/") ? parent : `${parent}/`;
-  return child.startsWith(parentWithSlash);
-};
-var classifyWorktreePath = (path, rootPath, managedRoot) => {
-  if (path === rootPath) {
-    return "root";
-  }
-  if (path === managedRoot || isWithin(managedRoot, path)) {
-    return "managed";
-  }
-  return "external";
-};
-
 // src/domain/porcelain.ts
 var REFS_HEADS_PREFIX = "refs/heads/";
 var branchNameFromRef = (ref) => ref.startsWith(REFS_HEADS_PREFIX) ? ref.slice(REFS_HEADS_PREFIX.length) : ref;
@@ -101,4 +83,4 @@ var parsePorcelain = (output) => {
   return result;
 };
 
-export { isWithin, classifyWorktreePath, REFS_HEADS_PREFIX, parsePorcelain };
+export { REFS_HEADS_PREFIX, parsePorcelain };

package/dist/{cli-pqd2qe7v.js → cli-btqjpf1q.js}

@@ -1,6 +1,6 @@
 import {
   REFS_HEADS_PREFIX
-} from "./cli-g72ra4e5.js";
+} from "./cli-b0tk5wcx.js";
 
 // src/domain/upstream.ts
 var NONE = { kind: "none" };

package/dist/{cli-71jgs14h.js → cli-fhta3tr8.js}

@@ -109,4 +109,18 @@ var truncateToWidthKeepingTail = (value, width, ellipsis = DEFAULT_ELLIPSIS) =>
   return ellipsis + keptFromEnd.toReversed().join("");
 };
 
-export { graphemes, displayWidth, padToWidth, truncateToWidth, truncateToWidthKeepingTail };
+// src/domain/ansi.ts
+var ESC = "\x1B";
+var SGR = {
+  bold: `${ESC}[1m`,
+  dim: `${ESC}[2m`,
+  inverse: `${ESC}[7m`,
+  red: `${ESC}[31m`,
+  green: `${ESC}[32m`,
+  yellow: `${ESC}[33m`,
+  magenta: `${ESC}[35m`,
+  cyan: `${ESC}[36m`
+};
+var SGR_RESET = `${ESC}[0m`;
+
+export { graphemes, displayWidth, padToWidth, truncateToWidth, truncateToWidthKeepingTail, ESC, SGR, SGR_RESET };

package/dist/{cli-ygt2w4e1.js → cli-hz0r7zw8.js}

@@ -1,19 +1,22 @@
 import {
   messageOf
-} from "./cli-qrxgkskr.js";
+} from "./cli-ph0gp56k.js";
 import {
   withRepoLock
-} from "./cli-rcw5adqd.js";
+} from "./cli-wcnyhk4w.js";
 import {
+  refArgumentRejection,
   loadRepoContext,
   isWorktreeDirty,
   resolveBranchCheckout
-} from "./cli-7jg5qqs9.js";
+} from "./cli-y8vsqre6.js";
 import {
   EXIT_SAFE_REJECTION,
   ok,
-  fail
-} from "./cli-2bhb9p0x.js";
+  fail,
+  pass,
+  reject
+} from "./cli-77yanq37.js";
 
 // src/commands/root-holder-swap.ts
 var holderRejection = (branch, holderPath, reason) => fail(EXIT_SAFE_REJECTION, `Branch "${branch}" is already checked out at ${holderPath}, and it ${reason}. Not swapping — cd there instead of using hop root.`);
@@ -27,51 +30,47 @@ var resolveHolderSwap = async ({
   policy
 }) => {
   if (target === "-") {
-    return { detachedHolder: null };
+    return pass(null);
   }
   const freshHolders = fresh.worktrees.filter((wt) => wt.branch === target && wt.kind !== "root");
   if (freshHolders.length > 1) {
-    return { rejection: multipleHoldersRejection(target, freshHolders) };
+    return reject(multipleHoldersRejection(target, freshHolders));
   }
   const [freshHolder] = freshHolders;
   if (freshHolder === undefined) {
-    return { detachedHolder: null };
+    return pass(null);
   }
   if (policy.expectedPath !== undefined && freshHolder.path !== policy.expectedPath) {
-    return {
-      rejection: holderRejection(target, freshHolder.path, `changed from the picker selection at ${policy.expectedPath}`)
-    };
+    return reject(holderRejection(target, freshHolder.path, `changed from the picker selection at ${policy.expectedPath}`));
   }
   if (freshHolder.kind === "external" && !policy.allowExternal) {
-    return {
-      rejection: holderRejection(target, freshHolder.path, "is external and requires confirmation before it can be put into detached HEAD")
-    };
+    return reject(holderRejection(target, freshHolder.path, "is external and requires confirmation before it can be put into detached HEAD"));
   }
   if (switchOptions.createBranch === true) {
-    return {
-      rejection: holderRejection(target, freshHolder.path, "wasn't visible when hop checked existing local branches (e.g. it has no commits yet, or was created after that check)")
-    };
+    return reject(holderRejection(target, freshHolder.path, "wasn't visible when hop checked existing local branches (e.g. it has no commits yet, or was created after that check)"));
   }
   if (freshHolder.locked) {
-    return {
-      rejection: holderRejection(target, freshHolder.path, `is locked by git${freshHolder.lockReason === null ? "" : ` (${freshHolder.lockReason})`}`)
-    };
+    return reject(holderRejection(target, freshHolder.path, `is locked by git${freshHolder.lockReason === null ? "" : ` (${freshHolder.lockReason})`}`));
   }
   if (freshHolder.prunable) {
-    return { rejection: prunableHolderRejection(target, freshHolder.path) };
+    return reject(prunableHolderRejection(target, freshHolder.path));
   }
   const holderDirty = await isWorktreeDirty(git, fresh.worktrees, freshHolder.path);
   if (holderDirty) {
-    return {
-      rejection: holderRejection(target, freshHolder.path, "has uncommitted or untracked changes")
-    };
+    return reject(holderRejection(target, freshHolder.path, "has uncommitted or untracked changes"));
   }
   await git.detachHead(freshHolder.path);
-  return { detachedHolder: { path: freshHolder.path, branch: target } };
+  return pass({ path: freshHolder.path, branch: target });
 };
 
 // src/commands/root.ts
 var root2 = async (git, fs, options) => {
+  if (options.target !== undefined && options.target !== "-") {
+    const refRejection = refArgumentRejection(options.target, options.track);
+    if (refRejection !== null) {
+      return refRejection;
+    }
+  }
   const context = await loadRepoContext(git, fs, options.cwd);
   if (options.target === undefined) {
     return ok({
@@ -106,7 +105,7 @@ var root2 = async (git, fs, options) => {
     fs,
     context,
     target: options.target,
-    switchOptions: checkout.options,
+    switchOptions: checkout.value,
     holderPolicy: {
       allowExternal: options.allowExternalHolderSwap ?? true,
       ...options.expectedHolderPath === undefined ? {} : { expectedPath: options.expectedHolderPath }
@@ -163,10 +162,10 @@ var switchAndReport = ({
       switchOptions,
       policy: holderPolicy
     });
-    if ("rejection" in holderSwap) {
+    if (!holderSwap.ok) {
       return holderSwap.rejection;
     }
-    ({ detachedHolder } = holderSwap);
+    detachedHolder = holderSwap.value;
     await git.switchBranch(fresh.rootPath, target, switchOptions);
     let resolvedBranch = target;
     if (target === "-") {