Sources
A source is where versions come from. Each dependency has one, chosen by its manager, and rules can select by it.
| Source | Package identity | Where versions come from |
|---|---|---|
npm |
package name | the npm registry, full metadata for publication times, dist-tags and deprecations |
crates |
crate name | the crates.io sparse index, with publication times; yanked releases are skipped |
go |
module path | the Go module proxy (@v/list, and .info once for each version it has not dated yet) |
pypi |
normalised name | the PyPI JSON API, falling back to the PEP 691 simple API |
docker |
image | registry v2 tags and manifests on Docker Hub, GHCR and other registries |
oci |
registry/chart |
OCI registry tags for Helm charts |
helm |
https://repo|chart |
the repository’s index.yaml |
terraform |
namespace/provider or namespace/module/system |
the public Terraform registry |
github-releases, github-tags |
owner/repo |
GitHub, through mise-versions when it can |
github-runners |
runner family | a catalog of GitHub-hosted runner labels |
forge-tags |
host/path |
GitLab and Gitea/Forgejo tags, for pre-commit hooks and GitLab CI includes and components |
mise |
tool name, as written in mise.toml |
mise ls-remote --json, run by the Count’s pinned mise (mise lookups) |
maven |
group:artifact |
maven-metadata.xml on Maven Central, Google Maven or the Gradle plugin portal; each POM’s Last-Modified, read once per version, dates it |
nuget |
package ID | the nuget.org flat container and every registration page, for dates and unlisted and deprecated flags |
rubygems |
gem name | the RubyGems versions API |
packagist |
vendor/name |
Packagist’s p2 metadata |
Fetching less
Section titled “Fetching less”Every response is stored with its validators, and every repeat request is
conditional. Unauthenticated registries honour their declared max-age. Go proxy
lists and validator-free OCI tag pages get a one-hour local freshness floor
(http.goFreshnessSecs and http.registryFreshnessSecs in the
settings; 0 restores upstream behaviour), because those endpoints would otherwise be read on every run.
OSV advisory listings get the same: http.advisoryFreshnessSecs (one hour by
default) keeps a version’s listed advisories local, so only stale or missing
queries are posted. A new advisory for a version already in use can go unseen
until the listing expires; 0 asks OSV on every run.
GitHub histories are read in pieces:
- A cold release history is fetched through batched GraphQL queries, sixteen sources at a time.
- A warm one starts with a conditional REST read of the newest releases. Only the fields that matter (tag, date, draft, prerelease) feed the fingerprint, so a download counter changing does not trigger a refetch.
- When the head did change, history is read newest first and merged into the cache until a known release turns up.
- Tags use one conditional read of the matching refs, then hydrate only new or moved tags.
A history-head check cannot see a release deleted or edited behind an unchanged head. Webhook invalidation or periodic reconciliation covers that.
mise lookups
Section titled “mise lookups”A mise dependency’s versions are what mise ls-remote --json --prerelease <tool> prints, so every backend mise reads release metadata from works, and
the Count keeps no copy of mise’s registry or backend rules. mise lists a
version, its date, whether it is a prerelease and, for GitHub-hosted tools, a
release URL. Backends leave out what they do not know: Node lists a date only,
and some go: versions have no date and so no release-age wait. Prereleases
are listed, and the Count’s prerelease rules decide
whether to offer them. A version mise marks prerelease, such as a GitHub
release flagged as one, counts as a prerelease even when it looks stable, just
as it does for github-releases.
The Count runs mise the way he runs the lockfile tools, and more strictly:
- With his own pinned mise from the tool store, not yours.
- From a new, empty directory for each lookup, with a scratch
HOMEand nothing inherited from the Count’s environment. mise loads no configuration (MISE_NO_CONFIG), env templates (MISE_NO_ENV) or hooks (MISE_NO_HOOKS), so neither your global configuration nor a repository’smise.tomlcan apply. - With the tool’s options passed on as mise reads them, in brackets on the
tool argument: the options in its table, sorted and written one way, or the
brackets on its name as written (an entry with both is refused). mise
applies them as it does when it installs; nothing installs, so options that
only matter then never run. mise does not merge a tool’s options across
configuration files (the highest-precedence file’s entry replaces the
others whole), so each entry goes with its own. Every version in an array
goes with the first one’s options, as mise lists the tool with them. A
task’s tool is refused when it or the tool’s
[tools]entry has options in a table, since mise layers the two by version in a way the Count does not reproduce; brackets on a task tool’s name are part of the tool and pass. - With tool names and options validated first: no leading
-in the name or in any option key or string value, no@outside an npm scope, no@versionselector, length limits, and options only in the Count’s own form (key="value"pairs joined by,) or mise’s plainkey=valueone, whose values must not read as numbers, booleans or dates. - With options that point mise at any host followed, apart from cloud
instance-metadata endpoints: a URL whose host is, or resolves to, a
link-local address (169.254.0.0/16, fe80::/10), AWS’s
fd00:ec2::254,metadata.google.internalormetadatais refused, since those hand out the credentials of the machine the Count runs on and the answer would become versions in a pull request. A host that does not resolve is refused too. mise resolves the name again and follows redirects, so a host that changes its answer or redirects there is not caught; block the metadata endpoint in the network where that matters. - With no AWS credentials for mise’s s3 backend: no
AWS_*variable is inherited, its config and credential files are in the scratch home, andAWS_EC2_METADATA_DISABLEDstops it fetching the machine’s own. - With the backends
asdfandvfoxdisabled (MISE_DISABLE_BACKENDS), and names for them refused before mise starts. A backend prefix mise does not know fails in mise, which runs no plugin for it. Nothing installs during a lookup (MISE_AUTO_INSTALL=0). - With a GitHub token as
MISE_GITHUB_TOKEN, only when he talks to github.com, and no other credential: mise’sghlogin, credential command and Git credential helper lookups are off. As a GitHub App (patchula serve,--all-reposwith App credentials, or an Action run on several repositories) the token is a read-only one he mints for the repository the lookup is for, so a repository’smise.tomlsees only that repository and public tools, never another private repository the App can read. Release notes for a mise tool look it up the same way. With a personal token, or the token of an Action run on its own repository, mise gets that token. A tool’s options can send mise elsewhere (api_urlfor a GitHub Enterprise server, say), and the token goes with them, as it does when mise installs the tool: it is the token of a repository whose own entry wrote those options, never another’s. - With a three-minute limit per lookup and at most four running at once.
What happens to a listing:
- It is cached for an hour, per tool, options, mirror setting and who may
see it. A tool released from another repository, or from a package
registry, lists public data, which every repository shares. A tool released
from the repository itself, or one whose source the Count cannot tell (a
go:orhttp:tool, or any tool with options) in a private repository, is listed for that repository alone. A listing made without a token is public. A manual retry, or a failed lookup, asks mise again. - The Node LTS line comes from
mise ls-remote node lts. When that listing fails or is empty, the catalog stays whole without LTS evidence, so only a dependency on the LTS channel reports it. - A tool installed from a Git ref (
cargo:with a Git URL) lists onlyHEAD, which the Count reports as having no release versions. - Any other listing is kept. Versions that do not order are never proposed, and a pin that does not order is reported as one the Count cannot classify.
- Where there is no release URL, release notes find a tool’s repository from the backend mise picks for it when that is npm, PyPI or crates.io. A tool whose listing and backend name no repository has no release notes.
Package backends and the project’s settings
Section titled “Package backends and the project’s settings”The sandbox lists versions without the project’s configuration, but mise
installs a tool with it. A tool whose backend installs from a package
registry (npm, pypi and pipx, cargo, gem, dotnet, explicitly or
through mise’s registry, as aws-cdk is npm:aws-cdk) fails its lookup
where committed settings could send it elsewhere: registry variables in a
mise configuration’s [env] (NPM_CONFIG_*, PIP_*, UV_*, CARGO_* and
the like, or variables loaded from files through _.file or _.source),
or the project’s own .npmrc or .yarnrc.yml mentioning a registry, any pip.conf or pip.ini, Python
index settings, Cargo registry settings, or NuGet feeds other than
nuget.org’s, in the tool’s folder, above it or below it. Every tool fails
its lookup where a mise configuration there holds
anything but tools, tasks, task_config, vars, env, settings,
min_version, redactions and wrappers, sets a MISE_* variable, or sets anything
but a few plain settings such as experimental and lockfile; where a
.miserc.toml, .miserc.local.toml or .config/miserc.toml exists; or
where the Count cannot read the configuration. Options on the tool’s own
entry do not fail it: they go to mise with the lookup.
A mise configuration is a file under a name mise reads one by, and no
other: mise.toml, .mise.toml and .config/mise.toml; config.toml in a
mise/, .mise/ or .config/mise/ folder; .config/mise/mise.toml; any
TOML file directly in one of those folders’ conf.d/ that is not hidden; and
mise.toml in a folder inside conf.d/. Each counts with its .local,
environment and environment .local variants (mise.local.toml,
mise/config.prod.toml, .mise.ci.local.toml). Other TOML files in those
folders, such as the Cargo.toml of a crate in crates/mise/, are not
configuration.
mise-versions host
Section titled “mise-versions host”By default (useVersionsHost = true), public GitHub repositories that appear in
mise’s registry are read from the public
mise-versions mirror instead of the GitHub API:
releases.json and tags.json, validated by ETag. The mirror dates a tag only
by its release, so when a github-tags lookup finds a tag without one, which
may be an annotated tag with a tagger date, that repository’s tags are read
from GitHub instead. Repositories outside the
registry, including private ones, go straight to GitHub. If the mirror fails
with a transport error, 429 or 5xx, the Count falls back to GitHub; a 403, 404 or
empty list does not, and a truncated list is reported as an incomplete lookup.
mise tools do not use this path: mise reads the mirror itself, and
useVersionsHost = false turns that off too (MISE_USE_VERSIONS_HOST=0). Set
it to read everything upstream.
Registries and limits
Section titled “Registries and limits”Docker Hub, GHCR and GitLab registries use anonymous registry tokens, cached
until shortly before they expire. A token comes from the registry’s own origin,
except Docker Hub’s from auth.docker.io/token, and a GitLab registry’s
(registry.gitlab.com, or registry.<instance> when self-hosted) from its
GitLab instance’s /jwt/auth, including a self-hosted registry on a port of
the instance (gitlab.example.com:5050). A token service anywhere else is
refused before any request reaches it. That includes a token service on
another port of the registry’s host, such as registry:2 with
cesanta/docker_auth on :5001, which therefore does not work.
Authenticated pulls, Docker Hub’s included, use a private
registry entry. When Docker Hub’s ratelimit-remaining
hits zero, queued reads stop. A 429 shares a cooldown across the host and
retries at most three times, honouring Retry-After. If the wait is too long,
the last cached response is used and marked stale in the report; a cold miss is
still an error.
Redirects are followed up to five times, HTTPS only, with credentials stripped when the origin changes.
Private registries
Section titled “Private registries”The operator settings hold credentials for private
registries, keyed by an https URL prefix. Repository configs never name
credentials: a patchula.pkl can point a dependency at any URL, so in the
server it could otherwise read another organisation’s registry. As
hygiene, a repository that commits a credential anyway is refused
outright: the repository’s report is an error and nothing runs for it.
Move the credential to the operator’s registries settings;
${VAR}-style environment references and $() command substitutions
stay allowed, since the secret lives outside the file.
The refusal is hygiene, not a security boundary — only the settings a
tool or a registry lookup reads as a credential are checked, with each
format’s parser so escapes cannot hide one: _authToken, _auth and
_password keys in .npmrc or pnpm-workspace.yaml with literal values;
npmAuthToken and npmAuthIdent in .yarnrc.yml; Composer config auth
keys (http-basic, bearer, github-oauth, gitlab-oauth,
gitlab-token, bitbucket-oauth, forgejo-oauth/forgejo-token,
gitea-oauth/gitea-token); Password and ClearTextPassword in a
nuget.config packageSourceCredentials (%VAR% references allowed);
Poetry http-basic and pypi-token literals in poetry.toml or
pyproject.toml; a Cargo registry token in .cargo/config*; and a URL
carrying a user and password in a field that names a registry, index
or source URL — .npmrc registry/@scope:registry, .yarnrc.yml
npmRegistryServer, pyproject/uv/poetry index and source URLs, Composer
repositories[].url, nuget.config packageSources, pip index URLs,
Gemfile source lines, and Cargo registry index values.
Everything else is left alone: a database DSN in a test script, a
user-only userinfo like https://user@bitbucket.org, .bundle/config
BUNDLE_* keys (no tool of the Count’s reads them), empty values, lockfile
resolved URLs and CI workflows — none of those is a credential a tool
reads, so none refuses a repository.
amends "PatchulaSettings.pkl"
registries { ["https://acme.jfrog.io/artifactory/api/helm/charts"] { auth = "bearer" secret { env = "ARTIFACTORY_TOKEN" } } ["https://acme.jfrog.io"] { auth = "basic" username = "ci-bot" secret { file = "/run/secrets/artifactory" } } ["https://registry-1.docker.io"] { auth = "basic" username = "acme" secret { env = "DOCKERHUB_TOKEN" } }}- A request whose URL is under a prefix, matched by whole path segments on the same origin, carries that entry’s credentials. The longest prefix wins.
bearersends the secret as a bearer token.basicsends the username and the secret to the URLs under the prefix, including a container registry’s first request. When a registry with an entry answers with a token service instead, the Count exchanges credentials there for a pull token: the registry’s own at a token service on its origin, Docker Hub’sauth.docker.io, orgitlab.comforregistry.gitlab.com, and otherwise only a token service’s own entry. A self-hosted GitLab registry needs entries for both the registry and its GitLab’s/jwt/auth. A registry without an entry only ever gets anonymous tokens. Tokens issued to an account stay in memory, and within the entry’s prefix.- A secret comes from an environment variable or a file, never the settings file. The server reads secrets again for every batch, so a rotated secret applies without a restart; one it cannot read is logged, and requests under that prefix carry no credentials, not even a broader entry’s. The CLI stops with a usage error instead.
- Responses read with credentials are cached under their entry and a one-way digest of its credentials, so a read without that entry, or after the secret or account changes, never sees them.
- In the server, an entry’s
allowedInstallationslimits which installations use it. For any other installation, requests under its prefix carry no credentials. - A redirect carries credentials only to a URL an entry covers, and only from a request that sent some: a request without credentials never gains any on a redirect. A token issued under an entry stays within that entry’s prefix.
A dependency’s source decides where its versions come from. Helm repositories,
OCI and Docker registries, Maven repositories and GitLab, Gitea or Forgejo tags carry
their URL, so a private one works with an entry. npm and Python dependencies
can name their own package registry. The other package
registries still read their public registry, or its mirror. Lockfile tools get
registry credentials only from entries that set tools = true; see
lockfiles for the
forms each tool takes and what that exposes.
Package registries
Section titled “Package registries”A dependency can come from a registry of its own instead of its source’s
public one. The repository says which, and the report shows it as the
dependency’s registry:
-
npm reads
.npmrcfiles at or above eachpackage.json:@scope:registry=for a scope, elseregistry=for every package, each from the nearest file that sets it. Yarn Berry’snpmRegistryServerin.yarnrc.yml, at the top level and undernpmScopes, works the same and wins over.npmrcin the same directory. A file that names no registry does not hide one further up. Packages only a lockfile records get the same registry as a declared one would.packageManagerstays on the public registry, since Corepack does not read.npmrc. -
Ruby gems come from what
Gemfile.lockrecords and what the Gemfile says. A Gemfile is Ruby, so the Count reads it only when every line is a plainsource,gem,group,platforms,gemspec,rubyorendwith literal values. Then each gem comes from itssource:option, else thesourceblock around it, else the one top-levelsource, and whereGemfile.lockrecords the gem too, the two must agree. A Gemfile with any other line, such as a condition, agit_source, aneval_gemfileor agemcontinued onto a second line, or with several top-level sources, leaves it to theremote:the lock records. A gem neither settles fails its lookup, saying it could come from several sources: commitGemfile.lock. A project.bundle/configwith a setting that could move gems, such as a mirror orBUNDLE_GEMFILE, fails every lookup. Gems from git, a path or GitHub are listed as skipped. Private gem sources are not read yet, so their gems’ lookups fail rather than read RubyGems. -
PHP packages come from what
composer.lockrecords. Composer marks a package from a Composer registry with the registry’snotification-url, Packagist’s beinghttps://packagist.org/downloads/; a package with another registry’s mark fails its lookup, since private Composer repositories are not read yet. Packages from apath, VCS, inlinepackageor artifact repository are listed as skipped. A package the lock does not record comes from Packagist only whencomposer.jsonconfigures no other repository, leaves Packagist on without filters such asexclude, and uses no merge plugin, and the lock holds no Composer plugin, since plugins can add repositories; otherwise its lookup fails: commitcomposer.lock. Withconfig.lockset to false, Composer and the Count ignore the lock. Acomposer.jsonwith comments, which Composer does not read, or a lock the Count cannot read, fails every lookup. -
NuGet packages come from nuget.org only when NuGet could not take them from anywhere else.
packages.lock.jsondoes not record a package’s source, and with several sources NuGet takes a package from whichever answers, so thenuget.configfiles from the project’s folder up to the repository root decide. Every source they add counts, even one a closer config clears or disables, along with the nuget.org source NuGet adds by default. With nuget.org alone, every package comes from it. With another source,packageSourceMappingmust say which source serves each package, from one config alone: its most specific pattern (an exact ID, else the longest prefix) decides. Mappings in several configs, which NuGet merges in ways the Count does not follow, fail every lookup. A package mapped to nuget.org alone comes from there; any other fails its lookup, since private NuGet feeds are not read yet. Adotnet-tools.jsonmanifest counts every folder below it with a config of its own, and a shared MSBuild file such asDirectory.Packages.props, which can be imported from anywhere, counts every folder with one. Anything NuGet could read differently fails every lookup it could affect: a config the Count cannot read, with a section it does not know such asfallbackPackageFolders, withremove, or with a pattern other than an ID or a prefix ending in its only*; a config spelled other thannuget.config,NuGet.configorNuGet.Config; a source or mapping key with spaces around it or outside ASCII; and an MSBuild file that setsRestoreSources,RestoreAdditionalProjectSources,RestoreConfigFile,RestoreFallbackFolders,RestoreRootConfigDirectoryorRestoreSolutionDirectory, or that the Count cannot read. -
Crates come from crates.io unless a dependency names another registry, since Cargo never looks a crate up anywhere else; one from an alternate registry, git or a path is listed as skipped. A
.cargo/config.tomlor.cargo/configin the crate’s folder or above that replaces crates.io with another source fails its crates.io lookups, sinceCargo.lockrecords crates.io for a replaced crate all the same; a vendoreddirectorysource, ascargo vendorsets up, keeps crates.io’s crates and is fine. Cargo reads configuration from wherever it runs, so one anywhere in the crate’s workspace counts. A configuration the Count cannot read, or one that includes others, fails them too, and so does a[patch]or[replace]entry taking a crate from another registry, in the crate’s manifest, any manifest above it or an applying configuration, since it can stand for any crate under any name Cargo takes for it. -
Go modules are looked up on
proxy.golang.org. A module path names the place its code is served from, so the proxy cannot serve someone else’s code under a private path; which paths are private isGOPRIVATEin the environment, which no committed file sets, so a private module’s path does reach the proxy in its lookup. Modules areplacedirective names are skipped; see Go. -
Maven and Gradle artifacts come from Maven Central (or Google’s Maven repository for Android groups, and the Gradle Plugin Portal for plugins) only when no build file in the repository could take them from anywhere else. Neither tool records which repository served an artifact, and both try repositories in order, so the Count does not work out which one an artifact comes from: any other repository anywhere fails every lookup of that build system, since private Maven repositories are not read yet. For Maven, that is a
repository,pluginRepositoryormirrorother than Central’s or Google’s in any POM or profile (including POMs a<module>, a parent’s<relativePath>or.mvn/maven.confignames), or in any file named*settings.xmlin the repository or named by.mvn/maven.config; one indistributionManagementdoes not count. For Gradle, the Count reads every script, the sources inbuildSrc,build-logic,build-conventionsandgradle/plugins, and everything the settings include and the scripts apply.mavenCentral(),google(),gradlePluginPortal()andjcenter()are fine, without a body, whilemaven,ivy,flatDir,mavenLocal,exclusiveContentor a customArtifactRepositoryoutside apublishingblock fails every lookup — the Count does not weighcontentfilters orexclusiveContent, so even a repository bounded to named groups fails them all — as dorepositories.allandrepositories.add, build logic the Count cannot read, anincludeBuildoutside the settings or with a computed name, and anapply fromother than a plain path,file(…),rootProject.file(…), or a path under$rootDiror$projectDir. A build whose lookups fail says so once, in a warning naming the file and, where the Count reads it, the repository’s address, rather than once per dependency. Repositories that a Gradle plugin, a Maven build extension, an init script or a CI machine’s own settings add are not in the repository’s files, so the Count does not see them; Maven Central and the Gradle Plugin Portal check who owns a group or plugin ID, which keeps someone else from publishing your coordinates there. -
Python packages come from what the project’s lockfile records. The Count does not work out which index uv or Poetry would pick from their settings; the tool already did, and wrote it down:
uv.lockrecords each package’s index; uv reads the one at its workspace root (the nearest whosemembersname the project and whoseexcludeleaves it in), or the project’s own outside a workspace.poetry.lockrecords each package’s source, and nothing for PyPI.- A lock above the project that belongs to another one does not count,
nor does a workspace member’s own
uv.lock. A package whose entries disagree, within one lockfile or betweenuv.lockandpoetry.lock, is ambiguous.
A package no lockfile records is PyPI’s only when the project configures no index at all: no index,
index-url,extra-index-url,find-links,no-indexortorch-backendin anyuv.tomlor[tool.uv](its[pip]table included) at or above it, no index pins in[tool.uv.sources], no override naming a URL, and no Poetry source or dependency pinned to one. Otherwise its lookup fails, saying it could come from several registries: commit a lockfile that records it. That is how a public package could otherwise stand in for a private one of the same name.A lockfile can be stale, recording PyPI for a package the project now takes from a private index. The update itself then runs the real
uv lockorpoetry lockwith the project’s settings, which resolves from the index the tool actually uses, so it never installs the public package in its place.A package from git, a path, a URL or a workspace member, by
[tool.uv.sources], a Poetry dependency, aname @ urlrequirement or the lockfile, is not looked up at all: its name on PyPI may be someone else’s. It is reported as skipped instead.Everything the Count cannot read fails closed, for every package, locked or not. Every setting uv accepts is either one that configures an index or known not to, and every key a Poetry source or dependency may have is known; tests check both lists against uv and Poetry themselves. A key the Count does not know, a section that does not fit, a
pyproject.toml,uv.tomlor lockfile that does not parse, a settings file it cannot read (such as one behind a symlink), or workspace globs it might read differently from uv make every lookup fail. So do index settings of tools the Count cannot check against the tool, in anypyproject.tomlat or above the project or inpdm.toml,pixi.tomlorhatch.toml: PDM sources and overrides, Rye sources, Pixi PyPI options, and Hatch installer flags orPIP_*andUV_*variables. Indexes come only from these files, never frompip.conf,PIP_*orUV_*variables, Dockerfiles or CI workflows. Private indexes are read through their simple API, as PEP 691 JSON or PEP 503 HTML; HTML gives no upload times, so no release-age wait.pip requirements files are not maintained at all; see managers.
-
An npm or PyPI custom extractor can set
registry, a template such as"{registry}"; an empty or unmatched capture means the public registry. Without it, npm packages follow.npmrclike apackage.jsonbeside them.
.npmrc and .yarnrc.yml are read whenever npm, Bun or an npm extractor is
enabled, and every pyproject.toml, uv.toml, uv.lock and poetry.lock
whenever pyproject is, with pdm.toml, pixi.toml and hatch.toml. files
and exclude do not limit these. Bun’s
bunfig.toml and Yarn 1’s .yarnrc are not read yet: a registry set only
there is not used.
npm’s, Yarn’s and PyPI’s public registries (registry.npmjs.org,
registry.yarnpkg.com, pypi.org, over https or plain http) count as none. A value the Count cannot read from,
such as a ${VAR} npm would take from the environment or a plain-http URL, is
recorded instead: that package’s lookup fails, rather than reading the public
package of its name, which may be someone else’s. Any user, password, query
or fragment is removed from it first, and a URL that does not parse cleanly
is recorded only as <unreadable URL>. A token in the path of a URL, as some
hosted registries issue, looks like any other path and is recorded; keep such
URLs in the operator’s registry settings rather than the repository.
A repository naming a registry never brings credentials: requests to it carry an operator entry’s, when one covers its URL, and nothing otherwise. Two packages with the same name from different registries are separate dependencies, with separate lookups and branches. A package from its own registry gets no advisories and no release notes, since the public package of that name is a different package.
Mirrors
Section titled “Mirrors”Where the public registries are out of reach, or should only be read through
a proxy such as an Artifactory remote repository or a Nexus proxy, an entry
can stand in for one with mirrorOf:
registries { ["https://acme.jfrog.io/artifactory/api/npm/npm-remote"] { auth = "bearer" secret { env = "ARTIFACTORY_TOKEN" } mirrorOf = "https://registry.npmjs.org" } ["https://nexus.acme.dev/repository/go-proxy"] { mirrorOf = "https://proxy.golang.org" }}- A request under the
mirrorOfprefix goes to the entry’s prefix instead, with the rest of the URL unchanged, and carries the entry’s credentials if it hasauth. An entry withoutauthsends none. - There is no fallback: when the mirror fails, the lookup fails.
- Dependencies keep their public identity, so branches, rules and the dashboard do not change when a mirror is added or removed. Responses are cached under the mirror’s entry.
- The mirror must serve the same paths as the registry it stands in for. A mirror that serves only part of an API, such as PyPI’s simple index but not its JSON API, covers only the prefix it names; the rest is still read from the public registry.
- Container registries are not mirrored: their token services belong to the registry’s own host.
- Release notes and advisories come from GitHub and OSV.dev, not the registry, and are not mirrored.
Dates and release age
Section titled “Dates and release age”Publication dates feed the release-age wait. Go dates
releases through the proxy’s .info documents, only for the 20 newest on a cold
lookup, since a module can list hundreds and older releases are outside any
wait; versions the proxy lists but cannot describe are dropped. npm, crates,
PyPI, RubyGems, NuGet and Packagist report them directly. Maven Central’s search
API lags by months, so Maven uses each POM’s Last-Modified header, for the ten
newest versions only. GitHub tags are dated as the release-age
wait describes. mise tools use the
date mise lists, which is a backend’s own release or publication date. GitLab
tags use the annotated tag’s date. Lightweight GitLab tags, Gitea and Forgejo
tags, and hosted runner labels are undated and have no wait.
Where release notes look for each dependency’s repository is under finding the upstream.
© 2026 Sweepy
