@cdxgen/cdxgen 0.0.1 → 13.0.0

package/README.md

@@ -1,136 +1,970 @@
-# `@cdxgen/cdxgen` name placeholder
+[![SBOM](https://img.shields.io/badge/SBOM-with_%E2%9D%A4%EF%B8%8F_by_cdxgen-FF753D)](https://github.com/cdxgen/cdxgen)
+[![AI-DECLARATION: pair](https://img.shields.io/badge/䷼%20AI--DECLARATION-pair-ffedd5?labelColor=ffedd5)](./AI-DECLARATION.md)
+[![JSR][badge-jsr]][jsr-cdxgen]
+[![NPM][badge-npm]][npmjs-cdxgen]
+[![GitHub Releases][badge-github-releases]][github-releases]
+[![NPM Downloads][badge-npm-downloads]][npmjs-cdxgen]
+[![GitHub License][badge-github-license]][github-license]
+[![GitHub Contributors][badge-github-contributors]][github-contributors]
+[![SWH][badge-swh]][swh-cdxgen]
 
-A minimal, deliberately inert package whose only job is to **create the
-`@cdxgen/cdxgen` name on npm and JSR** so trusted publishing can be configured
-against it.
+# CycloneDX Generator (cdxgen)
 
-Both registries attach a trusted publisher to an *existing* package. The
-package therefore has to exist before the v13 release can publish via OIDC, and
-the first publish has to use a token. That first publish is what this directory
-is for.
+<img src="./docs/_media/cdxgen.png" width="200" height="auto" />
 
-The `@cyclonedx` namespace already has this set up for v12; none of that
-configuration carries over to `@cdxgen`.
+cdxgen is a CLI tool, library, [REPL](./ADVANCED.md), and server to create, validate, sign, and verify software BOMs. It generates CycloneDX JSON BOMs and supports SPDX 3.0.1 JSON-LD export. CycloneDX is a full-stack BOM specification that is easily created, human and machine-readable, and simple to parse. The tool generates BOMs targeting CycloneDX specification versions 1.6, 1.7, and 2.0, and the output can be downgraded to 1.4 or 1.5 for legacy consumers.
 
-## What it deliberately does not do
+Supported BOM formats:
 
-- **No `bin`.** cdxgen's executable is called `cdxgen`. A placeholder shipping
-  an executable of that name would shadow the real tool for anyone who
-  installed it by accident.
-- **Not published as `latest`.** `publishConfig.tag` is `placeholder`, so
-  `npm install @cdxgen/cdxgen` does not resolve to it. Between this publish and
-  the v13 release the package has no `latest` tag at all, and an install fails
-  with "no matching version" — which is the correct outcome, because there is
-  nothing here worth installing.
-- **Version `0.0.1`**, so it sorts below `13.0.0` and never wins resolution.
+- Hardware (HBOM) - For supported live hosts such as Apple Silicon macOS and Linux amd64/arm64 systems.
+- Software (SBOM) - For many languages and container images.
+- Cryptography (CBOM) - For Java keystores and certificates, plus JavaScript and TypeScript source-level algorithm inventory.
+- Operations (OBOM) - For Linux container images and VMs running Linux or Windows operating systems.
+- Software-as-a-Service (SaaSBOM) - For Java, Python, JavaScript, TypeScript, and PHP projects.
+- AI/ML (AI-BOM) - For prompt files, AI services, MCP configs, and model metadata with explainable AI-governance, security, performance, and agentic findings.
+- Attestations (CDXA) - Generate SBOM with templates for multiple standards. Sign the BOM document at a granular level to improve authenticity.
+- Vulnerability Disclosure Report (VDR) - Use cdxgen with [OWASP depscan](https://github.com/owasp-dep-scan/dep-scan) to automate the generation of VDR at scale.
 
-## Step 1 — publish the placeholder with a token
+Supported output document formats:
 
-Trusted publishing cannot be used for this first publish; that is the
-bootstrapping problem it exists to solve.
+- CycloneDX JSON (primary native format)
+- SPDX 3.0.1 JSON-LD (`cdxgen --format spdx` or `cdx-convert`)
+
+## Choose your path
+
+| Persona               | What cdxgen helps you do                                                                                             | First command                                                              | Read next                                                                                                 |
+| --------------------- | -------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| **Developers**        | Generate a CycloneDX BOM from a local repo, git URL, purl, or container image                                        | `cdxgen -o bom.json .`                                                     | [CLI Usage][docs-cli], [Supported Project Types][docs-project-types]                                      |
+| **AI platform teams** | Generate AI/ML BOMs, catalog prompt/model/MCP surfaces, and run AI-BOM governance                                    | `aibom .`                                                                  | [AI-BOM Guide](docs/AI_BOM.md), [AI-BOM lesson](docs/LESSON15.md)                                         |
+| **Hardware teams**    | Generate an HBOM or merged HBOM+OBOM host view for the current host                                                  | `hbom -o hbom.json`                                                        | [HBOM guide](docs/HBOM.md), [HBOM lesson](docs/LESSON13.md)                                               |
+| **AppSec**            | Enrich BOMs with evidence, run BOM audit rules, and feed downstream security workflows                               | `cdxgen -o bom.json --profile appsec --evidence --bom-audit .`             | [BOM Audit](docs/BOM_AUDIT.md), [Threat Model](docs/THREAT_MODEL.md)                                      |
+| **SOC analysts**      | Build OBOM inventories for live hosts and triage runtime posture issues                                              | `obom -o obom.json --deep --bom-audit --bom-audit-categories obom-runtime` | [OBOM lessons](docs/OBOM_LESSONS.md), [Server Usage][docs-server]                                         |
+| **Compliance teams**  | Validate BOM quality, check SCVS/CRA posture, and export SPDX deliverables                                           | `cdx-validate -i bom.json --benchmark scvs-l2,cra`                         | [cdx-validate](docs/CDX_VALIDATE.md), [cdx-convert](docs/CDX_CONVERT.md), [Permissions][docs-permissions] |
+| **Security Teams**    | Dynamically trace executions to capture cryptographic activities, CBOM properties, software components, and services | `tracebom --cbom-output cbom.json -- npm test`                             | [Threat Model](docs/THREAT_MODEL.md)                                                                      |
+
+### Role-based quick starts
+
+#### For developers
+
+- Start with a local path, git URL, or purl and generate a BOM in one command.
+- Use [Supported Project Types][docs-project-types] to confirm ecosystem coverage before wiring cdxgen into CI.
+
+#### For hardware and platform teams
+
+- Use `hbom` when you need a CycloneDX hardware inventory for the current host rather than a software dependency graph.
+- Start with the [HBOM guide](docs/HBOM.md) and the [HBOM lesson](docs/LESSON13.md) for supported platforms, enrichment options, and validation workflows.
+- Use `hbom --dry-run` first when you want a read-only partial HBOM plus an exact list of blocked hardware probe commands before a full collection run.
+- Use `hbom diagnostics` when you want a focused summary of missing native utilities and permission-denied enrichments before deciding whether to install host packages or rerun with `--privileged`.
+- Use `hbom --include-runtime` when you want one topology-aware CycloneDX host document that merges hardware inventory with runtime evidence using strict, non-guessing joins.
+
+#### For AppSec
+
+- Use `--profile appsec`, `--evidence`, and `--bom-audit` when you want richer security context.
+- Combine generation with [BOM Audit](docs/BOM_AUDIT.md), [cdx-validate](docs/CDX_VALIDATE.md), signing, and verification for a fuller secure-SBOM workflow.
+- Use `tracebom` to dynamically profile applications & services and capture negotiated TLS cipher suites, protocols, cryptographic libraries, dynamically resolved software components, and services in CycloneDX 1.7 format.
+
+#### For AI platform and governance teams
+
+- Use `--include-formulation` plus `--bom-audit --bom-audit-categories ai-bom` when you want one AI-BOM workflow for prompt files, AI services, MCP configs, and model metadata.
+- Use `aibom` when you want the same defaults in one dedicated CLI, including direct Hugging Face purls/URLs and direct Modelfile / `.gguf` inputs.
+- Start with the [AI-BOM Guide](docs/AI_BOM.md) and the [AI-BOM lesson](docs/LESSON15.md) for the preferred alias, review flow, and category breakdown.
+
+#### For SOC analysts
+
+- Use `obom` for live-system and runtime inventory on Linux, Windows, and macOS hosts.
+- Focus on [OBOM lessons](docs/OBOM_LESSONS.md) when you need host triage, persistence review, Linux GTFOBins-backed runtime analysis, hardening drift review, or incident-response evidence.
+
+#### For compliance and platform governance
+
+- Use `cdx-validate` to assess structural and compliance posture, then `cdx-convert` when SPDX output is required.
+- Review [Permissions][docs-permissions] and hardened-environment guidance before adopting cdxgen in controlled pipelines.
+
+## Why cdxgen?
+
+Most SBOM tools are like simple barcode scanners. For easy applications, they can parse a few package manifests and create a list of components only based on these files without any deep inspection. Further, a typical application might have several repos, components, and libraries with complex build requirements. Traditional techniques to generate an SBOM per language or package manifest either do not work in enterprise environments or don't provide the confidence required for both compliance and automated analysis. So we built cdxgen - the universal polyglot SBOM generator that is user-friendly, precise, and comprehensive!
+
+**Our philosophy:**
+
+- _Explainability:_ Don't list, but explain with evidence.
+- _Precision:_ Try using multiple techniques to improve precision, even if it takes extra time.
+- _Personas:_ Cater to the needs of a range of personas such as security researchers, compliance auditors, developers, and SOC.
+- _Machine Learning:_ Optimize the generated data for Machine Learning (ML) purposes by considering the various model properties.
+- _Safety:_ Execute external build tools and handle untrusted inputs defensively, with hardened defaults, a [secure mode](docs/PERMISSIONS.md) for sensitive environments, and a read-only `--dry-run` mode for review-first workflows.
+
+## Documentation
+
+Please visit our [documentation site][docs-homepage] for detailed usage, tutorials, and support documentation.
+
+Sections include:
+
+- [Getting Started][docs-homepage]
+- [CLI Usage][docs-cli]
+- [Migration to v13](MIGRATING-TO-V13.md)
+- [HBOM Guide](docs/HBOM.md)
+- [Merged Host View Lesson](docs/LESSON13.md)
+- [Server Usage][docs-server]
+- [Hands-on Lessons](docs/LESSON8.md)
+- [Container Escape & Privilege Lesson](docs/LESSON9.md)
+- [HBOM Lesson](docs/LESSON13.md)
+- [Supported Project Types][docs-project-types]
+- [Environment Variables][docs-env-vars]
+- [Advanced Usage][docs-advanced-usage]
+- [Permissions][docs-permissions]
+- [cdx-audit Guide](docs/CDX_AUDIT.md)
+- [cdx-convert Guide](docs/CDX_CONVERT.md)
+- [cdx-validate Guide](docs/CDX_VALIDATE.md)
+- [cdx-verify Guide](docs/CDX_VERIFY.md)
+- [cdx-sign Guide](docs/CDX_SIGN.md)
+- [Tracebom Guide](docs/TRACEBOM.md)
+- [AI-BOM Guide](docs/AI_BOM.md)
+- [MCP Inventory](docs/MCP.md)
+- [REPL Guide](docs/REPL.md)
+- [Custom Properties](docs/CUSTOM_PROPERTIES.md)
+- [Deprecations](docs/DEPRECATIONS.md)
+- [Security Policy](SECURITY.md)
+- [Threat Model](docs/THREAT_MODEL.md)
+- [Support (Enterprise & Community)][docs-support]
+
+## Usage
+
+## Installing
+
+> [!IMPORTANT]
+> **The npm package was renamed in v13.** v13 and later are published as
+> [`@cdxgen/cdxgen`][npmjs-cdxgen]. v12 and earlier are published as
+> [`@cyclonedx/cdxgen`][npmjs-cdxgen-v12], which stays on npm and continues to
+> receive fixes on the `release/12.0.x` branch, but does not receive v13
+> features.
+>
+> Upgrading means changing the package name, not just the version:
+>
+> ```shell
+> npm uninstall -g @cyclonedx/cdxgen
+> npm install -g @cdxgen/cdxgen --ignore-scripts --min-release-age=2
+> ```
+>
+> The `cdxgen` command, the CLI flags, and the container images are unchanged.
+> If you import cdxgen as a library, update the specifier:
+> `import { createBom } from "@cdxgen/cdxgen"`.
+
+cdxgen is distributed three ways. The **standalone executables** and **container
+images** are the recommended choice for CI, production, and any environment
+where you want a self-contained tool with no Node.js dependency. The npm package
+is an alternative when you already manage JavaScript tooling or need cdxgen as a
+library. See [npm and JavaScript package managers](#npm-and-javascript-package-managers)
+below.
+
+Regardless of how you install, the following commands are available:
+
+| Command         | Purpose                                                                                                              | Standalone GitHub release binary |
+| --------------- | -------------------------------------------------------------------------------------------------------------------- | -------------------------------- |
+| `cdxgen`        | Generate CycloneDX / SPDX BOMs from source, images, binaries, git URLs, or purls                                     | yes                              |
+| `aibom`         | Generate CycloneDX AI/ML BOMs from source, Hugging Face URLs/purls, Modelfiles, or GGUF artifacts (`-t ai` defaults) | yes                              |
+| `hbom`          | Generate a CycloneDX hardware BOM for the current host                                                               | yes (`hbom`, `hbom-slim`)        |
+| `tracebom`      | Trace command execution to capture dynamic CBOM, cryptographic properties, software components, and services         | yes                              |
+| `cdx-audit`     | Prioritize existing BOM dependencies for upstream supply-chain review using explainable risk signals                 | yes                              |
+| `cdx-convert`   | Convert CycloneDX JSON to SPDX 3.0.1 JSON-LD                                                                         | yes                              |
+| `cdx-sign`      | Sign BOMs with JSF signatures                                                                                        | yes                              |
+| `cdx-validate`  | Validate BOMs and benchmark posture                                                                                  | yes                              |
+| `cdx-verify`    | Verify BOM signatures                                                                                                | yes                              |
+| `cdxi`          | Open the interactive REPL                                                                                            | no                               |
+| `evinse`        | Add evidence, reachability, and service context                                                                      | no                               |
+| `cbom`          | Alias for CBOM-oriented `cdxgen` defaults                                                                            | yes                              |
+| `obom`          | Alias for `cdxgen -t os`                                                                                             | yes                              |
+| `saasbom`       | Alias for SaaSBOM-oriented `cdxgen` defaults                                                                         | yes                              |
+| `spdxgen`       | Alias for `cdxgen --format spdx`                                                                                     | use `cdxgen`                     |
+| `cdxgen-secure` | Alias for hardened `cdxgen` defaults                                                                                 | use `cdxgen`                     |
+
+Standalone GitHub release binaries are published for `cdxgen`, `cdxgen-slim`, `aibom`, `cbom`, `obom`, `saasbom`, `hbom`, `hbom-slim`, `cdx-audit`, `cdx-convert`, `cdx-sign`, `cdx-validate`, `cdx-verify`, and `tracebom`.
+
+`hbom` release binaries bundle both `@cdxgen/cdx-hbom` and the matching `@cdxgen/cdxgen-plugins-bin*` companion helpers for the target platform. `hbom-slim` keeps the dedicated hardware collector (`@cdxgen/cdx-hbom`) but omits the companion plugin bundle when you want the smallest single-file HBOM executable.
+
+The `cbom` and `saasbom` release binaries bundle the Atom analysis stack (`@appthreat/atom` and `@appthreat/atom-parsetools`) plus protobuf export support (`@cdxgen/cdx-proto` and `@bufbuild/protobuf`). As of atom 3, `cbom` and `saasbom` embed a native atom binary and need **no JDK** on linux-amd64, linux-arm64 (glibc), linux-amd64-musl, darwin-arm64, and windows-amd64. On the jar-kind triples (darwin-amd64, windows-arm64, and linux-arm64-musl), the embedded atom still runs on the JVM and requires Java 23+. The `obom` release binary bundles the matching platform plugin package, pruned to runtime OS inventory helpers, plus the same protobuf export support. These aliases therefore support `--export-proto --proto-bin-file <file>` without requiring a separate npm install.
+
+`cdx-audit` is designed to accelerate upstream dependency review with explainable, evidence-backed risk prioritization. It complements provenance, reproducibility, and manual investigation rather than replacing them. Beyond the basic `cdx-audit --bom bom.json` usage, it supports three reporters (`--report console|json|sarif`), scope selection (`--scope all|required`), trusted-publishing filters (`--include-trusted` and `--only-trusted`), and license policies via `--license-policy`. Non-zero exit codes on findings make it easy to gate CI pipelines. See the [cdx-audit guide](docs/CDX_AUDIT.md) for the full reference.
+
+For AI-heavy repositories, cdxgen also supports an AI-BOM workflow via the `aibom` command or the `-t ai` project type aliases (`ai`, `aibom`, `ai-bom`). This emits AI service/model evidence and pairs naturally with the `ai-bom` BOM-audit category alias for governance, security, performance, AI-agent, and MCP findings.
+
+For host inventories, `hbom --include-runtime` produces a merged HBOM + OBOM view with strict topology links such as interface-name, driver-module, storage/runtime, and explicit secure-boot trust matches, plus a `host-topology` BOM audit pack for higher-confidence host findings. When the live hardware collector reports missing utilities or permission-sensitive enrichments, use `hbom diagnostics` (or inspect the derived `cdx:hbom:analysis:*` summary properties) before deciding whether a rerun with `--privileged` is justified.
+
+### Standalone executables (recommended)
+
+For a self-contained tool with no runtime dependencies, download a published
+release asset and verify its hash before executing it. This is the recommended
+method for CI and production use.
+
+Common asset names:
+
+- `cdxgen-linux-amd64`
+- `cdxgen-linux-amd64-musl`
+- `cdxgen-darwin-arm64`
+- `cdxgen-windows-amd64.exe`
+- `aibom-linux-amd64`
+- `aibom-darwin-arm64`
+- `aibom-windows-amd64.exe`
+- `hbom-linux-amd64`
+- `hbom-linux-amd64-slim`
+- `hbom-darwin-arm64`
+- `hbom-windows-amd64.exe`
+- `cdx-audit-linux-amd64`
+- `cdx-audit-darwin-arm64`
+- `cdx-audit-windows-amd64.exe`
+- `cdx-convert-*`, `cdx-sign-*`, `cdx-validate-*`, `cdx-verify-*`
+
+#### Linux
+
+```bash
+VERSION="v13.0.0"
+ASSET="cdx-audit-linux-amd64"
+BASE_URL="https://github.com/cdxgen/cdxgen/releases/download/${VERSION}"
+
+curl -fsSLO "${BASE_URL}/${ASSET}"
+curl -fsSLO "${BASE_URL}/${ASSET}.sha256"
+sha256sum -c "${ASSET}.sha256"
+chmod +x "${ASSET}"
+./"${ASSET}" --help
+```
+
+#### macOS
 
 ```bash
-cd ~/cdxgen-publish-placeholder
+VERSION="v13.0.0"
+ASSET="cdx-audit-darwin-arm64"
+BASE_URL="https://github.com/cdxgen/cdxgen/releases/download/${VERSION}"
+
+curl -fsSLO "${BASE_URL}/${ASSET}"
+curl -fsSLO "${BASE_URL}/${ASSET}.sha256"
+shasum -a 256 -c "${ASSET}.sha256"
+chmod +x "${ASSET}"
+./"${ASSET}" --help
+```
+
+#### Windows (PowerShell)
+
+```powershell
+$Version = "v13.0.0"
+$Asset = "cdx-audit-windows-amd64.exe"
+$BaseUrl = "https://github.com/cdxgen/cdxgen/releases/download/$Version"
+
+Invoke-WebRequest -Uri "$BaseUrl/$Asset" -OutFile $Asset
+Invoke-WebRequest -Uri "$BaseUrl/$Asset.sha256" -OutFile "$Asset.sha256"
+$Expected = (Get-Content "$Asset.sha256" | Select-Object -First 1).Trim().Split()[0]
+$Actual = (Get-FileHash $Asset -Algorithm SHA256).Hash.ToLowerInvariant()
+if ($Actual -ne $Expected.ToLowerInvariant()) {
+  throw "SHA256 mismatch for $Asset"
+}
+.\$Asset --help
+```
+
+#### GitHub Actions with the GitHub CLI
+
+```yaml
+permissions:
+  contents: read
+
+steps:
+  - name: Download cdx-audit release binary
+    env:
+      GH_TOKEN: ${{ github.token }}
+    run: |
+      gh release download v13.0.0 \
+        --repo cdxgen/cdxgen \
+        --pattern 'cdx-audit-linux-amd64' \
+        --pattern 'cdx-audit-linux-amd64.sha256'
+      sha256sum -c cdx-audit-linux-amd64.sha256
+      chmod +x cdx-audit-linux-amd64
+      ./cdx-audit-linux-amd64 --help
+```
+
+Package managers that install the standalone executable with a single command:
 
-npm pack --dry-run          # expect exactly: mod.js, README.md, LICENSE, package.json
+If you are a [Homebrew][homebrew-homepage] user, you can install [cdxgen][homebrew-cdxgen] via:
 
-npm login                   # or NODE_AUTH_TOKEN with publish rights on @cdxgen
-npm publish                 # access + placeholder tag come from publishConfig
+```shell
+$ brew install cdxgen
 ```
 
-Verify no `latest` tag was created:
+If you are a [Winget][winget-homepage] user on windows, you can also install cdxgen via:
+
+```shell
+winget install cdxgen
+```
+
+### Container images
+
+You can also use the cdxgen container image with node, deno, or bun runtime versions.
+
+The default version uses Node.js 24
 
 ```bash
-npm view @cdxgen/cdxgen dist-tags
-# { placeholder: '0.0.1' }   ← latest must be absent
+docker run --rm -e CDXGEN_DEBUG_MODE=debug -v /tmp:/tmp -v $(pwd):/app:rw -t ghcr.io/cdxgen/cdxgen:master -r /app -o /app/bom.json
 ```
 
-## Step 2 — publish to JSR
+To use the deno version, use `ghcr.io/cdxgen/cdxgen-deno` as the image name.
+
+```bash
+docker run --rm -e CDXGEN_DEBUG_MODE=debug -v /tmp:/tmp -v $(pwd):/app:rw -t ghcr.io/cdxgen/cdxgen-deno:master -r /app -o /app/bom.json
+```
 
-JSR requires the `@cdxgen` scope to exist first — create it at
-<https://jsr.io/new> if it does not. Then:
+For the bun version, use `ghcr.io/cdxgen/cdxgen-bun` as the image name.
 
 ```bash
-npx jsr publish
+docker run --rm -e CDXGEN_DEBUG_MODE=debug -v /tmp:/tmp -v $(pwd):/app:rw -t ghcr.io/cdxgen/cdxgen-bun:master -r /app -o /app/bom.json
 ```
 
-JSR has no dist-tag concept, so `0.0.1` becomes the only version until v13
-publishes over it.
+### npm and JavaScript package managers
 
-## Step 3 — configure the trusted publisher on npm
+The npm package is an alternative when you already have Node.js >= 24 available
+or need cdxgen as a library. It is the least self-contained option because it
+relies on a JavaScript runtime and optional native companions.
 
-<https://www.npmjs.com/package/@cdxgen/cdxgen> → **Settings** → **Trusted
-publisher** → GitHub Actions:
+Install the npm package without the optional binary plugins for basic SBOM generation.
 
-| Field | Value |
-| ----- | ----- |
-| Organization or user | `cdxgen` |
-| Repository | `cdxgen` |
-| Workflow filename | `npm-release.yml` |
-| Environment | *(leave empty unless the release job declares one)* |
+**npm**:
 
-The workflow filename must match the file in `.github/workflows/` **exactly**,
-and it must exist on the repository's default branch. A mismatch surfaces as a
-403 at publish time with no explanation of which field is wrong.
+```shell
+npm install -g @cdxgen/cdxgen --omit=optional --ignore-scripts --min-release-age=2
+```
 
-## Step 4 — configure the trusted publisher on JSR
+For a full and rich experience with support for multiple BOM types, remove `--omit=optional`.
 
-<https://jsr.io/@cdxgen/cdxgen/settings> → **GitHub repository** → link
-`cdxgen/cdxgen`. JSR verifies the OIDC token's repository claim, so any
-workflow in that repo with `id-token: write` can publish; there is no
-per-workflow field to match.
+```shell
+npm install -g @cdxgen/cdxgen --ignore-scripts --min-release-age=2
+```
 
-## Step 5 — fix the real release workflow
+**pnpm**:
 
-`.github/workflows/npm-release.yml` in `cdxgen/cdxgen` still carries the v12
-setup and will not authenticate against `@cdxgen`:
+```shell
+pnpm add -g @cdxgen/cdxgen --omit=optional --ignore-scripts --minimum-release-age=2880
+```
 
-```yaml
-      - name: Use Node.js
-        uses: actions/setup-node@...
-        with:
-          registry-url: https://registry.npmjs.org/
-          scope: '@cyclonedx'        # ← wrong namespace for v13
+**bun**:
+
+```shell
+bun install -g @cdxgen/cdxgen --ignore-scripts
 ```
 
-Two changes are needed, and the second is the one that silently breaks OIDC:
+To run cdxgen without installing (hotloading), use the [pnpm dlx](https://pnpm.io/cli/dlx) command.
 
-1. `scope: '@cyclonedx'` → `'@cdxgen'`, or drop it.
-2. **Drop `registry-url` as well.** `setup-node` writes an `.npmrc` containing
-   `//registry.npmjs.org/:_authToken=${NODE_AUTH_TOKEN}` whenever
-   `registry-url` is set. npm prefers that token over the OIDC exchange, so the
-   publish either fails on an empty token or succeeds using a long-lived
-   secret — quietly defeating the point of trusted publishing.
+```shell
+corepack pnpm dlx @cdxgen/cdxgen --help
+```
 
-The job already has `id-token: write`, which is the other half of the
-requirement.
+You can call any packaged command the same way:
+
+```shell
+corepack pnpm dlx --package=@cdxgen/cdxgen cdx-audit --help
+corepack pnpm dlx --package=@cdxgen/cdxgen cdx-convert --help
+corepack pnpm dlx --package=@cdxgen/cdxgen cdx-validate --help
+corepack pnpm dlx --package=@cdxgen/cdxgen cdx-sign --help
+corepack pnpm dlx --package=@cdxgen/cdxgen cdx-verify --help
+corepack pnpm dlx --package=@cdxgen/cdxgen hbom --help
+corepack pnpm dlx --package=@cdxgen/cdxgen hbom diagnostics --help
+corepack pnpm dlx --package=@cdxgen/cdxgen evinse --help
+corepack pnpm dlx --package=@cdxgen/cdxgen cdxi --help
+```
+
+cdxgen also runs under the [bun](https://bun.sh) runtime, including `bunx --bun @cdxgen/cdxgen`. Bun projects using a text lockfile (`bun.lock`) are supported as an SBOM target via the `bun` project type (`-t bun`); the legacy binary lockfile (`bun.lockb`) is not parsed, so regenerate a text lockfile with `bun install --save-text-lockfile`.
 
-Also confirm the npm CLI version: OIDC publishing needs **npm >= 11.5.1**, and
-the version bundled with a given Node release is often older. `npm install -g
-npm@latest` before publishing, or pin a known-good version.
+```shell
+bun install -g @cdxgen/cdxgen --ignore-scripts
+```
 
-See `.github/workflows/publish.yml` here for the full shape.
+cdxgen also runs under the [deno](https://deno.com) runtime. Deno projects with a lockfile (`deno.lock`, versions 2 - 5) are supported as an SBOM target via the `deno` project type (`-t deno`); `jsr:` imports are recorded under the `@jsr` npm-compat scope, `npm:` imports as regular npm components and remote `https://` imports as generic components.
+
+```shell
+deno install --allow-read --allow-env --allow-run --allow-sys=uid,systemMemoryInfo,gid,homedir --allow-write --allow-net -n cdxgen "npm:@cdxgen/cdxgen/cdxgen"
+```
+
+In deno applications, cdxgen could be directly imported without any conversion.
+
+```ts
+import { createBom, submitBom } from "npm:@cdxgen/cdxgen@^13";
+```
+
+## Common workflows
+
+| Goal                                                       | First command                                                                                               | Read next                                       |
+| ---------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | ----------------------------------------------- |
+| Generate a BOM from the current repository                 | `cdxgen -o bom.json .`                                                                                      | [CLI Usage][docs-cli]                           |
+| Generate a BOM from a git URL                              | `cdxgen -o bom.json https://github.com/example/project.git`                                                 | [CLI Usage][docs-cli]                           |
+| Generate a BOM from a package URL                          | `cdxgen -o bom.json "pkg:npm/lodash@4.17.21"`                                                               | [CLI Usage][docs-cli]                           |
+| Generate a dynamically traced CBOM for an application      | `tracebom --cbom-output cbom.json -- npm test`                                                              | [Threat Model](docs/THREAT_MODEL.md)            |
+| Generate and audit an AI-BOM from the current repository   | `cdxgen -r --include-formulation -o aibom.json --bom-audit --bom-audit-categories ai-bom .`                 | [AI-BOM Guide](docs/AI_BOM.md)                  |
+| Scan a container image                                     | `cdxgen ghcr.io/owasp-dep-scan/depscan:nightly -o bom.json -t docker`                                       | [Server Usage][docs-server]                     |
+| Audit a generated BOM for built-in supply-chain findings   | `cdxgen -o bom.json --bom-audit .`                                                                          | [BOM Audit](docs/BOM_AUDIT.md)                  |
+| Prioritize an existing BOM for upstream risk-driven review | `cdx-audit --bom bom.json`                                                                                  | [cdx-audit](docs/CDX_AUDIT.md)                  |
+| Re-audit a saved AI-BOM directly later                     | `cdx-audit --bom aibom.json --direct-bom-audit --categories ai-bom`                                         | [AI-BOM Guide](docs/AI_BOM.md)                  |
+| Enrich and audit a Go BOM with Golem semantic evidence     | `evinse -i bom.json -o bom.evinse.json -l go /absolute/path/to/go/project`                                  | [Go Evinse with Golem](docs/GO_EVINSE_GOLEM.md) |
+| Re-audit a saved OBOM or BOM directly later                | `cdx-audit --bom obom.json --direct-bom-audit --categories obom-runtime`                                    | [cdx-audit](docs/CDX_AUDIT.md)                  |
+| Validate a BOM against structural and compliance checks    | `cdx-validate -i bom.json`                                                                                  | [cdx-validate](docs/CDX_VALIDATE.md)            |
+| Convert CycloneDX JSON to SPDX JSON-LD                     | `cdx-convert -i bom.json -o bom.spdx.json`                                                                  | [cdx-convert](docs/CDX_CONVERT.md)              |
+| Generate an OBOM for live-system triage                    | `obom -o obom.json --deep --bom-audit --bom-audit-categories obom-runtime`                                  | [OBOM lessons](docs/OBOM_LESSONS.md)            |
+| Review an offline rootfs for hardening drift               | `cdxgen /absolute/path/to/rootfs -t rootfs -o bom.json --bom-audit --bom-audit-categories rootfs-hardening` | [BOM Audit](docs/BOM_AUDIT.md)                  |
+
+For the full option reference, use `cdxgen --help` or visit [CLI Usage][docs-cli].
+
+Companion commands also expose built-in help:
+
+- `cbom --help`
+- `cdx-audit --help`
+- `cdx-validate --help`
+- `cdx-convert --help`
+- `cdx-sign --help`
+- `cdx-verify --help`
+- `cdxgen-secure --help`
+- `cdxi --help`
+- `evinse --help`
+- `obom --help`
+- `saasbom --help`
+- `spdxgen --help`
+
+## Example
+
+Minimal example.
+
+```shell
+cdxgen -o bom.json
+```
+
+The primary positional input can be:
+
+- a local filesystem path (default: current directory)
+- a git URL that cdxgen clones before scanning
+- a package URL (purl) that cdxgen resolves to source and then scans
+
+Common source input examples:
+
+```shell
+# Local path
+cdxgen -o bom.json .
+
+# Git URL
+cdxgen -t java -o bom.json --git-branch main https://github.com/HooliCorp/java-sec-code.git
+
+# Package URL (purl)
+cdxgen -t js -o bom.json "pkg:npm/lodash@4.17.21"
+```
+
+For a java project. cdxgen would automatically detect maven, gradle, or sbt and build bom accordingly
+
+```shell
+cdxgen -t java -o bom.json
+```
+
+To print the SBOM as a table pass `-p` argument.
+
+```shell
+cdxgen -t java -o bom.json -p
+```
+
+To recursively generate a single BOM for all languages pass `-r` argument.
+
+```shell
+cdxgen -r -o bom.json
+```
+
+To generate an SBOM directly from a git URL:
+
+```shell
+cdxgen -t java -o bom.json --git-branch main https://github.com/HooliCorp/java-sec-code.git
+```
+
+This works anywhere cdxgen expects its primary source input, so a git URL can be used in place of `.` or any other local path.
+
+To generate an SBOM from a package URL (purl), cdxgen resolves registry metadata to a repository URL, clones it, and scans it:
+
+```shell
+cdxgen -t js -o bom.json "pkg:npm/lodash@4.17.21"
+```
 
-## Step 6 — after v13.0.0 is released
+Supported purl source types: `npm`, `pypi`, `gem`, `cargo`, `pub`, `github`, `bitbucket`, `maven` (version required), `composer`, and `generic` (with `vcs_url` or `download_url` qualifier).
 
-Remove the placeholder tag so the package has no stray pointers:
+> **Warning:** Repository URLs resolved from registries may be inaccurate or malicious. Review resolved sources before trusting generated output.
+
+The default specification used by cdxgen is 1.7. To generate BOM for a different specification version, such as 1.6, pass the version number using the `--spec-version` argument. Accepted values are 1.6, 1.7, and 2.0. Versions 1.4 and 1.5 are only available as output downgrades, not as generation targets; generate at 1.6 or higher and then use `cdx-convert --to 1.5` for legacy consumers.
+
+```shell
+# 1.6 is supported by most tools
+cdxgen -r -o bom.json --spec-version 1.6
+```
+
+Use repeated `--component-type` values to include only selected CycloneDX component types. This is a filter, not an inventory enabler: passing a type such as `machine-learning-model` does not enable machine-learning model discovery, and filtering to a type that the scan does not generate can produce an empty component list. The allowed values are validated against `--spec-version`; for example, `cryptographic-asset` requires 1.6 or newer, and unsupported component types are pruned during compatibility downgrades. The dedicated `cbom` command does not accept `--component-type`; use `cdxgen --include-crypto` for normal generation plus filtering.
+
+```shell
+cdxgen -t docker alpine:3.20 --spec-version 1.6 --component-type library --component-type data
+```
+
+To generate SBOM for C or Python, ensure Java >= 21 is installed.
+
+```shell
+# Install java >= 21
+cdxgen -t c -o bom.json
+```
+
+NOTE: cdxgen is known to freeze with Java 8 or 11, so ensure >= 21 is installed and JAVA_HOME environment variable is configured correctly. If in doubt, use the cdxgen container image.
+
+## Universal SBOM
+
+By passing the type argument `-t universal`, cdxgen could be forced to opportunistically collect as many components and services as possible by scanning all package, container, and Kubernetes manifests. The resulting SBOM could have over a thousand components, thus requiring additional triaging before use with traditional SCA tools.
+
+## SBOM server
+
+Invoke cdxgen with `--server` argument to run it in server mode. By default, it listens to port `9090`, which can be customized with the arguments `--server-host` and `--server-port`.
+
+```shell
+cdxgen --server
+```
+
+Or use the container image.
+
+```bash
+docker run --rm -v /tmp:/tmp -p 9090:9090 -v $(pwd):/app:rw -t ghcr.io/cdxgen/cdxgen -r /app --server --server-host 0.0.0.0
+```
+
+Use curl or your favorite tool to pass arguments to the `/sbom` route.
+
+### Server arguments
+
+Arguments can be passed either via the query string or as a JSON body. Please refer to [Server Usage][docs-server]
+
+### Health endpoint
+
+Use the /health endpoint to check if the SBOM server is up and running.
+
+```shell
+curl "http://127.0.0.1:9090/health"
+```
+
+### Scanning a local path
+
+```shell
+curl "http://127.0.0.1:9090/sbom?path=/Volumes/Work/sandbox/vulnerable-aws-koa-app&multiProject=true&type=js"
+```
+
+### Scanning a git repo
+
+```shell
+curl "http://127.0.0.1:9090/sbom?url=https://github.com/HooliCorp/vulnerable-aws-koa-app.git&multiProject=true&type=js"
+```
+
+If you need to pass credentials to authenticate.
+
+```shell
+curl "http://127.0.0.1:9090/sbom?url=https://<access_token>@github.com/some/repo.git&multiProject=true&type=js"
+curl "http://127.0.0.1:9090/sbom?url=https://<username>:<password>@bitbucket.org/some/repo.git&multiProject=true&type=js"
+```
+
+You can POST the arguments.
 
 ```bash
-npm dist-tag rm @cdxgen/cdxgen placeholder
-npm view @cdxgen/cdxgen dist-tags   # expect only: latest: 13.0.0
+curl -H "Content-Type: application/json" http://localhost:9090/sbom -XPOST -d $'{"url": "https://github.com/HooliCorp/vulnerable-aws-koa-app.git", "type": "nodejs", "multiProject": "true"}'
+```
+
+### Review-first dry runs
+
+When you want to inspect what cdxgen would do before allowing side effects, use `--dry-run`.
+
+```shell
+cdxgen --dry-run -p -t js .
+```
+
+Dry-run mode keeps cdxgen read-only: it reads local files, blocks writes/exec/temp creation/cloning/submission, and prints an activity summary table for both beginners and power users. When available, the recorded activity data also captures archive extraction intent, command I/O volume, and followed symlink-resolution traces.
+
+### Docker compose
+
+```shell
+git clone https://github.com/cdxgen/cdxgen.git
+docker compose up
 ```
 
-`0.0.1` stays published — npm unpublishing is restricted and the version is
-harmless once `latest` exists.
+## War file support
 
-## Verifying trusted publishing actually engaged
+cdxgen can generate a BOM file from a given war file.
 
-A successful OIDC publish attaches a provenance attestation. After the first
-real release:
+```shell
+# cdxgen -t java app.war
+cdxgen app.war
+```
+
+## Resolving licenses
+
+cdxgen can automatically query public registries such as maven, npm, or nuget to resolve the package licenses. This is a time-consuming operation and is disabled by default. To enable, set the environment variable `FETCH_LICENSE` to `true`, as shown. Ensure that `GITHUB_TOKEN` is set or provided by [built-in GITHUB_TOKEN in GitHub Actions][github-rate-limit], otherwise rate limiting might prevent license resolving.
 
 ```bash
-npm view @cdxgen/cdxgen dist.attestations
+export FETCH_LICENSE=true
+```
+
+## Dependency Tree
+
+cdxgen can retain the dependency tree under the `dependencies` attribute for a small number of supported package manifests. These are currently limited to:
+
+- package-lock.json
+- yarn.lock
+- pnpm-lock.yaml
+- Maven (pom.xml)
+- Gradle
+- Scala SBT
+- Python (requirements.txt, setup.py, pyproject.toml, poetry.lock)
+- .NET (packages.lock.json, project.assets.json, paket.lock, .nuspec/.nupkg)
+- Go (go.mod)
+- PHP (composer.lock)
+- Ruby (Gemfile.lock)
+- Rust (Cargo.lock)
+
+## Plugins
+
+`cdxgen` can be extended with external binary plugins to support more SBOM use cases. These are installed as optional dependencies and can be used without a global install.
+
+```shell
+pnpm dlx @cdxgen/cdxgen-plugins-bin
+```
+
+## Rust accelerator (cdxrs)
+
+cdxgen ships with an optional Rust accelerator binary, `cdxrs`, which speeds up hot paths such as registry metadata lookups where available. Use the `--rust` and `--no-rust` arguments to toggle it, or set the environment variable `CDXGEN_RS_DISABLE=all` to force the JavaScript path. See the [cdxrs protocol](./docs/CDXRS_PROTOCOL.md) document for implementation details.
+
+## Metadata cache
+
+cdxgen caches registry metadata on disk to speed up repeat runs. Use the `cdxgen cache <info|clear>` subcommand to inspect or purge the cache, the `--cache` and `--cache-ttl` arguments to control it per run, or the `CDXGEN_NO_CACHE` and `CDXGEN_CACHE_TTL` environment variables for the same effect.
+
+## Docker / OCI container support
+
+`docker` type is automatically detected based on the presence of values such as `sha256` or `docker.io` prefix etc in the path.
+
+```shell
+cdxgen odoo@sha256:4e1e147f0e6714e8f8c5806d2b484075b4076ca50490577cdf9162566086d15e -o /tmp/bom.json
+```
+
+You can also pass `-t docker` with repository names. Only the `latest` tag would be pulled if none was specified.
+
+```shell
+cdxgen shiftleft/scan-slim -o /tmp/bom.json -t docker
+```
+
+For offline or staged scans, point cdxgen at a locally reconstructed root filesystem directory. The container pipeline accepts `-t docker`, `-t rootfs`, or `-t oci-dir` for this mode.
+
+```shell
+cdxgen /tmp/remote_target -o /tmp/bom.json -t rootfs
+```
+
+With the packaged helpers installed, rootfs and container BOMs gain repository trust-source components, deep keyring / CA-store `cryptographic-asset` components, native CycloneDX origin fields such as `supplier`, `manufacturer`, and `authors` for OS package trust metadata, plus additional package trust-state properties such as `PackageArchitecture`, `PackageSource`, and `PackageStatus`.
+
+You can also pass the .tar file of a container image.
+
+```shell
+docker pull shiftleft/scan-slim
+docker save -o /tmp/slim.tar shiftleft/scan-slim
+podman save -q --format oci-archive -o /tmp/slim.tar shiftleft/scan-slim
+cdxgen /tmp/slim.tar -o /tmp/bom.json -t docker
+```
+
+### Podman in rootless mode
+
+Setup podman in either [rootless][podman-github-rootless] or [remote][podman-github-remote] mode
+
+Do not forget to start the podman socket required for API access on Linux.
+
+```shell
+systemctl --user enable --now podman.socket
+systemctl --user start podman.socket
+podman system service -t 0 &
+```
+
+## Generate OBOM for a live system
+
+You can use the `obom` command to generate an OBOM for a live system or a VM for compliance and vulnerability management purposes. Linux, Windows, and macOS are supported in this mode, though some macOS tables require elevated privileges and Full Disk Access.
+
+```shell
+# obom is an alias for cdxgen -t os
+obom
+# cdxgen -t os
+```
+
+This feature is powered by osquery, which is [installed](https://github.com/cdxgen/cdxgen-plugins-bin/blob/main/build.sh#L8) along with the binary plugins. cdxgen would opportunistically try to detect as many components, apps, and extensions as possible using the platform-specific default queries under `data/queries*.json`. The Linux profile includes dedicated `sysctl_hardening` and `mount_hardening` snapshots, GTFOBins enrichment for privileged and network-active runtime rows, Secure Boot certificate inventory, and improved npm package discovery. When the optional `trustinspector` helper is available, OBOM collection is further enriched with:
+
+- macOS code-signing authority, team ID, and notarization assessment metadata for discovered application paths
+- Windows Authenticode signer/timestamp metadata for discovered executable paths
+- Windows WDAC active-policy inventory
+- batched path inspection so large host inventories keep their trust metadata instead of stopping at the first few hundred paths
+
+Container and rootfs BOMs also summarize how many executable and shared-library file components were discovered outside OS package ownership. Look for `cdx:container:unpackagedExecutableCount` and `cdx:container:unpackagedSharedLibraryCount` in metadata, or use `.unpackagedbins` and `.unpackagedlibs` in `cdxi` for an interactive pivot.
+
+The process would take several minutes and result in an SBOM file with thousands of components of various types, such as operating-system, device-drivers, files, and data.
+
+For practical SOC/IR and compliance workflows, see the dedicated [OBOM lessons](./docs/OBOM_LESSONS.md). For macOS-specific setup and permission caveats, see [OBOM macOS troubleshooting](./docs/OBOM_MACOS_TROUBLESHOOTING.md). For compact before/after examples of the new trust metadata, see [Trust enrichment BOM diff examples](./docs/TRUST_ENRICHMENT_DIFF.md).
+
+## Generate Cryptography Bill of Materials (CBOM)
+
+Use the `cbom` alias to generate a CBOM. In addition to keystores and certificates, cdxgen can also derive cryptographic algorithm inventory from JavaScript and TypeScript source by following lightweight constant propagation through common `node:crypto`, WebCrypto, and JWT call sites.
+
+```shell
+cbom -t java
+# cdxgen -t java --include-crypto -o bom.json .
+
+# Add source-derived crypto algorithms for a JS or TS project
+cdxgen --include-crypto -o bom.json /absolute/path/to/js-project
+```
+
+When reviewing the result in `cdxi`, use `.cryptos` for the full cryptographic asset view or `.sourcecryptos` to narrow the list to source-derived algorithm components only.
+
+## Generating SaaSBOM and component evidences
+
+See [evinse mode](./ADVANCED.md) in the advanced documentation.
+
+---
+
+## BOM signing
+
+cdxgen features a best-in-class, native **JSON Signature Format (JSF)** implementation for BOM signing, providing robust authenticity and non-repudiation capabilities. Unlike basic signing tools, our implementation fully supports granular signatures (signing individual components, services, and annotations), parallel Multi-Signatures (`signers`), and sequential Signature Chains (`chain`).
+
+To enable automatic signing during BOM generation, set the following environment variables:
+
+- `SBOM_SIGN_ALGORITHM`: JSF Algorithm. Examples: `RS512`, `ES256`, `Ed25519`, `HS256`
+- `SBOM_SIGN_PRIVATE_KEY`: Location of the private key (PEM format)
+- `SBOM_SIGN_PUBLIC_KEY`: Optional. Location of the public key
+- `SBOM_SIGN_MODE`: Optional. Signature mode (`replace`, `signers`, `chain`). Default is `replace`.
+
+To quickly generate test public/private key pairs and sign your first BOM, you can run cdxgen with the `--generate-key-and-sign` argument.
+
+### Advanced Signing with `cdx-sign`
+
+For complex supply chain orchestration, use the bundled `cdx-sign` CLI. This tool allows multiple entities (e.g., a Builder and an Auditor) to co-sign an existing BOM without modifying its original data.
+
+```shell
+# Append a parallel multi-signature (Auditor co-signing)
+# Note: Granular component signing is disabled to preserve the Builder's original signature payload.
+cdx-sign -i bom.json -k auditor_private.pem -a ES256 --key-id "auditor-qa" --mode signers --no-sign-components
+```
+
+### Validating CycloneDX BOMs
+
+Use the bundled `cdx-validate` command to validate CycloneDX BOMs against **structural**, **deep**, and **compliance** checks. Refer to this [document](./docs/CDX_VALIDATE.md) for usage.
+
+### Verifying the signature
+
+Use the bundled `cdx-verify` command to validate BOM signatures. By default, `cdx-verify` performs a **strict deep verification**, meaning it mathematically validates the top-level BOM signature _and_ the signatures of every nested component, service, and annotation against the provided public key. Refer to this [lesson](./docs/LESSON6.md) for the usage of sign and verify commands.
+
+```shell
+npm install -g @cdxgen/cdxgen --omit=optional --ignore-scripts --min-release-age=2
+
+# Perform strict deep verification (default)
+cdx-verify -i bom.json --public-key public.key
+
+# Verify ONLY the top-level root signature (useful for verifying a multi-signer who didn't sign nested components)
+cdx-verify -i bom.json --public-key auditor_public.key --no-deep
+```
+
+### Verifying the signature (pnpm)
+
+You can run the verification tools directly using pnpm (no global install needed):
+
+```shell
+pnpm dlx @cdxgen/cdxgen cdx-verify -i bom.json --public-key public.key
+```
+
+You can also use pnpm to invoke the signing tool:
+
+```shell
+pnpm dlx @cdxgen/cdxgen cdx-sign -i bom.json -k private.key
+```
+
+---
+
+## Automatic usage detection
+
+For node.js projects, lock files are parsed initially, so the SBOM would include all dependencies, including dev ones. An AST parser powered by babel-parser is then used to detect packages that are imported and used by non-test code. Such imported packages would automatically set their scope property to `required` in the resulting SBOM. You can turn off this analysis by passing the argument `--no-babel`. Scope property would then be set based on the `dev` attribute in the lock file.
+
+This attribute can be later used for various purposes. For example, [dep-scan][depscan-github] uses this attribute to prioritize vulnerabilities. Unfortunately, tools such as dependency track, do not include this feature and might over-report the CVEs.
+
+With the argument `--required-only`, you can limit the SBOM only to include packages with the scope "required", commonly called production or non-dev dependencies. Combine with `--no-babel` to limit this list to only non-dev dependencies based on the `dev` attribute being false in the lock files.
+
+For go, `go mod why` command is used to identify required packages. For php, composer lock file is parsed to distinguish required (packages) from optional (packages-dev).
+
+## Automatic services detection
+
+cdxgen can automatically detect names of services from YAML manifests such as docker-compose, Kubernetes, or Skaffold manifests. These would be populated under the `services` attribute in the generated SBOM. With [evinse](./ADVANCED.md), additional services could be detected by parsing common annotations from the source code.
+
+## Conversion to SPDX format
+
+For direct conversion of an existing CycloneDX JSON BOM to SPDX JSON-LD, use
+the bundled `cdx-convert` command:
+
+```shell
+cdx-convert -i bom.json -o bom.spdx.json
+```
+
+`cdx-convert` currently supports CycloneDX 1.6, 1.7, and 2.0 inputs, accepts and
+produces protobuf, and exports SPDX 3.0.1 JSON-LD. The `--to` argument accepts
+either `spdx` or a CycloneDX spec version (1.5, 1.6, or 1.7) for
+CycloneDX-to-CycloneDX cross-version conversion, which is also the recommended
+way to produce 1.5 output for legacy consumers.
+
+Use `cdxgen --format spdx` (or `--format cyclonedx,spdx`) when generating BOMs.
+Use the [CycloneDX CLI][cyclonedx-cli-github] tool for advanced use cases such
+as diff and merging.
+
+To distribute BOMs through the Transparency Exchange API (TEA), use the
+`--tea-fetch` and `--tea-publish` arguments. See the [TEA lesson](docs/LESSON20.md)
+for usage.
+
+## Including .NET Global Assembly Cache dependencies in the results
+
+For `dotnet` and `dotnet-framework`, SBOM could include components without a version number. Often, these components begin with the prefix `System.`.
+
+Global Assembly Cache (GAC) dependencies (System Runtime dependencies) must be made available in the build output of the project for version detection. A simple way to have the dotnet build copy the GAC dependencies into the build directory is to place the file `Directory.Build.props` into the root of the project and ensure the contents include the following:
+
+```
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<ItemDefinitionGroup>
+  <Reference>
+    <Private>True</Private>
+  </Reference>
+</ItemDefinitionGroup>
+</Project>
+```
+
+Then, run cdxgen cli with the `--deep` argument.
+
+## License
+
+Permission to modify and redistribute is granted under the terms of the Apache 2.0 license. See the [LICENSE][github-license] file for the full license.
+
+## Integration as library
+
+cdxgen is [ESM only](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c) and could be imported and used with both deno and Node.js >= 24
+
+Minimal example:
+
+```ts
+import { createBom, submitBom } from "npm:@cdxgen/cdxgen@^13";
+```
+
+See the [Deno Readme](./contrib/deno/README.md) for detailed instructions.
+
+```javascript
+import { createBom, submitBom } from "@cdxgen/cdxgen";
+// bomNSData would contain bomJson
+const bomNSData = await createBom(filePath, options);
+// Submission to dependency track server
+const dbody = await submitBom(args, bomNSData.bomJson);
+```
+
+## Contributing
+
+Please check out our [open issues][github-contribute] if you are interested in helping.
+
+### Codeberg Mirror
+
+The project is mirrored on [Codeberg](https://codeberg.org/cdxgen/cdxgen). Users can clone the repository using the following URL:
+
+```shell
+git clone https://codeberg.org/cdxgen/cdxgen.git
+```
+
+The maintainers accept Pull Requests (PRs) against the Codeberg repository.
+
+> **Note:** The Codeberg repository is currently synced manually from GitHub.
+
+Before raising a PR, please run the following commands.
+
+```shell
+corepack enable pnpm
+pnpm install:frozen
+# Generate types using jsdoc syntax
+pnpm run gen-types
+# Run biomejs formatter and linter with auto fix
+pnpm run lint
+# Run poku tests
+pnpm test
+```
+
+### Testing main branch
+
+Use `pnpm add -g` command to quickly test the main branch.
+
+```shell
+corepack pnpm bin -g
+corepack pnpm setup
+corepack pnpm add -g https://github.com/cdxgen/cdxgen
+cdxgen --help
+```
+
+### Testing main branch (No Global Install)
+
+To quickly test the latest main branch without installing globally, you can use `pnpm` in a local or temporary environment.
+
+```shell
+corepack enable
+pnpm install --prefer-offline
+pnpm dlx cdxgen --help
+```
+
+## Sponsors
+
+<div style="display: flex; align-items: center; gap: 20px;">
+  <img src="./docs/_media/GithubLogo-LightBg.png" width="180" height="180">
+  <img src="./docs/_media/MicrosoftLogo.png" width="180" height="180">
+</div>
+
+Some features are funded through [NGI Zero Core](https://nlnet.nl/core), a fund established by [NLnet](https://nlnet.nl) with financial support from the European Commission's [Next Generation Internet](https://ngi.eu) program. Learn more at the [NLnet project page](https://nlnet.nl/project/OWASP-dep-scan).
+
+[<img src="https://nlnet.nl/logo/banner.png" alt="NLnet foundation logo" width="20%" />](https://nlnet.nl)
+[<img src="https://nlnet.nl/image/logos/NGI0_tag.svg" alt="NGI Zero Logo" width="20%" />](https://nlnet.nl/core)
+
+cdxgen is an OWASP Foundation production project.
+
+[<img src="https://owasp.org/assets/images/logo.png" width="20%" />](https://owasp.org)
+
+## cdxgen badge
+
+Copy the below block to your markdown files to show your ❤️ for cdxgen.
+
+```markdown
+[![SBOM](https://img.shields.io/badge/SBOM-with_%E2%9D%A4%EF%B8%8F_by_cdxgen-FF753D)](https://github.com/cdxgen/cdxgen)
 ```
 
-If that is empty, the publish used a token and the trusted-publisher path was
-never exercised, whatever the workflow logs suggest.
+<!-- LINK LABELS -->
+<!-- Badges -->
+
+[badge-github-contributors]: https://img.shields.io/github/contributors/cdxgen/cdxgen
+[badge-github-license]: https://img.shields.io/github/license/cdxgen/cdxgen
+[badge-github-releases]: https://img.shields.io/github/v/release/cdxgen/cdxgen
+[badge-jsr]: https://img.shields.io/jsr/v/%40cdxgen/cdxgen
+[badge-npm]: https://img.shields.io/npm/v/%40cdxgen%2Fcdxgen
+[badge-npm-downloads]: https://img.shields.io/npm/dy/%40cdxgen%2Fcdxgen
+[badge-swh]: https://archive.softwareheritage.org/badge/origin/https://github.com/cdxgen/cdxgen/
+
+<!-- cdxgen github project -->
+
+[github-contribute]: https://github.com/cdxgen/cdxgen/contribute
+[github-contributors]: https://github.com/cdxgen/cdxgen/graphs/contributors
+[github-license]: https://github.com/cdxgen/cdxgen/blob/master/LICENSE
+[github-releases]: https://github.com/cdxgen/cdxgen/releases
+
+<!-- cdxgen documentation site -->
+
+[docs-homepage]: https://cdxgen.github.io/cdxgen
+[docs-advanced-usage]: https://cdxgen.github.io/cdxgen/#/ADVANCED
+[docs-cli]: https://cdxgen.github.io/cdxgen/#/CLI
+[docs-env-vars]: https://cdxgen.github.io/cdxgen/#/ENV
+[docs-permissions]: https://cdxgen.github.io/cdxgen/#/PERMISSIONS
+[docs-project-types]: https://cdxgen.github.io/cdxgen/#/PROJECT_TYPES
+[docs-server]: https://cdxgen.github.io/cdxgen/#/SERVER
+[docs-support]: https://cdxgen.github.io/cdxgen/#/SUPPORT
+
+<!-- web links-->
+
+[cyclonedx-cli-github]: https://github.com/CycloneDX/cyclonedx-cli
+[depscan-github]: https://github.com/owasp-dep-scan/dep-scan
+[github-rate-limit]: https://docs.github.com/en/rest/overview/rate-limits-for-the-rest-api#primary-rate-limit-for-github_token-in-github-actions
+[homebrew-homepage]: https://brew.sh
+[homebrew-cdxgen]: https://formulae.brew.sh/formula/cdxgen
+[winget-homepage]: https://learn.microsoft.com/en-us/windows/package-manager/winget/
+[jsr-cdxgen]: https://jsr.io/@cdxgen/cdxgen
+[librariesio]: https://libraries.io/npm/@cdxgen%2Fcdxgen
+[npmjs-cdxgen]: https://www.npmjs.com/package/@cdxgen/cdxgen
+[npmjs-cdxgen-v12]: https://www.npmjs.com/package/@cyclonedx/cdxgen
+[podman-github-rootless]: https://github.com/containers/podman/blob/master/docs/tutorials/rootless_tutorial.md
+[podman-github-remote]: https://github.com/containers/podman/blob/master/docs/tutorials/mac_win_client.md
+[swh-cdxgen]: https://archive.softwareheritage.org/browse/origin/?origin_url=https://github.com/cdxgen/cdxgen