Do you use Bun? Dependabot doesn't see most of your dependencies (and how to fix it) ✅ yoDEV Tested

If your project uses Bun, Dependabot probably only checks what you declare in package.json: GitHub’s dependency graph doesn’t read bun.lock, so the entire transitive tree (the packages that your packages bring in) is left out. In our test repository, GitHub saw 1 package out of 50 and raised 2 alerts out of 16. A new open source GitHub Action, bun-lock-submission, closes that gap in about two minutes.

:white_check_mark: yoDEV Tested · November 4, 2026
We tested bun-lock-submission v1 (npm 1.0.0) with Bun 1.4.4 in a public GitHub repository created for testing, with express 4.17.1 as the only direct dependency. The results we report as ours come from that test.

Nicolas Charpentier, author of the Action, documented the problem on his blog on October 28, 2026: in his demo repository, GitHub saw 3 out of 12 installed packages. We reproduced it in our own repository, with even larger numbers.

What is Dependabot and where do its alerts come from?

Dependabot is GitHub’s tool that alerts you when one of your dependencies has a known vulnerability. Its alerts (Dependabot alerts) don’t scan your project on their own: they come from the dependency graph, the graph of dependencies that GitHub builds by reading your manifests and lockfiles. If a package isn’t in that graph, Dependabot can’t alert you about it.

It’s worth distinguishing three functions that share the name:

  • Dependabot alerts: vulnerability notifications, based on the dependency graph.
  • Dependabot version updates: pull requests to keep your dependencies up to date. They’ve supported Bun since early 2025 and do update bun.lock.
  • Dependabot security updates: automatic pull requests that fix vulnerabilities. They don’t open for projects with Bun.

Why doesn’t Dependabot detect dependencies from bun.lock?

Because GitHub’s dependency graph doesn’t parse bun.lock. In a Bun project, the graph only knows what package.json declares: transitive dependencies and versions resolved via catalog: are invisible to it, and Dependabot can’t raise alerts about them.

At the time of publishing this note (November 2026), GitHub hadn’t announced native support for bun.lock in the dependency graph, and the original article doesn’t cite any issue, roadmap entry, or date.

How do you know if your repository is affected?

Compare what GitHub sees with what Bun sees; it takes two minutes.

  1. Locally: run bun audit (the equivalent of npm audit). It reads your actual lockfile and lists each vulnerable package, direct or transitive.
  2. On GitHub: open Insights → Dependency graph and Security → Dependabot.

If the local list is longer than GitHub’s, you’re affected. If the graph only shows packages marked with package.json and none with bun.lock, you definitely are.

Something we found first: in our newly created public repository, both Dependency graph and Dependabot alerts were disabled in Settings → Advanced Security, even though for public repositories the graph usually comes enabled. Check that both are on before anything else: without a graph there’s nowhere to send the dependencies.

What is bun-lock-submission?

bun-lock-submission is a GitHub Action and CLI that read your bun.lock and send the complete tree of resolved dependencies to GitHub’s dependency graph submission API, the official way to register dependencies that GitHub doesn’t detect on its own. Once the tree is submitted, Dependabot raises alerts about it like it would with any other dependency.

  • MIT license, version 1.0.0 published on npm on October 27, 2026, single maintainer.
  • Tested by its author with Bun 1.1.43, 1.2.23, 1.3.14, and 1.4.4, covering lockfile versions 0 through 3.
  • Only supports text bun.lock. If you still have the old binary bun.lockb, convert it with bun install --save-text-lockfile.

How do you install bun-lock-submission?

Add this workflow in .github/workflows/dependency-submission.yml. It’s the one from the README unchanged, and it’s exactly what we ran:

# .github/workflows/dependency-submission.yml
name: Dependency submission

on:
  push:
    branches: [main]
    paths:
      - '**/bun.lock'
      # Editing this workflow, such as its inputs or the action version, changes
      # what gets submitted too.
      - .github/workflows/dependency-submission.yml
  workflow_dispatch:

permissions: {}

jobs:
  submit:
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - uses: actions/checkout@v7
      - uses: charpeni/bun-lock-submission@v1

What matters:

  • contents: write is required for the submission API. Permissions are empty at the global level and only granted to this job.
  • It runs on every push to main that modifies any bun.lock or the workflow itself, and also manually via workflow_dispatch.
  • In our test, pushing the workflow file triggered the first run on its own, because the file is within the paths filter. The README warns that the first push to a new repository doesn’t trigger a run filtered by paths, so if you don’t see anything, run it once from the Actions tab.
  • Is your default branch not called main? Change branches:. Snapshots from other branches are saved, but don’t generate alerts.
  • If your organization requires it, pin the Action to a commit SHA instead of @v1.

Optional inputs, according to the README: layout: workspaces (reports against the package.json of each workspace in a monorepo), exclude (packages that shouldn’t be submitted), include-exact-pins (also submit direct dependencies pinned to an exact version), and dry-run.

Can you test it without GitHub Actions?

Yes. The same tool comes as a CLI:

bunx bun-lock-submission snapshot   # print the snapshot as JSON
bunx bun-lock-submission submit     # submit it to GitHub
bunx bun-lock-submission clear      # remove what was submitted

snapshot is a safe preview: it shows what would be sent without actually sending anything. For submit, the token is taken from GITHUB_TOKEN, GH_TOKEN, or gh auth token, in that order. It also works with npx bun-lock-submission.

How many alerts were missing? What we saw in our test

14 out of 16 were missing. We created a disposable public repository with a single direct dependency, express pinned to 4.17.1, an old version with known vulnerabilities in its transitive tree. bun install resolved 50 packages and bun audit reported 16 vulnerabilities in 7 packages: 2 in express itself and 14 in transitive packages (body-parser, qs, path-to-regexp, cookie, send, serve-static).

Dependency graph Dependabot alerts
Before (GitHub only) 1 package 2
After bun-lock-submission 52 packages 16
bun audit (local) 50 installed 16
  • Before: the graph only showed express, marked with package.json. Dependabot raised 2 alerts, both about express. The 14 transitive vulnerabilities were invisible.
  • After: one workflow run, 9 seconds. The graph went to 52 entries, with the new ones labeled Transitive · bun.lock · Detected by bun-lock-submission. Dependabot showed 16 open alerts, exactly the 16 that bun audit found.
  • express remained marked with package.json: by default, exact versions are left to package.json (include-exact-pins: false), so nothing is counted twice.

The author’s numbers come from his own demo repository (3 out of 12 packages visible; 1 alert before and 3 after). Ours come from a different repository and point in the same direction.

Does bun-lock-submission fix the vulnerabilities?

No. The Action makes vulnerabilities visible, but Dependabot still doesn’t open security pull requests for Bun projects, so fixing is up to you:

  • bun audit fix updates vulnerable packages within their allowed ranges.
  • bun audit fix --latest also crosses major versions.

A single pass may not be enough. In a copy of our test, bun audit fix bumped express to 4.20.0 and fixed 6 vulnerabilities, but 11 remained, partly because newer transitive versions have their own warnings. Removing the rest meant moving to Express 5, which is a real migration and not a command. Keep bun audit in your CI too: the author recommends it as a complement to Dependabot, not as a replacement.

What precautions should you take?

  • Private packages with public names. Warnings are associated by package name, so a private package with the same name as a public one gets that public package’s alerts. Add it to exclude.
  • Lockfiles that disappear. If a lockfile stops appearing in a later submission, its alerts close as fixed. If it comes back, they reopen, but you lose any dismissals you made.
  • Monorepos. layout: workspaces fails if a workspace has its own outdated bun.lock. In that case, specify lockfiles explicitly with the lockfiles input.
  • Maturity. It’s a 1.0.0 with a single maintainer, published a week before this note. It uses GitHub’s official API and its scope is narrow, but treat it like any new dependency in your pipeline.

When should you remove it?

As soon as GitHub reads bun.lock natively. The author lists two steps to exit:

  1. Delete the dependency submission workflow.
  2. Run bunx bun-lock-submission clear from your default branch to erase what the Action submitted.

What about you? What did you find when comparing bun audit with Dependabot alerts in your repository?

How do you audit dependencies in your Bun projects today?
  • Only with Dependabot
  • With bun audit in CI
  • I don’t audit them yet
  • With another tool (tell us which)
0 votantes

Comment below or, if this article reached you by email, reply directly to the email: your reply gets published here.

Related: Bun check vs tsc: we tested Bun’s new type checker on zod, Playwright, and Hono :white_check_mark: yoDEV Tested