fix(yq): filter out special non-build files

fix(terraform): remove incorrect arch detection
fix(kube*): filter out companion util and legacy scripts
2026-06-03 22:42:48 +00:00 · 2023-11-15 21:26:13 -07:00 · 2023-11-15 21:26:13 -07:00 · 2023-11-15 21:26:12 -07:00 · 2023-11-15 21:26:08 -07:00 · 2023-11-15 21:25:47 -07:00
33 changed files with 1070 additions and 3113 deletions
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +0,0 @@
-[submodule "_webi/build-classifier"]
-	path = _webi/build-classifier
-	url = https://github.com/webinstall/webi-build-classifier.git
--- a/_common/git-tag.js
+++ b/_common/git-tag.js
@@ -6,12 +6,11 @@ var Crypto = require('crypto');
 var util = require('util');
 var exec = util.promisify(require('child_process').exec);
 var Fs = require('node:fs/promises');
-var FsSync = require('node:fs');
 var Path = require('node:path');

 var repoBaseDir = process.env.REPO_BASE_DIR || '';
 if (!repoBaseDir) {
-  repoBaseDir = Path.resolve('./_repos');
+  repoBaseDir = Path.resolve('./repos');
  // for stderr
  console.error(`[Warn] REPO_BASE_DIR= not set, ${repoBaseDir}`);
 }
@@ -21,29 +20,8 @@ var Repos = {};
 Repos.clone = async function (repoPath, gitUrl) {
  let uuid = Crypto.randomUUID();
  let tmpPath = `${repoPath}.${uuid}.tmp`;
-  let bakPath = `${repoPath}.${uuid}.dup`;
  await exec(`git clone --bare --filter=tree:0 ${gitUrl} ${tmpPath}`);
-
-  try {
-    FsSync.accessSync(repoPath);
-    return;
-  } catch (e) {
-    if (e.code !== 'ENOENT') {
-      throw e;
-    }
-  }
-
-  // sync to avoid race conditions
-  try {
-    FsSync.renameSync(repoPath, bakPath);
-  } catch (e) {
-    if (e.code !== 'ENOENT') {
-      throw e;
-    }
-  }
-  FsSync.renameSync(tmpPath, repoPath);
-
-  await Fs.rm(bakPath, { force: true, recursive: true });
+  await Fs.rename(tmpPath, repoPath);
 };

 Repos.checkExists = async function (repoPath) {
--- a/_webi/build-classifier
+++ b/_webi/build-classifier
--- a/_webi/builds-cacher.js
+++ b/_webi/builds-cacher.js
@@ -1,452 +0,0 @@
-'use strict';
-
-var BuildsCacher = module.exports;
-
-let Fs = require('node:fs/promises');
-let Path = require('node:path');
-
-let request = require('@root/request');
-let Triplet = require('./build-classifier/triplet.js');
-
-var ALIAS_RE = /^alias: (\w+)$/m;
-
-var LEGACY_ARCH_MAP = {
-  '*': 'ANYARCH',
-  arm64: 'aarch64',
-  armv6l: 'armv6',
-  armv7l: 'armv7',
-  amd64: 'x86_64',
-  mipsle: 'mipsel',
-  mips64le: 'mips64el',
-  mipsr6le: 'mipsr6el',
-  mips64r6le: 'mips64r6el',
-  // yes... el for arm and mips, but le for ppc
-  // (perhaps the joke got old?)
-  ppc64el: 'ppc64le',
-  386: 'x86',
-};
-var LEGACY_OS_MAP = {
-  '*': 'ANYOS',
-  macos: 'darwin',
-  posix: 'posix_2017',
-};
-
-var TERMS_META = [
-  // pattern
-  '{ARCH}',
-  '{EXT}',
-  '{LIBC}',
-  '{NAME}',
-  '{OS}',
-  '{VENDOR}',
-  // // os-/arch-indepedent
-  // 'ANYARCH',
-  // 'ANYOS',
-  // // libc
-  // 'none',
-  // channel
-  'beta',
-  'dev',
-  'preview',
-  'stable',
-];
-
-async function getPartialHeader(path) {
-  let readme = `${path}/README.md`;
-  let head = await readFirstBytes(readme).catch(function (err) {
-    if (err.code !== 'ENOENT') {
-      console.warn(`warn: ${path}: ${err.message}`);
-    }
-    return null;
-  });
-
-  return head;
-}
-
-// let fsOpen = util.promisify(Fs.open);
-// let fsRead = util.promisify(Fs.read);
-async function readFirstBytes(path) {
-  let start = 0;
-  let n = 1024;
-  let fh = await Fs.open(path, 'r');
-  let buf = new Buffer.alloc(n);
-  let result = await fh.read(buf, start, n);
-  let str = result.buffer.toString('utf8');
-  await fh.close();
-
-  return str;
-}
-
-let promises = {};
-async function getLatestBuilds(Releases, cacheDir, name, date) {
-  let id = `${cacheDir}/${name}`;
-  if (!promises[id]) {
-    promises[id] = Promise.resolve();
-  }
-
-  promises[id] = promises[id].then(async function () {
-    return await getLatestBuildsInner(Releases, cacheDir, name, date);
-  });
-
-  return await promises[id];
-}
-
-async function getLatestBuildsInner(Releases, cacheDir, name, date) {
-  let data = await Releases.latest(request);
-
-  if (!date) {
-    date = new Date();
-  }
-  let isoDate = date.toISOString();
-  let yearMonth = isoDate.slice(0, 7);
-
-  // TODO hash file
-  let dataFile = `${cacheDir}/${yearMonth}/${name}.json`;
-  // TODO fsstat releases.js vs require-ing time as well
-  let tsFile = `${cacheDir}/${yearMonth}/${name}.updated.txt`;
-
-  let dirPath = Path.dirname(dataFile);
-  await Fs.mkdir(dirPath, { recursive: true });
-
-  let json = JSON.stringify(data, null, 2);
-  await Fs.writeFile(dataFile, json, 'utf8');
-
-  let seconds = date.valueOf();
-  let ms = seconds / 1000;
-  let msStr = ms.toFixed(3);
-  await Fs.writeFile(tsFile, msStr, 'utf8');
-
-  return data;
-}
-
-BuildsCacher.create = function ({ ALL_TERMS, installers, caches }) {
-  if (!ALL_TERMS) {
-    ALL_TERMS = Triplet.TERMS_PRIMARY_MAP;
-  }
-
-  let bc = {};
-  bc.usedTerms = {};
-  bc.orphanTerms = Object.assign({}, ALL_TERMS);
-  bc.unknownTerms = {};
-  bc._triplets = {};
-  bc._targetsByBuildIdCache = {};
-  bc._caches = {};
-  bc._staleAge = 15 * 60 * 1000;
-
-  for (let term of TERMS_META) {
-    delete bc.orphanTerms[term];
-  }
-
-  bc.getPackages = async function () {
-    let dirs = {
-      hidden: {},
-      errors: {},
-      alias: {},
-      invalid: {},
-      selfhosted: {},
-      valid: {},
-    };
-
-    let entries = await Fs.readdir(installers, { withFileTypes: true });
-    for (let entry of entries) {
-      // skip non-installer dirs
-      if (entry.isSymbolicLink()) {
-        dirs.alias[entry.name] = 'symlink';
-        continue;
-      }
-      if (!entry.isDirectory()) {
-        dirs.hidden[entry.name] = '!directory';
-        continue;
-      }
-      if (entry.name === 'node_modules') {
-        dirs.hidden[entry.name] = 'node_modules';
-        continue;
-      }
-      if (entry.name.startsWith('_')) {
-        dirs.hidden[entry.name] = '_*';
-        continue;
-      }
-      if (entry.name.startsWith('.')) {
-        dirs.hidden[entry.name] = '.*';
-        continue;
-      }
-      if (entry.name.startsWith('~')) {
-        dirs.hidden[entry.name] = '~*';
-        continue;
-      }
-      if (entry.name.endsWith('~')) {
-        dirs.hidden[entry.name] = '*~';
-        continue;
-      }
-
-      // skip invalid installers
-      let path = Path.join(installers, entry.name);
-      let head = await getPartialHeader(path);
-      if (!head) {
-        dirs.invalid[entry.name] = '!README.md';
-        continue;
-      }
-
-      let alias = head.match(ALIAS_RE);
-      if (alias) {
-        dirs.alias[entry.name] = true;
-        continue;
-      }
-
-      let releasesPath = Path.join(path, 'releases.js');
-      let releases;
-      try {
-        releases = require(releasesPath);
-      } catch (err) {
-        if (err.code !== 'MODULE_NOT_FOUND') {
-          dirs.errors[entry.name] = err;
-          continue;
-        }
-        if (err.requireStack.length === 2) {
-          dirs.selfhosted[entry.name] = true;
-          continue;
-        }
-        // err.requireStack.length > 1
-        console.error('');
-        console.error('PROBLEM');
-        console.error(`    ${err.message}`);
-        console.error('');
-        console.error('SOLUTION');
-        console.error('    npm clean-install');
-        console.error('');
-        throw new Error(
-          '[SANITY FAIL] should never have missing modules in prod',
-        );
-      }
-
-      dirs.valid[entry.name] = true;
-    }
-
-    return dirs;
-  };
-
-  // Typically a package is organized by release (ex: go has 1.20, 1.21, etc),
-  // but we will organize by the build (ex: go1.20-darwin-arm64.tar.gz, etc).
-  bc.getBuilds = async function ({ Releases, name, date }) {
-    let cacheDir = caches;
-    let installerDir = installers;
-
-    if (!Releases) {
-      Releases = require(`${installerDir}/${name}/releases.js`);
-    }
-    // TODO update all releases files with object export
-    if (!Releases.latest) {
-      Releases.latest = Releases;
-    }
-
-    if (!date) {
-      date = new Date();
-    }
-    let isoDate = date.toISOString();
-    let yearMonth = isoDate.slice(0, 7);
-    let dataFile = `${cacheDir}/${yearMonth}/${name}.json`;
-
-    // let secondsStr = await Fs.readFile(tsFile, 'ascii').catch(function (err) {
-    //   if (err.code !== 'ENOENT') {
-    //     throw err;
-    //   }
-    //   return '0';
-    // });
-    // secondsStr = secondsStr.trim();
-    // let seconds = parseFloat(secondsStr) || 0;
-
-    // let age = now - seconds;
-
-    let data = bc._caches[name];
-    let versions = data?.versions || [];
-    let triplets = [];
-    let now = date.valueOf();
-    if (data) {
-      process.nextTick(async function () {
-        let age = now - data.updated;
-        if (age < bc._staleAge) {
-          return;
-        }
-        data = await getLatestBuilds(Releases, cacheDir, name);
-        let updated = date.valueOf();
-        updateVersions(data, versions);
-        Object.assign(data, { name, updated, versions, triplets });
-        bc._caches[name] = data;
-      });
-      return data;
-    }
-
-    let json = await Fs.readFile(dataFile, 'ascii').catch(async function (err) {
-      if (err.code !== 'ENOENT') {
-        throw err;
-      }
-
-      return null;
-    });
-
-    try {
-      data = JSON.parse(json);
-    } catch (e) {
-      console.error(`error: ${dataFile}:\n\t${e.message}`);
-      data = null;
-    }
-
-    if (!data) {
-      data = await getLatestBuilds(Releases, cacheDir, name);
-    }
-    let updated = date.valueOf();
-    updateVersions(data, versions);
-    Object.assign(data, { name, updated, versions, triplets });
-    bc._caches[name] = data;
-
-    for (let build of data.releases) {
-      if (LEGACY_OS_MAP[build.os]) {
-        build.os = LEGACY_OS_MAP[build.os];
-      }
-      if (LEGACY_ARCH_MAP[build.arch]) {
-        build.arch = LEGACY_ARCH_MAP[build.arch];
-      }
-    }
-
-    return data;
-  };
-
-  // TODO
-  //   - sort version
-  //   - tag channels
-  //   - @beta not install older than stable
-  function updateVersions(data, versions) {
-    for (let release of data.releases) {
-      let hasVersion = versions.includes(release.version);
-      if (!hasVersion) {
-        versions.unshift(release.version);
-      }
-    }
-  }
-
-  // Makes sure that packages are updated once an hour, on average
-  bc._staleNames = [];
-  bc._freshenTimeout = null;
-  bc.freshenRandomPackage = async function (minDelay) {
-    if (!minDelay) {
-      minDelay = 15 * 1000;
-    }
-
-    if (bc._staleNames.length === 0) {
-      let dirs = await bc.getPackages();
-      bc._staleNames = Object.keys(dirs.valid);
-      bc._staleNames.sort(function () {
-        return 0.5 - Math.random();
-      });
-    }
-
-    let name = bc._staleNames.pop();
-    let Releases = require(`${installers}/${name}/releases.js`);
-    //data = await getLatestBuilds(Releases, cacheDir, name);
-    void (await bc.getBuilds({
-      Releases: Releases,
-      name: name,
-      date: new Date(),
-    }));
-
-    let hour = 60 * 60 * 1000;
-    let delay = minDelay;
-    let spread = hour / bc._staleNames.length;
-    let seed = Math.random();
-    delay += seed * spread;
-
-    clearTimeout(bc._freshenTimeout);
-    bc._freshenTimeout = setTimeout(bc.freshenRandomPackage, delay);
-    bc._freshenTimeout.unref();
-  };
-
-  bc.classify = function (pkg, build) {
-    let maybeInstallable = Triplet.maybeInstallable(pkg, build);
-    if (!maybeInstallable) {
-      return null;
-    }
-
-    // because some packages are shimmed to match a single download against
-    let preTarget = Object.assign({ os: '', arch: '', libc: '' }, build);
-
-    let targetId = `${preTarget.os}:${preTarget.arch}:${preTarget.libc}`;
-    let buildId = `${pkg.name}:${targetId}@${build.download}`;
-    let target = bc._targetsByBuildIdCache[buildId];
-    if (target) {
-      Object.assign(build, { target: target, triplet: target.triplet });
-      return target;
-    }
-
-    let pattern = Triplet.toPattern(pkg, build);
-    if (!pattern) {
-      let err = new Error(`no pattern generated for ${name}`);
-      err.code = 'E_BUILD_NO_PATTERN';
-      target = { error: err };
-      bc._targetsByBuildIdCache[buildId] = target;
-      return target;
-    }
-
-    let rawTerms = pattern.split(/[_\{\}\/\.\-]+/g);
-    for (let term of rawTerms) {
-      delete bc.orphanTerms[term];
-      bc.usedTerms[term] = true;
-    }
-
-    // {NAME}/{NAME}-{VER}-Windows-x86_64_v2-musl.exe =>
-    //     {NAME}.windows.x86_64v2.musl.exe
-    let terms = Triplet.patternToTerms(pattern);
-    if (!terms.length) {
-      let err = new Error(`'${terms}' was trimmed to ''`);
-      target = { error: err };
-      bc._targetsByBuildIdCache[buildId] = target;
-      return target;
-    }
-
-    for (let term of terms) {
-      if (!term) {
-        continue;
-      }
-
-      if (ALL_TERMS[term]) {
-        delete bc.orphanTerms[term];
-        bc.usedTerms[term] = true;
-        continue;
-      }
-
-      bc.unknownTerms[term] = true;
-    }
-
-    // {NAME}.windows.x86_64v2.musl.exe
-    //     windows-x86_64_v2-musl
-    target = { triplet: '' };
-    void Triplet.termsToTarget(target, pkg, build, terms);
-
-    target.triplet = `${target.arch}-${target.vendor}-${target.os}-${target.libc}`;
-    let hasTriplet = pkg.triplets.includes(target.triplet);
-    if (!hasTriplet) {
-      // TODO I don't love this hidden behavior
-      // perhaps classify should just happen when the package is loaded
-      // (and the sanity error should be removed, or thrown after the loop is complete)
-      pkg.triplets.push(target.triplet);
-    }
-
-    bc._triplets[target.triplet] = true;
-    bc._targetsByBuildIdCache[buildId] = target;
-
-    let triple = [target.arch, target.vendor, target.os, target.libc];
-    for (let term of triple) {
-      if (!ALL_TERMS[term]) {
-        throw new Error(
-          `[SANITY FAIL] '${pkg.name}' '${target.triplet}' generated unknown term '${term}'`,
-        );
-      }
-
-      delete bc.orphanTerms[term];
-      bc.usedTerms[term] = true;
-    }
-
-    return target;
-  };
-
-  return bc;
-};
--- a/_webi/curl-pipe-bootstrap.tpl.sh
+++ b/_webi/curl-pipe-bootstrap.tpl.sh
@@ -16,45 +16,39 @@ export WEBI_CHECKSUM=06a7fb9f
 #                                       #
 #########################################

+# shellcheck disable=SC2005
 fn_show_welcome() { (
    echo ""
+    printf "%s %s\n" \
+        "$(t_strong 'Welcome to') $(t_stronger 'Webi')$(t_strong '!')" \
+        "$(t_dim "- Modern tools, instant installs.")"
+    echo "We expect your experience to be $(t_em 'absolutely perfect')!"
    echo ""
-    # invert t_task and t_pkg for top-level welcome message
-    printf -- ">>> %s %s  <<<\n" \
-        "$(t_pkg 'Welcome to') $(t_task 'Webi')$(t_pkg '!')" \
-        "$(t_dim "- modern tools, instant installs.")"
-    echo "    We expect your experience to be $(t_em 'absolutely perfect')!"
+    echo "    $(t_yellow 'Have a problem?') Please $(t_em 'let us know'):"
+    echo "        $(t_url 'https://github.com/webinstall/webi-installers/issues')"
+    echo "        $(t_dim "(your system is $(t_yellow "$(uname -s)")/$(t_yellow "$(uname -m)") with $(t_yellow "$(fn_get_libc)") & $(t_yellow "$(fn_get_http)"))")"
    echo ""
-    echo "    $(t_attn 'Success')? Star it!   $(t_url 'https://github.com/webinstall/webi-installers')"
-    echo "    $(t_attn 'Problem')? Report it: $(t_url 'https://github.com/webinstall/webi-installers/issues')"
-    echo "                        $(t_dim "(your system is") $(t_host "$(fn_get_os)")/$(t_host "$(uname -m)") $(t_dim "with") $(t_host "$(fn_get_libc)") $(t_dim "&") $(t_host "$(fn_get_http_client_name)")$(t_dim ")")"
+    echo "    $(t_yellow 'Love it?') Star it!"
+    echo "        $(t_url 'https://github.com/webinstall/webi-installers')"

    sleep 0.2
 ); }

-fn_get_os() { (
-    # Ex:
-    #     GNU/Linux
-    #     Android
-    #     Linux (often Alpine, musl)
-    #     Darwin
-    b_os="$(uname -o 2> /dev/null || echo '')"
-    b_sys="$(uname -s)"
-    if test -z "${b_os}" || test "${b_os}" = "${b_sys}"; then
-        # ex: 'Darwin' (and plain, non-GNU 'Linux')
-        echo "${b_sys}"
-        return 0
-    fi
+t_strong() { (printf '\e[36m%s\e[39m' "${1}"); }
+t_stronger() { (printf '\e[1m\e[32m%s\e[39m\e[22m' "${1}"); }
+t_url() { (printf '\e[2m%s\e[22m' "${1}"); }
+t_path() { (printf '\e[2m\e[32m%s\e[39m\e[22m' "${1}"); }
+t_cmd() { (printf '\e[2m\e[35m%s\e[39m\e[22m' "${1}"); }
+t_err() { (printf '\e[31m%s\e[39m' "${1}"); }

-    if echo "${b_os}" | grep -q "${b_sys}"; then
-        # ex: 'GNU/Linux'
-        echo "${b_os}"
-        return 0
-    fi
-
-    # ex: 'Android/Linux'
-    echo "${b_os}/${b_sys}"
-); }
+t_bold() { (printf '\e[1m%s\e[22m' "${1}"); }
+t_dim() { (printf '\e[2m%s\e[22m' "${1}"); }
+t_em() { (printf '\e[3m%s\e[23m' "${1}"); }
+t_under() { (printf '\e[4m%s\e[24m' "${1}"); }
+t_green() { (printf '\e[32m%s\e[39m' "${1}"); }
+t_yellow() { (printf '\e[33m%s\e[39m' "${1}"); }
+t_magenta() { (printf '\e[35m%s\e[39m' "${1}"); }
+t_cyan() { (printf '\e[36m%s\e[39m' "${1}"); }

 fn_get_libc() { (
    # Ex:
@@ -62,14 +56,14 @@ fn_get_libc() { (
    #     libc
    if ldd /bin/ls 2> /dev/null | grep -q 'musl' 2> /dev/null; then
        echo 'musl'
-    elif fn_get_os | grep -q 'GNU|Linux'; then
+    elif uname -o | grep -q 'GNU' || uname -s | grep -q 'Linux'; then
        echo 'gnu'
    else
        echo 'libc'
    fi
 ); }

-fn_get_http_client_name() { (
+fn_get_http() { (
    # Ex:
    #     curl
    #     curl+wget
@@ -88,56 +82,6 @@ fn_get_http_client_name() { (
    echo "${b_client}"
 ); }

-#########################################
-#                                       #
-#      For Making the Display Nice      #
-#                                       #
-#########################################
-
-# Term Types
-t_cmd() { (fn_printf '\e[2m\e[35m%s\e[39m\e[22m' "${1}"); }
-t_host() { (fn_printf '\e[2m\e[33m%s\e[39m\e[22m' "${1}"); }
-t_link() { (fn_printf '\e[1m\e[36m%s\e[39m\e[22m' "${1}"); }
-t_path() { (fn_printf '\e[2m\e[32m%s\e[39m\e[22m' "${1}"); }
-t_pkg() { (fn_printf '\e[1m\e[32m%s\e[39m\e[22m' "${1}"); }
-t_task() { (fn_printf '\e[36m%s\e[39m' "${1}"); }
-t_url() { (fn_printf '\e[2m%s\e[22m' "${1}"); }
-
-# Levels
-t_info() { (fn_printf '\e[1m\e[36m%s\e[39m\e[22m' "${1}"); }
-t_attn() { (fn_printf '\e[1m\e[33m%s\e[39m\e[22m' "${1}"); }
-t_warn() { (fn_printf '\e[1m\e[33m%s\e[39m\e[22m' "${1}"); }
-t_err() { (fn_printf '\e[31m%s\e[39m' "${1}"); }
-
-# Styles
-t_bold() { (fn_printf '\e[1m%s\e[22m' "${1}"); }
-t_dim() { (fn_printf '\e[2m%s\e[22m' "${1}"); }
-t_em() { (fn_printf '\e[3m%s\e[23m' "${1}"); }
-t_under() { (fn_printf '\e[4m%s\e[24m' "${1}"); }
-
-# FG Colors
-t_cyan() { (fn_printf '\e[36m%s\e[39m' "${1}"); }
-t_green() { (fn_printf '\e[32m%s\e[39m' "${1}"); }
-t_magenta() { (fn_printf '\e[35m%s\e[39m' "${1}"); }
-t_yellow() { (fn_printf '\e[33m%s\e[39m' "${1}"); }
-
-fn_printf() { (
-    a_style="${1}"
-    a_text="${2}"
-    if fn_is_tty; then
-        #shellcheck disable=SC2059
-        printf -- "${a_style}" "${a_text}"
-    else
-        printf -- '%s' "${a_text}"
-    fi
-); }
-
-fn_sub_home() { (
-    my_rel=${HOME}
-    my_abs=${1}
-    echo "${my_abs}" | sed "s:^${my_rel}:~:"
-); }
-
 ###################################
 #                                 #
 #       Detect HTTP Client        #
@@ -150,14 +94,9 @@ fn_wget() { (
    a_url="${1}"
    a_path="${2}"

-    cmd_wget="wget -c -q --user-agent"
-    if fn_is_tty; then
-        cmd_wget="wget -c -q --show-progress --user-agent"
-    fi
-    # busybox wget doesn't support --show-progress
-    # See <https://github.com/webinstall/webi-installers/pull/772>
-    if readlink "$(command -v wget)" | grep -q busybox; then
-        cmd_wget="wget --user-agent"
+    cmd_wget="wget -q --user-agent"
+    if fn_is_interactive; then
+        cmd_wget="wget -q --show-progress --user-agent"
    fi

    b_triple_ua="$(fn_get_target_triple_user_agent)"
@@ -166,9 +105,9 @@ fn_wget() { (
        b_agent="webi/wget+curl ${b_triple_ua}"
    fi

-    if ! $cmd_wget "${b_agent}" "${a_url}" -O "${a_path}"; then
+    if ! $cmd_wget "${b_agent}" -c "${a_url}" -O "${a_path}"; then
        echo >&2 "    $(t_err "failed to download (wget)") '$(t_url "${a_url}")'"
-        echo >&2 "    $cmd_wget '${b_agent}' '${a_url}' -O '${a_path}'"
+        echo >&2 "    $cmd_wget '${b_agent}' -c '${a_url}' -O '${a_path}'"
        echo >&2 "    $(wget -V)"
        return 1
    fi
@@ -180,9 +119,9 @@ fn_curl() { (
    a_url="${1}"
    a_path="${2}"

-    cmd_curl="curl -f -sSL -#"
-    if fn_is_tty; then
-        cmd_curl="curl -f -sSL"
+    cmd_curl="curl --fail-with-body -sSL -#"
+    if fn_is_interactive; then
+        cmd_curl="curl --fail-with-body sSL"
    fi

    b_triple_ua="$(fn_get_target_triple_user_agent)"
@@ -199,11 +138,21 @@ fn_curl() { (
    fi
 ); }

+fn_is_interactive() {
+    # Ex:
+    #     himBH
+    #     hBc
+    case $- in
+        *i*) return 0 ;;
+        *) return 1 ;;
+    esac
+}
+
 fn_get_target_triple_user_agent() { (
    # Ex:
-    #     x86_64/unknown GNU/Linux/5.15.107-2-pve gnu
+    #     x86_64/unknown Linux/5.15.107-2-pve gnu
    #     arm64/unknown Darwin/22.6.0 libc
-    echo "$(uname -m)/unknown $(fn_get_os)/$(uname -r) $(fn_get_libc)"
+    echo "$(uname -m)/unknown $(uname -s)/$(uname -r) $(fn_get_libc)"
 ); }

 fn_download_to_path() { (
@@ -211,10 +160,10 @@ fn_download_to_path() { (
    a_path="${2}"

    mkdir -p "$(dirname "${a_path}")"
-    if command -v curl > /dev/null; then
-        fn_curl "${a_url}" "${a_path}.part"
-    elif command -v wget > /dev/null; then
+    if command -v wget > /dev/null; then
        fn_wget "${a_url}" "${a_path}.part"
+    elif command -v curl > /dev/null; then
+        fn_curl "${a_url}" "${a_path}.part"
    else
        echo >&2 "    $(t_err "failed to detect HTTP client (curl, wget)")"
        return 1
@@ -228,40 +177,31 @@ fn_download_to_path() { (
 #                                            #
 ##############################################

-webi_bootstrap() { (
+webi_upgrade() { (
    a_path="${1}"

    echo ""
-    echo "$(t_task 'Bootstrapping') $(t_pkg 'Webi')"
+    echo "$(t_strong 'Bootstrapping') $(t_stronger 'Webi')"

    b_path_rel="$(fn_sub_home "${a_path}")"
    b_checksum=""
    if test -r "${a_path}"; then
+        echo "    $(t_dim 'Found') $(t_path "${b_path_rel}")"
        b_checksum="$(fn_checksum "${a_path}")"
    fi
    if test "$b_checksum" = "${WEBI_CHECKSUM}"; then
-        echo "    $(t_dim 'Found') $(t_path "${b_path_rel}")"
        sleep 0.1
        return 0
    fi

    b_webi_file_url="${WEBI_HOST}/packages/webi/webi.sh"
-    b_tmp=''
    if test -r "${a_path}"; then
-        b_ts="$(date -u '+%s')"
-        b_tmp="${a_path}.${b_ts}.bak"
-        mv "${a_path}" "${b_tmp}"
        echo "    Updating $(t_path "${b_path_rel}")"
    fi
-
    echo "    Downloading $(t_url "${b_webi_file_url}")"
    echo "        to $(t_path "${b_path_rel}")"
    fn_download_to_path "${b_webi_file_url}" "${a_path}"
    chmod u+x "${a_path}"
-
-    if test -r "${b_tmp}"; then
-        rm -f "${b_tmp}"
-    fi
 ); }

 fn_checksum() {
@@ -275,64 +215,29 @@ fn_checksum() {
    $cmd_shasum "${a_filepath}" | cut -d' ' -f1 | cut -c 1-8
 }

-##############################################
-#                                            #
-#          Detect TTY and run main           #
-#                                            #
-##############################################
-
-fn_is_tty() {
-    if test "${WEBI_TTY}" = 'tty'; then
-        return 0
-    fi
-    return 1
-}
-
-fn_detect_tty() { (
-    # stdin will NOT be a tty if it's being piped
-    # stdout & stderr WILL be a tty even when piped
-    # they are not a tty if being captured or redirected
-    # 'set -i' is NOT available in sh
-    if test -t 1 && test -t 2; then
-        return 0
-    fi
-
-    return 1
+fn_sub_home() { (
+    my_rel=${HOME}
+    my_abs=${1}
+    echo "${my_abs}" | sed "s:^${my_rel}:~:"
 ); }

 main() { (
-    set -e
-    set -u
-
-    WEBI_TTY="${WEBI_TTY:-}"
-    if test -z "${WEBI_TTY}"; then
-        if fn_detect_tty; then
-            WEBI_TTY="tty"
-        fi
-        export WEBI_TTY
-    fi
-
-    if test -z "${WEBI_WELCOME:-}"; then
-        fn_show_welcome
-    fi
-    export WEBI_WELCOME='shown'
+    fn_show_welcome
+    export WEBI_WELCOME=true

    # note: we may support custom locations in the future
    export WEBI_HOME="${HOME}/.local"
    b_home="$(fn_sub_home "${WEBI_HOME}")"
    b_webi_path="${WEBI_HOME}/bin/webi"
    b_webi_path_rel="${b_home}/bin/webi"
+    webi_upgrade "${b_webi_path}"

-    WEBI_CURRENT="${WEBI_CURRENT:-}"
-    if test "${WEBI_CURRENT}" != "${WEBI_CHECKSUM}"; then
-        webi_bootstrap "${b_webi_path}"
-        export WEBI_CURRENT="${WEBI_CHECKSUM}"
-    fi
-
-    echo "    Running $(t_cmd "${b_webi_path_rel} ${WEBI_PKG}")"
    echo ""
-
+    echo "$(t_strong 'Installing') $(t_stronger "${WEBI_PKG}") $(t_strong '...')"
+    echo "    Running $(t_cmd "${b_webi_path_rel} ${WEBI_PKG}")"
    "${b_webi_path}" "${WEBI_PKG}"
 ); }

+set -e
+set -u
 main
--- a/_webi/install-package.tpl.ps1
+++ b/_webi/install-package.tpl.ps1
@@ -69,7 +69,7 @@ function Invoke-DownloadUrl {
        Write-Host "        ?$Params"
        $URL = "${URL}?${Params}"
    }
-    curl.exe '-#' -f -sS -A $Env:WEBI_UA -L $URL | Out-File $TmpPath
+    curl.exe '-#' --fail-with-body -sS -A $Env:WEBI_UA -L $URL | Out-File $TmpPath

    Remove-Item -Path $Path -Force -ErrorAction Ignore
    Move-Item $TmpPath $Path
--- a/_webi/install-package.tpl.sh
+++ b/_webi/install-package.tpl.sh
@@ -0,0 +1,695 @@
+#!/bin/sh
+
+__bootstrap_webi() {
+
+    set -e
+    set -u
+    #set -x
+
+    my_libc=''
+    if ldd /bin/ls 2> /dev/null | grep -q 'musl' 2> /dev/null; then
+        my_libc='musl'
+    elif uname -o | grep -q 'GNU' || uname -s | grep -q 'Linux'; then
+        my_libc='gnu'
+    else
+        my_libc='libc'
+    fi
+    WEBI_UA="$(uname -s)/$(uname -r) $(uname -m)/unknown ${my_libc}"
+
+    #WEBI_PKG=
+    #PKG_NAME=
+    #WEBI_OS=
+    #WEBI_ARCH=
+    #WEBI_LIBC=
+    #WEBI_HOST=
+    #WEBI_RELEASES=
+    #WEBI_CSV=
+    #WEBI_TAG=
+    #WEBI_VERSION=
+    #WEBI_MAJOR=
+    #WEBI_MINOR=
+    #WEBI_PATCH=
+    # TODO not sure if BUILD is the best name for this
+    #WEBI_BUILD=
+    #WEBI_GIT_TAG=
+    #WEBI_LTS=
+    #WEBI_CHANNEL=
+    #WEBI_EXT=
+    #WEBI_FORMATS=
+    #WEBI_PKG_URL=
+    #WEBI_PKG_FILE=
+    #WEBI_PKG_PATHNAME=
+    #PKG_OSES=
+    #PKG_ARCHES=
+    #PKG_LIBCS=
+    #PKG_FORMATS=
+    WEBI_UA="$(uname -s)/$(uname -r) $(uname -m)/unknown ${my_libc}"
+    WEBI_PKG_DOWNLOAD=""
+    WEBI_DOWNLOAD_DIR="${HOME}/Downloads"
+    if command -v xdg-user-dir > /dev/null; then
+        WEBI_DOWNLOAD_DIR="$(xdg-user-dir DOWNLOAD)"
+        if [ "${WEBI_DOWNLOAD_DIR}" = "${HOME}" ]; then
+            WEBI_DOWNLOAD_DIR="${HOME}/Downloads"
+        fi
+    fi
+
+    WEBI_PKG_PATH="${WEBI_DOWNLOAD_DIR}/webi/${PKG_NAME:-error}/${WEBI_VERSION:-latest}"
+
+    export WEBI_HOST
+
+    ##
+    ## Set up tmp, download, and install directories
+    ##
+
+    WEBI_TMP=${WEBI_TMP:-"$(mktemp -d -t webinstall-"${WEBI_PKG-}".XXXXXXXX)"}
+    export _webi_tmp="${_webi_tmp:-"$HOME/.local/opt/webi-tmp.d"}"
+
+    mkdir -p "${WEBI_PKG_PATH}"
+    mkdir -p "$HOME/.local/bin"
+    mkdir -p "$HOME/.local/opt"
+
+    if test -e ~/.local/bin; then
+        echo "Found ~/.local/bin"
+    else
+        echo "Creating ~/.local/bin"
+        mkdir -p "$HOME/.local/bin"
+    fi
+
+    if test -e ~/.local/bin/webi; then
+        echo "Found ~/.local/bin/webi"
+    else
+        echo "Creating ~/.local/bin"
+        mkdir -p "$HOME/.local/bin"
+    fi
+
+    ##
+    ## Detect http client
+    ##
+    set +e
+    WEBI_CURL="$(command -v curl)"
+    export WEBI_CURL
+    WEBI_WGET="$(command -v wget)"
+    export WEBI_WGET
+    set -e
+
+    # get the special formatted version
+    # (i.e. "go is go1.14" while node is "node v12.10.8")
+    my_versioned_name=""
+    _webi_canonical_name() {
+        if [ -n "$my_versioned_name" ]; then
+            echo "$my_versioned_name"
+            return 0
+        fi
+
+        if command -v pkg_format_cmd_version > /dev/null; then
+            my_versioned_name="'$(pkg_format_cmd_version "$WEBI_VERSION")'"
+        else
+            my_versioned_name="'$pkg_cmd_name v$WEBI_VERSION'"
+        fi
+
+        echo "$my_versioned_name"
+    }
+
+    # Update symlinks as per $HOME/.local/opt and $HOME/.local/bin install paths.
+    webi_link() {
+        if command -v pkg_link > /dev/null; then
+            pkg_link
+            return 0
+        fi
+
+        if test -n "${WEBI_SINGLE}"; then
+            rm -rf "$pkg_dst_cmd"
+            ln -s "$pkg_src_cmd" "$pkg_dst_cmd"
+        else
+            # 'pkg_dst' will default to $HOME/.local/opt/<pkg>
+            # 'pkg_src' will be the installed version,
+            # such as to $HOME/.local/opt/<pkg>-<version>
+            rm -rf "$pkg_dst"
+            ln -s "$pkg_src" "$pkg_dst"
+        fi
+    }
+
+    # detect if this program is already installed
+    # or if an installed version may cause conflict
+    webi_check_installed() {
+        # Test for existing version
+        set +e
+        my_path="$PATH"
+        PATH="$(dirname "$pkg_dst_cmd"):$PATH"
+        export PATH
+        my_current_cmd="$(command -v "$pkg_cmd_name")"
+        set -e
+        if [ -n "$my_current_cmd" ]; then
+            my_canonical_name="$(_webi_canonical_name)"
+            if [ "$my_current_cmd" != "$pkg_dst_cmd" ]; then
+                echo >&2 "WARN: possible PATH conflict between $my_canonical_name and currently installed version"
+                echo >&2 "    ${pkg_dst_cmd} (new)"
+                echo >&2 "    ${my_current_cmd} (existing)"
+                #my_current_version=false
+            fi
+            # 'readlink' can't read links in paths on macOS 🤦
+            # but that's okay, 'cmp -s' is good enough for us
+            if cmp -s "${pkg_src_cmd}" "${my_current_cmd}"; then
+                echo "${my_canonical_name} already installed:"
+                my_dst_rel="$(
+                    webi_sub_home "${pkg_dst}"
+                )"
+                printf "    %s" "${my_dst_rel}"
+                if [ "${pkg_src_cmd}" != "${my_current_cmd}" ]; then
+                    my_src_rel="$(
+                        webi_sub_home "${pkg_src}"
+                    )"
+                    printf " => %s" "${my_src_rel}"
+                fi
+                echo ""
+                exit 0
+            fi
+            if [ -x "$pkg_src_cmd" ]; then
+                webi_link
+                echo "switched to $my_canonical_name:"
+                my_src_rel="$(
+                    webi_sub_home "${pkg_src}"
+                )"
+                my_dst_rel="$(
+                    webi_sub_home "${pkg_dst}"
+                )"
+                echo "    ${my_dst_rel} => ${my_src_rel}"
+                exit 0
+            fi
+        fi
+        export PATH="$my_path"
+    }
+
+    webi_check_available() {
+        if test "$WEBI_CHANNEL" != "error"; then
+            return 0
+        fi
+
+        echo >&2 "Error: no '${PKG_NAME:-"Unknown Package"}@${WEBI_TAG:-"Unknown Tag"}' release for '${WEBI_OS:-"Unknown OS"}' (${WEBI_LIBC:-"Unknown Libc"}) on '${WEBI_ARCH:-"Unknown CPU"}' as one of '${WEBI_FORMATS:-"Unknown File Type"}'"
+        echo >&2 "       '$PKG_NAME' is available for '$PKG_OSES' ($PKG_LIBCS) on '$PKG_ARCHES' as one of '$PKG_FORMATS'"
+        echo >&2 "       (check that the package name and version are correct)"
+        echo >&2 ""
+        my_release_url="$(
+            echo "$WEBI_RELEASES" |
+                sed 's:?.*::'
+        )"
+        my_release_params="$(
+            echo "$WEBI_RELEASES" |
+                sed 's:.*?:?:'
+        )"
+        echo >&2 "       Double check at ${my_release_url}"
+        echo >&2 "           ${my_release_params}"
+        echo >&2 ""
+
+        exit 1
+    }
+
+    is_interactive_shell() {
+        # $- shows shell flags (error,unset,interactive,etc)
+        case $- in
+            *i*) return 0 ;;
+            *) return 1 ;;
+        esac
+    }
+
+    webi_sub_home() { (
+        my_rel=${HOME}
+        my_abs=${1}
+        echo "${my_abs}" | sed "s:^${my_rel}:~:"
+    ); }
+
+    # detect if file is downloaded, and how to download it
+    webi_download() {
+        my_url="${1}"
+        my_dl="${2}"
+        my_dl_name="${3:-${PKG_NAME}}"
+
+        my_dl_rel="$(
+            webi_sub_home "${my_dl}"
+        )"
+
+        WEBI_PKG_DOWNLOAD="${my_dl}"
+        export WEBI_PKG_DOWNLOAD
+
+        if [ -e "${my_dl}" ]; then
+            echo "Found ${my_dl_rel}"
+            return 0
+        fi
+
+        echo "Downloading ${my_dl_name} from"
+        echo "$my_url"
+
+        # It's only 2020, we can't expect to have reliable CLI tools
+        # to tell us the size of a file as part of a base system...
+        if [ -n "$WEBI_WGET" ]; then
+            # wget has resumable downloads
+            # TODO wget -c --content-disposition "$my_url"
+            set +e
+            my_show_progress=""
+            if is_interactive_shell; then
+                my_show_progress="--show-progress"
+            fi
+            if ! wget -q $my_show_progress --user-agent="wget $WEBI_UA" -c "$my_url" -O "$my_dl.part"; then
+                echo >&2 "failed to download from $WEBI_PKG_URL"
+                exit 1
+            fi
+            set -e
+        else
+            # Neither GNU nor BSD curl have sane resume download options, hence we don't bother
+            my_show_progress="-#"
+            if is_interactive_shell; then
+                my_show_progress=""
+            fi
+            # shellcheck disable=SC2086
+            # we want the flags to be split
+            curl -fSL $my_show_progress -H "User-Agent: curl $WEBI_UA" "$my_url" -o "$my_dl.part"
+        fi
+        mv "$my_dl.part" "$my_dl"
+
+        echo ""
+        echo "Saved as ${my_dl_rel}"
+    }
+
+    webi_git_clone() { (
+        my_url="${1}"
+        my_dl="${2}"
+
+        my_dl_rel="$(
+            webi_sub_home "${my_dl}"
+        )"
+        if [ -e "${my_dl}" ]; then
+            echo "Found ${my_dl_rel}"
+
+            cp -RPp "${my_dl}" "${WEBI_TMP}/${WEBI_PKG_FILE}/"
+            return 0
+        fi
+
+        echo "Cloning ${my_url}"
+        cmd_git="git clone --config advice.detachedHead=false --quiet --depth=1 --single-branch"
+        rm -rf "${my_dl}.part"
+        if ! $cmd_git "${my_url}" --branch "${WEBI_GIT_TAG}" "${my_dl}.part"; then
+            echo >&2 "failed to git clone ${WEBI_PKG_URL}"
+            exit 1
+        fi
+        mv "${my_dl}.part" "${my_dl}"
+
+        cp -RPp "${my_dl}" "${WEBI_TMP}/${WEBI_PKG_FILE}/"
+    ); }
+
+    # detect which archives can be used
+    webi_extract() {
+        (
+            cd "$WEBI_TMP"
+
+            my_dl_rel="$(
+                webi_sub_home "${WEBI_PKG_PATH}/${WEBI_PKG_FILE}"
+            )"
+            if [ "tar" = "$WEBI_EXT" ]; then
+                echo "Extracting ${my_dl_rel}"
+                tar xf "${WEBI_PKG_PATH}/$WEBI_PKG_FILE"
+            elif [ "zip" = "$WEBI_EXT" ]; then
+                echo "Extracting ${my_dl_rel}"
+                unzip "${WEBI_PKG_PATH}/$WEBI_PKG_FILE" > __unzip__.log
+            elif [ "exe" = "$WEBI_EXT" ]; then
+                echo "Moving ${my_dl_rel}"
+                mv "${WEBI_PKG_PATH}/$WEBI_PKG_FILE" .
+            elif [ "git" = "$WEBI_EXT" ]; then
+                echo "Moving ${my_dl_rel}"
+                mv "${WEBI_PKG_PATH}/$WEBI_PKG_FILE" .
+            elif [ "xz" = "$WEBI_EXT" ]; then
+                echo "Inflating ${my_dl_rel}"
+                unxz -c "${WEBI_PKG_PATH}/$WEBI_PKG_FILE" > "$(basename "$WEBI_PKG_FILE")"
+            else
+                echo "Failed to extract ${WEBI_PKG_PATH}/$WEBI_PKG_FILE"
+                exit 1
+            fi
+        )
+    }
+
+    # use 'pathman' to update $HOME/.config/envman/PATH.env
+    webi_path_add() {
+        my_path="${1}"
+
+        fn_envman_init
+
+        # \v was chosen as it is extremely unlikely for a filename
+        # \1 could be an even better choice, but needs more testing.
+        # (currently tested working on: linux & mac)
+        # "\0001" should also work
+        my_delim="$(
+            printf '\v'
+        )"
+
+        my_path_expanded="$(
+            echo "${my_path}" |
+                sed -e "s${my_delim}\$HOME${my_delim}$HOME${my_delim}g" \
+                    -e "s${my_delim}\${HOME}${my_delim}$HOME${my_delim}g" \
+                    -e "s${my_delim}^~/${my_delim}$HOME/${my_delim}g"
+        )"
+
+        # A gift for @adamcstephens.
+        # See https://github.com/webinstall/webi-installers/issues/322
+        case "${PATH}" in
+            # matches whether the first, a middle, the last, or the only PATH entry
+            "${my_path_expanded}":* | \
+                *:"${my_path_expanded}":* | \
+                *:"${my_path_expanded}" | \
+                "${my_path_expanded}")
+
+                if fn_is_defined_in_all_shells "${my_path}"; then
+                    return 0
+                fi
+                ;;
+            *) ;;
+        esac
+
+        my_path_export="$(
+            echo "${my_path}" |
+                sed -e "s${my_delim}${HOME}${my_delim}\$HOME${my_delim}g" \
+                    -e "s${my_delim}\${HOME}${my_delim}\$HOME${my_delim}g" \
+                    -e "s${my_delim}^~/${my_delim}\$HOME/${my_delim}g"
+        )"
+
+        my_export="export PATH=\"$my_path_export:\$PATH\""
+        if grep -q -F "${my_export}" ~/.config/envman/PATH.env; then
+            return 0
+        fi
+
+        echo "${my_export}" >> ~/.config/envman/PATH.env
+
+        mkdir -p "$_webi_tmp"
+        my_path_tilde="$(
+            echo "${my_path}" |
+                sed -e "s${my_delim}${HOME}${my_delim}~${my_delim}g"
+        )"
+
+        if ! test -f "$_webi_tmp/.PATH.env" ||
+            ! grep -q -F "${my_path_tilde}" "$_webi_tmp/.PATH.env"; then
+            echo "${my_path_tilde}" >> "$_webi_tmp/.PATH.env"
+        fi
+    }
+
+    fn_envman_init() {
+        mkdir -p ~/.config/envman/
+        if ! test -e ~/.config/envman/PATH.env; then
+            touch ~/.config/envman/PATH.env
+        fi
+
+        if ! test -e ~/.config/envman/load.sh; then
+            # shellcheck disable=SC2016
+            {
+                echo '# Generated for envman. Do not edit.'
+                echo 'for x in ~/.config/envman/*.env; do'
+                echo '    my_basename="$(basename "${x}")"'
+                echo '    if [ "*.env" = "${my_basename}" ]; then'
+                echo '        continue'
+                echo '    fi'
+                echo ''
+                echo '    # shellcheck source=/dev/null'
+                echo '    . "${x}"'
+                echo 'done'
+            } > ~/.config/envman/load.sh
+        fi
+
+        if command -v sh > /dev/null; then
+            if test -e ~/.profile; then
+                if ! grep -q -F '/.config/envman/load.sh' ~/.profile; then
+                    fn_echo_load_sh >> ~/.profile
+                fi
+            fi
+        fi
+        if command -v bash > /dev/null; then
+            if test -e ~/.bashrc; then
+                if ! grep -q -F '/.config/envman/load.sh' ~/.bashrc; then
+                    fn_echo_load_sh >> ~/.bashrc
+                fi
+            fi
+        fi
+        if command -v zsh > /dev/null; then
+            if test -e ~/.zshrc; then
+                if ! grep -q -F '/.config/envman/load.sh' ~/.zshrc; then
+                    fn_echo_load_sh >> ~/.zshrc
+                fi
+            fi
+        fi
+
+        if command -v fish > /dev/null; then
+            if test ! -e ~/.config/envman/load.fish; then
+                # shellcheck disable=SC2016
+                {
+                    echo '# Generated for envman. Do not edit.'
+                    echo 'for x in ~/.config/envman/*.env'
+                    echo '	  source "$x"'
+                    echo 'end'
+                } > ~/.config/envman/load.fish
+            fi
+
+            mkdir -p ~/.config/fish
+            if test -e ~/.config/fish/config.fish; then
+                touch ~/.config/fish/config.fish
+            fi
+            if ! grep -q -F '/.config/envman/load.fish' ~/.config/fish/config.fish; then
+                fn_echo_load_fish >> ~/.config/fish/config.fish
+            fi
+        fi
+    }
+
+    fn_echo_load_fish() {
+        echo ''
+        echo '# Generated for envman. Do not edit.'
+        # shellcheck disable=SC2016
+        echo 'test -s "$HOME/.config/envman/load.fish"; and source "$HOME/.config/envman/load.fish"'
+    }
+
+    fn_echo_load_sh() {
+        echo ''
+        echo '# Generated for envman. Do not edit.'
+        # shellcheck disable=SC2016
+        echo '[ -s "$HOME/.config/envman/load.sh" ] && source "$HOME/.config/envman/load.sh"'
+    }
+
+    fn_is_defined_in_all_shells() {
+        my_path="${1}"
+
+        my_path_expanded="$(
+            echo "${my_path}" |
+                sed -e "s${my_delim}\$HOME|${my_delim}$HOME${my_delim}g" \
+                    -e "s${my_delim}\${HOME}${my_delim}$HOME${my_delim}g" \
+                    -e "s${my_delim}^~/${my_delim}$HOME/${my_delim}g"
+        )"
+        my_paths="$(
+            echo "${my_path_expanded}"
+            # $HOME/foo
+            echo "${my_path_expanded}" |
+                sed "s${my_delim}${HOME}${my_delim}\$HOME${my_delim}g"
+            # ${HOME}/foo
+            echo "${my_path_expanded}" |
+                sed "s${my_delim}${HOME}${my_delim}\${HOME}${my_delim}g"
+            echo "${my_path}"
+        )"
+
+        my_confs="$(
+            echo "${HOME}/.profile"
+            echo "${HOME}/.bashrc"
+            echo "${HOME}/.zshrc"
+            echo "${HOME}/.config/fish/config.fish"
+        )"
+        for my_conf in $my_confs; do
+            if test -e "${my_conf}"; then
+                if ! grep -q -F "${my_paths}" "${my_conf}"; then
+                    return 1
+                fi
+            fi
+        done
+    }
+
+    # group common pre-install tasks as default
+    webi_pre_install() {
+        webi_check_installed
+        webi_check_available
+        if test "git" = "${WEBI_EXT}"; then
+            webi_git_clone \
+                "${WEBI_PKG_URL}" \
+                "${WEBI_PKG_PATH}/${WEBI_PKG_FILE}"
+            return 0
+        fi
+        webi_download \
+            "${WEBI_PKG_URL}" \
+            "${WEBI_PKG_PATH}/${WEBI_PKG_FILE}"
+        webi_extract
+    }
+
+    # move commands from the extracted archive directory
+    # to $HOME/.local/opt or $HOME/.local/bin
+    webi_install() {
+        if test -n "${WEBI_SINGLE}"; then
+            mkdir -p "$(dirname "$pkg_src_cmd")"
+            mv ./"$pkg_cmd_name"* "$pkg_src_cmd"
+        else
+            rm -rf "$pkg_src"
+            mv ./"$pkg_cmd_name"* "$pkg_src"
+        fi
+    }
+
+    # run post-install functions - just updating PATH by default
+    webi_post_install() {
+        if test -n "${pkg_no_exec}"; then
+            return 0
+        fi
+
+        webi_path_add "$(dirname "$pkg_dst_cmd")"
+    }
+
+    _webi_enable_exec() {
+        if command -v spctl > /dev/null && command -v xattr > /dev/null; then
+            # note: some packages contain files that cannot be affected by xattr
+            xattr -r -d com.apple.quarantine "$pkg_src" || true
+            return 0
+        fi
+    }
+
+    _webi_done_message() {
+        my_dst_rel="$(
+            webi_sub_home "${pkg_dst_cmd}"
+        )"
+        my_canonical_name="$(
+            _webi_canonical_name
+        )"
+        echo "Installed ${my_canonical_name} as ${my_dst_rel}"
+    }
+
+    ##
+    ##
+    ## BEGIN custom override functions from <package>/install.sh
+    ##
+    ##
+
+    WEBI_SINGLE=
+
+    if [ -z "${WEBI_WELCOME-}" ]; then
+        echo ""
+        printf "Thanks for using webi to install '\e[32m%s\e[0m' on '\e[33m%s (%s) %s\e[0m'.\n" "${WEBI_PKG:-"Unknown Package"}" "$(uname -s)" "${WEBI_LIBC:-"Unknown Libc"}" "$(uname -m)"
+        echo "Have a problem? Experience a bug? Please let us know:"
+        printf "        \e[2m\e[36mhttps://github.com/webinstall/webi-installers/issues\e[0m\n"
+        echo ""
+        printf "\e[35mLovin'\e[0m it? Say thanks with a \e[1m\e[33mStar on GitHub\e[0m:\n"
+        printf "        \e[36mhttps://github.com/webinstall/webi-installers\e[0m\n"
+        echo ""
+    fi
+
+    WEBI_WELCOME=true
+    export WEBI_WELCOME
+
+    __init_installer() {
+        # the installer will be injected here
+        # {{ installer }}
+
+        return 0
+    }
+
+    __init_installer
+
+    ##
+    ##
+    ## END custom override functions
+    ##
+    ##
+
+    # run everything with defaults or overrides as needed
+    if command -v pkg_install > /dev/null ||
+        command -v pkg_link > /dev/null ||
+        command -v pkg_post_install > /dev/null ||
+        command -v pkg_done_message > /dev/null ||
+        command -v pkg_format_cmd_version > /dev/null ||
+        [ -n "${WEBI_SINGLE-}" ] ||
+        [ -n "${pkg_cmd_name-}" ] ||
+        [ -n "${pkg_dst_cmd-}" ] ||
+        [ -n "${pkg_dst_dir-}" ] ||
+        [ -n "${pkg_dst-}" ] ||
+        [ -n "${pkg_src_cmd-}" ] ||
+        [ -n "${pkg_src_dir-}" ] ||
+        [ -n "${pkg_src-}" ]; then
+
+        pkg_cmd_name="${pkg_cmd_name:-$PKG_NAME}"
+
+        pkg_no_exec="${pkg_no_exec:-}"
+
+        if [ -n "${pkg_no_exec}" ]; then
+            pkg_dst_cmd="${pkg_dst}"
+            pkg_src="${pkg_dst}"
+            pkg_src_cmd="${pkg_dst}"
+        elif [ -n "${WEBI_SINGLE}" ]; then
+            pkg_dst_cmd="${pkg_dst_cmd:-$HOME/.local/bin/$pkg_cmd_name}"
+            pkg_dst="$pkg_dst_cmd"
+
+            #pkg_src_cmd="${pkg_src_cmd:-$HOME/.local/opt/$pkg_cmd_name-v$WEBI_VERSION/bin/$pkg_cmd_name-v$WEBI_VERSION}"
+            pkg_src_cmd="${pkg_src_cmd:-$HOME/.local/opt/$pkg_cmd_name-v$WEBI_VERSION/bin/$pkg_cmd_name}"
+            pkg_src="$pkg_src_cmd"
+        else
+            pkg_dst="${pkg_dst:-$HOME/.local/opt/$pkg_cmd_name}"
+            pkg_dst_cmd="${pkg_dst_cmd:-$pkg_dst/bin/$pkg_cmd_name}"
+
+            pkg_src="${pkg_src:-$HOME/.local/opt/$pkg_cmd_name-v$WEBI_VERSION}"
+            pkg_src_cmd="${pkg_src_cmd:-$pkg_src/bin/$pkg_cmd_name}"
+        fi
+        # shellcheck disable=SC2034 # used in ${WEBI_PKG}/install.sh
+        pkg_src_bin="$(dirname "$pkg_src_cmd")"
+        # shellcheck disable=SC2034 # used in ${WEBI_PKG}/install.sh
+        pkg_dst_bin="$(dirname "$pkg_dst_cmd")"
+
+        if command -v pkg_pre_install > /dev/null; then pkg_pre_install; else webi_pre_install; fi
+
+        (
+            cd "$WEBI_TMP"
+            my_src_rel="$(
+                webi_sub_home "${pkg_src_cmd}"
+            )"
+            if test -e "${pkg_src_cmd}"; then
+                echo "Found ${my_src_rel} (remove to force reinstall)"
+            else
+                echo "Installing to ${my_src_rel}"
+                if command -v pkg_install > /dev/null; then pkg_install; else webi_install; fi
+                chmod a+x "$pkg_src"
+                chmod a+x "$pkg_src_cmd"
+            fi
+        )
+
+        if test -z "${pkg_no_exec}"; then
+            webi_link
+            _webi_enable_exec
+        fi
+        (
+            cd "$WEBI_TMP"
+            if command -v pkg_post_install > /dev/null; then pkg_post_install; else webi_post_install; fi
+        )
+
+        (
+            cd "$WEBI_TMP"
+            if command -v pkg_done_message > /dev/null; then pkg_done_message; else _webi_done_message; fi
+        )
+
+        echo ""
+    fi
+
+    webi_path_add "$HOME/.local/bin"
+    if [ -z "${_WEBI_CHILD-}" ] && [ -f "$_webi_tmp/.PATH.env" ]; then
+        if test -s "$_webi_tmp/.PATH.env"; then
+            printf 'PATH.env updated with:\n'
+            sort -u "$_webi_tmp/.PATH.env" | while read -r my_new_path; do
+                echo "        ${my_new_path}"
+            done
+            printf "\n"
+
+            rm -f "$_webi_tmp/.PATH.env"
+
+            printf "\e[1m\e[35mTO FINISH\e[0m: copy, paste & run the following command:\n"
+            printf "\n"
+            printf "        \e[1m\e[32msource ~/.config/envman/PATH.env\e[0m\n"
+            printf "        (newly opened terminal windows will update automatically)\n"
+        fi
+    fi
+
+    rm -rf "$WEBI_TMP"
+}
+
+__bootstrap_webi
--- a/_webi/lint-builds.js
+++ b/_webi/lint-builds.js
@@ -1,470 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-let Fs = require('node:fs/promises');
-let Path = require('node:path');
-
-let BuildsCacher = require('./builds-cacher.js');
-let HostTargets = require('./build-classifier/host-targets.js');
-let Parallel = require('./parallel.js');
-
-var INSTALLERS_DIR = Path.join(__dirname, '..');
-var CACHE_DIR = Path.join(__dirname, '../_cache');
-
-let UserAgentsMap = require('./build-classifier/uas.json');
-let uas = Object.keys(UserAgentsMap);
-let uaTargetsMap = {};
-for (let ua of uas) {
-  let terms = ua.split(/[\s\/]+/g);
-  let target = {};
-  void HostTargets.termsToTarget(target, terms);
-  if (!target) {
-    continue;
-  }
-  if (target.errors.length) {
-    throw target.errors[0];
-  }
-  if (!target.os) {
-    // TODO make target null, or create error for this
-    console.warn(`no os for terms: ${terms}`);
-    //throw new Error(`terms: ${terms}`);
-    continue;
-  }
-  if (!target.arch) {
-    // TODO make target null, or create error for this
-    console.warn(`no arch for terms: ${terms}`);
-    //throw new Error(`terms: ${terms}`);
-    continue;
-  }
-  if (!target.libc) {
-    // TODO make target null, or create error for this
-    console.warn(`no libc for terms: ${terms}`);
-    //throw new Error(`terms: ${terms}`);
-    continue;
-  }
-  let triplet = `${target.os}-${target.arch}-${target.libc}`;
-  uaTargetsMap[triplet] = target;
-}
-let uaTargets = [];
-let triplets = Object.keys(uaTargetsMap);
-for (let triplet of triplets) {
-  let target = uaTargetsMap[triplet];
-  uaTargets.push(target);
-}
-
-function showDirs(dirs) {
-  {
-    let errors = Object.keys(dirs.errors);
-    console.error('');
-    console.error(`Errors: ${errors.length}`);
-    for (let name of errors) {
-      let err = dirs.errors[name];
-      console.error(`${name}/: ${err.message}`);
-    }
-  }
-
-  {
-    let hidden = Object.keys(dirs.hidden);
-    console.debug('');
-    console.debug(`Hidden: ${hidden.length}`);
-    for (let name of hidden) {
-      let kind = dirs.hidden[name];
-      if (kind === '!directory') {
-        console.debug(`    ${name}`);
-      } else {
-        console.debug(`    ${name}/`);
-      }
-    }
-  }
-
-  {
-    let alias = Object.keys(dirs.alias);
-    console.debug('');
-    console.debug(`Alias: ${alias.length}`);
-    for (let name of alias) {
-      let kind = dirs.alias[name];
-      if (kind === 'symlink') {
-        console.debug(`    ${name} => ...`);
-      } else {
-        console.debug(`    ${name}/`);
-      }
-    }
-  }
-
-  {
-    let invalids = Object.keys(dirs.invalid);
-    console.warn('');
-    console.warn(`Invalid: ${invalids.length}`);
-    for (let name of invalids) {
-      console.warn(`    ${name}/`);
-    }
-  }
-
-  {
-    let selfhosted = Object.keys(dirs.selfhosted);
-    console.info('');
-    console.info(`Self-Hosted: ${selfhosted.length}`);
-    for (let name of selfhosted) {
-      console.info(`    ${name}/`);
-    }
-  }
-
-  {
-    let valids = Object.keys(dirs.valid);
-    console.info('');
-    console.info(`Found: ${valids.length}`);
-    for (let name of valids) {
-      console.info(`    ${name}/`);
-    }
-  }
-}
-
-let bc = BuildsCacher.create({
-  caches: CACHE_DIR,
-  installers: INSTALLERS_DIR,
-});
-
-async function getPackagesWithBuilds(installersDir, pkgNames, parallel = 25) {
-  let packages = [];
-
-  await Parallel.run(parallel, pkgNames, getAll);
-
-  async function getAll(name, i) {
-    let Releases = require(`${installersDir}/${name}/releases.js`);
-    let pkg = await bc.getBuilds({
-      Releases: Releases,
-      name: name,
-      date: new Date(),
-    });
-    packages[i] = pkg;
-  }
-
-  return packages;
-}
-
-function getBuildsByTarget(packages) {
-  let packagesByName = {};
-
-  for (let pkg of packages) {
-    let buildsByOs = getBuildsByOs(pkg);
-    packagesByName[pkg.name] = buildsByOs;
-  }
-
-  return packagesByName;
-}
-
-function getBuildsByOs(pkg) {
-  let buildsByOs = {};
-
-  for (let build of pkg.releases) {
-    // TODO check targets cache
-    let target = bc.classify(pkg, build);
-    if (!target) {
-      // ignore known, non-package extensions
-      continue;
-    }
-
-    if (target.error) {
-      let err = target.error;
-      let code = err.code || '';
-      console.error(`[ERROR]: ${code} ${pkg.name}: ${build.name}`);
-      console.error(`>>> ${err.message} <<<`);
-      console.error(pkg);
-      console.error(build);
-      console.error(`^^^ ${err.message} ^^^`);
-      console.error(err.stack);
-      continue;
-    }
-
-    let buildsByRelease = getBuildsByRelease(build, buildsByOs, target);
-    buildsByRelease.push(build);
-  }
-
-  return buildsByOs;
-}
-
-function getBuildsByRelease(build, buildsByOs, target) {
-  let archLibc = `${target.arch}-${target.libc}`;
-
-  if (!buildsByOs[target.os]) {
-    buildsByOs[target.os] = {};
-  }
-
-  let buildsByVersion = buildsByOs[target.os];
-  if (!buildsByVersion[build.version]) {
-    buildsByVersion[build.version] = {};
-  }
-
-  let buildsByArchLibc = buildsByVersion[build.version];
-  if (!buildsByArchLibc[archLibc]) {
-    buildsByArchLibc[archLibc] = [];
-  }
-
-  let buildsByRelease = buildsByArchLibc[archLibc];
-  return buildsByRelease;
-}
-
-function matchBuildsByTarget(pkg, buildsTree, target) {
-  let oses = [];
-  let targetOs = target.os;
-  if (target.os === 'windows') {
-    oses = ['ANYOS', 'windows'];
-    //buildsByOs = buildsTree.ANYOS || buildsTree[target.os];
-  } else if (target.os === 'android') {
-    oses = ['ANYOS', 'posix_2017', 'android', 'linux'];
-    // buildsByOs =
-    //   buildsTree.ANYOS || buildsTree.posix_2017 || buildsTree[target.os];
-    // if (!buildsByOs) {
-    //   targetOs = 'linux';
-    //   buildsByOs = buildsTree.linux;
-    // }
-  } else {
-    oses = ['ANYOS', 'posix_2017', target.os];
-    // buildsByOs =
-    //   buildsTree.ANYOS || buildsTree.posix_2017 || buildsTree[target.os];
-  }
-
-  // TODO can we move sortByOsAndArchLibc(builds, anything) down to the lib?
-  //     and then the matcher
-  //     and make the waterfall more optional?
-
-  let waterfall = HostTargets.WATERFALL[target.os] || {};
-  let arches = waterfall[target.arch] ||
-    HostTargets.WATERFALL.ANYOS[target.arch] || [target.arch];
-  arches = ['ANYARCH'].concat(arches);
-  let libcs = waterfall[target.libc] ||
-    HostTargets.WATERFALL.ANYOS[target.libc] || [target.libc];
-
-  //console.log('waterfalls', arches, libcs);
-
-  // TODO flatten earlier and precache?
-  let duplets = [];
-  for (let arch of arches) {
-    for (let libc of libcs) {
-      let duplet = `${arch}-${libc}`;
-      duplets.push(duplet);
-    }
-  }
-
-  let duplet;
-  let targetBuilds;
-  for (let os of oses) {
-    let buildsByOs = buildsTree[os];
-    if (!buildsByOs) {
-      continue;
-    }
-
-    // TODO
-    //   - latest supported triplets
-    //   - historical supported triplets
-
-    // TODO sort versions first, get channel (or 'stable' or 'latest') from user
-    for (let version of pkg.versions) {
-      let versionBuilds = buildsByOs[version];
-      if (!versionBuilds) {
-        continue;
-      }
-
-      for (let _duplet of duplets) {
-        targetBuilds = versionBuilds[_duplet];
-        //console.log(`    duplet: ${_duplet}`, versionBuilds, targetBuilds);
-        if (targetBuilds?.length > 0) {
-          targetOs = os;
-          duplet = _duplet;
-          break;
-        }
-      }
-      if (targetBuilds?.length > 0) {
-        break;
-      }
-    }
-    if (targetBuilds?.length > 0) {
-      break;
-    }
-  }
-
-  if (!targetBuilds?.length) {
-    // console.log('    no builds:', buildsByOs);
-    targetBuilds = [];
-  }
-
-  let match = { triplet: `${targetOs}-${duplet}`, builds: targetBuilds };
-  return match;
-}
-
-async function main() {
-  // TODO
-  //     node ./_webi/lint-builds.js caddy@beta 'x86_64/unknown Darwin libc'
-  //
-  // let [pkgName, userAgent] = process.argv[2].slice(0);
-  // create test case for zoxide, caddy, rg
-
-  let dirs = await bc.getPackages();
-  showDirs(dirs);
-  console.info('');
-
-  bc.freshenRandomPackage(600 * 1000);
-
-  let rows = [];
-  let triples = [];
-  let valids = Object.keys(dirs.valid);
-
-  let index = valids.indexOf('webi');
-  if (index >= 0) {
-    // TODO fix the webi faux package
-    // (not sure why I even created it)
-    void valids.splice(index, 1);
-  }
-
-  let parallel = 25;
-  //valids = ['atomicparsley', 'caddy', 'macos'];
-  //valids = ['atomicparsley'];
-  let packages = await getPackagesWithBuilds(INSTALLERS_DIR, valids, parallel);
-
-  console.info(`Fetching builds for`);
-  for (let pkg of packages) {
-    console.info(`    ${pkg.name}`);
-
-    let nStr = pkg.releases.length.toString();
-    let n = nStr.padStart(5, ' ');
-    let row = `##### ${n}\t${pkg.name}\tv`;
-    rows.push(row);
-
-    // ignore known, non-package extensions
-    for (let build of pkg.releases) {
-      let target = bc.classify(pkg, build);
-      if (!target) {
-        // non-build file
-        continue;
-      }
-      if (target.error) {
-        let e = target.error;
-        if (e.code === 'E_BUILD_NO_PATTERN') {
-          console.warn(`>>> ${e.message} <<<`);
-          console.warn(pkg);
-          console.warn(build);
-          console.warn(`^^^ ${e.message} ^^^`);
-        }
-        throw e;
-      }
-
-      triples.push(target.triplet);
-      // if (!build.version) {
-      //   throw new Error(`no version for ${pkg.name} ${build.name}`);
-      // }
-      // // For debug printing versions
-      // console.error(build.version);
-      rows.push(`${target.triplet}\t${pkg.name}\t${build.version}`);
-    }
-  }
-
-  let packagesTree = getBuildsByTarget(packages);
-  //console.log(`packagesTree`, packagesTree);
-
-  for (let pkg of packages) {
-    console.log('');
-    console.log('');
-    console.log('pkg', pkg.name);
-    let buildsTree = packagesTree[pkg.name];
-    console.log(buildsTree);
-    for (let target of uaTargets) {
-      let libc = target.libc || 'libc';
-      let hostTriplet = `${target.os}-${target.arch}-${libc}`;
-      console.log('');
-      console.log(`target: ${hostTriplet}`);
-      let match = matchBuildsByTarget(pkg, buildsTree, target);
-      if (!match) {
-        console.log(
-          `    pkg: ${pkg.name}: missing build for os '${target.os}'`,
-        );
-        continue;
-      }
-
-      if (match.builds.length === 0) {
-        console.log(
-          `    pkg: ${pkg.name}: missing build for os '${target.os}-${target.arch}-${libc}'`,
-        );
-      } else if (match.triplet === hostTriplet) {
-        console.log(`    selected ${match.builds.length}`);
-      } else {
-        console.log(
-          `    selected ${match.builds.length} (${match.triplet} fallback)`,
-        );
-      }
-    }
-  }
-
-  let tsv = rows.join('\n');
-  console.info('');
-  console.info('#rows', rows.length);
-  await Fs.writeFile('builds.tsv', tsv, 'utf8');
-
-  console.info('');
-  console.info('Triplets Detected:');
-  let triplets = Object.keys(bc._triplets);
-  if (triplets.length) {
-    triplets.sort();
-    console.info('   ', triplets.join('\n    '));
-  } else {
-    console.info('    (none)');
-  }
-
-  console.info('');
-  console.info('New / Unknown Terms:');
-  let unknowns = Object.keys(bc.unknownTerms);
-  if (unknowns.length) {
-    unknowns.sort();
-    console.warn('   ', unknowns.join('\n    '));
-  } else {
-    console.info('    (none)');
-  }
-
-  console.info('');
-  console.info('Unused Terms:');
-  let unuseds = Object.keys(bc.orphanTerms);
-  if (unuseds.length) {
-    unuseds.sort();
-    console.warn('   ', unuseds.join('\n    '));
-  } else {
-    console.info('    (none)');
-  }
-
-  console.info('');
-  // sort -u -k1 builds.tsv | rg -v '^#|^https?:' | rg -i arm
-  // cut -f1 builds.tsv | sort -u -k1 | rg -v '^#|^https?:' | rg -i arm
-}
-
-if (module === require.main) {
-  let times = [];
-  let now = Date.now();
-  main()
-    .then(async function () {
-      let then = Date.now();
-      let delta = then - now;
-      times.push(delta);
-      now = then;
-      await main();
-      then = Date.now();
-      delta = then - now;
-      times.push(delta);
-    })
-    .then(function () {
-      console.info('');
-      console.info('Run times');
-      for (let delta of times) {
-        let s = delta / 1000;
-        console.info(`    ${s}`);
-      }
-
-      function forceExit() {
-        console.warn(`warn: dangling event loop reference`);
-        process.exit(0);
-      }
-      let exitTimeout = setTimeout(forceExit, 250);
-      exitTimeout.unref();
-    })
-    .catch(function (err) {
-      console.error(err.stack || err);
-      process.exit(1);
-    });
-}
--- a/_webi/package-install.tpl.sh
+++ b/_webi/package-install.tpl.sh
@@ -1,984 +0,0 @@
-#!/bin/sh
-
-__bootstrap_webi() {
-    #PKG_NAME=
-    #WEBI_OS=
-    #WEBI_ARCH=
-    #WEBI_LIBC=
-    #WEBI_RELEASES=
-    #WEBI_CSV=
-    #WEBI_TAG=
-    #WEBI_VERSION=
-    #WEBI_MAJOR=
-    #WEBI_MINOR=
-    #WEBI_PATCH=
-    # TODO not sure if BUILD is the best name for this
-    #WEBI_BUILD=
-    #WEBI_GIT_TAG=
-    #WEBI_LTS=
-    #WEBI_CHANNEL=
-    #WEBI_EXT=
-    #WEBI_FORMATS=
-    #WEBI_PKG_URL=
-    #WEBI_PKG_FILE=
-    #WEBI_PKG_PATHNAME=
-    #PKG_OSES=
-    #PKG_ARCHES=
-    #PKG_LIBCS=
-    #PKG_FORMATS=
-    #PKG_LATEST=
-    WEBI_PKG_DOWNLOAD=""
-    WEBI_DOWNLOAD_DIR="${HOME}/Downloads"
-    if command -v xdg-user-dir > /dev/null; then
-        WEBI_DOWNLOAD_DIR="$(xdg-user-dir DOWNLOAD)"
-        if [ "${WEBI_DOWNLOAD_DIR}" = "${HOME}" ]; then
-            WEBI_DOWNLOAD_DIR="${HOME}/Downloads"
-        fi
-    fi
-
-    WEBI_PKG_PATH="${WEBI_DOWNLOAD_DIR}/webi/${PKG_NAME:-error}/${WEBI_VERSION:-latest}"
-
-    # get the special formatted version
-    # (i.e. "go is go1.14" while node is "node v12.10.8")
-    my_versioned_name=""
-    _webi_canonical_name() {
-        if [ -n "$my_versioned_name" ]; then
-            echo "$my_versioned_name"
-            return 0
-        fi
-
-        if command -v pkg_format_cmd_version > /dev/null; then
-            my_versioned_name="'$(pkg_format_cmd_version "$WEBI_VERSION")'"
-        else
-            my_versioned_name="'$pkg_cmd_name v$WEBI_VERSION'"
-        fi
-
-        echo "$my_versioned_name"
-    }
-
-    # Update symlinks as per $HOME/.local/opt and $HOME/.local/bin install paths.
-    webi_link() {
-        if command -v pkg_link > /dev/null; then
-            pkg_link
-            return 0
-        fi
-
-        if test -n "${WEBI_SINGLE}"; then
-            rm -rf "$pkg_dst_cmd"
-            ln -s "$pkg_src_cmd" "$pkg_dst_cmd"
-        else
-            # 'pkg_dst' will default to $HOME/.local/opt/<pkg>
-            # 'pkg_src' will be the installed version,
-            # such as to $HOME/.local/opt/<pkg>-<version>
-            rm -rf "$pkg_dst"
-            ln -s "$pkg_src" "$pkg_dst"
-        fi
-    }
-
-    # detect if this program is already installed
-    # or if an installed version may cause conflict
-    webi_check_installed() {
-        # Test for existing version
-        set +e
-        my_path="$PATH"
-        PATH="$(dirname "$pkg_dst_cmd"):$PATH"
-        export PATH
-        my_current_cmd="$(command -v "$pkg_cmd_name")"
-        set -e
-        if [ -n "$my_current_cmd" ]; then
-            my_canonical_name="$(_webi_canonical_name)"
-            if [ "$my_current_cmd" != "$pkg_dst_cmd" ]; then
-                echo >&2 "    $(t_err "WARN: possible PATH conflict between $my_canonical_name and currently installed version")"
-                echo >&2 "    $(t_path "${pkg_dst_cmd}") (new)"
-                echo >&2 "    $(t_path "${my_current_cmd}") (existing)"
-                #my_current_version=false
-            fi
-            # 'readlink' can't read links in paths on macOS 🤦
-            # but that's okay, 'cmp -s' is good enough for us
-            if cmp -s "${pkg_src_cmd}" "${my_current_cmd}"; then
-                echo "    $(t_pkg "${my_canonical_name}") already installed:"
-                my_dst_rel="$(fn_sub_home "${pkg_dst}")"
-                printf "    %s" "$(t_link "${my_dst_rel}")"
-                if [ "${pkg_src_cmd}" != "${my_current_cmd}" ]; then
-                    my_src_rel="$(fn_sub_home "${pkg_src}")"
-                    printf " => %s" "$(t_path "${my_src_rel}")"
-                fi
-                echo ""
-                exit 0
-            fi
-            if [ -x "$pkg_src_cmd" ]; then
-                webi_link
-                echo "    Switched to ${my_canonical_name}:"
-                my_src_rel="$(fn_sub_home "${pkg_src}")"
-                my_dst_rel="$(fn_sub_home "${pkg_dst}")"
-                echo "    $(t_link "${my_dst_rel}") => $(t_path "${my_src_rel}")"
-                exit 0
-            fi
-        fi
-        export PATH="$my_path"
-    }
-
-    webi_check_available() {
-        if test "$WEBI_CHANNEL" != "error"; then
-            return 0
-        fi
-
-        {
-            echo ""
-            echo "    $(t_err "Error: no '${PKG_NAME:-"Unknown Package"}@${WEBI_TAG:-"Unknown Tag"}' release for '${WEBI_OS:-"Unknown OS"}' (${WEBI_LIBC:-"Unknown Libc"}) on '${WEBI_ARCH:-"Unknown CPU"}' as one of '${WEBI_FORMATS:-"Unknown File Type"}'")"
-            echo ""
-            echo "        CPUs: $PKG_ARCHES"
-            echo "        OSes: $PKG_OSES"
-            echo "        libcs: $PKG_LIBCS"
-            echo "        Package Formats: $PKG_FORMATS"
-            echo "        (check that the package name and version are correct)"
-
-            echo ""
-            my_release_url="$(echo "$WEBI_RELEASES" | sed 's:?.*::')"
-            my_release_params="$(echo "$WEBI_RELEASES" | sed 's:.*?:?:')"
-            echo "      Double check at ${my_release_url}"
-            echo "          ${my_release_params}"
-            echo ""
-        } >&2
-
-        exit 1
-    }
-
-    # detect if file is downloaded, and how to download it
-    webi_download() {
-        my_url="${1}"
-        my_dl="${2}"
-        my_dl_name="${3:-${PKG_NAME}}"
-
-        my_dl_rel="$(fn_sub_home "${my_dl}")"
-
-        WEBI_PKG_DOWNLOAD="${my_dl}"
-        export WEBI_PKG_DOWNLOAD
-
-        if [ -e "${my_dl}" ]; then
-            echo "    $(t_dim 'Found') $(t_path "${my_dl_rel}")"
-            return 0
-        fi
-        echo "    Downloading $(t_pkg "${my_dl_name}") from"
-        echo "      $(t_url "${my_url}")"
-        fn_download_to_path "${my_url}" "${my_dl}"
-        echo "    $(t_dim 'Saved as') $(t_path "${my_dl_rel}")"
-    }
-
-    webi_git_clone() { (
-        my_url="${1}"
-        my_dl="${2}"
-
-        my_dl_rel="$(fn_sub_home "${my_dl}")"
-        if [ -e "${my_dl}" ]; then
-            echo "    $(t_dim 'Found') $(t_path "${my_dl_rel}")"
-
-            cp -RPp "${my_dl}" "${WEBI_TMP}/${WEBI_PKG_FILE}/"
-            return 0
-        fi
-
-        echo "    Cloning $(t_url "${my_url}")"
-        cmd_git="git clone --config advice.detachedHead=false --quiet --depth=1 --single-branch"
-        rm -rf "${my_dl}.part"
-        if ! $cmd_git "${my_url}" --branch "${WEBI_GIT_TAG}" "${my_dl}.part"; then
-            echo >&2 "    $(t_err "failed to git clone ${WEBI_PKG_URL}")"
-            exit 1
-        fi
-        mv "${my_dl}.part" "${my_dl}"
-
-        cp -RPp "${my_dl}" "${WEBI_TMP}/${WEBI_PKG_FILE}/"
-    ); }
-
-    # detect which archives can be used
-    webi_extract() { (
-        cd "$WEBI_TMP"
-
-        my_dl_rel="$(
-            fn_sub_home "${WEBI_PKG_PATH}/${WEBI_PKG_FILE}"
-        )"
-        if [ "tar" = "$WEBI_EXT" ]; then
-            echo "    Extracting $(t_path "${my_dl_rel}")"
-            tar xf "${WEBI_PKG_PATH}/$WEBI_PKG_FILE"
-        elif [ "zip" = "$WEBI_EXT" ]; then
-            echo "    Extracting $(t_path "${my_dl_rel}")"
-            unzip "${WEBI_PKG_PATH}/$WEBI_PKG_FILE" > __unzip__.log
-        elif [ "exe" = "$WEBI_EXT" ]; then
-            echo "    Moving $(t_path "${my_dl_rel}")"
-            echo "      to $(t_path "$(fn_sub_home "$(pwd)")")"
-            mv "${WEBI_PKG_PATH}/$WEBI_PKG_FILE" .
-        elif [ "git" = "$WEBI_EXT" ]; then
-            echo "    Moving $(t_path "${my_dl_rel}")"
-            mv "${WEBI_PKG_PATH}/$WEBI_PKG_FILE" .
-        elif [ "xz" = "$WEBI_EXT" ]; then
-            echo "    Inflating $(t_path "${my_dl_rel}")"
-            unxz -c "${WEBI_PKG_PATH}/$WEBI_PKG_FILE" > "$(basename "$WEBI_PKG_FILE")"
-        else
-            echo "    $(t_err 'Failed to extract') $(t_path "${WEBI_PKG_PATH}/$WEBI_PKG_FILE")"
-            exit 1
-        fi
-    ); }
-
-    # use 'pathman' to update $HOME/.config/envman/PATH.env
-    webi_path_add() {
-        my_path="${1}"
-
-        fn_envman_init
-
-        # \v was chosen as it is extremely unlikely for a filename
-        # \1 could be an even better choice, but needs more testing.
-        # (currently tested working on: linux & mac)
-        # "\0001" should also work
-        my_delim="$(
-            printf '\v'
-        )"
-
-        my_path_expanded="$(
-            echo "${my_path}" |
-                sed -e "s${my_delim}\$HOME${my_delim}$HOME${my_delim}g" \
-                    -e "s${my_delim}\${HOME}${my_delim}$HOME${my_delim}g" \
-                    -e "s${my_delim}^~/${my_delim}$HOME/${my_delim}g"
-        )"
-
-        # A gift for @adamcstephens.
-        # See https://github.com/webinstall/webi-installers/issues/322
-        case "${PATH}" in
-            # matches whether the first, a middle, the last, or the only PATH entry
-            "${my_path_expanded}":* | \
-                *:"${my_path_expanded}":* | \
-                *:"${my_path_expanded}" | \
-                "${my_path_expanded}")
-
-                if fn_is_defined_in_all_shells "${my_path}"; then
-                    return 0
-                fi
-                ;;
-            *) ;;
-        esac
-
-        my_path_export="$(
-            echo "${my_path}" |
-                sed -e "s${my_delim}${HOME}${my_delim}\$HOME${my_delim}g" \
-                    -e "s${my_delim}\${HOME}${my_delim}\$HOME${my_delim}g" \
-                    -e "s${my_delim}^~/${my_delim}\$HOME/${my_delim}g"
-        )"
-
-        my_export="export PATH=\"$my_path_export:\$PATH\""
-
-        touch -a ~/.config/envman/PATH.env
-        if grep -q -F "${my_export}" ~/.config/envman/PATH.env; then
-            return 0
-        fi
-
-        echo "${my_export}" >> ~/.config/envman/PATH.env
-
-        mkdir -p "$_webi_tmp"
-        my_path_tilde="$(
-            echo "${my_path}" |
-                sed -e "s${my_delim}${HOME}${my_delim}~${my_delim}g"
-        )"
-
-        if ! test -f "$_webi_tmp/.PATH.env" ||
-            ! grep -q -F "${my_path_tilde}" "$_webi_tmp/.PATH.env"; then
-            echo "${my_path_tilde}" >> "$_webi_tmp/.PATH.env"
-        fi
-    }
-
-    fn_is_defined_in_all_shells() {
-        my_path="${1}"
-
-        my_path_expanded="$(
-            echo "${my_path}" |
-                sed -e "s${my_delim}\$HOME|${my_delim}$HOME${my_delim}g" \
-                    -e "s${my_delim}\${HOME}${my_delim}$HOME${my_delim}g" \
-                    -e "s${my_delim}^~/${my_delim}$HOME/${my_delim}g"
-        )"
-        my_paths="$(
-            echo "${my_path_expanded}"
-            # $HOME/foo
-            echo "${my_path_expanded}" |
-                sed "s${my_delim}${HOME}${my_delim}\$HOME${my_delim}g"
-            # ${HOME}/foo
-            echo "${my_path_expanded}" |
-                sed "s${my_delim}${HOME}${my_delim}\${HOME}${my_delim}g"
-            echo "${my_path}"
-        )"
-
-        my_confs="$(
-            echo "${HOME}/.profile"
-            echo "${HOME}/.bashrc"
-            echo "${HOME}/.zshrc"
-            echo "${HOME}/.config/fish/config.fish"
-        )"
-        for my_conf in $my_confs; do
-            if ! test -e "${my_conf}"; then
-                continue
-            fi
-
-            if ! grep -q -F "${my_paths}" "${my_conf}"; then
-                return 1
-            fi
-        done
-    }
-
-    # group common pre-install tasks as default
-    webi_pre_install() {
-        webi_check_installed
-        webi_check_available
-        if test "git" = "${WEBI_EXT}"; then
-            webi_git_clone \
-                "${WEBI_PKG_URL}" \
-                "${WEBI_PKG_PATH}/${WEBI_PKG_FILE}"
-            return 0
-        fi
-        webi_download \
-            "${WEBI_PKG_URL}" \
-            "${WEBI_PKG_PATH}/${WEBI_PKG_FILE}"
-        webi_extract
-    }
-
-    # move commands from the extracted archive directory
-    # to $HOME/.local/opt or $HOME/.local/bin
-    webi_install() {
-        b_src=''
-        if test -n "${WEBI_SINGLE}"; then
-            b_src="${pkg_src_cmd}"
-            mkdir -p "$(dirname "$pkg_src_cmd")"
-        else
-            echo "    Removing $(t_path "${pkg_src}")"
-            rm -rf "$pkg_src"
-            b_src="${pkg_src}"
-        fi
-
-        echo "    Moving $(t_path "${pkg_cmd_name}")"
-        echo "      to $(t_path "$(fn_sub_home "${b_src}")")"
-        mv ./"${pkg_cmd_name}"* "${b_src}"
-    }
-
-    # run post-install functions - just updating PATH by default
-    webi_post_install() {
-        if test -n "${pkg_no_exec}"; then
-            return 0
-        fi
-
-        webi_path_add "$(dirname "$pkg_dst_cmd")"
-    }
-
-    _webi_enable_exec() {
-        if command -v spctl > /dev/null && command -v xattr > /dev/null; then
-            # note: some packages contain files that cannot be affected by xattr
-            xattr -r -d com.apple.quarantine "$pkg_src" || true
-            return 0
-        fi
-    }
-
-    _webi_done_message() {
-        my_dst_rel="$(fn_sub_home "${pkg_dst_cmd}")"
-        my_canonical_name="$(_webi_canonical_name)"
-        echo ""
-        echo "    Installed $(t_pkg "${my_canonical_name}") as $(t_link "${my_dst_rel}")"
-    }
-
-    ##
-    ## Set up tmp, download, and install directories
-    ##
-
-    WEBI_TMP=${WEBI_TMP:-"$(mktemp -d -t webinstall-"${WEBI_PKG-}".XXXXXXXX)"}
-    export _webi_tmp="${_webi_tmp:-"$HOME/.local/opt/webi-tmp.d"}"
-
-    mkdir -p "${WEBI_PKG_PATH}"
-    mkdir -p "$HOME/.local/bin"
-    mkdir -p "$HOME/.local/opt"
-
-    if test -e ~/.local/bin; then
-        echo "    $(t_dim 'Found') $(t_path ' ~/.local/bin')"
-    else
-        echo "    Creating$(t_path ' ~/.local/bin')"
-        mkdir -p "$HOME/.local/bin"
-    fi
-
-    ##
-    ##
-    ## BEGIN custom override functions from <package>/install.sh
-    ##
-    ##
-
-    WEBI_SINGLE=
-
-    __init_installer() {
-        # the installer will be injected here
-        # {{ installer }}
-
-        return 0
-    }
-
-    __init_installer
-
-    ##
-    ##
-    ## END custom override functions
-    ##
-    ##
-
-    # run everything with defaults or overrides as needed
-    if command -v pkg_install > /dev/null ||
-        command -v pkg_link > /dev/null ||
-        command -v pkg_post_install > /dev/null ||
-        command -v pkg_done_message > /dev/null ||
-        command -v pkg_format_cmd_version > /dev/null ||
-        [ -n "${WEBI_SINGLE-}" ] ||
-        [ -n "${pkg_cmd_name-}" ] ||
-        [ -n "${pkg_dst_cmd-}" ] ||
-        [ -n "${pkg_dst_dir-}" ] ||
-        [ -n "${pkg_dst-}" ] ||
-        [ -n "${pkg_src_cmd-}" ] ||
-        [ -n "${pkg_src_dir-}" ] ||
-        [ -n "${pkg_src-}" ]; then
-
-        pkg_cmd_name="${pkg_cmd_name:-$PKG_NAME}"
-
-        pkg_no_exec="${pkg_no_exec:-}"
-
-        if [ -n "${pkg_no_exec}" ]; then
-            pkg_dst_cmd="${pkg_dst}"
-            pkg_src="${pkg_dst}"
-            pkg_src_cmd="${pkg_dst}"
-        elif [ -n "${WEBI_SINGLE}" ]; then
-            pkg_dst_cmd="${pkg_dst_cmd:-$HOME/.local/bin/$pkg_cmd_name}"
-            pkg_dst="$pkg_dst_cmd"
-
-            #pkg_src_cmd="${pkg_src_cmd:-$HOME/.local/opt/$pkg_cmd_name-v$WEBI_VERSION/bin/$pkg_cmd_name-v$WEBI_VERSION}"
-            pkg_src_cmd="${pkg_src_cmd:-$HOME/.local/opt/$pkg_cmd_name-v$WEBI_VERSION/bin/$pkg_cmd_name}"
-            pkg_src="$pkg_src_cmd"
-        else
-            pkg_dst="${pkg_dst:-$HOME/.local/opt/$pkg_cmd_name}"
-            pkg_dst_cmd="${pkg_dst_cmd:-$pkg_dst/bin/$pkg_cmd_name}"
-
-            pkg_src="${pkg_src:-$HOME/.local/opt/$pkg_cmd_name-v$WEBI_VERSION}"
-            pkg_src_cmd="${pkg_src_cmd:-$pkg_src/bin/$pkg_cmd_name}"
-        fi
-        # shellcheck disable=SC2034 # used in ${WEBI_PKG}/install.sh
-        pkg_src_bin="$(dirname "$pkg_src_cmd")"
-        # shellcheck disable=SC2034 # used in ${WEBI_PKG}/install.sh
-        pkg_dst_bin="$(dirname "$pkg_dst_cmd")"
-
-        if command -v pkg_pre_install > /dev/null; then pkg_pre_install; else webi_pre_install; fi
-
-        (
-            cd "$WEBI_TMP"
-            my_src_rel="$(
-                fn_sub_home "${pkg_src_cmd}"
-            )"
-            if test -e "${pkg_src_cmd}"; then
-                echo "    $(t_dim 'Found') $(t_path "${my_src_rel}") $(t_dim '(remove to force reinstall)')"
-            else
-                echo "    Installing to $(t_path "${my_src_rel}")"
-                if command -v pkg_install > /dev/null; then pkg_install; else webi_install; fi
-                chmod a+x "$pkg_src"
-                chmod a+x "$pkg_src_cmd"
-            fi
-        )
-
-        if test -z "${pkg_no_exec}"; then
-            webi_link
-            _webi_enable_exec
-        fi
-        (
-            cd "$WEBI_TMP"
-            if command -v pkg_post_install > /dev/null; then pkg_post_install; else webi_post_install; fi
-        )
-
-        (
-            cd "$WEBI_TMP"
-            if command -v pkg_done_message > /dev/null; then pkg_done_message; else _webi_done_message; fi
-        )
-
-        echo ""
-    fi
-
-    webi_path_add "$HOME/.local/bin"
-    if [ -z "${_WEBI_CHILD-}" ] && [ -f "$_webi_tmp/.PATH.env" ]; then
-        if test -s "$_webi_tmp/.PATH.env"; then
-            # shellcheck disable=SC2088 # ~ should not expand here
-            echo "    Edit $(t_path '~/.config/envman/PATH.env') to add:"
-            sort -u "$_webi_tmp/.PATH.env" | while read -r my_new_path; do
-                echo "        $(t_path "${my_new_path}")"
-            done
-            echo ""
-
-            rm -f "$_webi_tmp/.PATH.env"
-
-            echo ">>> $(t_info 'ACTION REQUIRED') <<<"
-            echo "        Copy, paste & run the following command:"
-            echo "        $(t_attn 'source ~/.config/envman/PATH.env')"
-            echo "        (newly opened terminal windows will update automatically)"
-            echo ""
-        fi
-    fi
-
-    rm -rf "$WEBI_TMP"
-}
-
-#########################################
-#                                       #
-# Display Debug Info in Case of Failure #
-#                                       #
-#########################################
-
-fn_show_welcome_back() { (
-    if test -n "${WEBI_WELCOME:-}"; then
-        return 0
-    fi
-
-    echo ""
-    # invert t_task and t_pkg for top-level welcome message
-    printf -- ">>> %s %s  <<<\n" \
-        "$(t_pkg 'Welcome to') $(t_task 'Webi')$(t_pkg '!')" \
-        "$(t_dim "- modern tools, instant installs.")"
-    echo "    We expect your experience to be $(t_em 'absolutely perfect')!"
-    echo ""
-    echo "    $(t_attn 'Success')? Star it!   $(t_url 'https://github.com/webinstall/webi-installers')"
-    echo "    $(t_attn 'Problem')? Report it: $(t_url 'https://github.com/webinstall/webi-installers/issues')"
-    echo "                        $(t_dim "(your system is") $(t_host "$(fn_get_os)")/$(t_host "$(uname -m)") $(t_dim "with") $(t_host "$(fn_get_libc)") $(t_dim "&") $(t_host "$(fn_get_http_client_name)")$(t_dim ")")"
-
-    sleep 0.2
-); }
-
-fn_get_os() { (
-    # Ex:
-    #     GNU/Linux
-    #     Android
-    #     Linux (often Alpine, musl)
-    #     Darwin
-    b_os="$(uname -o 2> /dev/null || echo '')"
-    b_sys="$(uname -s)"
-    if test -z "${b_os}" || test "${b_os}" = "${b_sys}"; then
-        # ex: 'Darwin' (and plain, non-GNU 'Linux')
-        echo "${b_sys}"
-        return 0
-    fi
-
-    if echo "${b_os}" | grep -q "${b_sys}"; then
-        # ex: 'GNU/Linux'
-        echo "${b_os}"
-        return 0
-    fi
-
-    # ex: 'Android/Linux'
-    echo "${b_os}/${b_sys}"
-); }
-
-fn_get_libc() { (
-    # Ex:
-    #     musl
-    #     libc
-    if ldd /bin/ls 2> /dev/null | grep -q 'musl' 2> /dev/null; then
-        echo 'musl'
-    elif fn_get_os | grep -q 'GNU|Linux'; then
-        echo 'gnu'
-    else
-        echo 'libc'
-    fi
-); }
-
-fn_get_http_client_name() { (
-    # Ex:
-    #     curl
-    #     curl+wget
-    b_client=""
-    if command -v curl > /dev/null; then
-        b_client="curl"
-    fi
-    if command -v wget > /dev/null; then
-        if test -z "${b_client}"; then
-            b_client="wget"
-        else
-            b_client="curl+wget"
-        fi
-    fi
-
-    echo "${b_client}"
-); }
-
-#########################################
-#                                       #
-#      For Making the Display Nice      #
-#                                       #
-#########################################
-
-# Term Types
-t_cmd() { (fn_printf '\e[2m\e[35m%s\e[39m\e[22m' "${1}"); }
-t_host() { (fn_printf '\e[2m\e[33m%s\e[39m\e[22m' "${1}"); }
-t_link() { (fn_printf '\e[1m\e[36m%s\e[39m\e[22m' "${1}"); }
-t_path() { (fn_printf '\e[2m\e[32m%s\e[39m\e[22m' "${1}"); }
-t_pkg() { (fn_printf '\e[1m\e[32m%s\e[39m\e[22m' "${1}"); }
-t_task() { (fn_printf '\e[36m%s\e[39m' "${1}"); }
-t_url() { (fn_printf '\e[2m%s\e[22m' "${1}"); }
-
-# Levels
-t_info() { (fn_printf '\e[1m\e[36m%s\e[39m\e[22m' "${1}"); }
-t_attn() { (fn_printf '\e[1m\e[33m%s\e[39m\e[22m' "${1}"); }
-t_warn() { (fn_printf '\e[1m\e[33m%s\e[39m\e[22m' "${1}"); }
-t_err() { (fn_printf '\e[31m%s\e[39m' "${1}"); }
-
-# Styles
-t_bold() { (fn_printf '\e[1m%s\e[22m' "${1}"); }
-t_dim() { (fn_printf '\e[2m%s\e[22m' "${1}"); }
-t_em() { (fn_printf '\e[3m%s\e[23m' "${1}"); }
-t_under() { (fn_printf '\e[4m%s\e[24m' "${1}"); }
-
-# FG Colors
-t_cyan() { (fn_printf '\e[36m%s\e[39m' "${1}"); }
-t_green() { (fn_printf '\e[32m%s\e[39m' "${1}"); }
-t_magenta() { (fn_printf '\e[35m%s\e[39m' "${1}"); }
-t_yellow() { (fn_printf '\e[33m%s\e[39m' "${1}"); }
-
-fn_printf() { (
-    a_style="${1}"
-    a_text="${2}"
-    if fn_is_tty; then
-        #shellcheck disable=SC2059
-        printf -- "${a_style}" "${a_text}"
-    else
-        printf -- '%s' "${a_text}"
-    fi
-); }
-
-fn_sub_home() { (
-    my_rel=${HOME}
-    my_abs=${1}
-    echo "${my_abs}" | sed "s:^${my_rel}:~:"
-); }
-
-###################################
-#                                 #
-#       Detect HTTP Client        #
-#                                 #
-###################################
-
-fn_wget() { (
-    # Doc:
-    #     Downloads the file at the given url to the given path
-    a_url="${1}"
-    a_path="${2}"
-
-    cmd_wget="wget -c -q --user-agent"
-    if fn_is_tty; then
-        cmd_wget="wget -c -q --show-progress --user-agent"
-    fi
-    # busybox wget doesn't support --show-progress
-    # See <https://github.com/webinstall/webi-installers/pull/772>
-    if readlink "$(command -v wget)" | grep -q busybox; then
-        cmd_wget="wget --user-agent"
-    fi
-
-    b_triple_ua="$(fn_get_target_triple_user_agent)"
-    b_agent="webi/wget ${b_triple_ua}"
-    if command -v curl > /dev/null; then
-        b_agent="webi/wget+curl ${b_triple_ua}"
-    fi
-
-    if ! $cmd_wget "${b_agent}" "${a_url}" -O "${a_path}"; then
-        echo >&2 "    $(t_err "failed to download (wget)") '$(t_url "${a_url}")'"
-        echo >&2 "    $cmd_wget '${b_agent}' '${a_url}' -O '${a_path}'"
-        echo >&2 "    $(wget -V)"
-        return 1
-    fi
-); }
-
-fn_curl() { (
-    # Doc:
-    #     Downloads the file at the given url to the given path
-    a_url="${1}"
-    a_path="${2}"
-
-    cmd_curl="curl -f -sSL -#"
-    if fn_is_tty; then
-        cmd_curl="curl -f -sSL"
-    fi
-
-    b_triple_ua="$(fn_get_target_triple_user_agent)"
-    b_agent="webi/curl ${b_triple_ua}"
-    if command -v wget > /dev/null; then
-        b_agent="webi/curl+wget ${b_triple_ua}"
-    fi
-
-    if ! $cmd_curl -A "${b_agent}" "${a_url}" -o "${a_path}"; then
-        echo >&2 "    $(t_err "failed to download (curl)") '$(t_url "${a_url}")'"
-        echo >&2 "    $cmd_curl -A '${b_agent}' '${a_url}' -o '${a_path}'"
-        echo >&2 "    $(curl -V)"
-        return 1
-    fi
-); }
-
-fn_get_target_triple_user_agent() { (
-    # Ex:
-    #     x86_64/unknown GNU/Linux/5.15.107-2-pve gnu
-    #     arm64/unknown Darwin/22.6.0 libc
-    echo "$(uname -m)/unknown $(fn_get_os)/$(uname -r) $(fn_get_libc)"
-); }
-
-fn_download_to_path() { (
-    a_url="${1}"
-    a_path="${2}"
-
-    mkdir -p "$(dirname "${a_path}")"
-    if command -v curl > /dev/null; then
-        fn_curl "${a_url}" "${a_path}.part"
-    elif command -v wget > /dev/null; then
-        fn_wget "${a_url}" "${a_path}.part"
-    else
-        echo >&2 "    $(t_err "failed to detect HTTP client (curl, wget)")"
-        return 1
-    fi
-    mv "${a_path}.part" "${a_path}"
-); }
-
-##############################################
-#                                            #
-# Install or Update Webi and Install Package #
-#                                            #
-##############################################
-
-webi_upgrade() { (
-    a_path="${1}"
-
-    b_path_rel="$(fn_sub_home "${a_path}")"
-    b_checksum=""
-    if test -r "${a_path}"; then
-        b_checksum="$(fn_checksum "${a_path}")"
-    fi
-    if test "$b_checksum" = "${WEBI_CHECKSUM}"; then
-        sleep 0.1
-        return 0
-    fi
-
-    b_webi_file_url="${WEBI_HOST}/packages/webi/webi.sh"
-    b_tmp=''
-    if test -r "${a_path}"; then
-        b_ts="$(date -u '+%s')"
-        b_tmp="${a_path}.${b_ts}.bak"
-        mv "${a_path}" "${b_tmp}"
-        echo ""
-        echo "$(t_task 'Updating') $(t_pkg 'Webi')"
-    fi
-
-    echo "    Downloading $(t_url "${b_webi_file_url}")"
-    echo "        to $(t_path "${b_path_rel}")"
-    fn_download_to_path "${b_webi_file_url}" "${a_path}"
-    chmod u+x "${a_path}"
-
-    if test -r "${b_tmp}"; then
-        rm -f "${b_tmp}"
-    fi
-); }
-
-fn_checksum() {
-    a_filepath="${1}"
-
-    cmd_shasum='sha1sum'
-    if command -v shasum > /dev/null; then
-        cmd_shasum='shasum'
-    fi
-
-    $cmd_shasum "${a_filepath}" | cut -d' ' -f1 | cut -c 1-8
-}
-
-##############################################
-#                                            #
-#          Detect TTY and run main           #
-#                                            #
-##############################################
-
-fn_is_tty() {
-    if test "${WEBI_TTY}" = 'tty'; then
-        return 0
-    fi
-    return 1
-}
-
-fn_detect_tty() { (
-    # stdin will NOT be a tty if it's being piped
-    # stdout & stderr WILL be a tty even when piped
-    # they are not a tty if being captured or redirected
-    # 'set -i' is NOT available in sh
-    if test -t 1 && test -t 2; then
-        return 0
-    fi
-
-    return 1
-); }
-
-main() { (
-    set -e
-    set -u
-    #set -x
-
-    export WEBI_HOST=
-    export WEBI_CHECKSUM=
-    export WEBI_PKG=
-
-    WEBI_TTY="${WEBI_TTY:-}"
-    if test -z "${WEBI_TTY}"; then
-        if fn_detect_tty; then
-            WEBI_TTY="tty"
-        fi
-        export WEBI_TTY
-    fi
-
-    if test -z "${WEBI_WELCOME:-}"; then
-        fn_show_welcome_back
-    fi
-    export WEBI_WELCOME='shown'
-
-    # note: we may support custom locations in the future
-    export WEBI_HOME="${HOME}/.local"
-    b_webi_path="${WEBI_HOME}/bin/webi"
-
-    WEBI_CURRENT="${WEBI_CURRENT:-}"
-    if test "${WEBI_CURRENT}" != "${WEBI_CHECKSUM}"; then
-        webi_upgrade "${b_webi_path}"
-        export WEBI_CURRENT="${WEBI_CHECKSUM}"
-    fi
-
-    echo "$(t_task 'Installing') $(t_pkg "${WEBI_PKG}") $(t_task '...')"
-    __bootstrap_webi
-); }
-
-##############################################
-#                                            #
-#          envman helper functions           #
-#                                            #
-##############################################
-
-fn_envman_init() { (
-    if ! test -r ~/.config/envman/; then
-        echo "    Initializing ~/.config/envman/"
-        mkdir -p ~/.config/envman/
-    fi
-
-    # Note: the variables $BASH, $ZSH_NAME, etc are always empty
-    # because the active shell is always sh when this script runs
-    fn_envman_init_load_sh
-    fn_envman_init_shell sh '.profile' '.ash_history'
-    fn_envman_init_shell bash '.bashrc' '.bash_history'
-    fn_envman_init_shell zsh '.zshrc' '.zsh_sessions'
-
-    if command -v fish > /dev/null; then
-        fn_envman_init_load_fish
-        fn_envman_init_fish
-    fi
-); }
-
-fn_envman_init_load_sh() { (
-    touch -a ~/.config/envman/load.sh
-    if grep -q -F 'ENVMAN_LOAD' ~/.config/envman/load.sh; then
-        return 0
-    fi
-
-    cat << LOAD_SH > ~/.config/envman/load.sh
-# Generated for envman. Do not edit.
-# shellcheck disable=SC1090
-
-touch -a ~/.config/envman/PATH.env
-touch -a ~/.config/envman/ENV.env
-touch -a ~/.config/envman/alias.env
-touch -a ~/.config/envman/function.sh
-
-# ENV first because we may use it in PATH
-test -z "\${ENVMAN_LOAD:-}" && . ~/.config/envman/ENV.env
-test -z "\${ENVMAN_LOAD:-}" && . ~/.config/envman/PATH.env
-
-export ENVMAN_LOAD='loaded'
-
-# function first because we may use it in alias
-test -z "\${g_envman_load_sh:-}" && . ~/.config/envman/function.sh
-test -z "\${g_envman_load_sh:-}" && . ~/.config/envman/alias.env
-
-g_envman_load_sh='loaded'
-LOAD_SH
-
-); }
-
-fn_envman_init_shell() { (
-    a_shell="${1}"
-    a_rc="${2}"
-    a_history="${3:-_history_file_doesnt_exist}"
-    a_login_shell="$(basename "${SHELL:-}")"
-
-    if ! command -v "${a_shell}" > /dev/null; then
-        return 0
-    fi
-
-    # .bashrc and .zshrc no longer exist by default on macOS
-    if ! test -e ~/"${a_rc}" && ! test -e ~/"${a_history}"; then
-        if test "${a_login_shell}" != "${a_shell}"; then
-            return 0
-        fi
-    fi
-
-    touch -a ~/"${a_rc}"
-    if grep -q -F '/.config/envman/load.sh' ~/"${a_rc}"; then
-        return 0
-    fi
-
-    # shellcheck disable=SC2088 # ~ should not expand here
-    echo >&2 "    Edit $(t_path "~/${a_rc}") to $(t_cmd "source ~/.config/envman/load.sh")"
-    {
-        echo ''
-        echo '# Generated for envman. Do not edit.'
-        #shellcheck disable=SC2016 # vars should not expand here
-        echo '[ -s "$HOME/.config/envman/load.sh" ] && source "$HOME/.config/envman/load.sh"'
-    } >> ~/"${a_rc}"
-); }
-
-fn_envman_init_load_fish() { (
-    mkdir -p ~/.config/envman/
-
-    touch -a ~/.config/envman/load.fish
-    if grep -q -F 'ENVMAN_LOAD' ~/.config/envman/load.fish; then
-        return 0
-    fi
-
-    echo >&2 "    Create ~/.config/envman/load.fish"
-
-    cat << EOF > ~/.config/envman/load.fish
-# Generated for envman. Do not edit.
-
-touch -a ~/.config/envman/PATH.env
-touch -a ~/.config/envman/ENV.env
-touch -a ~/.config/envman/alias.env
-touch -a ~/.config/envman/function.fish
-
-not set -q ENVMAN_LOAD; and source ~/.config/envman/ENV.env
-not set -q ENVMAN_LOAD; and source ~/.config/envman/PATH.env
-
-set -x ENVMAN_LOAD 'loaded'
-
-not set -q g_envman_load_fish; and source ~/.config/envman/function.fish
-not set -q g_envman_load_fish; and source ~/.config/envman/alias.env
-
-set -g g_envman_load_fish 'loaded'
-EOF
-
-); }
-
-fn_envman_init_fish() {
-    mkdir -p ~/.config/fish/
-
-    touch -a ~/.config/fish/config.fish
-    if grep -q -F '/.config/envman/load.fish' ~/.config/fish/config.fish; then
-        return 0
-    fi
-
-    # shellcheck disable=SC2088 # ~ should not expand here
-    echo >&2 "    Edit $(t_path "~/.config/fish/config.fish") to $(t_cmd "source ~/.config/envman/load.fish")"
-
-    cat << EOF >> ~/.config/fish/config.fish
-
-# Generated for envman. Do not edit.
-test -s ~/.config/envman/load.fish; and source ~/.config/envman/load.fish
-EOF
-
-}
-
-main
--- a/_webi/packages.js
+++ b/_webi/packages.js
@@ -1 +0,0 @@
-projects.js
--- a/_webi/packages.js
+++ b/_webi/packages.js
@@ -0,0 +1,96 @@
+'use strict';
+
+var frontmarker = require('./frontmarker.js');
+var fs = require('fs');
+var path = require('path');
+
+var pkgs = module.exports;
+pkgs.create = function (Pkgs, basepath) {
+  if (!Pkgs) {
+    Pkgs = {};
+  }
+  if (!basepath) {
+    basepath = path.join(__dirname, '../');
+  }
+
+  Pkgs.all = function () {
+    return fs.promises.readdir(basepath).then(function (nodes) {
+      var items = [];
+      return nodes
+        .reduce(function (p, node) {
+          return p.then(function () {
+            return pkgs.get(node).then(function (meta) {
+              if (meta && '_' !== node[0]) {
+                meta.name = node;
+                items.push(meta);
+              }
+            });
+          });
+        }, Promise.resolve())
+        .then(function () {
+          return items;
+        });
+    });
+  };
+
+  Pkgs.get = function (node) {
+    return fs.promises.access(path.join(basepath, node)).then(function () {
+      return Pkgs._get(node);
+    });
+  };
+  Pkgs._get = function (node) {
+    var curlbash = path.join(basepath, node, 'install.sh');
+    var readme = path.join(basepath, node, 'README.md');
+    var winstall = path.join(basepath, node, 'install.ps1');
+    return Promise.all([
+      fs.promises
+        .readFile(readme, 'utf-8')
+        .then(function (txt) {
+          // TODO
+          return frontmarker.parse(txt);
+        })
+        .catch(function (e) {
+          if ('ENOENT' !== e.code && 'ENOTDIR' !== e.code) {
+            console.error("failed to read '" + node + "/README.md'");
+            console.error(e);
+          }
+        }),
+      fs.promises.access(curlbash).catch(function (e) {
+        // no *nix installer
+        curlbash = '';
+        if ('ENOENT' !== e.code && 'ENOTDIR' !== e.code) {
+          console.error("failed to parse '" + node + "/install.sh'");
+          console.error(e);
+        }
+      }),
+      fs.promises.access(winstall).catch(function (e) {
+        // no winstaller
+        winstall = '';
+        if ('ENOENT' !== e.code && 'ENOTDIR' !== e.code) {
+          console.error("failed to read '" + node + "/install.ps1'");
+          console.error(e);
+        }
+      }),
+    ]).then(function (items) {
+      var meta = items[0] || items[1];
+      if (!meta) {
+        // doesn't exist
+        return;
+      }
+      meta.windows = !!winstall;
+      meta.bash = !!curlbash;
+
+      return meta;
+    });
+  };
+
+  return Pkgs;
+};
+pkgs.create(pkgs);
+
+if (module === require.main) {
+  pkgs.all().then(function (data) {
+    console.info('package info:');
+    console.info(data);
+  });
+}
--- a/_webi/parallel.js
+++ b/_webi/parallel.js
@@ -1,44 +0,0 @@
-'use strict';
-
-var Parallel = module.exports;
-Parallel.run = async function (limit, arr, fn) {
-  let index = 0;
-  let actives = [];
-  let results = [];
-  limit = Math.min(limit, arr.length);
-
-  function launch() {
-    let _index = index;
-    let p = fn(arr[_index], _index, arr);
-
-    // some tasks may be synchronous
-    // so we must push before removing
-    actives.push(p);
-
-    p.then(function _resolve(result) {
-      let i = actives.indexOf(p);
-      actives.splice(i, 1);
-      results[_index] = result;
-    });
-
-    index += 1;
-  }
-
-  // start tasks in parallel, up to limit
-  for (; actives.length < limit; ) {
-    launch();
-  }
-
-  // keep the task queue full
-  for (; index < arr.length; ) {
-    // wait for one task to complete
-    await Promise.race(actives);
-    // add one task again
-    launch();
-  }
-
-  // wait for all remaining tasks
-  await Promise.all(actives);
-
-  return results;
-};
--- a/_webi/projects.js
+++ b/_webi/projects.js
@@ -1,96 +0,0 @@
-'use strict';
-
-var frontmarker = require('./frontmarker.js');
-var fs = require('fs');
-var path = require('path');
-
-var pkgs = module.exports;
-pkgs.create = function (Pkgs, basepath) {
-  if (!Pkgs) {
-    Pkgs = {};
-  }
-  if (!basepath) {
-    basepath = path.join(__dirname, '../');
-  }
-
-  Pkgs.all = function () {
-    return fs.promises.readdir(basepath).then(function (nodes) {
-      var items = [];
-      return nodes
-        .reduce(function (p, node) {
-          return p.then(function () {
-            return pkgs.get(node).then(function (meta) {
-              if (meta && '_' !== node[0]) {
-                meta.name = node;
-                items.push(meta);
-              }
-            });
-          });
-        }, Promise.resolve())
-        .then(function () {
-          return items;
-        });
-    });
-  };
-
-  Pkgs.get = function (node) {
-    return fs.promises.access(path.join(basepath, node)).then(function () {
-      return Pkgs._get(node);
-    });
-  };
-  Pkgs._get = function (node) {
-    var curlbash = path.join(basepath, node, 'install.sh');
-    var readme = path.join(basepath, node, 'README.md');
-    var winstall = path.join(basepath, node, 'install.ps1');
-    return Promise.all([
-      fs.promises
-        .readFile(readme, 'utf-8')
-        .then(function (txt) {
-          // TODO
-          return frontmarker.parse(txt);
-        })
-        .catch(function (e) {
-          if ('ENOENT' !== e.code && 'ENOTDIR' !== e.code) {
-            console.error("failed to read '" + node + "/README.md'");
-            console.error(e);
-          }
-        }),
-      fs.promises.access(curlbash).catch(function (e) {
-        // no *nix installer
-        curlbash = '';
-        if ('ENOENT' !== e.code && 'ENOTDIR' !== e.code) {
-          console.error("failed to parse '" + node + "/install.sh'");
-          console.error(e);
-        }
-      }),
-      fs.promises.access(winstall).catch(function (e) {
-        // no winstaller
-        winstall = '';
-        if ('ENOENT' !== e.code && 'ENOTDIR' !== e.code) {
-          console.error("failed to read '" + node + "/install.ps1'");
-          console.error(e);
-        }
-      }),
-    ]).then(function (items) {
-      var meta = items[0] || items[1];
-      if (!meta) {
-        // doesn't exist
-        return;
-      }
-      meta.windows = !!winstall;
-      meta.bash = !!curlbash;
-
-      return meta;
-    });
-  };
-
-  return Pkgs;
-};
-pkgs.create(pkgs);
-
-if (module === require.main) {
-  pkgs.all().then(function (data) {
-    console.info('package info:');
-    console.info(data);
-  });
-}
--- a/_webi/installers.js
+++ b/_webi/installers.js
@@ -1,19 +1,34 @@
 'use strict';

-var Installers = module.exports;
-
-var Crypto = require('crypto');
-var Fs = require('node:fs/promises');
+var fs = require('node:fs');
 var path = require('node:path');
+var request = require('@root/request');
+var _normalize = require('../_webi/normalize.js');

 var reInstallTpl = /\s*#?\s*{{ installer }}/;

+var Releases = module.exports;
+Releases.get = async function (pkgdir) {
+  let get;
+  try {
+    get = require(path.join(pkgdir, 'releases.js'));
+  } catch (e) {
+    let err = new Error('no releases.js for', pkgdir.split(/[\/\\]+/).pop());
+    err.code = 'E_NO_RELEASE';
+    throw err;
+  }
+
+  let all = await get(request);
+
+  return _normalize(all);
+};
+
 function padScript(txt) {
  return txt.replace(/^/g, '        ');
 }

 var BAD_SH_RE = /[<>'"`$\\]/;
-Installers.renderBash = async function (
+Releases.renderBash = async function (
  pkgdir,
  rel,
  { baseurl, pkg, tag, ver, os = '', arch = '', libc = '', formats },
@@ -24,7 +39,10 @@ Installers.renderBash = async function (
  if (!tag) {
    tag = '';
  }
-  let installTxt = await Fs.readFile(path.join(pkgdir, 'install.sh'), 'utf8');
+  let installTxt = await fs.promises.readFile(
+    path.join(pkgdir, 'install.sh'),
+    'utf8',
+  );
  installTxt = padScript(installTxt);
  var vers = rel.version.split('.');
  var v = {
@@ -37,8 +55,8 @@ Installers.renderBash = async function (
      .replace(/^-/, ''),
  };
  var pkgFile = rel.filename || rel.name;
-  let tplTxt = await Fs.readFile(
-    path.join(__dirname, 'package-install.tpl.sh'),
+  let tplTxt = await fs.promises.readFile(
+    path.join(__dirname, 'install-package.tpl.sh'),
    'utf8',
  );
  // ex: 'node@lts' or 'node'
@@ -72,17 +90,14 @@ Installers.renderBash = async function (
  ]
    .join(',')
    .replace(/'/g, '');
-
-  let webiChecksum = await Installers.getWebiShChecksum();
  let envReplacements = [
-    ['WEBI_CHECKSUM', webiChecksum],
    ['WEBI_PKG', webiPkg],
    ['WEBI_HOST', baseurl],
    ['WEBI_OS', os],
    ['WEBI_ARCH', arch],
    ['WEBI_LIBC', libc],
    ['WEBI_TAG', tag],
-    ['WEBI_RELEASES', `${baseurl}${releaseUrl}`],
+    ['WEBI_RELEASES', `${baseurl}/${releaseUrl}`],
    ['WEBI_CSV', releaseCsv],
    ['WEBI_VERSION', rel.version],
    ['WEBI_MAJOR', v.major],
@@ -112,7 +127,7 @@ Installers.renderBash = async function (
    // #export WEBI_FOO=xyz => export WEBI_FOO='123'
    // export WEBI_FOO=     => export WEBI_FOO='123'
    let envRe = new RegExp(
-      `^[ \\t]*#?[ \\t]*(export[ \\t])?[ \\t]*(${name})=.*`,
+      `^[ \\t]*#?[ \\t]*(export\\s)?[ \\t]*(${name})=.*`,
      'm',
    );
    if (BAD_SH_RE.test(value)) {
@@ -130,7 +145,7 @@ Installers.renderBash = async function (
  return tplTxt;
 };

-Installers.renderPowerShell = async function (
+Releases.renderPowerShell = async function (
  pkgdir,
  rel,
  { baseurl, pkg, tag, ver, os, arch, libc = '', formats },
@@ -141,7 +156,10 @@ Installers.renderPowerShell = async function (
  if (!tag) {
    tag = '';
  }
-  let installTxt = await Fs.readFile(path.join(pkgdir, 'install.ps1'), 'utf8');
+  let installTxt = await fs.promises.readFile(
+    path.join(pkgdir, 'install.ps1'),
+    'utf8',
+  );
  installTxt = padScript(installTxt);
  /*
    var vers = rel.version.split('.');
@@ -155,8 +173,8 @@ Installers.renderPowerShell = async function (
        .replace(/^-/, '')
    };
  */
-  let tplTxt = await Fs.readFile(
-    path.join(__dirname, 'package-install.tpl.ps1'),
+  let tplTxt = await fs.promises.readFile(
+    path.join(__dirname, 'install-package.tpl.ps1'),
    'utf8',
  );
  var pkgver = pkg + '@' + ver;
@@ -200,32 +218,3 @@ Installers.renderPowerShell = async function (
      .replace(reInstallTpl, '\n' + installTxt)
  );
 };
-
-var _webiShMeta = {
-  stale: 10 * 1000,
-  updated_at: 0,
-  checksum: '',
-  mtime: 0,
-};
-Installers.getWebiShChecksum = async function () {
-  let now = Date.now();
-  let ago = now - _webiShMeta.updated_at;
-  if (ago <= _webiShMeta.stale) {
-    return _webiShMeta.checksum;
-  }
-
-  let webiPath = path.join(__dirname, '../webi/webi.sh');
-  let stat = await Fs.stat(webiPath);
-  if (stat.mtimeMs === _webiShMeta.mtime) {
-    return _webiShMeta.checksum;
-  }
-
-  let webiBuf = await Fs.readFile(webiPath, null);
-  let webiHash = Crypto.createHash('sha1').update(webiBuf).digest('hex');
-  let webiChecksum = webiHash.slice(0, 8);
-
-  _webiShMeta.mtime = stat.mtimeMs;
-  _webiShMeta.updated_at = now;
-  _webiShMeta.checksum = webiChecksum;
-  return _webiShMeta.checksum;
-};
--- a/_webi/serve-installer.js
+++ b/_webi/serve-installer.js
@@ -1,19 +1,20 @@
 'use strict';

-var InstallerServer = module.exports;
+var Installers = module.exports;

+var Crypto = require('crypto');
 var Fs = require('fs/promises');
 var path = require('path');

 var uaDetect = require('./ua-detect.js');
-var Projects = require('./projects.js');
-var Installers = require('./installers.js');
+var packages = require('./packages.js');
+var Releases = require('./releases.js');

 // handlers caching and transformation, probably should be broken down
-var Releases = require('./transform-releases.js');
+var getReleases = require('./transform-releases.js');

-InstallerServer.INSTALLERS_DIR = path.join(__dirname, '..');
-InstallerServer.serveInstaller = async function (
+Installers.INSTALLERS_DIR = path.join(__dirname, '..');
+Installers.serveInstaller = async function (
  baseurl,
  ua,
  pkg,
@@ -22,7 +23,7 @@ InstallerServer.serveInstaller = async function (
  formats,
  libc,
 ) {
-  let [rel, opts] = await InstallerServer.helper({
+  let [rel, opts] = await Installers.helper({
    ua,
    pkg,
    tag,
@@ -33,13 +34,13 @@ InstallerServer.serveInstaller = async function (
    baseurl,
  });

-  var pkgdir = path.join(InstallerServer.INSTALLERS_DIR, pkg);
+  var pkgdir = path.join(Installers.INSTALLERS_DIR, pkg);
  if ('ps1' === ext) {
-    return Installers.renderPowerShell(pkgdir, rel, opts);
+    return Releases.renderPowerShell(pkgdir, rel, opts);
  }
-  return Installers.renderBash(pkgdir, rel, opts);
+  return Releases.renderBash(pkgdir, rel, opts);
 };
-InstallerServer.helper = async function ({ ua, pkg, tag, formats, libc }) {
+Installers.helper = async function ({ ua, pkg, tag, formats, libc }) {
  // TODO put some of this in a middleware? or common function?

  // TODO maybe move package/version/lts/channel detection into getReleases
@@ -84,7 +85,7 @@ InstallerServer.helper = async function ({ ua, pkg, tag, formats, libc }) {
    myLibc = 'libc';
  }

-  let cfg = await Projects.get(pkg);
+  let cfg = await packages.get(pkg);
  let releaseQuery = {
    pkg: cfg.alias || pkg,
    ver,
@@ -99,7 +100,7 @@ InstallerServer.helper = async function ({ ua, pkg, tag, formats, libc }) {
    limit: 1,
  };

-  let rels = await Releases.getReleases(releaseQuery);
+  let rels = await getReleases(releaseQuery);

  var rel = rels.releases[0];
  var opts = {
@@ -131,11 +132,7 @@ var CURL_PIPE_PS1_BOOT = path.join(__dirname, 'curl-pipe-bootstrap.tpl.ps1');
 var CURL_PIPE_SH_BOOT = path.join(__dirname, 'curl-pipe-bootstrap.tpl.sh');
 var BAD_SH_RE = /[<>'"`$\\]/;

-InstallerServer.getPosixCurlPipeBootstrap = async function ({
-  baseurl,
-  pkg,
-  ver,
-}) {
+Installers.getPosixCurlPipeBootstrap = async function ({ baseurl, pkg, ver }) {
  let bootTxt = await Fs.readFile(CURL_PIPE_SH_BOOT, 'utf8');

  var webiPkg = [pkg, ver].filter(Boolean).join('@');
@@ -152,7 +149,7 @@ InstallerServer.getPosixCurlPipeBootstrap = async function ({

    // TODO create REs once, in higher scope
    let envRe = new RegExp(
-      `^[ \\t]*#?[ \\t]*(export[ \\t])?[ \\t]*(${name})=.*`,
+      `^[ \\t]*#?[ \\t]*(export\\s)?[ \\t]*(${name})=.*`,
      'm',
    );

@@ -168,7 +165,7 @@ InstallerServer.getPosixCurlPipeBootstrap = async function ({
  return bootTxt;
 };

-InstallerServer.getPwshCurlPipeBootstrap = async function ({
+Installers.getPwshCurlPipeBootstrap = async function ({
  baseurl,
  pkg,
  ver,
@@ -177,7 +174,7 @@ InstallerServer.getPwshCurlPipeBootstrap = async function ({
  let bootTxt = await Fs.readFile(CURL_PIPE_PS1_BOOT, 'utf8');

  var webiPkg = [pkg, ver].filter(Boolean).join('@');
-  //var webiChecksum = await InstallerServer.getWebiPs1Checksum();
+  //var webiChecksum = await Installers.getWebiPs1Checksum();
  var envReplacements = [
    ['Env:WEBI_PKG', webiPkg],
    ['Env:WEBI_HOST', baseurl],
@@ -212,3 +209,32 @@ InstallerServer.getPwshCurlPipeBootstrap = async function ({

  return bootTxt;
 };
+
+var _webiShMeta = {
+  stale: 10 * 1000,
+  updated_at: 0,
+  checksum: '',
+  mtime: 0,
+};
+Installers.getWebiShChecksum = async function () {
+  let now = Date.now();
+  let ago = now - _webiShMeta.updated_at;
+  if (ago <= _webiShMeta.stale) {
+    return _webiShMeta.checksum;
+  }
+
+  let webiPath = path.join(__dirname, '../webi/webi.sh');
+  let stat = await Fs.stat(webiPath);
+  if (stat.mtimeMs === _webiShMeta.mtime) {
+    return _webiShMeta.checksum;
+  }
+
+  let webiBuf = await Fs.readFile(webiPath, null);
+  let webiHash = Crypto.createHash('sha1').update(webiBuf).digest('hex');
+  let webiChecksum = webiHash.slice(0, 8);
+
+  _webiShMeta.mtime = stat.mtimeMs;
+  _webiShMeta.updated_at = now;
+  _webiShMeta.checksum = webiChecksum;
+  return _webiShMeta.checksum;
+};
--- a/_webi/test.js
+++ b/_webi/test.js
@@ -32,8 +32,7 @@ if (/\b-?-h(elp)?\b/.test(process.argv.join(' '))) {
 var os = require('os');
 var fs = require('fs');
 var path = require('path');
-var Releases = require('./transform-releases.js');
-var Installers = require('./installers.js');
+var Releases = require('./releases.js');
 var ServeInstaller = require('./serve-installer.js');

 var pkg = process.argv[2].split('@');
@@ -117,8 +116,8 @@ Releases.get(path.join(process.cwd(), pkgdir)).then(async function (all) {
  console.info('');

  return Promise.all([
-    Installers.renderBash(pkgdir, rel, opts).catch(function () {}),
-    Installers.renderPowerShell(pkgdir, rel, opts).catch(function () {}),
+    Releases.renderBash(pkgdir, rel, opts).catch(function () {}),
+    Releases.renderPowerShell(pkgdir, rel, opts).catch(function () {}),
  ]).then(function (scripts) {
    var bashTxt = scripts[0];
    var ps1Txt = scripts[1];
--- a/_webi/transform-releases.js
+++ b/_webi/transform-releases.js
@@ -1,10 +1,7 @@
 'use strict';

-var Releases = module.exports;
-
 var path = require('path');
-var request = require('@root/request');
-var _normalize = require('./normalize.js');
+var Releases = require('./releases.js');

 var cache = {};
 //var staleAge = 5 * 1000;
@@ -14,21 +11,6 @@ var expiredAge = 15 * 60 * 1000;

 let installerDir = path.join(__dirname, '..');

-Releases.get = async function (pkgdir) {
-  let get;
-  try {
-    get = require(path.join(pkgdir, 'releases.js'));
-  } catch (e) {
-    let err = new Error('no releases.js for', pkgdir.split(/[\/\\]+/).pop());
-    err.code = 'E_NO_RELEASE';
-    throw err;
-  }
-
-  let all = await get(request);
-
-  return _normalize(all);
-};
-
 // TODO needs a proper test, and more accurate (though perhaps far less simple) code
 function createFormatsSorter(formats) {
  return function sortByVerExt(a, b) {
@@ -140,7 +122,7 @@ async function getCachedReleases(pkg) {
          cache[pkg].all = all;
          complete = true;
        }),
-      sleep(15000).then(function () {
+      sleep(5000).then(function () {
        if (complete) {
          return;
        }
@@ -260,7 +242,7 @@ async function filterReleases(
  return sortedRels.slice(0, limit || 1000);
 }

-Releases.getReleases = function ({
+module.exports = function getReleases({
  _count,
  pkg,
  ver,
@@ -308,7 +290,7 @@ Releases.getReleases = function ({
        if (_count < 1) {
          // Apple Silicon M1 hacky-do workaround fix
          if ('macos' === os && 'arm64' === arch) {
-            return Releases.getReleases({
+            return getReleases({
              pkg,
              ver,
              os,
@@ -322,7 +304,7 @@ Releases.getReleases = function ({
          }
          // Windows ARM hacky-do workaround fix
          if ('windows' === os && 'arm64' === arch) {
-            return Releases.getReleases({
+            return getReleases({
              pkg,
              ver,
              os,
@@ -336,7 +318,7 @@ Releases.getReleases = function ({
          }
          // Raspberry Pi 3+ on Ubuntu arm64 (via Bionic?)
          if ('linux' === os && 'arm64' === arch) {
-            return Releases.getReleases({
+            return getReleases({
              _count: _count + 1,
              pkg,
              ver,
@@ -351,7 +333,7 @@ Releases.getReleases = function ({
          }
          // armv7 can run armv6
          if ('linux' === os && 'armv7l' === arch) {
-            return Releases.getReleases({
+            return getReleases({
              _count: _count + 1,
              pkg,
              ver,
@@ -369,7 +351,7 @@ Releases.getReleases = function ({
          // Raspberry Pi 3+ on Raspbian arm7 (not Ubuntu arm64)
          // hail mary
          if ('linux' === os && 'armv7l' === arch) {
-            return Releases.getReleases({
+            return getReleases({
              _count: _count + 1,
              pkg,
              ver,
--- a/chromedriver/install.sh
+++ b/chromedriver/install.sh
@@ -20,28 +20,20 @@ __init_chromedriver() {

    # pkg_install must be defined by every package
    pkg_install() {
-        # ~/.local/opt/chromedriver-v121.0.6130.0/bin
+        # ~/.local/opt/chromedriver-v88.0.4324.96/bin
        mkdir -p "$(dirname "$pkg_src_cmd")"

-        # mv ./chromedriver-macos-arm64/chromedriver \
-        #     ~/.local/opt/chromedriver-v121.0.6130.0/bin/chromedriver
-        mv ./chromedriver-*/chromedriver "$pkg_src_cmd"
-
-        echo ""
-        echo "    $(t_warn 'MANUAL STEPS TO FINISH:') you may need to install libnss3:"
-        echo "        $(t_cmd 'sudo apt install -y') $(t_warn 'libnss3')"
+        # mv ./chromedriver-*/chromedriver ~/.local/opt/chromedriver-v88.0.4324.96/bin/chromedriver
+        mv ./chromedriver* "$pkg_src_cmd"
    }

    # pkg_get_current_version is recommended, but (soon) not required
    pkg_get_current_version() {
        # 'chromedriver --version' has output in this format:
-        #       ChromeDriver 121.0.6130.0 (5fc19c7ab5e88bb674c2efc65db4b7890a52a4ec-refs/branch-heads/6130@{#1})
+        #       ChromeDriver 88.0.4324.96 (68dba2d8a0b149a1d3afac56fa74648032bcf46b-refs/branch-heads/4324@{#1784})
        # This trims it down to just the version number:
-        #       121.0.6130.0
-        chromedriver --version 2> /dev/null |
-            head -n 1 |
-            tr -s ' ' |
-            cut -d' ' -f2
+        #       88.0.4324.96
+        chromedriver --version 2> /dev/null | head -n 1 | cut -d ' ' -f 2
    }

 }
--- a/goreleaser/releases.js
+++ b/goreleaser/releases.js
@@ -6,7 +6,6 @@ var repo = 'goreleaser';

 module.exports = function (request) {
  return github(request, owner, repo).then(function (all) {
-    all._names = ['goreleaser', '1'];
    return all;
  });
 };
--- a/node/install.sh
+++ b/node/install.sh
@@ -40,7 +40,5 @@ pkg_link() {
 }

 pkg_done_message() {
-    b_dst="$(fn_sub_home "${pkg_dst}")"
-    echo ""
-    echo "    Installed $(t_pkg 'node') and $(t_pkg 'npm') at $(t_path "${b_dst}/")"
+    echo "Installed 'node' and 'npm' at $pkg_dst"
 }
--- a/ollama/releases.js
+++ b/ollama/releases.js
@@ -7,25 +7,19 @@ var repo = 'ollama';
 module.exports = async function (request) {
  let all = await github(request, owner, repo);

+  // TODO why are the 0.0.x releases sorting so high?
  let releases = [];
  for (let rel of all.releases) {
-    // this is a janky, sudo-wantin' .app
-    let isJank = rel.name.startsWith('Ollama-darwin');
-    if (isJank) {
+    let isLow = rel.version.startsWith('v0.0.');
+    if (isLow) {
      continue;
    }

-    let isUniversal = rel.name === 'ollama-darwin';
-    if (isUniversal) {
-      let x64 = Object.assign({ arch: 'x86_64' }, rel);
-      releases.push(x64);
-
-      rel.arch = 'aarch64';
-    }
    releases.push(rel);
  }
  all.releases = releases;

+  all._names = ['Ollama', 'ollama'];
  return all;
 };

--- a/pwsh/releases.js
+++ b/pwsh/releases.js
@@ -4,38 +4,16 @@ var github = require('../_common/github.js');
 var owner = 'powershell';
 var repo = 'powershell';

-let ODDITIES = ['-fxdependent'];
-
-function isOdd(build) {
-  for (let oddity of ODDITIES) {
-    let isOddity = build.name.includes(oddity);
-    if (isOddity) {
-      return true;
-    }
-  }
-}
-
 module.exports = function (request) {
  return github(request, owner, repo).then(function (all) {
    // remove checksums and .deb
    all.releases = all.releases.filter(function (rel) {
-      let odd = isOdd(rel);
-      if (odd) {
-        return false;
-      }
-
      let isPreview = rel.name.includes('-preview.');
      if (isPreview) {
        rel.channel = 'beta';
      }

-      let isMusl = rel.download.match(/(\b|_)(musl|alpine)(\b|_)/i);
-      if (isMusl) {
-        // not a fully static build, not gnu-compatible
-        rel.libc = 'musl';
-      }
-
-      return true;
+      return !/(alpine)|(fxdependent)|(\.deb)|(\.pkg)|(\.rpm)$/i.test(rel.name);
    });

    all._names = ['PowerShell', 'powershell'];
--- a/sd/install.sh
+++ b/sd/install.sh
@@ -20,22 +20,10 @@ __init_sd() {

    # pkg_install must be defined by every package
    pkg_install() {
+        # ~/.local/opt/sd-v0.99.9/bin
+        mkdir -p "$(dirname "$pkg_src_cmd")"
        # mv ./sd-*/sd "$pkg_src_cmd"
-        if test -f sd-*; then
-            # ~/.local/opt/sd-v0.99.9/bin
-            mkdir -p "$(dirname "$pkg_src_cmd")"
-            mv sd-* "$pkg_src_cmd"
-        elif test -f sd-*/sd; then
-            # ~/.local/opt/sd-v0.99.9/bin
-            mkdir -p "$(dirname "$pkg_src_cmd")"
-            mv sd-*/sd "$pkg_src_cmd"
-            if test -f sd-*/sd.1; then
-                mkdir -p "$pkg_src_dir/share/man/man1"
-                mv sd-*/sd.1 "$pkg_src_dir/share/man/man1"
-            fi
-        elif test -d sd-*/bin; then
-            mv sd-* "$pkg_src_dir"
-        fi
+        mv sd-* "$pkg_src_cmd"
    }

    # pkg_get_current_version is recommended, but (soon) not required
--- a/shellcheck/releases.js
+++ b/shellcheck/releases.js
@@ -6,6 +6,27 @@ var repo = 'shellcheck';

 module.exports = function (request) {
  return github(request, owner, repo).then(function (all) {
+    all.releases = all.releases.filter(function (rel) {
+      // don't include meta versions as actual versions
+      if (
+        ['latest', 'stable'].includes(rel.version) ||
+        'v' !== rel.version[0]
+      ) {
+        return false;
+      }
+      return true;
+    });
+
+    all.releases.forEach(function (rel) {
+      // if there is no os or arch or source designation, and it's a .zip, it's Windows amd64
+      if (
+        !/(darwin|mac|linux|x86_64|arm|src|source)/i.test(rel.name) &&
+        /\.zip$/.test(rel.name)
+      ) {
+        rel.os = 'windows';
+        rel.arch = 'amd64';
+      }
+    });
    return all;
  });
 };
--- a/ssh-authorize/ssh-authorize.ps1
+++ b/ssh-authorize/ssh-authorize.ps1
@@ -166,7 +166,7 @@ function Add-AuthorizedKey($UrlOrPath) {

    $TmpKeys = "new_authorized_keys.tmp.txt"

-    curl.exe -f -sS $UrlOrPath | Out-File -Force "${TmpKeys}.partial"
+    curl.exe --fail-with-body -sS $UrlOrPath | Out-File -Force "${TmpKeys}.partial"
    $null = Move-Item -Force "${TmpKeys}.partial" $TmpKeys

    IF ($IsHttp) {
--- a/vcruntime/install.sh
+++ b/vcruntime/install.sh
@@ -1,2 +1,2 @@
-echo >&2 "    $(t_err 'Error: vcruntime140.dll is only for Windows')"
+echo >&2 "vcruntime140.dll is only for Windows"
 exit 1
--- a/watchexec/releases.js
+++ b/watchexec/releases.js
@@ -6,13 +6,6 @@ var repo = 'watchexec';

 module.exports = function (request) {
  return github(request, owner, repo).then(function (all) {
-    let builds = [];
-    for (let build of all.releases) {
-      build.version = build.version.replace(/^cli-/, '');
-      builds.push(build);
-    }
-    all.releases = builds;
-
    return all;
  });
 };
--- a/webi-essentials/README.md
+++ b/webi-essentials/README.md
@@ -1,117 +0,0 @@
---
-title: Webi Essentials
-homepage: https://webinstall.dev/webi-essentials
-tagline: |
-  The Webi Essentials are curl, git, tar, wget, xz, zip, & webi shell integrations
---
-
-## Cheat Sheet
-
-> Even Webi needs a place to start.
-
-This installs the tools that are commonly needed to download and unpack various
-packages, using the native package manager.
-
-This requires **root or `sudo`** for `apt` or `apk` on Linux.
-
-## Table of Contents
-
- Files
- Manual Install
-  - macOS
-  - Linux
-  - Alpine
-  - Windows
-
-### Files
-
-These are the files / directories that are created and/or modified with this
-install:
-
-```sh
-# macOS
-/Library/Developer/CommandLineTools/
-/Library/Apple/usr/libexec/oah/libRosettaRuntime
-
-# macOS & Windows
-~/.local/bin/xz
-~/.local/bin/unxz
-
-# Windows
-~/.local/opt/git/
-
-# Linux
-/usr/bin/git
-```
-
-### How to Install Manually
-
-Most of these utilities are either built-in or provided by the native package
-manager.
-
-Webi makes it easy to automate across a wide variety of development systems, but
-if you wanted to automate for a specific system, you could do so in a much
-simpler way - because you don't have to worry about autodetection or fallbacks
-😉.
-
-So here's how to do that for each:
-
-#### macOS
-
- Rosetta
-  ```sh
-  softwareupdate --install-rosetta --agree-to-license
-  ```
- Command Line Developer Tools (incl. `git`)
-  ```sh
-  xcode-select --install
-  ```
- `xz`
-  ```sh
-  curl https://webi.sh/xz | sh
-  ```
-  See <https://github.com/therootcompany/xz-static>.
-
-#### Linux (Debian, Ubuntu)
-
-```sh
-sudo apt update
-sudo apt install -y \
-    curl \
-    git \
-    tar \
-    wget \
-    xz \
-    zip
-```
-
-#### Alpine (Docker)
-
-```sh
-sudo apk add --no-cache \
-    curl \
-    git \
-    tar \
-    wget \
-    xz \
-    zip
-```
-
-#### Windows
-
-`curl.exe` and BSD `tar.exe` are included as part of Windows 10+ - so there's no
-needfor `wget` or `zip`.
-
- `git`
-
-  ```sh
-  curl.exe -A MS https://webi.ms/git | powershell
-  ```
-
-  See <https://github.com/git-for-windows/git/wiki/MinGit>
-
- `xz`
-  ```sh
-  curl https://webi.sh/xz | sh
-  ```
-  See <https://github.com/therootcompany/xz-static>.
--- a/webi-essentials/install.ps1
+++ b/webi-essentials/install.ps1
@@ -1,38 +0,0 @@
-#!/usr/bin/env pwsh
-
-function Install-WebiEssential() {
-    # wget: we only use curl.exe on Windows (Invoke-WebRequest is too slow)
-    # zip: BSD tar.exe handles .zip as well
-
-    # Fetch curl
-    Write-Output "    Checking for Windows 10+ Built-in curl.exe ..."
-    IF (-Not (Get-Command -Name "curl.exe" -ErrorAction Silent)) {
-        Write-Error"error: curl.exe not found: something is very wrong"
-        Exit 1
-    }
-
-    # Fetch git
-    Write-Output "    Checking for git ..."
-    IF (-Not (Get-Command -Name "git" -ErrorAction Silent)) {
-        & "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" git
-        $null = Sync-EnvPath
-    }
-
-    # Fetch tar
-    Write-Output "    Checking for Windows 10+ Built-in BSD tar ..."
-    IF (-Not (Get-Command -Name "tar.exe" -ErrorAction Silent)) {
-        Write-Error"error: tar.exe not found: something is very wrong"
-        Exit 1
-    }
-
-    # Fetch xz
-    Write-Output "    Checking for xz ..."
-    IF (-Not (Get-Command -Name "xz" -ErrorAction Silent)) {
-        & "$Env:USERPROFILE\.local\bin\webi-pwsh.ps1" xz
-        $null = Sync-EnvPath
-    }
-
-    Write-Output "    OK"
-}
-
-Install-WebiEssential
--- a/webi-essentials/install.sh
+++ b/webi-essentials/install.sh
@@ -1,260 +0,0 @@
-#!/bin/sh
-set -e
-set -u
-#set -x
-
-fn_install_webi_essentials_macos() { (
-    # streamline the output to be pretty
-    b_pkgs="$(
-        fn_check_pkg 'curl'
-        fn_check_pkg '/Library/Developer/CommandLineTools/usr/bin/git' 'git'
-        if test "$(uname -m)" = 'arm64'; then
-            fn_check_pkg '/Library/Apple/usr/libexec/oah/libRosettaRuntime' 'rosetta'
-        fi
-        fn_check_pkg 'tar'
-        # no wget because it requires brew
-        #fn_check_pkg 'wget'
-        fn_check_pkg 'xz'
-        fn_check_pkg 'zip'
-    )"
-    echo >&2 ""
-
-    #curl - built-in
-    # git
-    if ! xcode-select -p > /dev/null 2> /dev/null; then
-        cmd_xcode_cli_tools_install="xcode-select --install"
-        echo "    Running $(t_cmd "${cmd_xcode_cli_tools_install}")"
-        $cmd_xcode_cli_tools_install 2> /dev/null
-        echo ""
-        echo ">>> $(t_attn 'ACTION REQUIRED') <<<"
-        echo ""
-        echo "        $(t_attn "Click") '$(t_bold 'Install')' $(t_attn "in the pop-up")"
-        echo "        (it may appear $(t_em 'under') this window)"
-        echo ""
-        echo "^^^ $(t_attn 'ACTION REQUIRED') ^^^"
-        echo ""
-        echo "    waiting $(t_em 'for you') to finish installing Command Line Developer Tools ..."
-        while ! test -x /Library/Developer/CommandLineTools/usr/bin/git; do
-            sleep 0.25
-        done
-        echo "    $(t_info 'OK')"
-        echo ""
-        sleep 1
-    fi
-    # rosetta
-    if test "$(uname -m)" = 'arm64'; then
-        # Also pkgutil --pkg-info com.apple.pkg.RosettaUpdateAuto
-        # See <https://apple.stackexchange.com/q/427970/27465>
-        cmd_install_rosetta="softwareupdate --install-rosetta --agree-to-license"
-        if ! arch -arch x86_64 uname -m > /dev/null 2>&1; then
-            echo "    Running $(t_cmd "${cmd_install_rosetta}")"
-            $cmd_install_rosetta
-        fi
-    fi
-    #tar - built-in
-    #wget - skip
-    #xz
-    if ! command -v xz > /dev/null; then
-        echo "    Running $(t_cmd "webi xz")"
-        ~/.local/bin/webi xz
-    fi
-    #zip - built-in
-
-    # This should NEVER fail, but... Sanity check :)
-    {
-        b_pkgs_builtin="$(
-            fn_check_pkg 'curl'
-            fn_check_pkg 'tar'
-            fn_check_pkg 'zip'
-        )"
-    } 2> /dev/null
-    if test -n "${b_pkgs_builtin}"; then
-        echo ""
-        echo "error: expected these to be macOS built-ins:"
-        echo "    ${b_pkgs}"
-        echo ""
-        exit 1
-    fi
-
-    echo "    $(t_dim 'OK')"
-); }
-
-fn_check_pkg() { (
-    a_pkg="${1}"
-    a_pkgname="${2:-$a_pkg}"
-
-    printf >&2 '    %s %s %s' \
-        "$(t_dim "Checking for")" \
-        "$(t_pkg "${a_pkgname}")" \
-        "$(t_dim "...")"
-
-    if command -v "${a_pkg}" > /dev/null; then
-        echo >&2 " $(t_dim 'OK')"
-        return 0
-    fi
-
-    echo >&2 ' missing'
-    echo "${a_pkg}"
-); }
-
-###########
-# mainish #
-###########
-
-fn_polite_sudo() { (
-    a_sudo="${1}"
-    a_cmds="${2}"
-
-    # no sudo needed, so don't ask
-    if test -z "${a_sudo}"; then
-        return 0
-    fi
-
-    # this is scripted, not user-interactive, continue
-    if test -z "${WEBI_TTY}"; then
-        return 0
-    fi
-
-    # this is user interactive, ask the user,defaulting to yes
-    echo ""
-    #shellcheck disable=SC2005 # echo for newline
-    echo "$(t_attn 'Use sudo for the following? [Y/n]')"
-    echo "${a_cmds}"
-    read -r b_yes < /dev/tty
-
-    b_yes="$(
-        echo "${b_yes}" |
-            tr '[:upper:]' '[:lower:]' |
-            tr -d '[:space:]'
-    )"
-    if test -z "${b_yes}" || test "${b_yes}" = "y" || test "${b_yes}" = "yes"; then
-        return 0
-    fi
-    echo "    aborted"
-    return 1
-); }
-
-_install_webi_essentials() { (
-    if test "$(uname -s)" = 'Darwin'; then
-        fn_install_webi_essentials_macos
-        return 0
-    fi
-
-    b_pkgs="$(
-        fn_check_pkg 'curl'
-        fn_check_pkg 'git'
-        fn_check_pkg 'tar'
-        fn_check_pkg 'wget'
-        fn_check_pkg 'xz'
-        fn_check_pkg 'zip'
-    )"
-    b_pkgs="$(echo "${b_pkgs}" | tr '\n' ' ' | tr -s ' ')"
-    if test "${b_pkgs}" = " "; then
-        b_pkgs=''
-    fi
-
-    if test -z "${b_pkgs}"; then
-        echo "    $(t_dim 'OK')"
-        return 0
-    fi
-
-    cmd_sudo=''
-    if test "$(id -u)" != "0"; then
-        echo "    $(t_dim 'Checking for sudo ...')"
-        if command -v sudo > /dev/null; then
-            cmd_sudo='sudo '
-        else
-            if test "${b_pkgs}" = "xz"; then
-                _install_webi_essentials_webi "${cmd_sudo}" "${b_pkgs}"
-                echo "    $(t_dim 'OK')"
-                return 0
-            fi
-
-            echo ""
-            echo ">>> $(t_warn 'WARNING') <<<"
-            echo ""
-            echo "    You are not the 'root' user and there is no 'sudo'."
-            echo "    (We'll try anyway but... this isn't going to work.)"
-            echo ""
-            echo "^^^ $(t_warn 'WARNING') ^^^"
-            echo ""
-        fi
-    fi
-
-    printf '%s' "    $(t_dim 'Checking for apt/apk ...')"
-    if command -v apt > /dev/null; then
-        echo " $(t_pkg 'apt')"
-        _install_webi_essentials_apt "${cmd_sudo}" "${b_pkgs}"
-        echo "    $(t_dim 'OK')"
-        return 0
-    fi
-
-    if command -v apk > /dev/null; then
-        echo " $(t_pkg 'apk')"
-        _install_webi_essentials_apk "${cmd_sudo}" "${b_pkgs}"
-        echo "    $(t_dim 'OK')"
-        return 0
-    fi
-
-    echo " $(t_dim 'none')"
-    _install_webi_essentials_webi "${cmd_sudo}" "${b_pkgs}"
-    echo "    $(t_dim 'OK')"
-); }
-
-_install_webi_essentials_apt() { (
-    cmd_sudo="${1}"
-    b_pkgs="${2}"
-    b_pkgs="$(echo "${b_pkgs}" | sed 's/xz/xz-utils/g')"
-
-    b_cmds="$(
-        printf '    %s\n    %s' \
-            "$(t_cmd 'apt update')" \
-            "$(t_cmd "apt install -y ${b_pkgs}")"
-    )"
-    fn_polite_sudo "${cmd_sudo}" "${b_cmds}"
-
-    echo "    $(t_dim 'Running') $(t_cmd "${cmd_sudo}apt update")"
-    ${cmd_sudo} apt update
-
-    echo "    $(t_dim 'Running') $(t_cmd "${cmd_sudo}apt install -y ${b_pkgs}")"
-    # shellcheck disable=SC2086
-    ${cmd_sudo} apt install -y ${b_pkgs}
-); }
-
-_install_webi_essentials_apk() { (
-    cmd_sudo="${1}"
-    b_pkgs="${2}"
-
-    echo "    $(t_dim 'Running') $(t_cmd "${cmd_sudo}apk add --no-cache")"
-    fn_polite_sudo "${cmd_sudo}" "    $(t_cmd "apk add --no-cache ${b_pkgs}")"
-    # shellcheck disable=SC2086
-    ${cmd_sudo} apk add --no-cache ${b_pkgs}
-); }
-
-_install_webi_essentials_webi() { (
-    cmd_sudo="${1}"
-    b_pkgs="${2}"
-
-    if test "${b_pkgs}" == 'xz'; then
-        ~/.local/bin/webi xz
-        return 0
-    fi
-
-    if echo "${b_pkgs}" | grep -q xz; then
-        ~/.local/bin/webi xz
-        b_pkgs="$(echo "${b_pkgs}" | sed 's/\sxz\s/ /')"
-    fi
-
-    echo ""
-    echo "error: unknown operating system:"
-    echo "    $(uname -srm)"
-    if test -r /etc/issue; then
-        echo "    $(cat /etc/issue)"
-    fi
-    echo ""
-    echo "$(t_err 'could not install'): $(t_warn "${b_pkgs}")"
-    echo ""
-    return 1
-); }
-
-_install_webi_essentials
--- a/webi/webi-pwsh.ps1
+++ b/webi/webi-pwsh.ps1
@@ -71,7 +71,7 @@ function Invoke-DownloadUrl {
        Write-Host "        ?$Params"
        $URL = "${URL}?${Params}"
    }
-    curl.exe '-#' -f -sS -A $Env:WEBI_UA -L $URL | Out-File $TmpPath
+    curl.exe '-#' --fail-with-body -sS -A $Env:WEBI_UA -L $URL | Out-File $TmpPath

    Remove-Item -Path $Path -Force -ErrorAction Ignore
    Move-Item $TmpPath $Path
--- a/webi/webi.sh
+++ b/webi/webi.sh
@@ -61,6 +61,8 @@ __webi_main() {
    set +e
    WEBI_CURL="$(command -v curl)"
    export WEBI_URL
+    WEBI_WGET="$(command -v wget)"
+    export WEBI_WGET
    set -e

    my_libc=''
@@ -85,38 +87,39 @@ __webi_main() {

    webinstall() {

-        b_package="${1:-}"
-        if test -z "${b_package}"; then
+        my_package="${1:-}"
+        if [ -z "$my_package" ]; then
            echo >&2 "Usage: webi <package>@<version> ..."
            echo >&2 "Example: webi node@lts rg"
            exit 1
        fi

-        b_install_tmpdir="$(
-            mktemp -d -t "${b_package}-install.${WEBI_TIMESTAMP}.XXXXXXXX"
+        WEBI_BOOT="$(
+            mktemp -d -t "$my_package-bootstrap.$WEBI_TIMESTAMP.XXXXXXXX"
        )"
+        export WEBI_BOOT

-        my_installer_url="$WEBI_HOST/api/installers/${b_package}.sh?formats=${my_ext}"
+        my_installer_url="$WEBI_HOST/api/installers/$my_package.sh?formats=$my_ext"
        if [ -n "$WEBI_CURL" ]; then
            if ! curl -fsSL "$my_installer_url" -H "User-Agent: curl $WEBI_UA" \
-                -o "${b_install_tmpdir}/${b_package}-install.sh"; then
+                -o "$WEBI_BOOT/$my_package-bootstrap.sh"; then
                echo >&2 "error fetching '$my_installer_url'"
                exit 1
            fi
        else
            if ! wget -q "$my_installer_url" --user-agent="wget $WEBI_UA" \
-                -O "${b_install_tmpdir}/${b_package}-install.sh"; then
+                -O "$WEBI_BOOT/$my_package-bootstrap.sh"; then
                echo >&2 "error fetching '$my_installer_url'"
                exit 1
            fi
        fi

        (
-            cd "${b_install_tmpdir}"
-            sh "${b_package}-install.sh"
+            cd "$WEBI_BOOT"
+            sh "$my_package-bootstrap.sh"
        )

-        rm -rf "${b_install_tmpdir}"
+        rm -rf "$WEBI_BOOT"

    }

@@ -152,7 +155,7 @@ __webi_main() {
        my_checksum="$(
            fn_checksum
        )"
-        my_version=v1.2.8
+        my_version=v1.2.0
        printf "\e[35mwebi\e[32m %s\e[0m Copyright 2020+ AJ ONeal\n" "${my_version} (${my_checksum})"
        printf "    \e[36mhttps://webinstall.dev/webi\e[0m\n"
    }
@@ -188,8 +191,6 @@ __webi_main() {
        echo "               Output the version number of webi and exit."
        echo ""
        echo "    Helper Utilities"
-        echo "        --init Register command line completions with shell"
-        echo ""
        echo "        --list Show everything webi has to offer."
        echo ""
        echo "        --info <package>"
@@ -214,295 +215,80 @@ __webi_main() {
        exit 0
    fi

-    if echo "$1" | grep -q -E '^(--list|list)$'; then
-        webi_list
+    if echo "$1" | grep -q -E '^(-l|--list|list)$'; then
+        echo >&2 "[warn] the format of --list output may change"
+
+        # because we don't have sitemap.xml for dev sites yet
+        my_host="https://webinstall.dev"
+        my_len="${#my_host}"
+
+        # 6 because the field will looks like "loc>WEBI_HOST/PKG_NAME"
+        # and the count is 1-indexed
+        my_count="$((my_len + 6))"
+
+        curl -fsS "${my_host}/sitemap.xml" |
+            grep -F "${my_host}" |
+            cut -d'<' -f2 |
+            cut -c "${my_count}"-
+
        exit 0
    fi

    if echo "${1}" | grep -q -E '^(--info|info)$'; then
-        webi_info "$@"
-        exit 0
-    fi
+        if test -z "${2}"; then
+            echo >&2 "Usage: webi --info <package>"
+            exit 1
+        fi
+
+        echo >&2 "[warn] the output of --info is completely half-baked and will change"
+        my_pkg="${2}"
+        # TODO need a way to check that it exists at all (readme, win, lin)
+        echo ""
+        echo "    Cheat Sheet: ${WEBI_HOST}/${my_pkg}"
+        echo "          POSIX: curl -sS ${WEBI_HOST}/${my_pkg} | sh"
+        echo "        Windows: curl.exe -A MS ${WEBI_HOST}/${my_pkg} | powershell"
+        echo "Releases (JSON): ${WEBI_HOST}/api/releases/${my_pkg}.json"
+        echo " Releases (tsv): ${WEBI_HOST}/api/releases/${my_pkg}.tab"
+        echo " (query params):     ?channel=stable&limit=10"
+        echo "                     &os=${my_os}&arch=${my_arch}"
+        echo " Install Script: ${WEBI_HOST}/api/installers/${my_pkg}.sh?formats=tar,zip,xz,git,dmg,pkg"
+        echo "  Static Assets: ${WEBI_HOST}/packages/${my_pkg}/README.md"
+        echo ""
+
+        # TODO os=linux,macos,windows (limit to tagged releases)
+        my_releases="$(
+            curl -fsS "${WEBI_HOST}/api/releases/${my_pkg}.json?channel=stable&limit=1&pretty=true"
+        )"
+
+        if printf '%s\n' "${my_releases}" | grep -q "error"; then
+            my_releases_beta="$(
+                curl -fsS "${WEBI_HOST}/api/releases/${my_pkg}.json?&limit=1&pretty=true"
+            )"
+            if printf '%s\n' "${my_releases_beta}" | grep -q "error"; then
+                echo >&2 "'${my_pkg}' is a special case that does not have releases"
+            else
+                echo >&2 "ERROR no stable releases for '${my_pkg}'!"
+            fi
+            exit 0
+        fi
+
+        echo >&2 "Stable '${my_pkg}' releases:"
+        if command -v jq > /dev/null; then
+            printf '%s\n' "${my_releases}" |
+                jq
+        else
+            printf '%s\n' "${my_releases}"
+        fi

-    if echo "$1" | grep -q -E '^(--init|init)$'; then
-        webi_shell_init "$@"
        exit 0
    fi

    for pkgname in "$@"; do
        webinstall "$pkgname"
-        export WEBI_WELCOME='shown'
    done

    show_path_updates

 }

-webi_shell_init() { (
-    a_shell="${2:-}"
-
-    fn_shell_integrate_bash ""
-    fn_shell_integrate_zsh ""
-    fn_shell_integrate_fish ""
-
-    # update completions now
-    webi_list > /dev/null
-
-    if [ $# -eq 1 ]; then
-        exit 0
-    fi
-
-    case "${a_shell}" in
-        bash)
-            fn_shell_integrate_bash "force"
-            fn_shell_init_bash
-            ;;
-        zsh)
-            fn_shell_integrate_zsh "force"
-            fn_shell_init_zsh
-            ;;
-        fish)
-            fn_shell_integrate_fish "force"
-            fn_shell_init_fish
-            ;;
-        *)
-            echo >&2 "Unsupported shell: $2"
-            exit 1
-            ;;
-    esac
-) }
-
-fn_shell_integrate_bash() { (
-    a_force="${1}"
-    if test -z "${a_force}"; then
-        if ! command -v bash > /dev/null; then
-            return 0
-        fi
-
-        if ! test -e ~/.bashrc && ! test -e ~/.bash_history; then
-            return 0
-        fi
-    fi
-
-    touch -a ~/.bashrc
-    if grep -q 'webi --init' ~/.bashrc; then
-        return 0
-    fi
-
-    echo >&2 "    Edit ~/.bashrc to add 'eval \"\$(webi --init bash)\"'"
-    # shellcheck disable=SC2016
-    {
-        echo ''
-        echo '# Generated by Webi. Do not edit.'
-        echo 'eval "$(webi --init bash)"'
-    } >> ~/.bashrc
-); }
-
-# shellcheck disable=SC2016
-fn_shell_init_bash() { (
-    echo '_webi() {'
-    echo '    COMPREPLY=()'
-    echo '    local cur="${COMP_WORDS[COMP_CWORD]}"'
-    echo '    if [ "$COMP_CWORD" -eq 1 ]; then'
-    echo '        local completions=$(webi --list | cut -d" " -f1)'
-    echo '        COMPREPLY=( $(compgen -W "$completions" -- "$cur") )'
-    echo '    fi'
-    echo '}'
-    echo ''
-    echo 'complete -F _webi webi'
-); }
-
-fn_shell_integrate_zsh() { (
-    a_force="${1}"
-    if test -z "${a_force}"; then
-        if ! command -v zsh > /dev/null; then
-            return 0
-        fi
-
-        if ! test -e ~/.zshrc &&
-            ! test -e ~/.zsh_sessions &&
-            ! test -e ~/.zsh_history; then
-            return 0
-        fi
-    fi
-
-    touch -a ~/.zshrc
-    if grep -q 'webi --init' ~/.zshrc; then
-        return 0
-    fi
-
-    echo >&2 "    Edit ~/.zshrc to add 'eval \"\$(webi --init zsh)\"'"
-    # shellcheck disable=SC2016
-    {
-        echo ''
-        echo '# Generated by Webi. Do not edit.'
-        echo 'eval "$(webi --init zsh)"'
-    } >> ~/.zshrc
-); }
-
-# shellcheck disable=SC2016
-fn_shell_init_zsh() { (
-    echo '_webi() {'
-    echo '    local -a list completions'
-    echo '    list=$(webi --list | cut -d" " -f1)'
-    echo '    completions=(${(f)list})'
-    echo '    _describe -t commands "command" completions && ret=0'
-    echo '}'
-    echo ''
-    echo 'autoload -Uz compinit && compinit'
-    echo 'compdef _webi webi'
-); }
-
-fn_shell_integrate_fish() { (
-    a_force="${1}"
-    if test -z "${a_force}"; then
-        if ! command -v fish > /dev/null; then
-            return 0
-        fi
-    fi
-
-    mkdir -p ~/.config/fish
-    touch -a ~/.config/fish/config.fish
-    if grep -q 'webi --init' ~/.config/fish/config.fish; then
-        return 0
-    fi
-
-    echo >&2 "    Edit ~/.config/fish/config.fish to add 'webi --init fish | source'"
-    # shellcheck disable=SC2016
-    {
-        echo ''
-        echo '# Generated by Webi. Do not edit.'
-        echo 'webi --init fish | source'
-    } >> ~/.config/fish/config.fish
-); }
-
-# shellcheck disable=SC2016
-fn_shell_init_fish() { (
-    echo 'function __fish_webi_needs_command'
-    echo '    set cmd (commandline -opc)'
-    echo '    if [ (count $cmd) -eq 1 -a $cmd[1] = "webi" ]'
-    echo '        return 0'
-    echo '    end'
-    echo '    return 1'
-    echo 'end'
-    echo ''
-    echo 'set completions (webi --list | cut -d" " -f1)'
-    echo 'complete -f -c webi -n __fish_webi_needs_command -a "$completions"'
-); }
-
-webi_list() { (
-    # make sure there's always a cache dir and timestamp file
-    mkdir -p ~/.local/share/webi/var/
-
-    if ! test -r ~/.local/share/webi/var/list.txt; then
-        echo '0' > ~/.local/share/webi/var/last_update
-    elif ! test -r ~/.local/share/webi/var/last_update; then
-        echo '0' > ~/.local/share/webi/var/last_update
-    fi
-
-    # compare the timestamp in the timestamp file to now
-    # (in seconds since unix epoch)
-    my_stale_age=600
-    my_expire_age=900
-    my_now="$(date -u '+%s')"
-    my_then="$(cat ~/.local/share/webi/var/last_update)"
-    my_diff=$((my_now - my_then))
-
-    # show when the cache will update
-    my_stales_in=$((my_stale_age - my_diff))
-    my_expires_in=$((my_expire_age - my_diff))
-
-    # update if it's been longer than the staletime
-    if test "${my_stales_in}" -lt "0"; then
-        if test "${my_expires_in}" -lt "0"; then
-            fn_list_uncached
-        else
-            fn_list_uncached &
-        fi
-    fi
-
-    # give back the list
-    cat ~/.local/share/webi/var/list.txt
-); }
-
-fn_list_uncached() { (
-    # because we don't have sitemap.xml for dev sites yet
-    my_host="https://webinstall.dev"
-
-    my_len="${#my_host}"
-    # 6 because the field will looks like "loc>WEBI_HOST/PKG_NAME"
-    # and the count is 1-indexed
-    my_count="$((my_len + 6))"
-
-    my_now="$(date -u '+%s')"
-    echo "${my_now}" > ~/.local/share/webi/var/last_update
-
-    my_tmp="$(mktemp)"
-    {
-        echo "help"
-        echo "--help"
-        echo "version"
-        echo "-V"
-        echo "--version"
-        echo "--init" # <shell>
-        echo "--list"
-        echo "--info" # <package>
-    } > "${my_tmp}"
-    curl -fsS "${my_host}/sitemap.xml" |
-        grep -F "${my_host}" |
-        cut -d'<' -f2 |
-        cut -c "${my_count}"- >> "${my_tmp}"
-    mv "${my_tmp}" ~/.local/share/webi/var/list.txt
-
-    my_now="$(date -u '+%s')"
-    echo "${my_now}" > ~/.local/share/webi/var/last_update
-); }
-
-webi_info() { (
-    if test -z "${2}"; then
-        echo >&2 "Usage: webi --info <package>"
-        exit 1
-    fi
-
-    echo >&2 "[warn] the output of --info is completely half-baked and will change"
-    my_pkg="${2}"
-    # TODO need a way to check that it exists at all (readme, win, lin)
-    echo ""
-    echo "    Cheat Sheet: ${WEBI_HOST}/${my_pkg}"
-    echo "          POSIX: curl -sS ${WEBI_HOST}/${my_pkg} | sh"
-    echo "        Windows: curl.exe -A MS ${WEBI_HOST}/${my_pkg} | powershell"
-    echo "Releases (JSON): ${WEBI_HOST}/api/releases/${my_pkg}.json"
-    echo " Releases (tsv): ${WEBI_HOST}/api/releases/${my_pkg}.tab"
-    echo " (query params):     ?channel=stable&limit=10"
-    echo "                     &os=${my_os}&arch=${my_arch}"
-    echo " Install Script: ${WEBI_HOST}/api/installers/${my_pkg}.sh?formats=tar,zip,xz,git,dmg,pkg"
-    echo "  Static Assets: ${WEBI_HOST}/packages/${my_pkg}/README.md"
-    echo ""
-
-    # TODO os=linux,macos,windows (limit to tagged releases)
-    my_releases="$(
-        curl -fsS "${WEBI_HOST}/api/releases/${my_pkg}.json?channel=stable&limit=1&pretty=true"
-    )"
-
-    if printf '%s\n' "${my_releases}" | grep -q "error"; then
-        my_releases_beta="$(
-            curl -fsS "${WEBI_HOST}/api/releases/${my_pkg}.json?&limit=1&pretty=true"
-        )"
-        if printf '%s\n' "${my_releases_beta}" | grep -q "error"; then
-            echo >&2 "'${my_pkg}' is a special case that does not have releases"
-        else
-            echo >&2 "ERROR no stable releases for '${my_pkg}'!"
-        fi
-        exit 0
-    fi
-
-    echo >&2 "Stable '${my_pkg}' releases:"
-    if command -v jq > /dev/null; then
-        printf '%s\n' "${my_releases}" |
-            jq
-    else
-        printf '%s\n' "${my_releases}"
-    fi
-); }
-
 __webi_main "$@"
--- a/zig/releases.js
+++ b/zig/releases.js
@@ -1,7 +1,6 @@
 'use strict';

 var NON_BUILDS = ['bootstrap', 'src'];
-var ODDITIES = NON_BUILDS.concat(['armv6kz-linux']);

 module.exports = function (request) {
  return request({
@@ -28,8 +27,8 @@ module.exports = function (request) {
          return;
        }

-        let isOdd = ODDITIES.includes(platform);
-        if (isOdd) {
+        let isNonBuild = NON_BUILDS.includes(platform);
+        if (isNonBuild) {
          return;
        }

--- a/zoxide/releases.js
+++ b/zoxide/releases.js
@@ -6,6 +6,11 @@ var repo = 'zoxide';

 module.exports = function (request) {
  return github(request, owner, repo).then(function (all) {
+    all.releases.forEach(function (rel) {
+      if (/-arm-/.test(rel.download)) {
+        rel.arch = 'armv6l';
+      }
+    });
    return all;
  });
 };
Author	SHA1	Message	Date
AJ ONeal	06216f522a	fix(yq): filter out special non-build files	2023-11-15 21:26:13 -07:00
AJ ONeal	cc1c8fb6f3	fix(terraform): remove incorrect arch detection	2023-11-15 21:26:13 -07:00
AJ ONeal	498931c620	fix(kube*): filter out companion util and legacy scripts	2023-11-15 21:26:12 -07:00
AJ ONeal	827e1217cf	fix(jq): filter out special non-build files	2023-11-15 21:26:08 -07:00
AJ ONeal	54e82c9fd6	fix(go): filter out typoed beta release	2023-11-15 21:25:47 -07:00
AJ ONeal	c219f55119	fix(flutter): add _version to match version in filepath	2023-11-15 21:25:46 -07:00
AJ ONeal	4e73760ac7	fix(flutter): remove incorrect os/arch detection	2023-11-15 21:25:46 -07:00
AJ ONeal	2f7303c9a5	fix(fd): filter out unmatchable legacy build	2023-11-15 21:25:46 -07:00
AJ ONeal	21c5a86a64	ref(dashcore): remove custom filtering on generic asset type	2023-11-15 21:25:46 -07:00
AJ ONeal	6fc346a947	fix(dashcore): add _version to match version in filepath	2023-11-15 21:25:46 -07:00
AJ ONeal	3cb5145c1b	fix(cmake): add _version to match version in filepath	2023-11-15 21:25:46 -07:00
AJ ONeal	05e30a15a8	fix!(chromedriver): rewrite for latest releases URL	2023-11-15 21:25:42 -07:00