Skip to main content
ZeroPath’s SCA analyzers recognize the following ecosystems out of the box:

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)

Every dependency record tracks whether ZeroPath saw it declared directly or pulled in transitively, so you can apply different policies to first-party choices and vendor libraries. Development and optional dependencies declared in your manifests are inventoried too; reachability helps separate runtime-relevant findings from dev-only noise.

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

For every ecosystem marked Direct deps only, a missing lockfile means transitive dependencies aren’t resolved and range specifiers stay ambiguous, so transitive vulnerability matching and SBOM completeness suffer. ZeroPath still records your direct dependencies and flags the manifest with a Transitive dependencies unresolved warning so the gap is visible. See Coverage & warnings for how to clear it, including the commands to generate each lockfile.
For npm/Yarn/pnpm, Maven, and a fully ==-pinned requirements.txt, a committed lockfile is optional — it only makes scans faster and more deterministic.

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

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.
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.
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.
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.
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.
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.
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.
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.
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 (both dependencies and optional-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.