diff --git a/doc/zsdoc/zinit-install.zsh.adoc b/doc/zsdoc/zinit-install.zsh.adoc
index ec60f4752..02c9ba06f 100644
--- a/doc/zsdoc/zinit-install.zsh.adoc
+++ b/doc/zsdoc/zinit-install.zsh.adoc
@@ -59,7 +59,7 @@ Uses feature(s): _source_
 
 ==== .zi::get-architecture
 
-Has 43 line(s). Calls functions:
+Has 39 line(s). Calls functions:
 
  .zi::get-architecture
  `-- zinit.zsh/+zi-log
@@ -282,7 +282,7 @@ ____
 
 ____
 
-Has 52 line(s). Calls functions:
+Has 57 line(s). Calls functions:
 
  .zinit-get-latest-gh-r-url-part
  `-- zinit.zsh/+zi-log
diff --git a/tests/gh-r.zunit b/tests/gh-r.zunit
index 004ca5108..e8f0ceb82 100755
--- a/tests/gh-r.zunit
+++ b/tests/gh-r.zunit
@@ -4,7 +4,7 @@
 @setup {
   export ZBIN="${ZPFX}/bin"
   export os_type="${OSTYPE//[0-9\.]*/}"
-  zinit default-ice --quiet from'gh-r' nocompile lbin'!'
+  zinit default-ice --quiet from'gh-r' nocompile lbin
 }
 
 # @test 'atmos' {  Universal Tool for DevOps and Cloud Automation (works with terraform, helm, helmfile, etc)
@@ -46,12 +46,12 @@
 @test 'alist' { # A file list program that supports multiple storage, powered by Gin and React
   run zinit lbin'!* -> alist' for @alist-org/alist; assert $state equals 0
   local alist="$ZBIN/alist"; assert "$alist" is_executable
-  $alist version; assert $state equals 0
+  run $alist version; assert $state equals 0
 }
 @test 'asciigraph' { # Go package to make lightweight ASCII line graphs in command line apps with no external dependencies.
   run zinit for @guptarohit/asciigraph; assert $state equals 0
   local asciigraph="$ZBIN/asciigraph"; assert "$asciigraph" is_executable
-  $asciigraph --help; assert $state equals 0
+  run $asciigraph --help; assert $state equals 0
 }
 @test 'assh' { # make your ssh client smarter
   run zinit for @moul/assh; assert $state equals 0
@@ -104,7 +104,7 @@
 @test 'bottom' { # Yet another cross-platform graphical process/system monitor
   run zinit lbin'!**/btm' for ClementTsang/bottom; assert $state equals 0
   local bottom="$ZBIN/btm"; assert "$bottom" is_executable
-  $bottom --version; assert $state equals 0
+  run $bottom --version; assert $state equals 0
 }
 @test 'broot' { # A new way to see and navigate directory trees
   [[ $OSTYPE =~ 'darwin*' ]] && skip " on $os_type"
@@ -120,7 +120,7 @@
 @test 'calico' { # Cloud native networking and network security
   run zinit lbin"!* -> calico" for @projectcalico/calico; assert $state equals 0
   local calico="$ZBIN/calico"; assert "$calico" is_executable
-  run $calico --help; assert $state equals 0
+  run $calico --version; assert $state equals 0
 }
 @test 'certificates' { # An opinionated helper for generating tls certificates
   run zinit lbin"!* -> certificates" for @mvmaasakkers/certificates; assert $state equals 0
@@ -133,7 +133,7 @@
   run $checkmake --version; assert $state equals 0
 }
 @test 'cog' { # Containers for machine learning
-  run zinit lbin'!cog* -> cog' for @replicate/cog; assert $state equals 0
+  run zinit lbin'!* -> cog' for @replicate/cog; assert $state equals 0
   local cog="$ZBIN/cog"; assert "$cog" is_executable
   run $cog --version; assert $state equals 0
 }
@@ -146,37 +146,37 @@
   run zinit for id-as'cgapp' @create-go-app/cli; assert $state equals 0
   local cgapp="$ZBIN/cgapp"; assert "$cgapp" is_executable
   [[ $OSTYPE =~ 'darwin*' ]] && assert "$output" contains "darwin_${$(uname -m)//x86_/amd}" && pass
-  $cgapp --version; assert $state equals 0
+  run $cgapp --version; assert $state equals 0
 }
 @test 'csview' { # Pretty csv viewer for cli with cjk/emoji support
   run zinit for @wfxr/csview; assert $state equals 0
   local csview="$ZBIN/csview"; assert "$csview" is_executable
-  $csview --version; assert $state equals 0
+  run $csview --version; assert $state equals 0
 }
 @test 'delta' { # A syntax-highlighting pager for git, diff, and grep output
   run zinit for @dandavison/delta; assert $state equals 0
   local delta="$ZBIN/delta"; assert "$delta" is_executable
-  $delta --version; assert $state equals 0
+  run $delta --version; assert $state equals 0
 }
 @test 'difftastic' { # A structural diff that understands syntax
   run zinit id-as'difft' for  @Wilfred/difftastic; assert $state equals 0
   local difftastic="$ZBIN/difft"; assert "$difftastic" is_executable
-  $difftastic --version; assert $state equals 0
+  run $difftastic --version; assert $state equals 0
 }
 @test 'dive' { # A tool for exploring each layer in a docker image
   run zinit for @wagoodman/dive; assert $state equals 0
   local dive="$ZBIN/dive"; assert "$dive" is_executable
-  $dive --version; assert $state equals 0
+  run $dive --version; assert $state equals 0
 }
 @test 'docker-buildx' { # A monitor of resources
   run zinit for lbin'!* -> buildx' @docker/buildx; assert $state equals 0
   local buildx="$ZBIN/buildx"; assert "$buildx" is_executable
-  $buildx version; assert $state equals 0
+  run $buildx version; assert $state equals 0
 }
 @test 'docker-compose' { # Define and run multi-container applications with Docker
   run zinit lbin'!* -> docker-compose' for @docker/compose; assert $state equals 0
   local dc="$ZBIN/docker-compose"; assert "$dc" is_executable
-  $dc --version; assert $state equals 0
+  run $dc --version; assert $state equals 0
 }
 @test 'docker-credential-helpers' { # A monitor of resources
   [[ $OSTYPE =~ 'linux*' ]] && skip "on $os_type"
@@ -187,32 +187,32 @@
 @test 'documize' { # Modern Confluence alternative designed for internal & external docs, built with Go & Ember JS
   run zinit lbin'!* -> documize' for @documize/community; assert $state equals 0
   local documize="$ZBIN/documize"; assert "$documize" is_executable
-  $documize version; assert $state equals 0
+  run $documize version; assert $state equals 0
 }
 @test 'dstask' { # Git powered terminal-based todo/note manager -- markdown note page per task
   run zinit lbin'!*->dstask' bpick'^*import*' for @naggie/dstask; assert $state equals 0
   local dstask="$ZBIN/dstask"; assert "$dstask" is_executable
-  $dstask help; assert $state equals 0
+  run $dstask version; assert $state equals 0
 }
 @test 'dua' { # View disk space usage and delete unwanted data, fast
   run zinit lbin'!**/dua' for @Byron/dua-cli; assert $state equals 0
   local dua="$ZBIN/dua"; assert "$dua" is_executable
-  $dua --version; assert $state equals 0
+  run $dua --version; assert $state equals 0
 }
 @test 'duci' { # The simple CI server
   run zinit lbin'!**/duci' for @duck8823/duci; assert $state equals 0
   local duci="$ZBIN/duci"; assert "$duci" is_executable
-  $duci version; assert $state equals 0
+  run $duci version; assert $state equals 0
 }
 @test 'dust' { # A more intuitive version of du in rust
   run zinit lbin'!**/dust' for @bootandy/dust; assert $state equals 0
   local dust="$ZBIN/dust"; assert "$dust" is_executable
-  $dust --version; assert $state equals 0
+  run $dust --version; assert $state equals 0
 }
 @test 'dyff' { # diff tool for YAML files, and sometimes JSON
   run zinit lbin'!**/dyff' for @homeport/dyff; assert $state equals 0
   local dyff="$ZBIN/dyff"; assert "$dyff" is_executable
-  $dyff version; assert $state equals 0
+  run $dyff version; assert $state equals 0
 }
 @test 'dysk' { # A linux utility to get information on filesystems, like df but better
   [[ $OSTYPE =~ 'darwin*' ]] && skip "skipped on $os_type"
@@ -223,12 +223,12 @@
 @test 'etcd' { # Distributed reliable key-value store for the most critical data of a distributed system
   run zinit lbin'!**/etcd' for @etcd-io/etcd; assert $state equals 0
   local etcd="$ZBIN/etcd"; assert "$etcd" is_executable
-  $etcd --version; assert $state equals 0
+  run $etcd --version; assert $state equals 0
 }
 @test 'exa' { # A modern replacement for ls
   run zinit lbin'!**/exa' for @ogham/exa; assert $state equals 0
   local exa="$ZBIN/exa"; assert "$exa" is_executable
-  $exa --version; assert $state equals 0
+  run $exa --version; assert $state equals 0
 }
 @test 'fclones' { # Efficient duplicate file Finder
   [[ $OSTYPE =~ 'darwin*' ]] && skip "on $os_type"
@@ -239,145 +239,145 @@
 @test 'fd' { # A fast, simple, and user-friendly alternative to find
   run zinit for @sharkdp/fd; assert $state equals 0
   local fd="$ZBIN/fd"; assert "$fd" is_executable
-  $fd version; assert $state equals 0
+  run $fd version; assert $state equals 0
 }
 @test 'fnm' { # Fast and simple Node.js version manager, built in Rust
   run zinit for @Schniz/fnm; assert $state equals 0
   local fnm="$ZBIN/fnm"; assert "$fnm" is_executable
-  $fnm --version; assert $state equals 0
+  run $fnm --version; assert $state equals 0
 }
 @test 'fogg' { # Manage Infrastructure as Code with less pain
   run zinit for @chanzuckerberg/fogg; assert $state equals 0
   local fogg="$ZBIN/fogg"; assert "$fogg" is_executable
-  $fogg version; assert $state equals 0
+  run $fogg version; assert $state equals 0
 }
 @test 'fx' { # Terminal JSON viewer
   run zinit lbin'!* -> fx' for @antonmedv/fx; assert $state equals 0
   local fx="$ZBIN/fx"; assert "$fx" is_executable
-  $fx -v; assert $state equals 0
+  run $fx -v; assert $state equals 0
 }
 @test 'fzf' { # A command-line fuzzy finder
   run zinit for @junegunn/fzf; assert $state equals 0
   local fzf="$ZBIN/fzf"; assert "$fzf" is_executable
-  $fzf --version; assert $state equals 0
+  run $fzf --version; assert $state equals 0
 }
 @test 'gaper' { # Builds and restarts a Go project when it crashes or some watched file changes
   [[ $OSTYPE =~ "linux*" ]] && skip "on $os_type"
   run zinit lbin'!**/gaper' for @maxcnunes/gaper; assert $state equals 0
   local gaper="$ZBIN/gaper"; assert "$gaper" is_executable
-  $gaper --version; assert $state equals 0
+  run $gaper --version; assert $state equals 0
 }
 @test 'gdu' { # Fast disk usage analyzer with console interface written in Go
   run zinit lbin'!* -> gdu' for @dundee/gdu; assert $state equals 0
   local gdu="$ZBIN/gdu"; assert "$gdu" is_executable
-  $gdu --version; assert $state equals 0
+  run $gdu --version; assert $state equals 0
 }
 @test 'gf' { # Fast disk usage analyzer with console interface written in Go
   run zinit lbin'!* -> gf' for @gogf/gf; assert $state equals 0
   local gf="$ZBIN/gf"; assert "$gf" is_executable
-  $gf --version; assert $state equals 0
+  run $gf --version; assert $state equals 0
 }
 @test 'ggsrun' { # This is a CLI tool to execute Google Apps Script (GAS) at own terminal on local PC. Also this CLI tool can be used for managing files in Google Drive for OAuth2 and Service Account
   run zinit lbin'!* -> ggsrun' ver'v2.0.0' for @tanaikech/ggsrun; assert $state equals 0
   local git_sizer="$ZBIN/ggsrun"; assert "$git_sizer" is_executable
-  $git_sizer --version; assert $state equals 0
+  run $git_sizer --version; assert $state equals 0
 }
 @test 'gh-cli' { # GitHub’s official command line tool
   run zinit lbin'!**/gh' for @cli/cli; assert $state equals 0
   local gh_cli="$ZBIN/gh"; assert "$gh_cli" is_executable
-  $gh_cli --version; assert $state equals 0
+  run $gh_cli --version; assert $state equals 0
 }
 @test 'gh-hub' { # A command-line tool that makes git easier to use with GitHub
   run zinit cp"hub-*/etc/hub.zsh_completion -> _hub" for @mislav/hub; assert $state equals 0
   local hub="$ZBIN/hub"; assert "$hub" is_executable
-  $hub --version; assert $state equals 0
+  run $hub --version; assert $state equals 0
 }
 @test 'ghg' { # Get the executable from github releases easily
   run zinit for @Songmu/ghg; assert $state equals 0
   local ghg="$ZBIN/ghg"; assert "$ghg" is_executable
-  $ghg version; assert $state equals 0
+  run $ghg version; assert $state equals 0
 }
 @test 'ghq' { # Remote repository management made easy
   run zinit for @x-motemen/ghq; assert $state equals 0
   local ghq="$ZBIN/ghq"; assert "$ghq" is_executable
-  $ghq --version; assert $state equals 0
+  run $ghq --version; assert $state equals 0
 }
 @test 'git-absorb' { # git commit --fixup, but automatic
   run zinit for @tummychow/git-absorb; assert $state equals 0
   local git_absorb="$ZBIN/git-absorb"; assert "$git_absorb" is_executable
-  $git_absorb --version; assert $state equals 0
+  run $git_absorb --version; assert $state equals 0
 }
 @test 'git-chglog' { # CHANGELOG generator implemented in Go
   run zinit for @git-chglog/git-chglog; assert $state equals 0
   local git_chglog="$ZBIN/git-chglog"; assert "$git_chglog" is_executable
-  $git_chglog --version; assert $state equals 0
+  run $git_chglog --version; assert $state equals 0
 }
 @test 'git-mkver' { # Automatic Semantic Versioning for git based software development
   run zinit ver'v1.2.2' for @idc101/git-mkver; assert $state equals 0
   local git_mkver="$ZBIN/git-mkver"; assert "$git_mkver" is_executable
   # use git-mkver info because --version exits with 130?
-  $git_mkver info; assert $state equals 0
+  run $git_mkver info; assert $state equals 0
 }
 @test 'git-sizer' { # Compute various size metrics for a Git repository, flagging those that might cause problems
   run zinit for @github/git-sizer; assert $state equals 0
   local git_sizer="$ZBIN/git-sizer"; assert "$git_sizer" is_executable
-  $git_sizer --version; assert $state equals 0
+  run $git_sizer --version; assert $state equals 0
 }
 @test 'glow' { # Render markdown on the CLI, with pizzazz
   run zinit for @charmbracelet/glow; assert $state equals 0
   local git_sizer="$ZBIN/glow"; assert "$git_sizer" is_executable
-  $git_sizer --version; assert $state equals 0
+  run $git_sizer --version; assert $state equals 0
 }
 @test 'go-james' { # James is your butler and helps you to create, build, debug, test and run your Go projects
   run zinit for @pieterclaerhout/go-james; assert $state equals 0
   local git_sizer="$ZBIN/go-james"; assert "$git_sizer" is_executable
-  $git_sizer version; assert $state equals 0
+  run $git_sizer version; assert $state equals 0
 }
 @test 'go-swagger' { # Swagger 2.0 implementation for go
   run zinit lbin'!* -> go-swagger' for @go-swagger/go-swagger; assert $state equals 0
   local git_sizer="$ZBIN/go-swagger"; assert "$git_sizer" is_executable
-  $git_sizer version; assert $state equals 0
+  run $git_sizer version; assert $state equals 0
 }
 @test 'gojq' { # Pure Go implementation of jq
   run zinit for @itchyny/gojq; assert $state equals 0
   local git_sizer="$ZBIN/gojq"; assert "$git_sizer" is_executable
-  $git_sizer --version; assert $state equals 0
+  run $git_sizer --version; assert $state equals 0
 }
 @test 'gomi' { # Replacement for UNIX rm command
   run zinit for @babarot/gomi; assert $state equals 0
   local gomi="$ZBIN/gomi"; assert "$gomi" is_executable
-  $gomi --version; assert $state equals 0
+  run $gomi --version; assert $state equals 0
 }
 @test 'gosu' { # Simple Go-based setuid+setgid+setgroups+exec
   [[ $OSTYPE =~ "darwin*" ]] && skip "on $os_type"
   run zinit lbin'!* -> gosu' for @tianon/gosu; assert $state equals 0
   local gosu="$ZBIN/gosu"; assert "$gosu" is_executable
-  $gosu --version; assert $state equals 0
+  run $gosu --version; assert $state equals 0
 }
 @test 'got' { # Simple golang package and CLI tool to download large files faster than cURL and Wget
   run zinit for @melbahja/got; assert $state equals 0
   local got="$ZBIN/got"; assert "$got" is_executable
-  $got --version; assert $state equals 0
+  run $got --version; assert $state equals 0
 }
 @test 'gotestfmt' { # go test output for humans
   run zinit for @GoTestTools/gotestfmt; assert $state equals 0
   local gotestfmt="$ZBIN/gotestfmt"; assert "$gotestfmt" is_executable
-  $gotestfmt --help; assert $state equals 0
+  run $gotestfmt --help; assert $state equals 0
 }
 @test 'gothanks' { # go test output for humans
   run zinit for @psampaz/gothanks; assert $state equals 0
   local gothanks="$ZBIN/gothanks"; assert "$gothanks" is_executable
-  $gothanks --help; assert $state equals 0
+  run $gothanks --help; assert $state equals 0
 }
 @test 'grex' { # A command-line tool and library for generating regular expressions from user-provided test cases
   run zinit for @pemistahl/grex; assert $state equals 0
   local grex="$ZBIN/grex"; assert "$grex" is_executable
-  $grex --version; assert $state equals 0
+  run $grex --version; assert $state equals 0
 }
 @test 'gron' { # go test output for humans
   run zinit for @tomnomnom/gron; assert $state equals 0
   local gron="$ZBIN/gron"; assert "$gron" is_executable
-  $gron --version; assert $state equals 0
+  run $gron --version; assert $state equals 0
 }
 @test 'hadolint' { # Dockerfile linter, validate inline bash, written in Haskell
   run zinit ver'v2.12.1-beta' lbin'!hadolint* -> hadolint' for @hadolint/hadolint; assert $state equals 0
@@ -389,33 +389,33 @@
   [[ $OSTYPE =~ "darwin*" ]] && skip "on $os_type"
   run zinit for @raspi/heksa; assert $state equals 0
   local heksa="$ZBIN/heksa"; assert "$heksa" is_executable
-  $heksa --version; assert $state equals 0
+  run $heksa --version; assert $state equals 0
 }
 @test 'helix' { # A post-modern modal text editor
   run zinit lbin'!**/hx' for @helix-editor/helix; assert $state equals 0
   local helix="$ZBIN/hx"; assert "$helix" is_executable
-  $helix --version; assert $state equals 0
+  run $helix --version; assert $state equals 0
 }
 @test 'hexyl' { # A command-line hex viewer
   run zinit for @sharkdp/hexyl; assert $state equals 0
   local hexyl="$ZBIN/hexyl"; assert "$hexyl" is_executable
-  $hexyl --version; assert $state equals 0
+  run $hexyl --version; assert $state equals 0
 }
 @test 'hit-on' { # Git Workflow Helper Tool
   run zinit lbin'!* -> hit' for kowainik/hit-on; assert $state equals 0
   local hit="$ZBIN/hit"; assert "$hit" is_executable
-  $hit --version; assert $state equals 0
+  run $hit --version; assert $state equals 0
 }
 @test 'hoofli' { # Generate PlantUML diagrams from Chrome or Firefox network inspection
   run zinit lbin'!* -> hoofli' for @dnnrly/hoofli; assert $state equals 0
   local hoofli="$ZBIN/hoofli"; assert "$hoofli" is_executable
-  $hoofli -h; assert $state equals 0
+  run $hoofli -h; assert $state equals 0
 }
 @test 'hors' { # instant coding answers via the command line
   [[ $OSTYPE =~ "linux*" ]] && skip "skipped on $os_type"
   run zinit for @WindSoilder/hors; assert $state equals 0
   local hors="$ZBIN/hors"; assert "$hors" is_executable
-  $hors --version; assert $state equals 0
+  run $hors --version; assert $state equals 0
 }
 @test 'htmlq' { # Like jq, but for HTML
   run zinit for @mgdm/htmlq; assert $state equals 0
@@ -425,58 +425,58 @@
 @test 'hyperfine' { # A command-line benchmarking tool
   run zinit bpick'*tar.gz*' for @sharkdp/hyperfine; assert $state equals 0
   local hyperfine="$ZBIN/hyperfine"; assert "$hyperfine" is_executable
-  $hyperfine --version; assert $state equals 0
+  run $hyperfine --version; assert $state equals 0
 }
 @test 'igo' { # Improved Go Syntax (transpiler)
   run zinit for @rocketlaunchr/igo; assert $state equals 0
   local igo="$ZBIN/igo"; assert "$igo" is_executable
-  $igo version; assert $state equals 0
+  run $igo version; assert $state equals 0
 }
 @test 'insect' { # High precision scientific calculator with support for physical units
   run zinit ver'v5.7.0' lbin'!* -> insect' for @sharkdp/insect; assert $state equals 0
   local insect="$ZBIN/insect"; assert "$insect" is_executable
-  $insect help; assert $state equals 0
+  run $insect help; assert $state equals 0
 }
 @test 'joincap' { # Merge multiple pcap files together, gracefully
   run zinit lbin'!* -> joincap' for @assafmo/joincap; assert $state equals 0
   local joincap="$ZBIN/joincap"; assert "$joincap" is_executable
-  $joincap --version; assert $state equals 0
+  run $joincap --version; assert $state equals 0
 }
 @test 'jq' { # Command-line JSON processor
   run zinit lbin'!* -> jq' for jqlang/jq; assert $state equals 0
   local jq="$ZBIN/jq"; assert "$jq" is_executable
-  $jq --version; assert $state equals 0
+  run $jq --version; assert $state equals 0
 }
 @test 'just' { # Just a command runner
   run zinit for @casey/just; assert $state equals 0
   local just="$ZBIN/just"; assert "$just" is_executable
-  $just --version; assert $state equals 0
+  run $just --version; assert $state equals 0
 }
 @test 'keepassxc' { # a cross-platform community-driven port of the Windows application Keepass Password Safe
   [[ $OSTYPE =~ 'linux*' ]] && skip "skipped on $os_type"
-  run zinit for @keepassxreboot/keepassxc; assert $state equals 0
-  local keepassxc="$ZBIN/keepassxc"; assert "$keepassxc" is_executable
-  $keepassxc -v; assert $state equals 0
+  run zinit for lbin'!*-cli -> keepassxc-cli' @keepassxreboot/keepassxc; assert $state equals 0
+  local keepassxc="$ZBIN/keepassxc-cli"; assert "$keepassxc" is_executable
+  run $keepassxc --version; assert $state equals 0
 }
 @test 'ko' { # Build and deploy Go applications on Kubernetes
   run zinit for @ko-build/ko; assert $state equals 0
   local ko="$ZBIN/ko"; assert "$ko" is_executable
-  $ko version; assert $state equals 0
+  run $ko version; assert $state equals 0
 }
 @test 'kopia' { # Cross-platform backup tool with fast, incremental backups, client-side end-to-end encryption, compression and data deduplication
-run zinit for @kopia/kopia; assert $state equals 0
-local kopia="$ZBIN/kopia"; assert "$kopia" is_executable
-$kopia --version; assert $state equals 0
+  run zinit for @kopia/kopia; assert $state equals 0
+  local kopia="$ZBIN/kopia"; assert "$kopia" is_executable
+  run $kopia --version; assert $state equals 0
 }
 @test 'krew' { # Build and deploy Go applications on Kubernetes
   run zinit lbin'!krew* -> krew' for @kubernetes-sigs/krew; assert $state equals 0
   local krew="$ZBIN/krew"; assert "$krew" is_executable
-  $krew version; assert $state equals 0
+  run $krew version; assert $state equals 0
 }
 @test 'lazygit' { # simple terminal UI for git commands
   run zinit for @jesseduffield/lazygit; assert $state equals 0
   local lazygit="$ZBIN/lazygit"; assert "$lazygit" is_executable
-  $lazygit --version; assert $state equals 0
+  run $lazygit --version; assert $state equals 0
 }
 @test 'lemmeknow' { # The fastest way to identify anything
   run zinit lbin'!* -> lemmeknow' for @swanandx/lemmeknow; assert $state equals 0
@@ -486,23 +486,23 @@ $kopia --version; assert $state equals 0
 @test 'lf' { # Terminal file manager
   run zinit for @gokcehan/lf; assert $state equals 0
   local lf="$ZBIN/lf"; assert "$lf" is_executable
-  $lf -version; assert $state equals 0
+  run $lf -version; assert $state equals 0
 }
 @test 'lnav' { # advanced log file viewer
   run zinit for @tstack/lnav; assert $state equals 0
   local lnav="$ZBIN/lnav"; assert "$lnav" is_executable
-  $lnav --version; assert $state equals 0
+  run $lnav --version; assert $state equals 0
 }
 @test 'lsd' { # The next gen ls command
   run zinit for @lsd-rs/lsd; assert $state equals 0
   local lsd="$ZBIN/lsd"; assert "$lsd" is_executable
-  $lsd --version; assert $state equals 0
+  run $lsd --version; assert $state equals 0
 }
 @test 'lstf' { # The aggregated TCP flows printer in Linux
   [[ $OSTYPE =~ 'darwin*' ]] && skip "skipped on $os_type"
   run zinit for @yuuki/lstf; assert $state equals 0
   local lstf="$ZBIN/lstf"; assert "$lstf" is_executable
-  $lstf --version; assert $state equals 0
+  run $lstf --version; assert $state equals 0
 }
 @test 'macchina' { # A system information frontend with an emphasis on performance
   [[ $OSTYPE =~ 'darwin*' ]] && skip "skipped on $os_type"
@@ -513,18 +513,23 @@ $kopia --version; assert $state equals 0
 @test 'mage' { # A Make/rake-like dev tool using Go
   run zinit for @magefile/mage; assert $state equals 0
   local mage="$ZBIN/mage"; assert "$mage" is_executable
-  $mage -version; assert $state equals 0
+  run $mage -version; assert $state equals 0
 }
 @test 'mas' { # Mac App Store command line interface
   [[ $OSTYPE =~ 'linux*' ]] && skip "skipped on $os_type"
   run zinit lbin'!**/bin/mas' for @mas-cli/mas; assert $state equals 0
   local mas="$ZBIN/mas"; assert "$mas" is_executable
-  $mas version; assert $state equals 0
+  run $mas version; assert $state equals 0
+}
+@test 'mcfly' { # Fly through your shell history. Great Scott
+  run zinit for @cantino/mcfly; assert $state equals 0
+  local mcfly="$ZBIN/mcfly"; assert "$mcfly" is_executable
+  run $mcfly --version; assert $state equals 0
 }
 @test 'mdbook' { # Create book from markdown files. Like Gitbook but implemented in Rust
   run zinit for @rust-lang/mdBook; assert $state equals 0
   local mdbook="$ZBIN/mdbook"; assert "$mdbook" is_executable
-  $mdbook --version; assert $state equals 0
+  run $mdbook --version; assert $state equals 0
 }
 @test 'mdcat' { # cat for markdown
   run zinit for @swsnr/mdcat; assert $state equals 0
@@ -534,7 +539,7 @@ $kopia --version; assert $state equals 0
 @test 'micro' { # A modern and intuitive terminal-based text editor
   run zinit for @zyedidia/micro; assert $state equals 0
   local micro="$ZBIN/micro"; assert "$micro" is_executable
-  $micro --version; assert $state equals 0
+  run $micro --version; assert $state equals 0
 }
 @test 'miniserve' { # For when you really just want to serve some files over HTTP right now!
   [[ $OSTYPE =~ 'darwin*' ]] && skip "skipped on $os_type"
@@ -545,27 +550,27 @@ $kopia --version; assert $state equals 0
 @test 'mkcert' { # A simple zero-config tool to make locally trusted development certificates
   run zinit lbin'!* -> mkcert' for @FiloSottile/mkcert; assert $state equals 0
   local mkcert="$ZBIN/mkcert"; assert "$mkcert" is_executable
-  $mkcert --version; assert $state equals 0
+  run $mkcert --version; assert $state equals 0
 }
 @test 'mmake' { # A Make/rake-like dev tool using Go
   run zinit for ver'v1.4.0' @tj/mmake; assert $state equals 0
   local mmake="$ZBIN/mmake"; assert "$mmake" is_executable
-  $mmake --version; assert $state equals 0
+  run $mmake --version; assert $state equals 0
 }
 @test 'mmv' { # rename multiple files with editor
   run zinit for @itchyny/mmv; assert $state equals 0
   local mmv="$ZBIN/mmv"; assert "$mmv" is_executable
-  $mmv --version; assert $state equals 0
+  run $mmv --version; assert $state equals 0
 }
 @test 'mob' { # rename multiple files with editor
   run zinit for @remotemobprogramming/mob; assert $state equals 0
   local mob="$ZBIN/mob"; assert "$mob" is_executable
-  $mob --version; assert $state equals 0
+  run $mob --version; assert $state equals 0
 }
 @test 'mocword' { # Predict next words
   run zinit lbin'!**/mocword* -> mocword' for @high-moctane/mocword; assert $state equals 0
   local mocword="$ZBIN/mocword"; assert "$mocword" is_executable
-  $mocword --version; assert $state equals 0
+  run $mocword --version; assert $state equals 0
 }
 @test 'monolith' { # CLI tool for saving complete web pages as a single HTML file
   [[ $OSTYPE =~ 'darwin*' ]] && skip "skipped on $os_type"
@@ -576,22 +581,22 @@ $kopia --version; assert $state equals 0
 @test 'moonwalk' { # Cover your tracks during Linux Exploitation by leaving zero traces on system logs and filesystem timestamps
   run zinit lbin'!**/moonwalk* -> moonwalk' for @mufeedvh/moonwalk; assert $state equals 0
   local moonwalk="$ZBIN/moonwalk"; assert "$moonwalk" is_executable
-  $moonwalk --version; assert $state equals 0
+  run $moonwalk --version; assert $state equals 0
 }
-@test 'navi' { # Declarative, asynchronous routing for React
-  run zinit for @denisidoro/navi && assert $state equals 0
-  local navi="$ZBIN/navi" && assert "$navi" is_executable
-  $navi --version && assert $state equals 0
+@test 'navi' { # An interactive cheatsheet tool for the command-line
+  run zinit lbin'* -> navi' for @denisidoro/navi; assert $state equals 0
+  local navi="$ZBIN/navi"; assert "$navi" is_executable
+  run $navi --version; assert $state equals 0
 }
 @test 'onefetch' { # Git repository summary on your terminal
   run zinit for @o2sh/onefetch; assert $state equals 0
   local onefetch="$ZBIN/onefetch"; assert "$onefetch" is_executable
-  $onefetch --version; assert $state equals 0
+  run $onefetch --version; assert $state equals 0
 }
 @test 'ouch' { # Painless compression and decompression for your terminal
   run zinit for @ouch-org/ouch; assert $state equals 0
   local ouch="$ZBIN/ouch"; assert "$ouch" is_executable
-  run "$ouch" --help; assert $state equals 0
+  run "$ouch" --version; assert $state equals 0
 }
 @test 'pastel' { # A command-line tool to generate, analyze, convert and manipulate colors
   run zinit for @sharkdp/pastel; assert $state equals 0
@@ -729,22 +734,22 @@ $kopia --version; assert $state equals 0
 @test 'tokei' { # Count your code, quickly.
   run zinit lbin'!*tokei -> tokei' ver'v12.1.1' for @XAMPPRocky/tokei; assert $state equals 0
   local tokei="$ZBIN/tokei"; assert "$tokei" is_executable
-  $tokei --version; assert $state equals 0
+  run $tokei --version; assert $state equals 0
 }
 @test 'topgrade' { # Upgrade everything
   run zinit for @r-darwish/topgrade; assert $state equals 0
   local topgrade="$ZBIN/topgrade"; assert "$topgrade" is_executable
-  $topgrade --version; assert $state equals 0
+  run $topgrade --version; assert $state equals 0
 }
 @test 'tre' { # Tree command, improved
   run zinit for @dduan/tre; assert $state equals 0
   local tre="$ZBIN/tre"; assert "$tre" is_executable
-  $tre --version; assert $state equals 0
+  run $tre --version; assert $state equals 0
 }
 @test 'tv' { # A cross-platform CLI csv pretty printer that uses column styling to maximize viewer enjoyment
   run zinit for @uzimaru0000/tv; assert $state equals 0
   local tv="$ZBIN/tv"; assert "$tv" is_executable
-  $tv --version; assert $state equals 0
+  run $tv --version; assert $state equals 0
 }
 @test 'up' { # Deploy infinitely scalable serverless apps, apis, and sites in seconds to AWS
   run zinit lbin'!up* -> up' for akavel/up; assert $state equals 0
@@ -753,7 +758,8 @@ $kopia --version; assert $state equals 0
 }
 @test 'volta-cli' { # JS Toolchains as Code
   [[ "$OSTYPE" =~ 'linux*' ]] && skip 'Volta CLI skipped on Linux'
-  run zinit for @volta-cli/volta; assert $state equals 0
+  export VOLTA_HOME="${ZPFX}/bin"
+  run zinit lbin'volta;volta-migrate' for @volta-cli/volta; assert $state equals 0
   local volta="$ZBIN/volta"; assert "$volta" is_executable
   run $volta --version; assert $state equals 0
 }
@@ -791,7 +797,7 @@ $kopia --version; assert $state equals 0
   [[ $OSTYPE =~ 'linux*' ]] && skip 'Yabai skipped on Linux'
   run zinit for @koekeishiya/yabai; assert $state equals 0
   local yabai="$ZBIN/yabai"; assert "$yabai" is_executable
-  $yabai --version; assert $state equals 0
+  run $yabai --version; assert $state equals 0
 }
 @test 'yq' { # a portable command-line YAML, JSON and XML processor
   run zinit lbin'!* -> yq' for @mikefarah/yq; assert $state equals 0
diff --git a/zinit-install.zsh b/zinit-install.zsh
index 14fb11eac..3cb0dc844 100644
--- a/zinit-install.zsh
+++ b/zinit-install.zsh
@@ -1478,8 +1478,8 @@ builtin source "${ZINIT[BIN_DIR]}/zinit-side.zsh" || {
 } # ]]]
 # FUNCTION: .zi::get-architecture [[[
 .zi::get-architecture () {
-  emulate -LR zsh
-  setopt extendedglob noshortloops nowarncreateglobal rcquotes typesetsilent
+  emulate -L zsh
+  setopt extendedglob noshortloops nowarncreateglobal rcquotes
   local _clib="gnu" _cpu="$(uname -m)" _os="$(uname -s)" _sys=""
   case "$_os" in
     (Darwin)
@@ -1490,11 +1490,7 @@ builtin source "${ZINIT[BIN_DIR]}/zinit-side.zsh" || {
       fi
       ;;
     (Linux)
-      if [[ -n /lib/*musl*(#qN) ]] || (( ${+commands[musl-gcc]} )); then
-        _sys='(linux[\-\_])*~^*((gnu|musl)[\-\_\.])'
-      else
-        _sys='(linux[\-\_])*~^*(gnu[\-\_\.])'
-      fi
+      _sys='(musl|gnu)*~^*(unknown|)linux*'
       ;;
     (MINGW* | MSYS* | CYGWIN* | Windows_NT)
       _sys='pc-windows-gnu'
@@ -1559,13 +1555,17 @@ builtin source "${ZINIT[BIN_DIR]}/zinit-side.zsh" || {
       fi
     fi
 
-    local junk="([3-6]86|md5|sig|asc|txt|vsix|sum|sha256*|pkg|.(apk|deb|json|rpm|sh(#e)))"
+    local junk="(md5|sig|asc|txt|vsix|sum|sha256*|pkg|.(apk|deb|json|rpm|sh(#e)))"
     filtered=( ${list[@]:#(#i)*${~junk}*} ) && (( $#filtered > 0 )) && list=( ${filtered[@]} )
 
+    local -a array=( $(print -rm "*($(arch)|${VENDOR}|)*~^*(${parts[1]}|${(L)$(uname)})*" $list[@]) )
+    (( ${#array} > 0 )) && list=( ${array[@]} )
+    +zi-log -- "{dbg} filtered ${#filtered} to ${#array} release assets"
+
+    +zi-log -- "{dbg}${(@pj:\n  - :)list[1,2]}{nl}"
     for part in "${parts[@]}"; do
       if (( $#list > 1 )); then
         filtered=( ${(M)list[@]:#(#i)*${~part}*} ) && (( $#filtered > 0 )) && list=( ${filtered[@]} )
-        # +zi-log "{info}[{pre}gh-r{info}]{rst} filter -> {glob}${part}{rst}{nl}  - ${(@pj:\n  - :)list[1,2]}{nl}"
       else
         break
       fi