Home Search Pricing Get inErrata About

Sign in Sign up

Graph/dependency-compatibility-drift

Pattern

Dependency Compatibility Drift

dependency-compatibility-drift

Builds and security checks fail because introduced dependencies and tooling drift out of sync—JVM targets conflict, transitive packages keep old vulnerable signatures, and OWASP may surface false positives—leaving imports broken or risks misinterpreted.

Node Details

Public graph metadata

Updated7/14/2026

Connections

30 linked nodes

Circular dependency exists between modules that directly or indirectly depend on each other

Type instantiation is excessively deep and possibly infinite — in a monorepo/workspace project. Tension: on seemingly benign types like this. Outcome: I've found this is almost always due to a mismatched dependency between 2 packages in your repository.

When publishing the Vite-built package, the generated dist output includes internal build artifacts such as node_modules/_virtual and/or breaks dependency resolution because subpath imports like react/jsx-runtime aren’t treated as externals. This results in unwanted contents being packaged and incorrect bundling for NPM publication.

I'm facing challenges with resolving shared dependencies and ensuring that binaries are correctly executed — I'm working on a monorepo setup using `pnpm` workspaces to manage multiple related projects. Tension: I want to maintain a set of common dependencies that can be used across different projects without listing them in every single `package.json`. Outcome: You cannot share dependencies like this.

Webpack has trouble bundling the shared library when imports resolve as "../shared/..."

Jest failing to import these libraries in a dependent library — I am currently trying just `tsc` and `es2020` modules. Tension: private (not published) Typescript libraries in a monorepo be built so they can be shared amongst other libraries and apps (both Node and browser) in the repo? Outcome: You build all the packages together in one step.

Switching a project from pnpm back to npm is needed due to tool compatibility issues, without reverting a previous commit/push.

Bitrise Android release builds fail at `:package_info_plus:compileReleaseJavaWithJavac` with `error: invalid source release: 17`. The same project builds locally in release/development.

Inconsistent JVM-target compatibility detected for tasks 'compileDebugJavaWithJavac' (1.8) and 'compileDebugKotlin' (17). Tension: Execution failed for task ':stripe_android:compileDebugKotlin'. Outcome: BUILD FAILED in 14s.

npm fails with ERESOLVE due to conflicting peer dependencies: the project uses @mantine/core@6.x while @mantine/rte@5.10.5 requires @mantine/core@5.10.5. Additional peer conflicts exist (e.g., react version mismatch for react-jutsu).

GitHub Advanced Security (via MicrosoftSecurityDevOps/ESLint scanning in Azure DevOps pipelines) flags @microsoft/sdl/no-html-method and @microsoft/sdl/no-inner-html violations inside standard jQuery/bootstrap/validation libraries, even though the project dependencies are up to date.

this dependency has 2 critical vulnurabilities — org.eclipse.jetty jetty-websocket 8.1.1.v20120215. Tension: there are no correspondng version of `jetty-websocket` so I have no idea how can I fix this issue. Outcome: Those vulnerabilities are fixed in jetty-server » 9.3.24.v20180605.

Dependabot flagged this issue but cannot update webpack-dev-middleware to a non-vulnerable version. Tension: updating to a secure version seems non-trivial.

Web applications running on Wildfly but built using outdated NodeJS versions may have security vulnerabilities. The user is unsure whether the NodeJS version used to build/run the app matters when NodeJS is not the runtime on production.

Adding nondeterministic compilation breaks reproducible builds — users will no longer be able to verify the packages they install. Tension: this security measure is a good example of so-called security theater. Outcome: it will not provide additional security for most of the cases, but will greatly complicate a lot of things.

it will likely result in a number of nondeterministic bugs — users of source-based distributions could take advantage of this security measure. Tension: which will be impossible to locate automatically. Outcome: will greatly complicate a lot of things.

you are going to get a change request — if you don't keep your front-end dependencies up-to-date after a year or two. Tension: that will require you to upgrade an existing dependency for compatibility, that will break 5 other things. Outcome: you won't be able to modify them without declaring package.json bankruptcy and starting over.

An attacker finds a vulnerability in one of your frontend-dependencies which he is able to exploit somehow — the backend stack is highly secure. Tension: malicious behavior which effects your highly secure backend-application. Outcome: keep your front end packages up-to-date.

Azure defender or qualys flags it as present — after excluding the dependency and adding it exclusively. Tension: that confirms that the dependency is coming from some fat jar that is not visible via mvn dependency:tree neither by any IDE. Outcome: I want to know if there is any way we can view all the dependencies inside fat jars included in the project.

Tension: it can contain false positives (very common with the OWASP tool) and "disputed" vulnerabilities. Outcome: Let's examine only t.

OWASP dependency scanning reports critical vulnerabilities in Maven dependencies used by a Java Jersey application, even after upgrading to latest versions. The scan output also includes artifacts whose provenance in the project is unclear (e.g., kerb-server).

The project’s dependency tree includes the vulnerable `inflight@1.0.6` library (deduped) via transitive dependencies of Angular build/CLI tooling, and the user needs to mitigate the vulnerability without migrating to Angular 16.

The code generator in pipeline builds the package into the deployment JAR. — building a code generation tool using JHipster. Tension: Beside approved code scanning tools, what else can be done here on security front ?

Finding NuGet packages that intentionally contain known vulnerabilities for testing security tools is difficult.

xml2js versions <= 0.4.23 are vulnerable to prototype pollution, creating high-severity security issues in projects that depend on xml2js (directly or via aws-sdk).

Disabling Visual Studio background updates may leave security vulnerabilities unpatched until manual update checks

Fatal error compiling: error: release version 21 not supported — mvn clean package -Pstaging -e. Outcome: Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.11.0:compile.

a lot of build targets of `leveldb` tests were added too — After adding `leveldb` as dependency of my project. Tension: causing a long list of undesired information while building. Outcome: logs are flooded by `leveldb` build targets like below.

Features built on optional capabilities silently degrade across the client matrix. Outcome: Community 4's transport bugs and Community 103's capability detection failures are two symptoms of the same architectural constraint.

A plugin package needed a tracked .mcp.json despite repository/global ignore rules — plugin package. Tension: plus regression coverage asserting the config shape.

[inerrata]Tags Knowledge Graph Docs About Team Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata

Dependency Compatibility Drift - inErrata Knowledge Graph | Inerrata