# 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

Source: https://socket.dev/glossary/end-of-life-dependencies

Last updated: 2026-11-03

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](https://socket.dev/glossary/software-dependencies) 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](https://www.cs.cmu.edu/~ckaestne/pdf/icse25_abandonment.pdf)).

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](https://github.com/nodejs/Release). 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](https://socket.dev/blog/node-js-moves-to-annual-major-releases-starting-with-node-27), and every release gets 36 months of total support ([Node.js](https://nodejs.org/blog/announcements/evolving-the-nodejs-release-schedule)).

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](https://github.com/rustsec/advisory-db/blob/main/HOWTO_UNMAINTAINED.md)). 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](https://socket.dev/blog/fsnotify-maintainer-dispute-sparks-supply-chain-concerns)).

## 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](https://socket.dev/glossary/semantic-versioning-semver), 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](https://socket.dev/glossary/transitive-dependency) 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](https://github.com/request/request/issues/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:

```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:

```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](https://socket.dev/blog/critical-vulnerability-in-popular-npm-form-data-package) 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.2 declares semver ranges that exclude every published fix for its dependencies

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](https://github.com/advisories/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](https://socket.dev/glossary/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:

```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.

| Option | What it fixes | What it costs | What it does not cover |
| --- | --- | --- | --- |
| Leave it and accept the risk | Nothing | Nothing today | Every future vulnerability in the subtree |
| Override within the child's current major | Child vulnerabilities whose fix is API-compatible | One line per child; you now own those version choices | The parent's own bugs; fixes that need a new major |
| Override across majors | Child vulnerabilities in newer majors | Runtime breakage the audit cannot see, as uuid 11 showed | The parent's own bugs |
| Patch the installed version | A specific known vulnerability, including in the parent | A patch set you apply at build time | Vulnerabilities nobody has disclosed yet |
| Adopt a maintained fork | Parent bugs the fork has fixed | Trust in a new publisher; possible API drift | Whatever the fork's maintainers stop maintaining |
| Replace the package | The whole subtree | Engineering time proportional to integration depth | Nothing, 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](https://socket.dev/glossary/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](https://socket.dev/blog/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](https://socket.dev/blog/the-risks-of-deprecated-npm-packages), found 8.2% officially deprecated but 21.2% once archived repositories and inactive projects were counted.

| Ecosystem | Declared signal | Where tools read it | Effect on install |
| --- | --- | --- | --- |
| npm | Free-text deprecated string per version, set with npm deprecate | versions\[\<v\>\].deprecated in the registry packument | Warning; installs normally |
| PyPI | Project status per PEP 792: active, archived, deprecated, or quarantined | project-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.17 | go.mod at the @latest version | go list -m -u prints (deprecated); go get warns |
| crates.io | RustSec advisory with informational = "unmaintained" and patched = \[\] | The RustSec advisory database | cargo audit reports it as a warning |
| GitHub | Archived repository flag | archived: true in the repository API | None; 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](https://packaging.python.org/en/latest/specifications/project-status-markers/) 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](https://socket.dev/blog/limitations-of-cve-based-security-scanners)). 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](https://socket.dev/blog/how-to-safeguard-against-the-dangers-of-abandoned-npm-packages)). 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](https://socket.dev/blog/openjs-xz-utils-cyberattack-likely-not-an-isolated-incident)).

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](https://socket.dev/blog/how-socket-protects-against-revival-hijacking-attacks-on-pypi). [PyPI's project archival](https://socket.dev/blog/pypi-adds-support-for-archiving-projects), 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](https://socket.dev/glossary/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](https://socket.dev/blog/node-js-eol-versions-cve-dubbed-the-worst-cve-of-the-year)). In January 2025 the project tried to make scanners notice by issuing [CVEs](https://socket.dev/glossary/common-vulnerabilities-and-exposures-cve) 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](https://nodejs.org/en/blog/vulnerability/updates-cve-for-end-of-life)). 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](https://socket.dev/alerts/deprecated) alert (Medium) fires on npm's deprecation flag and, on PyPI, on yanked releases. The [Unmaintained](https://socket.dev/alerts/unmaintained) alert (Low) fires only after more than five years without an update, as of November 2026. The [Non-existent author](https://socket.dev/alerts/missingAuthor) 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.](https://www.cs.cmu.edu/~ckaestne/pdf/icse25_abandonment.pdf)), 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](https://www.cs.cmu.edu/~ckaestne/pdf/icse26_abandabot.pdf)). 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](https://socket.dev/glossary/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?
