Back to glossary

End-of-Life and Abandoned Dependencies

An end-of-life dependency is end of life software your code relies on: a package or runtime that will ship no more releases, including security fixes.

Also known as EOL dependency, end of life software, abandoned dependency, abandoned package, unmaintained dependency, unmaintained package

An end-of-life dependency, also called an EOL, abandoned, or unmaintained dependency, is a package, framework, or runtime your code relies on that will never ship another release, security fixes included. End of life software is either declared, through npm deprecate or a published EOL date, or silent. Either way, the next vulnerability found in it stays unpatched.

Age is not the problem. A 40-line dependency that has not changed since 2016 may simply be finished. End of life matters because it removes the one thing a dependency tree quietly assumes: someone upstream who will respond to the next bug report. That assumption fails often. Researchers at Carnegie Mellon and the University of Tennessee found that 4,108 of 28,100 widely used npm packages (15%) became abandoned during a six-year window, and that only 18% of still-active projects exposed to them ever removed the dependency (Miller et al., ICSE 2025).

Our position is that end of life is a property of the edges in your dependency graph, not a label on a package. An abandoned package freezes every version range it ever declared, so fixes that already exist upstream can never reach you through it. Detect end of life from declared signals and from changes in who can publish, not from time since the last release. Then decide your exit path when you adopt a dependency, not when its maintainer leaves.

What does end of life mean for software?

#

End of life means the owner of a piece of software has stopped producing releases for it, including security patches. For runtimes and frameworks, end of life is a date on a published schedule. Node.js 20 reached end of life on April 30, 2026, according to the Node.js release schedule. As of November 2026, Node.js 22 and 24 are in maintenance LTS, and Node.js 26 became the active LTS line on October 28, 2026. Starting with Node.js 27, the project ships one major release per year, and every release gets 36 months of total support (Node.js).

Packages rarely publish dates, so their end of life has to be read from weaker signals. Four states get conflated, and only the first three are end of life:

  • Deprecated. The maintainer has flagged a version or a whole package as not to be used, usually pointing at a replacement. Deprecated packages still install.
  • Archived or declared EOL. The maintainer has said there will be no further releases, through a registry status, an archived repository, or a README notice.
  • Silently abandoned. Nobody said anything. Releases, issue triage, and security responses simply stopped.
  • Feature-complete. No releases because nothing needs to change. This is not end of life, and treating it as such creates churn for nothing.

Telling the last two apart from the outside is hard, and that is why we distrust release-age thresholds. The RustSec advisory database, which files formal advisories for unmaintained Rust crates, defers to the author over activity metrics: "Repository metrics like recent commits, open issues, latest release, etc are not reasons to go against the direct word of a crate author" (RustSec). The cost of getting this wrong is real. In April 2026, a user of fsnotify, a Go library GitHub lists with 321k dependent projects, asked for a release because scanners had flagged it as unmaintained after 12 months without one. The rush of new maintainer activity that followed ended in a public access dispute (fsnotify maintainer dispute).

How does an abandoned dependency freeze its subtree?

#

An abandoned dependency freezes its subtree because every version range it declared becomes permanent the day it stops publishing. To see why, start with how npm resolution is supposed to work. A package does not pin its own dependencies. It declares semver ranges, and the resolver installs the highest published version that satisfies each range. That design lets the maintainer of a child package ship a patch that flows to every consumer without the parent republishing anything.

The design has one precondition: the fix must land inside the range the parent declared. A tilde range such as ~2.3.2 accepts only 2.3.x patches. While the parent is maintained, someone eventually widens the range. Once the parent is abandoned, nobody ever will, and its transitive dependencies are fixed in place for every project that installs it.

The npm package request is the clearest real case. Its maintainers announced the end of active development in a GitHub issue, writing that "The most valuable thing request can do for the JavaScript ecosystem is to go into maintenance mode" (request#3142). Version 2.88.2, published February 11, 2020, was its last release, and its README declares it fully deprecated as of that date. We installed it in a clean project on November 3, 2026:

Plain text
$ npm install request@2.88.2 --ignore-scripts
npm warn deprecated har-validator@5.1.5: this library is no longer supported
npm warn deprecated uuid@3.4.0: uuid@10 and below is no longer supported.  For ESM codebases, update to uuid@latest.  For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028).
npm warn deprecated request@2.88.2: request has been deprecated, see https://github.com/request/request/issues/3142

added 47 packages, and audited 48 packages in 3s

5 vulnerabilities (3 moderate, 2 critical)

The deprecation is only a warning. The package installs normally, and so do two other deprecated packages beneath it. The audit is where the freeze shows:

Plain text
$ npm audit
form-data  <=2.5.5
Severity: critical
form-data uses unsafe random function in form-data for choosing boundary - https://github.com/advisories/GHSA-fjxv-7rqg-78g4
form-data: CRLF injection in form-data via unescaped multipart field names and filenames - https://github.com/advisories/GHSA-hmw2-7cc7-3qxx
No fix available
node_modules/form-data
  request  *
  Depends on vulnerable versions of form-data
  Depends on vulnerable versions of qs
  Depends on vulnerable versions of tough-cookie
  Depends on vulnerable versions of uuid
  node_modules/request
...
5 vulnerabilities (3 moderate, 2 critical)

"No fix available" is not true for form-data. Its maintainers patched the form-data boundary vulnerability in 2.5.4 on July 17, 2025, and the CRLF injection in 2.5.6 on June 12, 2026. But request declares form-data: ~2.3.2, and the last 2.3.x release is 2.3.3 from October 2018. The fix exists on the registry and is unreachable from it.

request@2.88.2Deprecated. Last publish 2020-02-11. Its declared ranges can never change again.
request declares
npm installs
Fix published at
form-data ~2.3.2
npm installs2.3.32018-10-17, last 2.3.x
Fix published at2.5.4 and 2.5.62025-07-17 and 2026-06-12, outside the range
qs ~6.5.2
npm installs6.5.52026-02-13, a backport into 6.5.x
Fix published at6.14.1 and 6.16.0outside the range
tough-cookie ~2.5.0
npm installs2.5.02018-11-26
Fix published at4.1.32023-06-05, two majors away
uuid ^3.3.2
npm installs3.4.02020-01-16
Fix published at11.1.12026-04-29, eight majors away
request itself
npm installs2.88.2SSRF, CVE-2023-28155
Fix published atNo fixed requestFixed only in the fork @cypress/request 3.0.0
Green cells are fixes that exist on npm outside the range request declared. Nothing in request's own metadata can ever select them.

The figure shows each edge request@2.88.2 declares, the version npm installs today, and where the fix actually lives. form-data ~2.3.2 installs 2.3.3 (October 17, 2018); the fixes are in 2.5.4 (July 17, 2025) and 2.5.6 (June 12, 2026). qs ~6.5.2 installs 6.5.5 (February 13, 2026); the fixes for its current advisories are in 6.14.1 and 6.16.0. tough-cookie ~2.5.0 installs 2.5.0 (November 26, 2018); its prototype pollution fix is in 4.1.3 (June 5, 2023), two majors away. uuid ^3.3.2 installs 3.4.0 (January 16, 2020); its bounds-check fix is in 11.1.1 (April 29, 2026), eight majors away. request itself has a server-side request forgery bug, CVE-2023-28155, with no patched version of request at all. The fix shipped only in the @cypress/request fork, version 3.0.0 (GHSA-p8p7-x288-28g6).

The qs row shows the one way an abandoned parent's subtree still gets fixes: a maintained child backports into the old line. qs 6.5.3, released in January 2022, carried the __proto__ parsing fix into 6.5.x, so every request install picked it up with no action from anyone. form-data never got a 2.3.x backport. Whether a frozen subtree stays patched depends entirely on the goodwill of maintainers further down.

Why can't npm audit fix an abandoned dependency?

#

npm audit cannot fix an abandoned dependency because the fixes either sit outside ranges the abandoned parent declared or do not exist at all. Your remaining levers are to rewrite the edges yourself, patch the code you have, take over the code, or replace it.

Rewriting edges is what dependency overrides do. We overrode the two children whose fixes stay inside their current major:

JSON
"overrides": {
  "request": {
    "form-data": "2.5.6",
    "qs": "^6.16.0"
  }
}

That took the audit from 5 findings (2 critical) to 3 moderate, and require('request') still loaded. The remaining fixes require crossing majors. Overriding uuid to ^11.1.1 and tough-cookie to ^4.1.3 dropped the audit to a single finding, and broke the package on load:

Plain text
$ node -e "require('request')"
Error [ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath './v4' is not defined by "exports" in node_modules/uuid/package.json

request calls require('uuid/v4') in lib/auth.js, lib/oauth.js, and lib/multipart.js, a deep import that uuid's later majors no longer export. The audit got quieter and the application stopped working. The one finding no override can touch is the last one: CVE-2023-28155 lives in request's own code, and nobody will ever publish a request that fixes it.

OptionWhat it fixesWhat it costsWhat it does not cover
Leave it and accept the riskNothingNothing todayEvery future vulnerability in the subtree
Override within the child's current majorChild vulnerabilities whose fix is API-compatibleOne line per child; you now own those version choicesThe parent's own bugs; fixes that need a new major
Override across majorsChild vulnerabilities in newer majorsRuntime breakage the audit cannot see, as uuid 11 showedThe parent's own bugs
Patch the installed versionA specific known vulnerability, including in the parentA patch set you apply at build timeVulnerabilities nobody has disclosed yet
Adopt a maintained forkParent bugs the fork has fixedTrust in a new publisher; possible API driftWhatever the fork's maintainers stop maintaining
Replace the packageThe whole subtreeEngineering time proportional to integration depthNothing, if the replacement is maintained

Our verdict: override inside a major as a stopgap, never across one without running your tests. Patch when a known, reachable vulnerability needs to close this week. Replace when the package is shallowly integrated, which for an HTTP client like request usually means moving to the fetch() built into current Node.js. A fork such as @cypress/request is a replacement with a smaller diff, and it should get the same scrutiny as any new publisher.

For the patch row, Socket Certified Patches are designed for cases that include packages with no active maintainers. A certified patch is a small, reviewed change to the exact vulnerable version you already have. It lives in a .socket/ directory in your repository and is applied during your build, so no new upstream code enters your tree. It covers known vulnerabilities only. It does nothing for the next bug in an abandoned package, which is why we treat patching as a bridge to replacement, not a substitute for it.

End of life software signals are opt-in at every registry

#

Every major registry now has some way to declare end of life, and every one of them depends on a maintainer choosing to use it. That is the structural reason silent abandonment dominates. An analysis of the 50,000 most-downloaded npm packages, which we covered in our post on deprecated npm packages, found 8.2% officially deprecated but 21.2% once archived repositories and inactive projects were counted.

EcosystemDeclared signalWhere tools read itEffect on install
npmFree-text deprecated string per version, set with npm deprecateversions[<v>].deprecated in the registry packumentWarning; installs normally
PyPIProject status per PEP 792: active, archived, deprecated, or quarantinedproject-status in the Simple API JSON (api-version 1.4)archived blocks new uploads and still installs; quarantined serves nothing
Go modules// Deprecated: comment on the module line in go.mod, since Go 1.17go.mod at the @latest versiongo list -m -u prints (deprecated); go get warns
crates.ioRustSec advisory with informational = "unmaintained" and patched = []The RustSec advisory databasecargo audit reports it as a warning
GitHubArchived repository flagarchived: true in the repository APINone; package managers never see it

Verdict: the PyPI model is the best of the five, because its states are enumerated, machine-readable, and enforced by the index. npm's signal is the weakest, a free-text string that installers print and then ignore. Only RustSec has a process for the most common case, a maintainer who simply stopped, and it needs a person to file an advisory. The project status markers specification itself only says installers "may warn" about an archived project.

Declared metadata reports what a maintainer last said, not what they stopped doing. Here is what PyPI's Simple and JSON APIs returned for two projects on November 3, 2026:

Bash
$ curl -s -H 'Accept: application/vnd.pypi.simple.v1+json' https://pypi.org/simple/typed-ast/ | jq -c '."project-status"'
{"status":"archived"}

$ curl -s -H 'Accept: application/vnd.pypi.simple.v1+json' https://pypi.org/simple/pycrypto/ | jq -c '."project-status"'
{"status":"active"}

$ curl -s https://pypi.org/pypi/pycrypto/2.6.1/json | jq -c '.urls[0].upload_time, [.vulnerabilities[] | {id, fixed_in}]'
"2014-06-20T08:10:20"
[{"id":"PYSEC-2017-94","fixed_in":[]},{"id":"PYSEC-2018-97","fixed_in":[]},{"id":"GHSA-6528-wvf6-f6qg","fixed_in":[]},{"id":"GHSA-cq27-v7xp-c356","fixed_in":[]}]

typed-ast's maintainers archived it, so tools can see it. pycrypto has not had a release since June 20, 2014, carries two CVEs (CVE-2013-7459 and CVE-2018-6594, each listed under a PYSEC and a GHSA ID) with an empty fixed_in list, and still reports active, with a Development Status :: 5 - Production/Stable classifier. This is why we analyze what a package is and does rather than trusting what its metadata claims.

Abandoned packages are a takeover target

#

An abandoned package keeps its install base and its update channel, so whoever publishes its next version inherits both. Every dependent whose declared range covers that version will take it on its next fresh resolve or lockfile update. Attackers have used this path repeatedly, and registries have changed policy in response.

In 2018, the original author of event-stream, short on time, handed control of the package to a new maintainer. The new maintainer added a dependency, flatmap-stream, whose payload targeted a single Bitcoin wallet application, and shipped it in event-stream 3.3.6 (event-stream compromise). In 2021 npm stopped granting requests to adopt abandoned packages. npm's Myles Borins explained that "We opted to move towards not allowing adoption of abandoned packages as it was an attack vector" (npm's abandoned package policy). The xz-utils backdoor followed the same playbook against an under-resourced C project, and the OpenJS Foundation later intercepted a similar attempt to be named maintainer of one of its JavaScript projects (xz-utils backdoor).

PyPI had a variant of the same problem. Before 2025, a maintainer who wanted to retire a project could only delete it, which freed the name for anyone to register, a technique known as revival hijacking. PyPI's project archival, launched in January 2025, lets owners mark a project inactive without giving up the name. On npm, packages stay installable after the account that published them is deleted, leaving a widely installed name with no accountable owner. Every route to maintainer account takeover applies to abandoned packages with extra force, because nobody is watching the account.

The practical rule follows: the riskiest release an abandoned package will ever ship is its next one. A new version of a package that has been silent for years, especially from a publisher that did not ship the previous release, deserves full code review before it reaches a lockfile.

How do you manage end-of-life dependencies?

#

You manage end-of-life dependencies by tracking declared EOL dates, detecting silent abandonment from evidence, triaging by integration depth, and choosing an exit before you need one. Each step has limits worth knowing.

Track runtime and framework dates like certificate expiry. Runtime end of life is predictable, yet ignored at scale. The Node.js team reported Node.js 16 was still downloaded 11 million times per month more than a year after its end of life (Node.js EOL CVE controversy). In January 2025 the project tried to make scanners notice by issuing CVEs for end-of-life release lines. The CVE Program rejected them. Node.js now marks end-of-life lines as affected in every new CVE: "all new CVEs issued will include EOL releases in the applicability" (Node.js). If you still run Node.js 20, expect every future Node.js advisory to list your version.

Detect declared and silent end of life separately. Socket raises three alerts for this. The Deprecated alert (Medium) fires on npm's deprecation flag and, on PyPI, on yanked releases. The Unmaintained alert (Low) fires only after more than five years without an update, as of November 2026. The Non-existent author alert fires when the npm account that published a package no longer exists. None of the three catches a package abandoned two years ago with no notice and its publisher's account intact, which is exactly the case Miller et al. measured. Their data also shows why declaring matters: "removal is significantly faster when a package's end-of-life status is explicitly stated" (Miller et al.), at 1.58 times the probability of removal in a given span.

Triage by integration depth, not by the flag. A follow-up study from the same group interviewed 22 maintainers and found that whether abandonment matters depends on context. Maintainers rated two factors most useful: how deeply the dependency is integrated, and whether alternatives exist (Abandabot, ICSE 2026). For vulnerabilities inside a frozen subtree, reachability still decides urgency. An abandoned dependency on a code path you never call is debt, not an incident.

Budget for it if you sell into the EU. The EU Cyber Resilience Act requires manufacturers to "exercise due diligence when integrating components sourced from third parties" under Article 13(5), open source included. Article 13(8) sets a product support period of at least five years, unless the product is expected to be used for less time. A component whose maintainers have stopped is a component whose vulnerabilities you will have to fix yourself for the rest of that period.

Choose the exit at adoption. Before adding a dependency, check how many people can publish it, whether it has a stated support policy, and what you would replace it with. The cheapest time to plan a migration off request was before the first require('request').

The open problem is that "no fix yet" and "no fix ever" look identical in tooling. npm audit printed "No fix available" for form-data, which has published fixes, and for request, which will never get one. Registries should make end of life a structured state, as PEP 792 does, and scanners should report a vulnerability in an abandoned package as permanent. Until then, the only reliable signal is the one you build yourself: who can publish this package, and have they said they will?