rshow 0.0.7 → 0.0.9

package/dist/main.js

@@ -26,8 +26,8 @@
  */
 
 // src/main.ts
-import path26 from "node:path";
-import process23 from "node:process";
+import path28 from "node:path";
+import process25 from "node:process";
 
 // src/binary.ts
 import { mkdir, mkdtemp, rename, rm, stat, writeFile } from "node:fs/promises";
@@ -38,7 +38,7 @@ import process from "node:process";
 // src/version.ts
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-var VERSION = true ? "0.0.7" : versionFromPackage();
+var VERSION = true ? "0.0.9" : versionFromPackage();
 
 // src/binary.ts
 var ASSET_MANIFEST = "assets.json";
@@ -382,8 +382,12 @@ var Client = class {
   async patchArtifact(slug, patch) {
     return (await this.send("PATCH", `/api/artifacts/${encodeURIComponent(slug)}`, { json: patch })).body;
   }
-  async deleteArtifact(slug) {
-    await this.send("DELETE", `/api/artifacts/${encodeURIComponent(slug)}`);
+  async deleteArtifact(slug, force = false) {
+    await this.send("DELETE", `/api/artifacts/${encodeURIComponent(slug)}${force ? "?force=1" : ""}`);
+  }
+  async deleteVersion(slug, n, force = false) {
+    const pathname = `/api/artifacts/${encodeURIComponent(slug)}/versions/${n}${force ? "?force=1" : ""}`;
+    return (await this.send("DELETE", pathname)).body;
   }
   async putShare(slug, email, role) {
     const pathname = `/api/artifacts/${encodeURIComponent(slug)}/shares/${encodeURIComponent(email)}`;
@@ -444,6 +448,7 @@ var SLUG_PATTERN = /^[a-z0-9][a-z0-9-]{0,62}$/;
 var TAG_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
 var THEME_NAME_PATTERN = /^[a-z0-9-]{1,40}$/;
 var THEME_VERSION_PATTERN = /^([a-z0-9-]{1,40})@([0-9]{1,9})$/;
+var THEME_LATEST_PATTERN = /^([a-z0-9-]{1,40})@latest$/;
 var DATA_KEY_PATTERN = /^[A-Za-z0-9_.-]{1,128}$/;
 var EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 var TOKEN_PREFIX = "rsh_";
@@ -991,7 +996,9 @@ commands:
   show <slug>             artifact, versions and shares
   share <slug>            set mode or change shares
   pin <slug> <n|live>     serve version n, or live for the newest
-  delete <slug> --yes     delete an artifact
+  delete <slug> [--version n] [--force] --yes
+                          delete an artifact, or one version of it
+  upgrade [--check]       update rshow to the newest release
   login [--url u]         save the API token for this account
   logout [--url u]        remove the saved token for a server
   completion <shell>      print a completion script for bash, zsh or fish
@@ -1041,8 +1048,10 @@ usage error. --offline skips the theme version lookup on the art host.
 errors:
   no index.html at the root, unless theme.json makes the folder a theme
   a local href, src, poster, srcset, CSS url() or @import with no file behind it
-  a root-relative reference other than /_themes/<name>@<n>/<path>
-  a /_themes/<name>@<n>/ path whose version the art host does not have
+  a root-relative reference other than /_themes/<name>@<n>/<path> or
+    /_themes/<name>@latest/<path>
+  a /_themes/<name>@<n>/ path whose version the art host does not have, or an
+    @latest whose theme it does not have
   a script from a host other than cdnjs.cloudflare.com, cdn.jsdelivr.net,
     unpkg.com, or one of those without an exact version (@1.2.3, /1.2.3/ on cdnjs)
   a stylesheet from a host other than fonts.googleapis.com, cdn.jsdelivr.net,
@@ -1101,9 +1110,9 @@ Style warnings:
 var PREVIEW_USAGE = `usage: rshow preview <dir> [--theme <dir>] [--offline] [--no-reload] [--port 4321]
 
 Serves <dir> on 127.0.0.1: index.html for a folder, content types for files.
-Works offline: /_themes/<name>@<n>/ is served from --theme when it names that
-theme, then from the built-in themes on disk, and only then proxied to the art
-URL from config, which --offline turns off.
+Works offline: /_themes/<name>@<n>/ and /_themes/<name>@latest/ are served
+from --theme when it names that theme, then from the built-in themes on disk,
+and only then proxied to the art URL from config, which --offline turns off.
 The page is reloaded on its own when a file changes; --no-reload turns that off.
 Scripts that use <artifact>/_data/<key> get a local store in that same session.`;
 var CONFIG_USAGE = `usage: rshow config [dir] [--offline]
@@ -1112,9 +1121,10 @@ Prints the merged config as JSON: ~/.config/rshow/config.json first, then
 <dir>/rshow.json (default: the current folder). RSHOW_URL overrides url and
 RSHOW_ART overrides art. <dir>/rshow.json also takes project and tags; later
 files win. Run rshow init to write url and art.
-A theme with no version, or @latest, is looked up on the art host and printed
-as <name>@<n>; when that fails a warning goes to stderr. --offline skips it, and
-so does a config with no art host.
+A theme with no version, or @latest, prints as <name>@latest, and with the
+network its lookup adds theme_resolved as <name>@<n>; when the lookup fails a
+warning goes to stderr and the key is left out. --offline prints the loaded
+config as it is, and so does a config with no art host.
 The token is RSHOW_TOKEN, else the token rshow login saved in the macOS
 Keychain, the Linux keyring or a file with mode 600.`;
 var INIT_USAGE = `usage: rshow init --url <admin-url> --art <viewer-url> [--theme <name>] [--force]
@@ -1174,11 +1184,11 @@ var THEME_PREVIEW_USAGE = `usage: rshow theme preview <dir> [--offline] [--no-re
 
 Builds the theme folder into a temporary folder, serves that on 127.0.0.1 and
 prints the URL of index.html, the preview page that shows every layout. The
-built folder answers /_themes/<name>@<n>/ and is rebuilt, and the page reloaded,
-when the folder changes; --no-reload turns the reload off. A /_themes/ path for
-another theme comes from the built-in themes on disk, then from the art URL
-from config, which --offline turns off. The temporary folder goes when the
-server stops.`;
+built folder answers /_themes/<name>@<n>/ and /_themes/<name>@latest/ and is
+rebuilt, and the page reloaded, when the folder changes; --no-reload turns the
+reload off. A /_themes/ path for another theme comes from the built-in themes
+on disk, then from the art URL from config, which --offline turns off. The
+temporary folder goes when the server stops.`;
 var THEME_PUBLISH_USAGE = `usage: rshow theme publish <dir> [--label l] [--build cmd] [--no-check] [--force]
 
 <dir> needs theme.json with a name. The folder is published as theme-<name>,
@@ -1190,7 +1200,8 @@ built on top of its base theme, and the built folder is what gets published.
 When the newest version already holds the built folder's paths and hashes, it
 prints unchanged: theme-<name> is already v<n> and publishes nothing.
 --force publishes a new version anyway.
-Prints /_themes/<name>@<n>/.`;
+Prints /_themes/<name>@<n>/. Pages link /_themes/<name>@latest/ by default, so
+they follow every version you publish here.`;
 var THEME_LIST_USAGE = `usage: rshow theme list
 
 Lists artifacts whose slug starts with theme- and their served version.`;
@@ -1258,9 +1269,38 @@ var SHARE_USAGE = `usage: rshow share <slug> [--mode private|people|public] [--a
 var PIN_USAGE = `usage: rshow pin <slug> <n|live>
 
 Pins version n, or live to serve the newest version again.`;
-var DELETE_USAGE = `usage: rshow delete <slug> --yes
+var DELETE_USAGE = `usage: rshow delete <slug> [--version n] [--force] --yes
+
+Deletes the artifact, or with --version n only that version, and needs --yes.
+A theme or a theme version also needs --force, because pages link to it.
+A pinned version and the only version of an artifact cannot be deleted.
+A public version can stay visible for up to 5 minutes after the delete, and a
+theme file for longer.`;
+var UPGRADE_USAGE = `usage: rshow upgrade [--check] [--version <x.y.z>] [--force]
 
-Deletes the artifact and needs --yes.`;
+Updates rshow to the newest release, or to the release --version names, which
+may be an older one.
+A single executable is replaced in place, and an npm global install runs
+npm install -g rshow@<version>.
+Any other install, such as a source checkout, an npx cache or a local
+dependency, is left alone and named with the tool that owns it.
+Running the command is the consent: there is no --yes.
+No config and no token are read, so it works before rshow init.
+
+--check prints the current and the newest version and changes nothing, and
+exits 0 either way; --json prints {current, latest, upgrade_available}.
+A run prints upgraded <old> -> <new>, or already at <version>. --json prints
+{previous, version, upgraded, kind}, where kind is binary or npm.
+--version takes x.y.z with an optional leading v; --force reinstalls the same
+version, which is how a broken binary comes back.
+Skills that rshow installed are refreshed by the new rshow, and a bash, zsh or
+fish completion that is already there is replaced; RSHOW_NO_COMPLETIONS=1
+leaves the completions alone.
+RSHOW_DOWNLOAD_BASE downloads from a mirror instead of the release, and takes
+an http or https url; it cannot be used with --check.
+
+A release older than this one has no upgrade command, so after a downgrade
+come back with curl -fsSL https://rslib.github.io/rshow/install.sh | sh.`;
 var LOGIN_USAGE = `usage: rshow login [--url u]
 
 Reads the token from stdin, checks it with the API, then saves it in the macOS
@@ -1954,27 +1994,27 @@ var sqrtTall = function sqrtTall2(extraVinculum, hLinePad2, viewBoxHeight) {
 };
 var sqrtPath = function sqrtPath2(size, extraVinculum, viewBoxHeight) {
   extraVinculum = 1e3 * extraVinculum;
-  var path27 = "";
+  var path29 = "";
   switch (size) {
     case "sqrtMain":
-      path27 = sqrtMain(extraVinculum, hLinePad);
+      path29 = sqrtMain(extraVinculum, hLinePad);
       break;
     case "sqrtSize1":
-      path27 = sqrtSize1(extraVinculum, hLinePad);
+      path29 = sqrtSize1(extraVinculum, hLinePad);
       break;
     case "sqrtSize2":
-      path27 = sqrtSize2(extraVinculum, hLinePad);
+      path29 = sqrtSize2(extraVinculum, hLinePad);
       break;
     case "sqrtSize3":
-      path27 = sqrtSize3(extraVinculum, hLinePad);
+      path29 = sqrtSize3(extraVinculum, hLinePad);
       break;
     case "sqrtSize4":
-      path27 = sqrtSize4(extraVinculum, hLinePad);
+      path29 = sqrtSize4(extraVinculum, hLinePad);
       break;
     case "sqrtTall":
-      path27 = sqrtTall(extraVinculum, hLinePad, viewBoxHeight);
+      path29 = sqrtTall(extraVinculum, hLinePad, viewBoxHeight);
   }
-  return path27;
+  return path29;
 };
 var innerPath = function innerPath2(name, height) {
   switch (name) {
@@ -6188,8 +6228,8 @@ var svgData = {
 };
 var staticSvg = function staticSvg2(value, options) {
   var _svgData$value = svgData[value], pathName = _svgData$value[0], width = _svgData$value[1], height = _svgData$value[2];
-  var path27 = new PathNode(pathName);
-  var svgNode = new SvgNode([path27], {
+  var path29 = new PathNode(pathName);
+  var svgNode = new SvgNode([path29], {
     "width": makeEm(width),
     "height": makeEm(height),
     // Override CSS rule `.katex svg { width: 100% }`
@@ -7332,8 +7372,8 @@ var stretchySvg = function stretchySvg2(group, options) {
           pathName = "tilde" + imgIndex;
         }
       }
-      var path27 = new PathNode(pathName);
-      var svgNode = new SvgNode([path27], {
+      var path29 = new PathNode(pathName);
+      var svgNode = new SvgNode([path29], {
         "width": "100%",
         "height": makeEm(_height),
         "viewBox": "0 0 " + viewBoxWidth + " " + viewBoxHeight,
@@ -8547,8 +8587,8 @@ var makeGlyphSpan = function makeGlyphSpan2(symbol, font, mode, options) {
 };
 var makeInner = function makeInner2(ch2, height, options) {
   var width = fontMetricsData["Size4-Regular"][ch2.charCodeAt(0)] ? fontMetricsData["Size4-Regular"][ch2.charCodeAt(0)][4] : fontMetricsData["Size1-Regular"][ch2.charCodeAt(0)][4];
-  var path27 = new PathNode("inner", innerPath(ch2, Math.round(1e3 * height)));
-  var svgNode = new SvgNode([path27], {
+  var path29 = new PathNode("inner", innerPath(ch2, Math.round(1e3 * height)));
+  var svgNode = new SvgNode([path29], {
     "width": makeEm(width),
     "height": makeEm(height),
     // Override CSS rule `.katex svg { width: 100% }`
@@ -8717,10 +8757,10 @@ var makeStackedDelim = function makeStackedDelim2(delim, heightTotal, center, op
     var midHeight = realHeightTotal - topHeightTotal - bottomHeightTotal;
     var viewBoxHeight = Math.round(realHeightTotal * 1e3);
     var pathStr = tallDelim(svgLabel, Math.round(midHeight * 1e3));
-    var path27 = new PathNode(svgLabel, pathStr);
+    var path29 = new PathNode(svgLabel, pathStr);
     var width = makeEm(viewBoxWidth / 1e3);
     var height = makeEm(viewBoxHeight / 1e3);
-    var svg = new SvgNode([path27], {
+    var svg = new SvgNode([path29], {
       "width": width,
       "height": height,
       "viewBox": "0 0 " + viewBoxWidth + " " + viewBoxHeight
@@ -8761,8 +8801,8 @@ var makeStackedDelim = function makeStackedDelim2(delim, heightTotal, center, op
 var vbPad = 80;
 var emPad = 0.08;
 var sqrtSvg = function sqrtSvg2(sqrtName, height, viewBoxHeight, extraVinculum, options) {
-  var path27 = sqrtPath(sqrtName, extraVinculum, viewBoxHeight);
-  var pathNode = new PathNode(sqrtName, path27);
+  var path29 = sqrtPath(sqrtName, extraVinculum, viewBoxHeight);
+  var pathNode = new PathNode(sqrtName, path29);
   var svg = new SvgNode([pathNode], {
     // Note: 1000:1 ratio of viewBox to document em width.
     "width": "400em",
@@ -9261,8 +9301,8 @@ var htmlBuilder$7 = (group, options) => {
     var angleHeight = inner2.height + inner2.depth + lineWeight + clearance;
     inner2.style.paddingLeft = makeEm(angleHeight / 2 + lineWeight);
     var viewBoxHeight = Math.floor(1e3 * angleHeight * scale);
-    var path27 = phasePath(viewBoxHeight);
-    var svgNode = new SvgNode([new PathNode("phase", path27)], {
+    var path29 = phasePath(viewBoxHeight);
+    var svgNode = new SvgNode([new PathNode("phase", path29)], {
       "width": "400em",
       "height": makeEm(viewBoxHeight / 1e3),
       "viewBox": "0 0 400000 " + viewBoxHeight,
@@ -13291,11 +13331,11 @@ var newcommand = (context, existsOK, nonexistsOK, skipIfExists) => {
     throw new ParseError("\\newcommand's first argument must be a macro name");
   }
   var name = arg[0].text;
-  var exists2 = context.isDefined(name);
-  if (exists2 && !existsOK) {
+  var exists3 = context.isDefined(name);
+  if (exists3 && !existsOK) {
     throw new ParseError("\\newcommand{" + name + "} attempting to redefine " + (name + "; use \\renewcommand"));
   }
-  if (!exists2 && !nonexistsOK) {
+  if (!exists3 && !nonexistsOK) {
     throw new ParseError("\\renewcommand{" + name + "} when command " + name + " does not yet exist; use \\newcommand");
   }
   var numArgs = 0;
@@ -13313,7 +13353,7 @@ var newcommand = (context, existsOK, nonexistsOK, skipIfExists) => {
     numArgs = parseInt(argText);
     arg = context.consumeArg().tokens;
   }
-  if (!(exists2 && skipIfExists)) {
+  if (!(exists3 && skipIfExists)) {
     context.macros.set(name, {
       tokens: arg,
       numArgs
@@ -15984,7 +16024,7 @@ var EMOJI = new RegExp("\\p{Emoji_Presentation}", "gu");
 var COLOR = /#[0-9a-f]{3,8}\b|\b(?:rgba?|hsla?)\([^()]*\)/gi;
 var GOOGLE_URL = /fonts\.googleapis\.com\/[^"'\s)>]*/gi;
 var GOOGLE_FAMILY = /[?&]family=([^&"'\s]+)/gi;
-var THEME_LINK = /\/_themes\/[a-z0-9][a-z0-9-]*@[0-9]+\//i;
+var THEME_LINK = /\/_themes\/[a-z0-9][a-z0-9-]*@(?:[0-9]+|latest)\//i;
 function stylePathSkipped(rel2) {
   const parts2 = rel2.toLowerCase().split("/");
   const name = parts2[parts2.length - 1] ?? "";
@@ -16372,7 +16412,7 @@ var VERSION_AT = /@[0-9]+\.[0-9]+\.[0-9]+/;
 var VERSION_PATH = /\/[0-9]+\.[0-9]+\.[0-9]+\//;
 var EXTERNAL = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
 var IGNORED = /^(?:#|data:|blob:|mailto:|tel:|javascript:)/i;
-var THEME_REF = /^\/_themes\/([a-z0-9][a-z0-9-]*)@([0-9]+)\//;
+var THEME_REF = /^\/_themes\/([a-z0-9][a-z0-9-]*)@(latest|[0-9]+)\//;
 var TAG_PATTERN2 = /<([a-zA-Z][a-zA-Z0-9:-]*)((?:[^>"']|"[^"]*"|'[^']*')*)>/g;
 var ATTR_PATTERN = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
 var CSS_URL = /url\(\s*(?:"([^"]*)"|'([^']*)'|([^)'"\s]*))\s*\)/gi;
@@ -16498,7 +16538,7 @@ function resolveRef(scan, file, raw, line) {
       file,
       line,
       "error",
-      `root-relative reference ${value} (only /_themes/<name>@<n>/ paths may start with a slash)`
+      `root-relative reference ${value} (only /_themes/<name>@<n>/ or /_themes/<name>@latest/ paths may start with a slash)`
     );
     return;
   }
@@ -17032,7 +17072,7 @@ function sameFiles(local, remote) {
   const paths = Object.keys(local);
   const other = remote;
   if (paths.length !== Object.keys(other).length) return false;
-  return paths.every((path27) => other[path27]?.hash === local[path27]?.hash);
+  return paths.every((path29) => other[path29]?.hash === local[path29]?.hash);
 }
 function reportUnchanged(out, result) {
   out.data({ unchanged: true, slug: result.slug, version: result.version.n });
@@ -17770,8 +17810,8 @@ function keyLine(text2, key2, mode) {
   }
   return 0;
 }
-function finding(path27, line, severity, message) {
-  return { path: path27, line: Math.max(1, line), severity, message };
+function finding(path29, line, severity, message) {
+  return { path: path29, line: Math.max(1, line), severity, message };
 }
 function resolveValue(name, map, fallback) {
   let current = map[name] ?? fallback[name];
@@ -18093,7 +18133,7 @@ async function handleTheme(req, res, session, raw, pathname, method) {
   const rest = pathname.slice(PROXY_PREFIX.length);
   const slash = rest.indexOf("/");
   const segment = slash < 0 ? rest : rest.slice(0, slash);
-  const match = THEME_VERSION_PATTERN.exec(segment);
+  const match = THEME_VERSION_PATTERN.exec(segment) ?? THEME_LATEST_PATTERN.exec(segment);
   if (match === null) {
     if (session.art !== "" && !session.offline) {
       await proxy(session.art, raw, method, res);
@@ -18488,15 +18528,16 @@ async function resolveTheme2(config) {
   const theme = config.theme ?? "default";
   const ref = themeRefOf(theme);
   if (ref.version !== void 0 && ref.version !== "latest") return config;
+  const latest = { ...config, theme: `${ref.name}@latest` };
   if (config.art === void 0) {
     warn("no art host configured; skipping theme version lookup");
-    return config;
+    return config.theme === void 0 ? config : latest;
   }
   try {
-    return { ...config, theme: await resolvedTheme(config.art, theme) };
+    return { ...latest, theme_resolved: await resolvedTheme(config.art, theme) };
   } catch (err) {
     warn(`cannot resolve theme ${ref.name}: ${messageOf8(err)}`);
-    return config.theme === void 0 ? config : { ...config, theme: ref.name };
+    return config.theme === void 0 ? config : latest;
   }
 }
 async function run4(argv, ctx) {
@@ -19156,8 +19197,8 @@ async function create(argv, ctx) {
   if (baseDir === void 0) throw new UsageError(`no built-in theme: ${from}`);
   const parent = path18.resolve(stringValue(args, "dir") ?? ".");
   const target = path18.join(parent, name);
-  const exists2 = await stat13(target).catch(() => void 0);
-  if (exists2 !== void 0) throw new UsageError(`${target} already exists`);
+  const exists3 = await stat13(target).catch(() => void 0);
+  if (exists3 !== void 0) throw new UsageError(`${target} already exists`);
   const values = await baseRoleValues(baseDir, ROLE_TOKENS);
   const doc = { name, extends: from, tokens: {}, modeTokens: values };
   await mkdir6(target, { recursive: true });
@@ -19473,13 +19514,35 @@ async function run12(argv, ctx) {
 
 // src/commands/delete.ts
 async function run13(argv, ctx) {
-  const args = parseCommandArgs(argv, { yes: { type: "boolean" } }, 1, 1, DELETE_USAGE);
+  const args = parseCommandArgs(
+    argv,
+    { version: { type: "string" }, force: { type: "boolean" }, yes: { type: "boolean" } },
+    1,
+    1,
+    DELETE_USAGE
+  );
   const slug = validateSlug(args.positionals[0]);
+  const raw = stringValue(args, "version");
+  let version2 = null;
+  if (raw !== void 0) {
+    if (!/^[0-9]+$/.test(raw) || Number(raw) < 1) {
+      throw new UsageError(`expected a version number, got: ${raw}`);
+    }
+    version2 = Number(raw);
+  }
   if (!boolValue(args, "yes")) throw new UsageError(`delete needs --yes (try: ${usageLine(DELETE_USAGE)})`);
   const api = await ctx.api();
-  await api.deleteArtifact(slug);
-  ctx.out.data(null);
-  ctx.out.line(`deleted: ${slug}`);
+  const force = boolValue(args, "force");
+  if (version2 === null) {
+    await api.deleteArtifact(slug, force);
+    ctx.out.data(null);
+    ctx.out.line(`deleted: ${slug}`);
+    return;
+  }
+  const artifact = await api.deleteVersion(slug, version2, force);
+  ctx.out.data(artifact);
+  ctx.out.line(`deleted: ${slug} v${version2}`);
+  ctx.out.line(`served: ${artifact?.served === null || artifact?.served === void 0 ? "-" : artifact.served}`);
 }
 
 // src/commands/project.ts
@@ -22692,6 +22755,7 @@ var USAGE = {
   delete: DELETE_USAGE,
   login: LOGIN_USAGE,
   logout: LOGOUT_USAGE,
+  upgrade: UPGRADE_USAGE,
   completion: COMPLETION_USAGE
 };
 var WHEN = {
@@ -22713,8 +22777,15 @@ function listLines(usage) {
   if (start < 0) return [];
   const out = [];
   for (const line of lines.slice(start)) {
-    if (!/^\s{2}\S/.test(line)) break;
-    out.push(line);
+    if (/^\s{2}\S/.test(line)) {
+      out.push(line);
+      continue;
+    }
+    if (out.length > 0 && /^\s{3,}\S/.test(line)) {
+      out[out.length - 1] = `${out[out.length - 1].trimEnd()}  ${line.trim()}`;
+      continue;
+    }
+    break;
   }
   return out;
 }
@@ -23061,6 +23132,7 @@ var SPECS = {
   delete: { usage: DELETE_USAGE },
   login: { usage: LOGIN_USAGE },
   logout: { usage: LOGOUT_USAGE },
+  upgrade: { usage: UPGRADE_USAGE },
   completion: { usage: COMPLETION_USAGE, choices: [...SHELLS] }
 };
 function optionsOf(usage) {
@@ -23426,15 +23498,507 @@ async function run20(argv, ctx, platform = process21.platform) {
   ctx.out.line(`logged in as ${email} (scope ${scope}) for ${url}, saved in ${store2.description}`);
 }
 
-// src/commands/logout.ts
+// src/commands/upgrade.ts
+import { realpath as realpath2 } from "node:fs/promises";
+import path27 from "node:path";
+import process23 from "node:process";
+
+// src/upgrade.ts
+import { execFile, spawn as spawn6 } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
+import { createReadStream, createWriteStream } from "node:fs";
+import { chmod as chmod2, copyFile as copyFile2, lstat as lstat2, mkdtemp as mkdtemp5, readFile as readFile19, realpath, rename as rename3, rm as rm8, stat as stat15 } from "node:fs/promises";
+import path26 from "node:path";
 import process22 from "node:process";
-async function run21(argv, ctx, platform = process22.platform) {
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+var REPO = "rslib/rshow";
+var NPM_HINT = "npm i -g rshow";
+var INSTALLER_ELSEWHERE = `curl -fsSL https://rslib.github.io/rshow/install.sh | RSHOW_INSTALL_DIR=$HOME/.local/bin sh`;
+var LATEST_URL = `https://github.com/${REPO}/releases/latest`;
+var RELEASES = `https://github.com/${REPO}/releases/download/v`;
+var TARGETS = ["linux-x64", "linux-arm64", "darwin-arm64"];
+var VERSION_PATTERN = /^v?([0-9]+\.[0-9]+\.[0-9]+)$/;
+var TAG_PATH = /\/tag\/v([0-9]+\.[0-9]+\.[0-9]+)$/;
+var LOOKUP_TIMEOUT_MS = 15e3;
+var DOWNLOAD_TIMEOUT_MS = 6e5;
+var UNPACK_TIMEOUT_MS = 12e4;
+var RUN_TIMEOUT_MS = 2e4;
+var NPM_TIMEOUT_MS = 3e5;
+var SKILLS_TIMEOUT_MS = 12e4;
+var UpgradeFailure = class extends Error {
+  exit;
+  constructor(message, exit = EXIT.api) {
+    super(message);
+    this.name = "UpgradeFailure";
+    this.exit = exit;
+  }
+};
+function messageOf12(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function codeOf(err) {
+  const code = typeof err === "object" && err !== null ? err.code : void 0;
+  if (typeof code === "number") return `exit ${code}`;
+  if (typeof code === "string" && code !== "") return code;
+  return messageOf12(err);
+}
+function runProgram(file, args, options = {}) {
+  return new Promise((resolve2, reject) => {
+    const run23 = { timeout: options.timeoutMs, maxBuffer: 16 * 1024 * 1024 };
+    execFile(file, [...args], run23, (err, stdout) => {
+      if (err !== null) {
+        reject(err);
+        return;
+      }
+      resolve2(stdout);
+    });
+  });
+}
+function parseVersion(raw) {
+  const found = VERSION_PATTERN.exec(raw.trim());
+  if (found === null) throw new UsageError(`--version needs x.y.z, got: ${raw}`);
+  return found[1];
+}
+function compareVersions(left, right) {
+  const a = left.split(".").map(Number);
+  const b = right.split(".").map(Number);
+  for (let index = 0; index < 3; index += 1) {
+    const diff = (a[index] ?? 0) - (b[index] ?? 0);
+    if (diff !== 0) return diff < 0 ? -1 : 1;
+  }
+  return 0;
+}
+function targetOf2(platform, arch) {
+  const name = `${platform}-${arch}`;
+  return TARGETS.includes(name) ? name : void 0;
+}
+function releaseTagOf(location) {
+  if (location === null || location.trim() === "") return void 0;
+  let pathname;
+  try {
+    pathname = new URL(location, LATEST_URL).pathname;
+  } catch {
+    return void 0;
+  }
+  return TAG_PATH.exec(pathname)?.[1];
+}
+async function latestVersion(options) {
+  const reply = await sendRequest(
+    options.fetch,
+    LATEST_URL,
+    { redirect: "manual", signal: AbortSignal.timeout(LOOKUP_TIMEOUT_MS) },
+    options.env
+  );
+  const location = reply.headers.get("location");
+  const version2 = releaseTagOf(location);
+  if (version2 === void 0) {
+    throw new UpgradeFailure(`${LATEST_URL} did not name a release (location: ${location ?? "none"})`);
+  }
+  return version2;
+}
+function mirrorOf(options) {
+  const raw = (options.env.RSHOW_DOWNLOAD_BASE ?? "").trim();
+  if (raw === "") return void 0;
+  const base = raw.replace(/\/+$/, "");
+  let protocol;
+  try {
+    protocol = new URL(base).protocol;
+  } catch {
+    throw new UsageError(`RSHOW_DOWNLOAD_BASE is not a url: ${raw}`);
+  }
+  if (protocol !== "http:" && protocol !== "https:") {
+    throw new UsageError(`RSHOW_DOWNLOAD_BASE needs an http or https url, got: ${raw}`);
+  }
+  return base;
+}
+function otherError(options) {
+  const from = options.install.argv1 ?? options.install.execPath;
+  const version2 = options.wanted ?? "<version>";
+  const where = from.split(path26.sep).join("/");
+  if (where.includes("/_npx/")) {
+    return new UsageError(`rshow runs from ${from}, an npx cache that npm owns; run npx rshow@${version2}`);
+  }
+  if (where.includes("/node_modules/")) {
+    return new UsageError(
+      `rshow runs from ${from}, a local dependency that npm owns; run npm install rshow@${version2} to update it`
+    );
+  }
+  return new UsageError(`rshow runs from ${from}, a source checkout; update it with git pull and npm run build`);
+}
+function dataHome(env) {
+  const xdg = (env.XDG_DATA_HOME ?? "").trim();
+  return xdg !== "" ? xdg : path26.join(homeDir(env), ".local", "share");
+}
+function configHome(env) {
+  const xdg = (env.XDG_CONFIG_HOME ?? "").trim();
+  return xdg !== "" ? xdg : path26.join(homeDir(env), ".config");
+}
+function completionPaths(env) {
+  const data = dataHome(env);
+  const config = configHome(env);
+  return [
+    { name: "rshow.bash", dst: path26.join(data, "bash-completion", "completions", "rshow") },
+    { name: "_rshow", dst: path26.join(data, "zsh", "site-functions", "_rshow") },
+    { name: "rshow.fish", dst: path26.join(config, "fish", "completions", "rshow.fish") }
+  ];
+}
+async function exists2(file) {
+  return await stat15(file).catch(() => void 0) !== void 0;
+}
+function missingFile(name, url, named) {
+  if (named === void 0) {
+    return new UpgradeFailure(
+      `this release has no ${name} (${url}); a new release attaches its binaries a few minutes after it appears, so try again`
+    );
+  }
+  return new UpgradeFailure(
+    `release v${named} has no ${name} (${url}); it may not exist, and a release before 0.0.6 has no tarball, so use the installer with RSHOW_VERSION=${named}`
+  );
+}
+async function download(options, url, file, name, named) {
+  const reply = await sendRequest(options.fetch, url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) }, options.env);
+  if (reply.status === 404) throw missingFile(name, url, named);
+  if (reply.status !== 200 || reply.body === null) {
+    throw new UpgradeFailure(`cannot download ${url}: HTTP ${reply.status}`);
+  }
+  try {
+    await pipeline(Readable.fromWeb(reply.body), createWriteStream(file));
+  } catch (err) {
+    throw new UpgradeFailure(`cannot write ${file}: ${messageOf12(err)}`);
+  }
+}
+function sumOf(text2, name) {
+  for (const line of text2.split("\n")) {
+    const parts2 = line.trim().split(/\s+/);
+    if (parts2.length < 2) continue;
+    if (parts2[1].replace(/^\*/, "") === name) return parts2[0];
+  }
+  return void 0;
+}
+async function sha256Of(file) {
+  const hash = createHash3("sha256");
+  await pipeline(createReadStream(file), hash);
+  return hash.digest("hex");
+}
+async function checkSum(file, name, sumsFile) {
+  const expected = sumOf(await readFile19(sumsFile, "utf8"), name);
+  const actual = await sha256Of(file);
+  if (expected === void 0) {
+    throw new UpgradeFailure(`SHA256SUMS holds no line for ${name}, and the download is ${actual}`);
+  }
+  if (expected !== actual) {
+    throw new UpgradeFailure(`checksum mismatch for ${name}: SHA256SUMS says ${expected}, the download is ${actual}`);
+  }
+}
+async function unpack2(file, dir, tarball) {
+  try {
+    await runProgram("tar", ["-xzf", file, "-C", dir], { timeoutMs: UNPACK_TIMEOUT_MS });
+  } catch (err) {
+    throw new UpgradeFailure(`cannot unpack ${tarball}: ${codeOf(err)}`);
+  }
+}
+async function printedVersion(file) {
+  try {
+    return (await runProgram(file, ["--version"], { timeoutMs: RUN_TIMEOUT_MS })).trim();
+  } catch (err) {
+    throw new UpgradeFailure(`the new rshow does not run (${codeOf(err)}); the old rshow is still in place`);
+  }
+}
+async function replaceCompletions(options, dir, target) {
+  if ((options.env.RSHOW_NO_COMPLETIONS ?? "").trim() === "1") return;
+  for (const entry of completionPaths(options.env)) {
+    const src = path26.join(dir, `rshow-${target}`, "completions", entry.name);
+    try {
+      if (!await exists2(entry.dst) || !await exists2(src)) continue;
+      await copyFile2(src, entry.dst);
+    } catch (err) {
+      warn(`cannot replace the completion ${entry.dst}: ${messageOf12(err)}`);
+    }
+  }
+}
+function modeOf(target, statuses) {
+  const kinds = statuses.filter((entry) => entry.target === target).map((entry) => entry.state.kind);
+  if (kinds.includes("copy")) return "copy";
+  if (kinds.includes("link")) return "link";
+  return void 0;
+}
+async function refreshSkills(options, file, prefix) {
+  const targets = await detectedTargets(options.home);
+  if (targets.length === 0) return;
+  let source;
+  try {
+    source = await skillsSource(options.env);
+  } catch {
+    return;
+  }
+  if (source === void 0) return;
+  const statuses = await skillsStatus({ home: options.home, source, targets });
+  const groups = { copy: [], link: [] };
+  for (const target of targets) {
+    const mode = modeOf(target, statuses);
+    if (mode !== void 0) groups[mode].push(target);
+  }
+  for (const mode of ["copy", "link"]) {
+    if (groups[mode].length === 0) continue;
+    try {
+      await runProgram(file, [...prefix, "skills", "install", `--${mode}`, ...groups[mode]], {
+        timeoutMs: SKILLS_TIMEOUT_MS
+      });
+    } catch (err) {
+      warn(`the new rshow could not refresh the skills (${codeOf(err)}); run rshow skills install`);
+    }
+  }
+}
+function versionIn(printed) {
+  return /^rshow ([0-9]+\.[0-9]+\.[0-9]+)/.exec(printed)?.[1];
+}
+async function replaceBinary(job, dest) {
+  const dir = path26.dirname(dest);
+  let tmp;
+  try {
+    tmp = await mkdtemp5(path26.join(dir, ".rshow-upgrade-"));
+  } catch (err) {
+    const code = err.code;
+    if (code === "EACCES" || code === "EPERM" || code === "EROFS") {
+      throw new UpgradeFailure(`${dir} is not writable; install elsewhere instead: ${INSTALLER_ELSEWHERE}`);
+    }
+    throw new UpgradeFailure(`cannot write next to ${dest}: ${messageOf12(err)}`);
+  }
+  try {
+    const tarball = `rshow-${job.target}.tar.gz`;
+    const file = path26.join(tmp, tarball);
+    const sums = path26.join(tmp, "SHA256SUMS");
+    const url = `${job.base}/${tarball}`;
+    process22.stderr.write(`rshow: downloading ${url}
+`);
+    await download(job.options, url, file, tarball, job.named);
+    await download(job.options, `${job.base}/SHA256SUMS`, sums, "SHA256SUMS", job.named);
+    await checkSum(file, tarball, sums);
+    await unpack2(file, tmp, tarball);
+    const folder = `rshow-${job.target}`;
+    const unpacked = path26.join(tmp, folder, "rshow");
+    const info = await lstat2(unpacked).catch(() => void 0);
+    if (info === void 0) {
+      throw new UpgradeFailure(`${tarball} holds no ${folder}/rshow; the old rshow is still in place`);
+    }
+    if (!info.isFile()) {
+      throw new UpgradeFailure(`${tarball} holds a ${folder}/rshow that is not a file; the old rshow is still in place`);
+    }
+    await chmod2(unpacked, 493);
+    const printed = await printedVersion(unpacked);
+    let version2;
+    if (job.version === void 0) {
+      const found = versionIn(printed);
+      if (found === void 0) {
+        throw new UpgradeFailure(`the new rshow printed ${printed || "no version"}; the old rshow is still in place`);
+      }
+      if (!job.force && found === job.options.current) return { replaced: false, version: found };
+      version2 = found;
+    } else {
+      if (!printed.startsWith(`rshow ${job.version}`)) {
+        throw new UpgradeFailure(
+          `the new rshow printed ${printed || "no version"}, not rshow ${job.version}; the old rshow is still in place`
+        );
+      }
+      version2 = job.version;
+    }
+    await rename3(unpacked, dest);
+    await replaceCompletions(job.options, tmp, job.target);
+    return { replaced: true, version: version2 };
+  } finally {
+    await rm8(tmp, { recursive: true, force: true });
+  }
+}
+async function installPath(options) {
+  try {
+    return await realpath(options.install.execPath);
+  } catch (err) {
+    throw new UpgradeFailure(`cannot read ${options.install.execPath}: ${messageOf12(err)}`);
+  }
+}
+function targetOrFail(options) {
+  const platform = options.platform ?? process22.platform;
+  const arch = options.arch ?? process22.arch;
+  const target = targetOf2(platform, arch);
+  if (target === void 0) {
+    throw new UsageError(`no rshow single executable for ${platform}-${arch}; run ${NPM_HINT}`);
+  }
+  return target;
+}
+async function installBinary(job) {
+  const dest = await installPath(job.options);
+  const outcome = await replaceBinary(job, dest);
+  if (!outcome.replaced) return { status: "current", kind: "binary", version: outcome.version };
+  await refreshSkills(job.options, dest, []);
+  return { status: "upgraded", kind: "binary", previous: job.options.current, version: outcome.version };
+}
+function runNpm(args) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn6("npm", [...args], { stdio: ["ignore", 2, 2], timeout: NPM_TIMEOUT_MS });
+    child.on("error", (err) => {
+      child.emit("exit", null, null);
+      reject(err);
+    });
+    child.on("close", (code, signal) => {
+      if (code === 0) {
+        resolve2();
+        return;
+      }
+      if (code !== null) {
+        const err = Object.assign(new Error(`npm exited ${code}`), { code });
+        reject(err);
+        return;
+      }
+      reject(new Error(`npm stopped on ${signal ?? "a timeout"}`));
+    });
+  });
+}
+async function npmInstall(version2) {
+  const command = `npm install -g rshow@${version2}`;
+  try {
+    await runNpm(["install", "-g", `rshow@${version2}`]);
+  } catch (err) {
+    const code = err.code;
+    if (typeof code === "number") throw new UpgradeFailure(`${command} failed (exit ${code})`, code);
+    throw new UpgradeFailure(`cannot run npm (${codeOf(err)}); run ${command}`, EXIT.usage);
+  }
+}
+async function upgrade(options) {
+  const mirror = mirrorOf(options);
+  const force = options.force === true;
+  const kind = options.install.kind;
+  if (options.check === true) {
+    if (mirror !== void 0) {
+      throw new UsageError(`--check cannot be used with RSHOW_DOWNLOAD_BASE (${mirror}), which names no release`);
+    }
+    const latest = options.wanted ?? await latestVersion(options);
+    return {
+      status: "check",
+      current: options.current,
+      latest,
+      upgrade: compareVersions(latest, options.current) > 0
+    };
+  }
+  if (kind === "other") throw otherError(options);
+  if (kind === "binary" && mirror !== void 0 && options.wanted === void 0) {
+    return installBinary({ options, base: mirror, target: targetOrFail(options), force });
+  }
+  let version2 = options.wanted;
+  if (version2 === void 0) {
+    const latest = await latestVersion(options);
+    if (compareVersions(latest, options.current) < 0) {
+      return { status: "newer", kind, current: options.current, latest };
+    }
+    version2 = latest;
+  }
+  if (version2 === options.current && !force) {
+    return { status: "current", kind, version: version2 };
+  }
+  if (kind === "binary") {
+    const base = mirror ?? `${RELEASES}${version2}`;
+    return installBinary({ options, base, target: targetOrFail(options), version: version2, named: options.wanted, force });
+  }
+  await npmInstall(version2);
+  const argv1 = options.install.argv1;
+  if (argv1 !== void 0) await refreshSkills(options, process22.execPath, [argv1]);
+  return { status: "upgraded", kind: "npm", previous: options.current, version: version2 };
+}
+function reportOf(result) {
+  if (result.status === "check") {
+    return {
+      data: { current: result.current, latest: result.latest, upgrade_available: result.upgrade },
+      lines: [`current: ${result.current}`, `latest: ${result.latest}`]
+    };
+  }
+  if (result.status === "newer") {
+    return {
+      data: { previous: result.current, version: result.current, upgraded: false, kind: result.kind },
+      lines: [`rshow: ${result.current} is newer than the newest release, ${result.latest}`]
+    };
+  }
+  if (result.status === "current") {
+    return {
+      data: { previous: result.version, version: result.version, upgraded: false, kind: result.kind },
+      lines: [`rshow: already at ${result.version}`]
+    };
+  }
+  return {
+    data: { previous: result.previous, version: result.version, upgraded: true, kind: result.kind },
+    lines: [`rshow: upgraded ${result.previous} -> ${result.version}`]
+  };
+}
+
+// src/commands/upgrade.ts
+var TIMEOUT_MS2 = 6e4;
+function isUnder2(file, dir) {
+  const rel2 = path27.relative(dir, file);
+  return rel2 !== "" && rel2 !== ".." && !rel2.startsWith(`..${path27.sep}`) && !path27.isAbsolute(rel2);
+}
+async function npmRoot() {
+  try {
+    const root2 = (await runProgram("npm", ["root", "-g"], { timeoutMs: TIMEOUT_MS2 })).trim();
+    return root2 === "" ? void 0 : await realpath2(root2);
+  } catch {
+    return void 0;
+  }
+}
+async function installKind() {
+  if (await isBinary()) return { kind: "binary", execPath: process23.execPath };
+  const argv1 = process23.argv[1];
+  const root2 = await npmRoot();
+  if (root2 !== void 0 && argv1 !== void 0) {
+    const script3 = await realpath2(argv1).catch(() => void 0);
+    if (script3 !== void 0 && isUnder2(script3, root2)) {
+      return { kind: "npm", execPath: process23.execPath, argv1: script3 };
+    }
+  }
+  return { kind: "other", execPath: process23.execPath, argv1 };
+}
+async function run21(argv, ctx) {
+  const args = parseCommandArgs(
+    argv,
+    { check: { type: "boolean" }, version: { type: "string" }, force: { type: "boolean" } },
+    0,
+    0,
+    UPGRADE_USAGE
+  );
+  const raw = stringValue(args, "version");
+  const wanted = raw === void 0 ? void 0 : parseVersion(raw);
+  const env = process23.env;
+  let result;
+  try {
+    result = await upgrade({
+      current: VERSION,
+      wanted,
+      check: boolValue(args, "check"),
+      force: boolValue(args, "force"),
+      install: await installKind(),
+      fetch,
+      env,
+      home: homeDir(env)
+    });
+  } catch (err) {
+    if (!(err instanceof UpgradeFailure)) throw err;
+    process23.stderr.write(`rshow: ${err.message}
+`);
+    return err.exit;
+  }
+  const report = reportOf(result);
+  ctx.out.data(report.data);
+  for (const line of report.lines) ctx.out.line(line);
+  return EXIT.ok;
+}
+
+// src/commands/logout.ts
+import process24 from "node:process";
+async function run22(argv, ctx, platform = process24.platform) {
   const args = parseCommandArgs(argv, { url: { type: "string" } }, 0, 0, LOGOUT_USAGE);
   const settings = await ctx.config();
   const given = (stringValue(args, "url") ?? "").trim();
   const url = (given === "" ? requireUrl(settings) : given).replace(/\/+$/, "");
   const removed = [];
-  for (const store2 of await every(process22.env, platform)) {
+  for (const store2 of await every(process24.env, platform)) {
     if (await store2.remove(url)) removed.push(store2.description);
   }
   if (removed.length === 0) {
@@ -23464,14 +24028,15 @@ var COMMANDS = {
   pin: { usage: PIN_USAGE, run: run12 },
   delete: { usage: DELETE_USAGE, run: run13 },
   login: { usage: LOGIN_USAGE, run: run20 },
-  logout: { usage: LOGOUT_USAGE, run: run21 },
+  logout: { usage: LOGOUT_USAGE, run: run22 },
+  upgrade: { usage: UPGRADE_USAGE, run: run21 },
   completion: { usage: COMPLETION_USAGE, run: run19 },
   // Kept out of the general help: the docs site runs it, a person rarely does.
   docs: { usage: DOCS_USAGE, run: run18 }
 };
 function fail(err) {
   const message = err instanceof Error ? err.message : String(err);
-  process23.stderr.write(`rshow: ${message}
+  process25.stderr.write(`rshow: ${message}
 `);
   if (err instanceof UsageError) return EXIT.usage;
   if (err instanceof CheckError) return EXIT.check;
@@ -23483,39 +24048,40 @@ function fail(err) {
 async function main2(argv) {
   const wantsJson = argv.includes("--json");
   const args = argv.filter((arg) => arg !== "--json");
-  const wantsVersion = args.includes("--version") || args.includes("-v");
   const wantsHelp = args.includes("--help") || args.includes("-h");
-  const name = args.find((arg) => !arg.startsWith("-"));
+  const commandAt = args.findIndex((arg) => !arg.startsWith("-"));
+  const name = commandAt < 0 ? void 0 : args[commandAt];
   const spec = name === void 0 ? void 0 : COMMANDS[name];
+  const versionAt = args.findIndex((arg) => arg === "--version" || arg === "-v");
+  const wantsVersion = versionAt >= 0 && (commandAt < 0 || versionAt < commandAt);
   if (wantsVersion) {
     const suffix = await isBinary() ? " (binary)" : "";
-    process23.stdout.write(`rshow ${VERSION}${suffix}
+    process25.stdout.write(`rshow ${VERSION}${suffix}
 `);
     return EXIT.ok;
   }
   if (wantsHelp) {
-    process23.stdout.write(`${spec === void 0 ? GENERAL_USAGE : spec.usage}
+    process25.stdout.write(`${spec === void 0 ? GENERAL_USAGE : spec.usage}
 `);
     return EXIT.ok;
   }
   if (name === void 0) {
-    process23.stderr.write(`${GENERAL_USAGE}
+    process25.stderr.write(`${GENERAL_USAGE}
 `);
     return EXIT.usage;
   }
   if (spec === void 0) {
     throw new UsageError(`unknown command: ${name} (try: rshow --help)`);
   }
-  const index = args.indexOf(name);
-  const rest = [...args.slice(0, index), ...args.slice(index + 1)];
+  const rest = [...args.slice(0, commandAt), ...args.slice(commandAt + 1)];
   const configs = /* @__PURE__ */ new Map();
   const clients = /* @__PURE__ */ new Map();
-  const keyOf = (dir) => dir === void 0 ? "" : path26.resolve(dir);
+  const keyOf = (dir) => dir === void 0 ? "" : path28.resolve(dir);
   const configFor = (dir) => {
     const key2 = keyOf(dir);
     let pending = configs.get(key2);
     if (pending === void 0) {
-      pending = loadConfig(process23.env, dir);
+      pending = loadConfig(process25.env, dir);
       configs.set(key2, pending);
     }
     return pending;
@@ -23528,7 +24094,7 @@ async function main2(argv) {
       if (cached !== void 0) return cached;
       const settings = await configFor(dir);
       const url = requireUrl(settings);
-      const client = new Client(url, await readToken(process23.env, url));
+      const client = new Client(url, await readToken(process25.env, url));
       clients.set(key2, client);
       return client;
     },
@@ -23537,11 +24103,11 @@ async function main2(argv) {
   const code = await spec.run(rest, ctx);
   return code ?? EXIT.ok;
 }
-main2(process23.argv.slice(2)).then(
+main2(process25.argv.slice(2)).then(
   (code) => {
-    process23.exitCode = code;
+    process25.exitCode = code;
   },
   (err) => {
-    process23.exitCode = fail(err);
+    process25.exitCode = fail(err);
   }
 );