npm / Yarn / pnpm
PyPI
Go modules
Maven / Gradle / SBT / Ivy
NuGet
RubyGems
crates.io (Cargo)
Packagist / Composer
Hex (Elixir)
Pub (Dart/Flutter)
Swift
Haskell (Hackage)
R (CRAN)
How resolution works
ZeroPath resolves your dependency graph directly from your manifests wherever it can. It also uses committed lockfiles and native build-tool resolution for supported ecosystems. The practical contract is per-ecosystem, summarized in the table below. Two rules hold everywhere:- Direct dependencies can still be scanned when the transitive graph can’t be built, as described below. Native Ivy requires a complete resolution; a failure leaves that manifest unscanned and produces a coverage warning.
- Unknown versions aren’t guessed. If a version can’t be determined, for example an unresolved range or a broken parent chain, the package is still recorded in your inventory and SBOM but is not vulnerability-matched. This avoids false positives from guessed versions.
Private packages? Connect npm registries
or follow the Maven, Gradle, and sbt setup guide.
Maven and Gradle share a connection; sbt needs its own. Run a new scan after
connecting and check coverage.
Coverage without a committed lockfile
Compiled & vendored artifacts
Binary JVM artifacts committed to your repository, such as JARs and WARs, are scanned for the packages embedded inside them. Those packages appear in your inventory alongside source-declared dependencies, with a Compiled source-type badge (e.g. JAR, WAR), so you can see vendored or pre-built libraries that manifest-only analysis would miss. The Dependencies inventory lets you filter by Source Type to isolate compiled vs. source-declared findings.Ecosystem notes
pnpm workspaces
pnpm workspaces
Commit the workspace’s
pnpm-lock.yaml and the member manifests it covers.
ZeroPath reads the project dependencies from supported pnpm lockfiles,
including lockfiles with a separate configuration document. If declared
dependencies are missing from the lockfile, check
coverage warnings and regenerate it.Go modules
Go modules
ZeroPath handles the
+incompatible suffix used by pre-module Go packages
(major version 2+), matching versions like v3.2.0+incompatible to known
advisories. Go pseudo-versions (e.g. v0.0.0-20231215084216-abcdef123456) are
commit snapshots, not published releases, so ZeroPath records them in inventory
but doesn’t attempt advisory version-matching on them.Maven
Maven
Multi-module (reactor) builds are fully resolved: ZeroPath indexes every POM
in the repository and resolves
<parent> references across modules even when
<relativePath/> is empty or absent, so a child can inherit
<dependencyManagement> versions from a sibling’s parent. Parent POMs that
declare dependencies only in <dependencyManagement> are captured, and
classifier-bearing artifacts are attributed to the correct package. When a
parent POM can’t be resolved locally or remotely, versions inherited through
that chain are treated as unresolved rather than guessed.Gradle
Gradle
Beyond plain
build.gradle(.kts) declarations, ZeroPath also recognizes
dependencies declared through version catalogs (libs.versions.toml),
convention plugins, platform/BOM constraints, and the Kotlin DSL. Transitives
can come from native Gradle resolution or a committed gradle.lockfile.
For private libraries or plugins, configure the
Maven / Gradle connection.If a build plugin requires newer Java, ZeroPath can retry resolution with
an installed JDK that supports both the plugin and your Gradle version.
If there is no compatible JDK, check the resolution warning.Ivy
Ivy
ZeroPath resolves
ivy.xml with native Ivy, preserving selected versions,
configuration mappings, inherited descriptors, exclusions and transitive
dependency paths. Packages use Maven organisation:module identities.
This works with standard and next-gen SCA. Resolution reads dependency
metadata without compiling the project or downloading dependency JARs.
Colocated ivysettings.xml supports Maven, URL, filesystem, chain and dual
resolvers, including settings includes and property files. Local files must
stay within the repository. Ant targets, custom plugins, SSH/SFTP resolvers
and properties computed by a build are unsupported and produce a coverage
warning. Ivy files are not updated by the Maven upgrade patcher.Maven registry connections also provide
credentials for private Ivy repositories.SBT (Scala)
SBT (Scala)
ZeroPath records direct dependencies from
build.sbt and can resolve
transitives with native sbt. It also parses committed lockfiles: build.sbt.lock
(sbt-dependency-lock) or
lock.sbt (sbt-lock).
Connect private libraries and build plugins through the separate
sbt connection. Check coverage warnings
if the build or dependency resolution fails.Native sbt resolution preserves full published artifact IDs, including Scala
binary suffixes (for example, org.typelevel:cats-core_2.13). This ensures
advisory matching uses the exact Maven coordinate the advisory was filed
against, rather than a stripped name that could match the wrong package.NuGet
NuGet
Package ids are matched case-insensitively, so casing differences between a
manifest and the registry never cause a miss. Opt into NuGet lockfile mode and
commit
packages.lock.json (dotnet restore --use-lock-file --force-evaluate,
NuGet 4.9+) for transitive coverage.Cargo (Rust)
Cargo (Rust)
Binary crates commit
Cargo.lock by default, and ZeroPath uses it directly.
Library crates commonly omit it (per Cargo’s guidance); commit
Cargo.lock (cargo generate-lockfile) for transitive coverage. A crate that
resolves to multiple versions in the same graph is reported as separate
(name, version) pairs, so each one reaches advisory matching.Python manifest formats
Python manifest formats
All common formats are supported:
- requirements.txt — standard pip format
- Pipfile — Pipenv (
[packages]/[dev-packages]) - pyproject.toml (Poetry) — including 1.2+ group dependencies
- pyproject.toml (PEP 621) — the
[project]table used by uv, hatch, flit, setuptools, and pdm (bothdependenciesandoptional-dependencies)
Every finding records a package’s place in the graph (direct or transitive) and
the chain that introduced it, and links back to the exact manifest file and line
where the dependency was declared rather than the lockfile. A package reached
through multiple dependency paths is deduplicated into a single inventory entry,
so counts reflect unique packages. See Blast radius for how
the dependency chain becomes call-site impact during an upgrade.