@n-seiji/nuthatch 0.1.7 → 0.2.1

package/dist/{cli-update-7exha1em.js → cli-update-x0r4b4xk.js}

@@ -2,16 +2,11 @@ import {
   isRunningAsCompiledBinary,
   wantsJson,
   reportFatalError,
-  firstExecutable,
   VERSION
-} from "./cli-3ya15je0.js";
+} from "./cli-sre95k9x.js";
 import {
-  parentDir,
-  baseName,
-  absoluteCandidates,
-  splitPathEnv,
   messageOf
-} from "./cli-qrxgkskr.js";
+} from "./cli-ph0gp56k.js";
 import {
   reportResult
 } from "./cli-dbzx9nzg.js";
@@ -21,43 +16,67 @@ import {
   EXIT_SAFE_REJECTION,
   ok,
   fail
-} from "./cli-2bhb9p0x.js";
+} from "./cli-77yanq37.js";
+import {
+  parentDir
+} from "./cli-s5qcjcwk.js";
 
-// src/domain/install-roots.ts
-var MANAGER_ROOTS = [
-  {
-    markers: ["/Cellar/", "/Caskroom/"],
-    manager: "Homebrew",
-    update: '"brew upgrade"',
-    ownsNpmPrefix: true
-  },
-  {
-    markers: ["/nix/store/"],
-    manager: "Nix",
-    update: "Nix (the store is read-only)",
-    ownsNpmPrefix: true
-  },
-  {
-    markers: ["/aquaproj-aqua/", "/aqua/pkgs/"],
-    manager: "aqua",
-    update: "aqua",
-    ownsNpmPrefix: false
-  },
-  { markers: ["/.proto/tools/"], manager: "proto", update: "proto", ownsNpmPrefix: false }
+// src/domain/install-method.ts
+var RELEASE_ASSETS = new Map([
+  ["darwin-arm64", "hop-darwin-arm64"],
+  ["darwin-x64", "hop-darwin-x64"],
+  ["linux-x64", "hop-linux-x64"]
+]);
+var MANAGED_TREES = [
+  "/Cellar/",
+  "/Caskroom/",
+  "/nix/store/",
+  "/aquaproj-aqua/",
+  "/aqua/pkgs/",
+  "/.proto/",
+  "/installs/"
 ];
-var reasonWithin = (path, roots) => {
-  const root = roots.find(({ markers }) => markers.some((marker) => path.includes(marker)));
-  return root === undefined ? null : `installed by ${root.manager} (${path}); update it with ${root.update}`;
+var MISE_TREE = "/mise/installs/";
+var NODE_MODULES = "/node_modules/";
+var detectInstallMethod = (facts) => {
+  const path = facts.compiled ? facts.executablePath : facts.scriptPath;
+  if (path === null) {
+    return { kind: "other" };
+  }
+  if (path.includes(MISE_TREE)) {
+    return { kind: "mise" };
+  }
+  if (!facts.compiled) {
+    return { kind: path.includes(NODE_MODULES) ? "package-manager" : "other" };
+  }
+  const assetName = RELEASE_ASSETS.get(`${facts.platform}-${facts.arch}`);
+  if (assetName === undefined || MANAGED_TREES.some((tree) => path.includes(tree))) {
+    return { kind: "other" };
+  }
+  return {
+    kind: "standalone",
+    binaryPath: path,
+    installDir: parentDir(path),
+    assetName
+  };
+};
+var suggestedCommand = (kind) => {
+  if (kind === "mise") {
+    return ["mise", "upgrade"];
+  }
+  return kind === "package-manager" ? ["npm", "i", "-g", "@n-seiji/nuthatch@latest"] : null;
+};
+var updateHint = (kind) => {
+  const command = suggestedCommand(kind)?.join(" ");
+  if (kind === "mise") {
+    return `Update with mise: ${command}`;
+  }
+  return kind === "package-manager" ? `Update with your package manager, e.g. ${command}` : "Update hop with the tool you installed it with.";
 };
-var managerRootReason = (binaryPath) => reasonWithin(binaryPath, MANAGER_ROOTS);
-var managerNpmPrefixReason = (prefix) => reasonWithin(prefix, MANAGER_ROOTS.filter(({ ownsNpmPrefix }) => ownsNpmPrefix));
 
 // src/domain/self-update.ts
-var NPM_PACKAGE = "@n-seiji/nuthatch";
-var NPM_PACKAGE_LATEST = `${NPM_PACKAGE}@latest`;
 var GITHUB_REPO = "n-seiji/nuthatch";
 var GITHUB_LATEST_RELEASE_URL = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
-var NPM_LATEST_URL = `https://registry.npmjs.org/${NPM_PACKAGE.replace("/", "%2F")}/latest`;
 var releaseAssetUrl = (version, assetName) => `https://github.com/${GITHUB_REPO}/releases/download/v${version}/${assetName}`;
 var VERSION_PATTERN = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)$/u;
 var TAG_PATTERN = /^v(?<version>\d+\.\d+\.\d+)$/u;
@@ -74,10 +93,6 @@ var compareVersions = (a, b) => {
   const [bMajor, bMinor, bPatch] = parseVersion(b);
   return aMajor - bMajor || aMinor - bMinor || aPatch - bPatch;
 };
-var requireVersion = (text) => {
-  parseVersion(text);
-  return text;
-};
 var versionFromTag = (tag) => {
   const version = TAG_PATTERN.exec(tag)?.groups?.version;
   if (version === undefined) {
@@ -96,165 +111,8 @@ var parseChecksumFile = (text, assetName) => {
   }
   return { ok: true, digest: digest.toLowerCase() };
 };
-var pathExecutableCandidates = (name, pathEnv, preferredDir = null) => absoluteCandidates([...preferredDir === null ? [] : [preferredDir], ...splitPathEnv(pathEnv)], name);
 var isWriteDenied = (error) => error instanceof Error && ("code" in error) && (error.code === "EACCES" || error.code === "EPERM" || error.code === "EROFS");
 
-// src/domain/install-script.ts
-var NPX_MARKER = "/_npx/";
-var BUNX_MARKER = "/bunx-";
-var BUN_GLOBAL_MARKER = "/.bun/install/global/node_modules/";
-var NPM_GLOBAL_MARKER = `/lib/node_modules/${NPM_PACKAGE}/`;
-var NODE_MODULES_MARKER = `/node_modules/${NPM_PACKAGE}/`;
-var PNPM_GLOBAL_MARKER = "/pnpm/global/";
-var YARN_GLOBAL_MARKER = "/yarn/global/";
-var unsupported = (reason) => ({ kind: "unsupported", reason });
-var npmGlobalPrefixOf = (scriptPath) => {
-  const index = scriptPath.lastIndexOf(NPM_GLOBAL_MARKER);
-  return index > 0 ? scriptPath.slice(0, index) : null;
-};
-var otherNodeModulesReason = (scriptPath) => {
-  if (scriptPath.includes(PNPM_GLOBAL_MARKER)) {
-    return `installed globally with pnpm, which hop does not drive; run "pnpm add -g ${NPM_PACKAGE_LATEST}" yourself`;
-  }
-  if (scriptPath.includes(YARN_GLOBAL_MARKER)) {
-    return `installed globally with yarn, which hop does not drive; run "yarn global add ${NPM_PACKAGE_LATEST}" yourself`;
-  }
-  return "installed as a project dependency (a local node_modules); update it in that project";
-};
-var detectScriptInstall = (scriptPath, npmGlobalPrefix) => {
-  if (scriptPath.includes(NPX_MARKER)) {
-    return unsupported("running through npx, which already fetches the published version on every run");
-  }
-  if (scriptPath.includes(BUNX_MARKER)) {
-    return unsupported("running through bunx, which already fetches the published version on every run");
-  }
-  if (scriptPath.includes(BUN_GLOBAL_MARKER)) {
-    return { kind: "bun" };
-  }
-  if (npmGlobalPrefix !== null) {
-    const managedBy = managerNpmPrefixReason(npmGlobalPrefix);
-    return managedBy === null ? { kind: "npm", prefix: npmGlobalPrefix } : unsupported(managedBy);
-  }
-  if (scriptPath.includes(NODE_MODULES_MARKER)) {
-    return unsupported(otherNodeModulesReason(scriptPath));
-  }
-  return unsupported("running from a source checkout; update it with git (git pull)");
-};
-
-// src/domain/mise-tool.ts
-var MISE_WALK_LIMIT = 8;
-var HOP_BACKEND_PATTERN = /^[a-z0-9_-]+:@?n-seiji\/nuthatch$/iu;
-var HOP_TOOL_DIR_PATTERN = /(?:^|-)n-seiji-nuthatch$/iu;
-var parseMiseBackendToml = (text) => {
-  const match = /^\s*full\s*=\s*"(?<tool>[^"]+)"\s*$/mu.exec(text);
-  return match?.groups?.tool ?? null;
-};
-var parseLegacyMiseBackend = (text) => {
-  const lines = text.split(`
-`).map((line) => line.trim()).filter((line) => line.length > 0);
-  return lines.at(-1) ?? null;
-};
-var withoutToolOptions = (backend) => backend.replace(/\[[^\]]*\]$/u, "");
-var isHopBackend = (backend) => HOP_BACKEND_PATTERN.test(backend);
-var isHopToolDirName = (name) => HOP_TOOL_DIR_PATTERN.test(name);
-var ancestorDirs = (path, limit) => {
-  const dirs = [];
-  let dir = parentDir(path);
-  while (dirs.length < limit && dir !== "/" && dir !== ".") {
-    dirs.push(dir);
-    dir = parentDir(dir);
-  }
-  return dirs;
-};
-var miseToolDir = (path) => ancestorDirs(path, MISE_WALK_LIMIT).find((dir) => baseName(parentDir(dir)) === "installs") ?? null;
-
-// src/domain/install-method.ts
-var RELEASE_ASSETS = new Map([
-  ["darwin-arm64", "hop-darwin-arm64"],
-  ["darwin-x64", "hop-darwin-x64"],
-  ["linux-x64", "hop-linux-x64"]
-]);
-var releaseAssetName = (platform, arch) => RELEASE_ASSETS.get(`${platform}-${arch}`) ?? null;
-var GITHUB_BACKEND_PREFIXES = ["github:", "ubi:", "aqua:"];
-var NPM_BACKEND_PREFIX = "npm:";
-var unsupported2 = (reason) => ({
-  kind: "unsupported",
-  reason
-});
-var miseChannel = (tool) => {
-  if (tool.startsWith(NPM_BACKEND_PREFIX)) {
-    return "npm";
-  }
-  return GITHUB_BACKEND_PREFIXES.some((prefix) => tool.startsWith(prefix)) ? "github" : null;
-};
-var insideVersionManager = (dir, marker) => unsupported2(`installed under a version manager's install dir (${dir}) ${marker}; update it with the tool that installed it`);
-var detectUnmarkedToolDir = (dir, compiled) => {
-  if (isHopToolDirName(baseName(dir))) {
-    return unsupported2(`installed by mise, but its backend is unknown (no readable marker in ${dir}); run "mise upgrade" yourself`);
-  }
-  return compiled ? insideVersionManager(dir, "without a readable mise marker") : null;
-};
-var detectMise = ({ mise, compiled }) => {
-  if (mise === null) {
-    return null;
-  }
-  if (mise.backend === null) {
-    return detectUnmarkedToolDir(mise.dir, compiled);
-  }
-  const tool = withoutToolOptions(mise.backend);
-  if (!isHopBackend(tool)) {
-    return compiled ? insideVersionManager(mise.dir, `whose marker names "${tool}", not hop`) : null;
-  }
-  const channel = miseChannel(tool);
-  return channel === null ? unsupported2(`mise installed hop through "${tool}", which is neither a GitHub nor an npm backend; run "mise upgrade ${tool}" yourself`) : { kind: "mise", tool, channel };
-};
-var detectStandalone = (facts) => {
-  const { executablePath, platform, arch } = facts;
-  if (executablePath === null) {
-    return unsupported2("cannot tell where the hop binary is installed");
-  }
-  const managedBy = managerRootReason(executablePath);
-  if (managedBy !== null) {
-    return unsupported2(managedBy);
-  }
-  const assetName = releaseAssetName(platform, arch);
-  if (assetName === null) {
-    return unsupported2(`there is no prebuilt binary for ${platform}-${arch}; install with npm instead (npm i -g ${NPM_PACKAGE})`);
-  }
-  return {
-    kind: "standalone",
-    binaryPath: executablePath,
-    installDir: parentDir(executablePath),
-    assetName
-  };
-};
-var detectInstallMethod = (facts) => {
-  const mise = detectMise(facts);
-  if (mise !== null) {
-    return mise;
-  }
-  return facts.compiled ? detectStandalone(facts) : detectScriptInstall(facts.scriptPath ?? "", facts.npmGlobalPrefix);
-};
-var latestChannel = (method) => {
-  if (method.kind === "mise") {
-    return method.channel;
-  }
-  return method.kind === "standalone" ? "github" : "npm";
-};
-var upgradeCommand = (method) => {
-  if (method.kind === "mise") {
-    return ["mise", "upgrade", method.tool];
-  }
-  return method.kind === "npm" ? ["npm", "install", "-g", "--prefix", method.prefix, NPM_PACKAGE_LATEST] : ["bun", "add", "-g", NPM_PACKAGE_LATEST];
-};
-var miseDryRunCommand = (method) => [
-  "mise",
-  "upgrade",
-  "--dry-run-code",
-  method.tool
-];
-var preferredProgramDir = (method) => method.kind === "npm" ? `${method.prefix}/bin` : null;
-
 // src/commands/self-update-attempt.ts
 var attempt = async (run) => {
   try {
@@ -264,48 +122,6 @@ var attempt = async (run) => {
   }
 };
 
-// src/commands/self-update-delegated.ts
-var MISE_WOULD_NOT_UPGRADE = 0;
-var runLogged = (port, term, executable, [, ...args]) => {
-  const command = [executable, ...args];
-  term.logStderr(`Running: ${command.join(" ")}`);
-  return attempt(() => port.runCommand(command));
-};
-var miseNothingToUpgradeWarning = ({ tool }, { current, latest }) => [
-  `mise has nothing to upgrade for ${tool}, so hop stays at ${current} although ${latest} is the latest release.`,
-  "Likely causes: the version is pinned in your global mise config, a minimum_release_age setting holds the release back,",
-  `or ${tool} is not in your global mise config (hop runs mise from your home directory, so a project's mise.toml does not count).`,
-  `Run "mise upgrade --dry-run ${tool}" from your home directory to see what mise decides.`
-].join(" ");
-var runDelegated = async (port, term, method, base) => {
-  const argv = upgradeCommand(method);
-  const [program] = argv;
-  const command = argv.join(" ");
-  const executable = await port.resolveExecutable(program, preferredProgramDir(method));
-  if (executable === null) {
-    return fail(EXIT_GENERAL_ERROR, `Cannot find "${program}" on PATH. Run it yourself: ${command}`);
-  }
-  if (method.kind === "mise") {
-    const question = miseDryRunCommand(method);
-    const answer = await runLogged(port, term, executable, question);
-    if (!answer.ok) {
-      return fail(EXIT_GENERAL_ERROR, `Failed to run ${question.join(" ")}: ${messageOf(answer.error)}`);
-    }
-    if (answer.value === MISE_WOULD_NOT_UPGRADE) {
-      return ok({ data: base, warnings: [miseNothingToUpgradeWarning(method, base)] });
-    }
-  }
-  const run = await runLogged(port, term, executable, argv);
-  if (!run.ok) {
-    return fail(EXIT_GENERAL_ERROR, `Failed to run ${command}: ${messageOf(run.error)}`);
-  }
-  if (run.value !== 0) {
-    return fail(EXIT_GENERAL_ERROR, `${command} exited with code ${run.value}.`);
-  }
-  term.logStderr(`${command} finished; run "hop --version" to see which version you have now.`);
-  return ok({ data: { ...base, action: "delegated", command: [...argv] } });
-};
-
 // src/commands/self-update-standalone.ts
 var checksumRejection = (port, assetName, checksumText, bytes) => {
   const expected = parseChecksumFile(checksumText, assetName);
@@ -349,24 +165,18 @@ var replaceStandalone = async (port, term, method, base) => {
 };
 
 // src/commands/self-update.ts
-var fetchLatest = (port, method) => latestChannel(method) === "npm" ? port.latestNpmVersion() : port.latestGithubVersion();
-var checkCommand = (method) => method.kind === "standalone" ? null : [...upgradeCommand(method)];
-var describeCheck = (method, base) => {
-  const how = method.kind === "standalone" ? `replaces ${method.binaryPath}` : `runs: ${upgradeCommand(method).join(" ")}`;
-  return `Update available: ${base.current} -> ${base.latest}. "hop --update" ${how}.`;
-};
 var selfUpdate = async (port, term, options) => {
   const facts = await attempt(() => port.installFacts());
   if (!facts.ok) {
     return fail(EXIT_GENERAL_ERROR, `Cannot update hop: could not tell how it was installed (${messageOf(facts.error)}).`);
   }
   const method = detectInstallMethod(facts.value);
-  if (method.kind === "unsupported") {
-    return fail(EXIT_GENERAL_ERROR, `Cannot update hop: ${method.reason}.`);
+  if (method.kind !== "standalone" && !options.check) {
+    return fail(EXIT_GENERAL_ERROR, updateHint(method.kind));
   }
   term.logStderr("Checking for the latest release...");
   const release = await attempt(async () => {
-    const latest = await fetchLatest(port, method);
+    const latest = await port.latestGithubVersion();
     return {
       latest,
       updateAvailable: compareVersions(latest, options.currentVersion) > 0
@@ -387,94 +197,43 @@ var selfUpdate = async (port, term, options) => {
     term.logStderr(`hop ${base.current} is up to date (latest release: ${base.latest}).`);
     return ok({ data: base });
   }
+  const available = `Update available: ${base.current} -> ${base.latest}.`;
+  if (method.kind !== "standalone") {
+    term.logStderr(`${available} ${updateHint(method.kind)}`);
+    const command = suggestedCommand(method.kind);
+    return ok({
+      data: { ...base, command: command === null ? null : [...command] }
+    });
+  }
   if (options.check) {
-    term.logStderr(describeCheck(method, base));
-    return ok({ data: { ...base, command: checkCommand(method) } });
+    term.logStderr(`${available} "hop --update" replaces ${method.binaryPath}.`);
+    return ok({ data: base });
   }
-  return method.kind === "standalone" ? replaceStandalone(port, term, method, base) : runDelegated(port, term, method, base);
+  return replaceStandalone(port, term, method, base);
 };
 
 // src/infra/install-facts.ts
-import { readFile, realpath } from "node:fs/promises";
-import { join } from "node:path";
-var MISE_BACKEND_TOML = ".mise.backend.toml";
-var MISE_BACKEND_LEGACY = ".mise.backend";
-var realpathOrNull = async (path) => {
+import { realpath } from "node:fs/promises";
+var realpathOrSelf = async (path) => {
   try {
     return await realpath(path);
   } catch {
-    return null;
-  }
-};
-var realpathOrSelf = async (path) => await realpathOrNull(path) ?? path;
-var readTextOrNull = async (path) => {
-  try {
-    return await readFile(path, "utf8");
-  } catch {
-    return null;
-  }
-};
-var readMiseBackend = async (dir) => {
-  const toml = await readTextOrNull(join(dir, MISE_BACKEND_TOML));
-  const fromToml = toml === null ? null : parseMiseBackendToml(toml);
-  if (fromToml !== null) {
-    return fromToml;
-  }
-  const legacy = await readTextOrNull(join(dir, MISE_BACKEND_LEGACY));
-  return legacy === null ? null : parseLegacyMiseBackend(legacy);
-};
-var findMiseTool = async (path) => {
-  const dir = path === null ? null : miseToolDir(path);
-  return dir === null ? null : { dir, backend: await readMiseBackend(dir) };
-};
-var verifiedNpmPrefix = async (scriptPath) => {
-  const prefix = scriptPath === null ? null : npmGlobalPrefixOf(scriptPath);
-  if (prefix === null) {
-    return null;
+    return path;
   }
-  return await realpathOrNull(join(prefix, "bin", "hop")) === scriptPath ? prefix : null;
 };
-var readInstallFacts = async (source) => {
-  const executablePath = source.compiled ? await realpathOrSelf(source.execPath) : null;
-  const scriptPath = source.compiled || source.argv1 === undefined ? null : await realpathOrSelf(source.argv1);
-  return {
-    compiled: source.compiled,
-    executablePath,
-    scriptPath,
-    mise: await findMiseTool(executablePath ?? scriptPath),
-    npmGlobalPrefix: await verifiedNpmPrefix(scriptPath),
-    platform: source.platform,
-    arch: source.arch
-  };
-};
-
-// src/infra/package-manager.ts
-import { spawn } from "node:child_process";
-import { homedir } from "node:os";
-import { basename } from "node:path";
-var STDERR_FD = 2;
-var resolveExecutable = (name, pathEnv, preferredDir = null) => firstExecutable(pathExecutableCandidates(name, pathEnv, preferredDir));
-var runCommand = (argv) => new Promise((resolve, reject) => {
-  const [program, ...args] = argv;
-  const child = spawn(program, args, {
-    cwd: homedir(),
-    stdio: ["inherit", STDERR_FD, STDERR_FD]
-  });
-  child.once("error", reject);
-  child.once("close", (code, signal) => {
-    if (code === null) {
-      reject(new Error(`${basename(program)} was killed by signal ${signal ?? "unknown"}`));
-      return;
-    }
-    resolve(code);
-  });
+var readInstallFacts = async (source) => ({
+  compiled: source.compiled,
+  executablePath: source.compiled ? await realpathOrSelf(source.execPath) : null,
+  scriptPath: source.compiled || source.argv1 === undefined ? null : await realpathOrSelf(source.argv1),
+  platform: source.platform,
+  arch: source.arch
 });
 
 // src/infra/release-binary.ts
 import { createHash, randomBytes } from "node:crypto";
 import { constants } from "node:fs";
 import { access, open, realpath as realpath2, rename, rm } from "node:fs/promises";
-import { basename as basename2, dirname, join as join2 } from "node:path";
+import { basename, dirname, join } from "node:path";
 var EXECUTABLE_MODE = 493;
 var TEMP_SUFFIX_BYTES = 6;
 var sha256Hex = (bytes) => createHash("sha256").update(bytes).digest("hex");
@@ -496,7 +255,7 @@ var writeDurably = async (path, bytes) => {
 var replaceExecutable = async (path, bytes) => {
   const target = await realpath2(path);
   const suffix = randomBytes(TEMP_SUFFIX_BYTES).toString("hex");
-  const temp = join2(dirname(target), `.${basename2(target)}.update-${suffix}`);
+  const temp = join(dirname(target), `.${basename(target)}.update-${suffix}`);
   try {
     await writeDurably(temp, bytes);
     await rename(temp, target);
@@ -737,7 +496,6 @@ var GITHUB_API_ORIGIN = "https://api.github.com/";
 var HTTP_FORBIDDEN = 403;
 var HTTP_TOO_MANY_REQUESTS = 429;
 var GithubLatestSchema = object({ tag_name: string() });
-var NpmLatestSchema = object({ version: string() });
 var DECODER = new TextDecoder;
 var send = async (fetcher, url, { headers, timeoutMs }) => {
   try {
@@ -806,14 +564,6 @@ var createReleaseHttp = (userAgent, fetcher = fetch) => ({
     });
     return versionFromTag(release.tag_name);
   },
-  async latestNpmVersion() {
-    const latest = await getJson(fetcher, NPM_LATEST_URL, NpmLatestSchema, {
-      headers: { Accept: "application/json", "User-Agent": userAgent },
-      timeoutMs: METADATA_TIMEOUT_MS,
-      maxBytes: METADATA_MAX_BYTES
-    });
-    return requireVersion(latest.version);
-  },
   async downloadReleaseAsset(version, assetName) {
     return await getBytes(fetcher, releaseAssetUrl(version, assetName), {
       headers: { Accept: "application/octet-stream", "User-Agent": userAgent },
@@ -846,9 +596,7 @@ var createSelfUpdatePort = ({
   ...createReleaseHttp(`hop/${version}`),
   sha256Hex,
   assertWritableDir,
-  replaceExecutable,
-  resolveExecutable: (name, preferredDir) => resolveExecutable(name, process.env.PATH, preferredDir),
-  runCommand
+  replaceExecutable
 });
 
 // src/cli-update.ts

package/dist/{cli-rcw5adqd.js → cli-wcnyhk4w.js}

@@ -1,7 +1,7 @@
 import {
   EXIT_SAFE_REJECTION,
   fail
-} from "./cli-2bhb9p0x.js";
+} from "./cli-77yanq37.js";
 
 // src/infra/lock.ts
 import { randomUUID } from "node:crypto";

package/dist/{cli-7jg5qqs9.js → cli-y8vsqre6.js}

@@ -1,12 +1,21 @@
 import {
-  isWithin,
-  classifyWorktreePath,
   parsePorcelain
-} from "./cli-g72ra4e5.js";
+} from "./cli-b0tk5wcx.js";
 import {
   EXIT_USAGE_ERROR,
-  fail
-} from "./cli-2bhb9p0x.js";
+  fail,
+  pass,
+  reject
+} from "./cli-77yanq37.js";
+import {
+  isWithin,
+  classifyWorktreePath
+} from "./cli-a56b2ar0.js";
+
+// src/domain/branch-name.ts
+var isOptionLikeRef = (name) => name.startsWith("-");
+var optionLikeRefRejection = (label, name) => isOptionLikeRef(name) ? fail(EXIT_USAGE_ERROR, `Refusing ${label} "${name}": names starting with "-" would be parsed as git options.`) : null;
+var refArgumentRejection = (branch, track) => optionLikeRefRejection("branch", branch) ?? (track === undefined ? null : optionLikeRefRejection("--track ref", track));
 
 // src/infra/repo.ts
 import { basename, dirname, join } from "node:path";
@@ -49,9 +58,8 @@ var loadRepoContext = async (git, fs, cwd) => {
   }));
   return { rootPath, managedRoot, commonDir, worktrees };
 };
-var nestedWorktreePaths = (worktrees, path) => nestedWorktrees(worktrees, path).map((wt) => wt.path);
 var nestedWorktrees = (worktrees, path) => worktrees.filter((wt) => wt.path !== path && !wt.prunable && isWithin(path, wt.path));
-var isWorktreeDirty = (git, worktrees, path) => git.isDirty(path, nestedWorktreePaths(worktrees, path));
+var isWorktreeDirty = (git, worktrees, path) => git.isDirty(path, nestedWorktrees(worktrees, path).map((wt) => wt.path));
 var worktreeDirtyState = async (git, fs, worktrees, wt) => {
   if (wt.bare || wt.prunable || !await fs.exists(wt.path)) {
     return null;
@@ -66,16 +74,17 @@ var resolveBranchCheckout = async (git, rootPath, branch, explicitTrack) => {
     const remotes = await git.remotesWithBranch(rootPath, branch);
     const resolution = resolveTrackingRef(branch, remotes);
     if (resolution.kind === "ambiguous") {
-      return {
-        ok: false,
-        rejection: fail(EXIT_USAGE_ERROR, `Branch "${branch}" exists on multiple remotes (${remotes.join(", ")}). Use --track to disambiguate.`)
-      };
+      return reject(fail(EXIT_USAGE_ERROR, `Branch "${branch}" exists on multiple remotes (${remotes.join(", ")}). Use --track to disambiguate.`));
     }
     if (resolution.kind === "track") {
+      const rejection = optionLikeRefRejection("--track ref", resolution.ref);
+      if (rejection !== null) {
+        return reject(rejection);
+      }
       track = resolution.ref;
     }
   }
-  return { ok: true, options: { createBranch, ...track === undefined ? {} : { track } } };
+  return pass({ createBranch, ...track === undefined ? {} : { track } });
 };
 var realpathOrRaw = async (fs, path) => {
   try {
@@ -85,4 +94,4 @@ var realpathOrRaw = async (fs, path) => {
   }
 };
 
-export { loadRepoContext, nestedWorktrees, isWorktreeDirty, worktreeDirtyState, resolveBranchCheckout };
+export { isOptionLikeRef, optionLikeRefRejection, refArgumentRejection, loadRepoContext, nestedWorktrees, isWorktreeDirty, worktreeDirtyState, resolveBranchCheckout };