@trustify-da/trustify-da-javascript-client 0.3.0-ea.0c4e031 → 0.3.0-ea.0d78462

package/dist/src/providers/base_java.js

@@ -14,6 +14,13 @@ export const ecosystem_gradle = 'gradle';
 export default class Base_Java {
     DEP_REGEX = /(([-a-zA-Z0-9._]{2,})|[0-9])/g;
     CONFLICT_REGEX = /.*omitted for conflict with (\S+)\)/;
+    /**
+     * Maven dependency scopes. Used to detect whether the trailing column of a
+     * dependency-tree line is a scope keyword — which in turn signals that an
+     * optional classifier column is present between the packaging and version.
+     * @type {string[]}
+     */
+    static MAVEN_SCOPES = ['compile', 'provided', 'runtime', 'test', 'system', 'import'];
     globalBinary;
     localWrapper;
     /**
@@ -82,31 +89,71 @@ export default class Base_Java {
         }
         return ((line.indexOf('-') - 1) / 3) + 1;
     }
+    /**
+     * Parse a single dependency-tree line into its Maven coordinate parts.
+     *
+     * This is the single source of truth for interpreting a dependency-tree
+     * line. Both {@link parseDep} (used to build SBOM component PURLs) and the
+     * Maven hash-map builder rely on it, so the PURL key and the artifact file
+     * path can never drift from one another.
+     *
+     * A line has the shape `groupId:artifactId:packaging[:classifier]:version[:scope]`.
+     * The classifier column is only present when a sixth column holds a known
+     * Maven scope keyword; otherwise the fourth column is the version.
+     *
+     * @param {string} line - line to parse from a dependency tree
+     * @returns {{groupId: string, artifactId: string, packaging: string, classifier: (string|null), version: string, scope: (string|null), overridden: boolean}}
+     *   Parsed coordinate. `version` is the resolved concrete version — when the
+     *   line carries a conflict override the override version replaces it and
+     *   `overridden` is set, mirroring how Maven records the winning version.
+     */
+    parseCoordinate(line) {
+        const parts = line.split(':').map(part => part ? part.match(this.DEP_REGEX)?.[0] ?? '' : '');
+        const groupId = parts[0] ?? '';
+        const artifactId = parts[1] ?? '';
+        const packaging = parts[2] ?? '';
+        // A classifier column exists only when a sixth column holds a scope keyword.
+        const hasClassifier = parts.length >= 6 && Base_Java.MAVEN_SCOPES.includes(parts[5]);
+        const classifier = hasClassifier ? parts[3] : null;
+        let version = (hasClassifier ? parts[4] : parts[3]) ?? '';
+        const scope = hasClassifier ? parts[5] : (parts.length >= 5 ? parts[4] : null);
+        // A conflict override replaces the resolved version entirely.
+        const override = line.match(this.CONFLICT_REGEX);
+        const overridden = Boolean(override);
+        if (overridden) {
+            version = override[1];
+        }
+        return { groupId, artifactId, packaging, classifier, version, scope, overridden };
+    }
+    /**
+     * Build the canonical PackageURL for a parsed coordinate.
+     *
+     * The classifier is folded into the version component (e.g.
+     * `4.1.0-linux-x86_64`) except when the version came from a conflict
+     * override, in which case the override version stands alone — matching the
+     * historical behavior of {@link parseDep}.
+     *
+     * @param {{groupId: string, artifactId: string, classifier: (string|null), version: string, overridden: boolean}} coord
+     * @returns {PackageURL} The canonical packageURL for the coordinate
+     * @protected
+     */
+    _coordinateToPurl(coord) {
+        const purlVersion = (coord.classifier && !coord.overridden)
+            ? `${coord.version}-${coord.classifier}`
+            : coord.version;
+        return this.toPurl(coord.groupId, coord.artifactId, purlVersion);
+    }
     /**
      * Create a PackageURL from any line in a Text Graph dependency tree for a manifest path.
      * @param {string} line - line to parse from a dependencies.txt file
      * @returns {PackageURL} The parsed packageURL
      */
     parseDep(line) {
-        let match = line.split(':').map(part => part ? part.match(this.DEP_REGEX)[0] : '');
-        if (!match) {
-            throw new Error(`Unable generate SBOM from dependency tree. Line: ${line} cannot be parsed into a PackageURL`);
-        }
-        let version;
-        if (match.length >= 5 && ['compile', 'provided', 'runtime'].includes(match[5])) {
-            version = `${match[4]}-${match[3]}`;
-        }
-        else {
-            version = match[3];
-        }
-        let override = line.match(this.CONFLICT_REGEX);
-        if (override) {
-            version = override[1];
-        }
-        if (match[0].trim() === '') {
+        const coord = this.parseCoordinate(line);
+        if (coord.groupId.trim() === '') {
             throw new Error(`Artifact coordinates should have a non-empty group ID: ${line}`);
         }
-        return this.toPurl(match[0], match[1], version);
+        return this._coordinateToPurl(coord);
     }
     /**
      * Returns a PackageUrl For Java maven dependencies

package/dist/src/providers/golang_gomodules.js

@@ -187,6 +187,36 @@ function performManifestVersionsCheck(rootElementName, goModGraphOutputRows, man
         throw error;
     }
 }
+/** Parses go.sum to build a hash map of module@version to CycloneDX hashes. */
+function parseGoSumHashes(manifestDir) {
+    let goSumPath = path.join(manifestDir, 'go.sum');
+    if (!fs.existsSync(goSumPath)) {
+        return new Map();
+    }
+    let hashMap = new Map();
+    let content = fs.readFileSync(goSumPath, 'utf-8');
+    for (let line of content.split('\n')) {
+        line = line.trim();
+        if (!line) {
+            continue;
+        }
+        let parts = line.split(/\s+/);
+        if (parts.length < 3) {
+            continue;
+        }
+        let [mod, version, hash] = parts;
+        if (version.endsWith('/go.mod')) {
+            continue;
+        }
+        if (!hash.startsWith('h1:')) {
+            continue;
+        }
+        let base64Part = hash.slice(3);
+        let hexDigest = Buffer.from(base64Part, 'base64').toString('hex');
+        hashMap.set(`${mod}@${version}`, [{ alg: "SHA-256", content: hexDigest }]);
+    }
+    return hashMap;
+}
 /**
  * Create SBOM json string for go Module.
  * @param {string} manifest - path for go.mod
@@ -241,6 +271,7 @@ async function getSBOM(manifest, opts = {}, includeTransitive) {
     if (matchManifestVersions === "true") {
         performManifestVersionsCheck(root, rows, manifestContent, parser, requireQuery);
     }
+    let goSumHashes = parseGoSumHashes(manifestDir);
     const mainModule = toPurl(root, "@");
     const license = readLicenseFromManifest(manifest);
     sbom.addRoot(mainModule, license);
@@ -262,7 +293,7 @@ async function getSBOM(manifest, opts = {}, includeTransitive) {
             if (getParentVertexFromEdge(row) === root && !directDepPaths.has(getPackageName(child))) {
                 return;
             }
-            sbom.addDependency(source, target);
+            sbom.addDependency(source, target, undefined, goSumHashes.get(child));
         });
         // at the end, filter out all ignored dependencies including versions.
         sbom.filterIgnoredDepsIncludingVersion(allIgnoredDeps);
@@ -275,12 +306,22 @@ async function getSBOM(manifest, opts = {}, includeTransitive) {
             let target = toPurl(child, "@");
             if (dependencyNotIgnored(ignoredDeps, target)) {
                 if (directDepPaths.has(getPackageName(child))) {
-                    sbom.addDependency(mainModule, target);
+                    sbom.addDependency(mainModule, target, undefined, goSumHashes.get(child));
                 }
             }
         });
         enforceRemovingIgnoredDepsInCaseOfAutomaticVersionUpdate(ignoredDeps, sbom);
     }
+    // Backfill hashes for components that were only seen as dependency sources
+    for (const comp of sbom.sbomModel.components) {
+        if (!comp.hashes && comp.purl) {
+            let key = decodeURIComponent(comp.purl.replace('pkg:golang/', ''));
+            let hashes = goSumHashes.get(key);
+            if (hashes) {
+                comp.hashes = hashes;
+            }
+        }
+    }
     return sbom.getAsJsonString(opts);
 }
 /**

package/dist/src/providers/java_maven.d.ts

@@ -11,6 +11,10 @@ export function discoverMavenModules(workspaceRoot: string, opts?: object): Prom
 /** @typedef {{name: string, version: string}} Package */
 /** @typedef {{groupId: string, artifactId: string, version: string, scope: string, ignore: boolean}} Dependency */
 export default class Java_maven extends Base_java {
+    /** @type {Object<string, string>} Packaging types that produce .jar files despite non-jar packaging names. */
+    static PACKAGING_TO_JAR: {
+        [x: string]: string;
+    };
     constructor();
     /**
      * @param {string} manifestName - the subject manifest name-type
@@ -25,9 +29,9 @@ export default class Java_maven extends Base_java {
      * Provide content and content type for maven-maven stack analysis.
      * @param {string} manifest - the manifest path or name
      * @param {{}} [opts={}] - optional various options to pass along the application
-     * @returns {Provided}
+     * @returns {Promise<Provided>}
      */
-    provideStack(manifest: string, opts?: {}): Provided;
+    provideStack(manifest: string, opts?: {}): Promise<Provided>;
     /**
      * Provide content and content type for maven-maven component analysis.
      * @param {string} manifest - path to the manifest file
@@ -42,13 +46,34 @@ export default class Java_maven extends Base_java {
      */
     readLicenseFromManifest(manifestPath: string): string | null;
     /**
+     * Build a Map of PURL string → CycloneDX hash entries by reading artifact files from the local Maven repository.
+     *
+     * Both the artifact file path and the hash-map key are derived from the
+     * shared {@link Base_java#parseCoordinate} parser: the file path uses the
+     * resolved version and raw classifier, while the key uses the same canonical
+     * PURL builder as {@link Base_java#parseDep}. This guarantees the key always
+     * matches the PURL that {@link Base_java#parseDependencyTree} looks up.
      *
+     * @param {string} depTreeText Raw dependency tree text from mvn dependency:tree
+     * @param {{}} [opts={}] Options bag (may contain TRUSTIFY_DA_MVN_REPO)
+     * @returns {Promise<Map<string, Array<{alg: string, content: string}>>>}
+     */
+    _buildMavenHashMap(depTreeText: string, opts?: {}): Promise<Map<string, Array<{
+        alg: string;
+        content: string;
+    }>>>;
+    /**
      * @param {String} textGraphList Text graph String of the manifest
      * @param {[String]} ignoredDeps List of ignored dependencies to be omitted from sbom
+     * @param {{}} opts Options
      * @param {String} manifestPath Path to the pom.xml manifest
+     * @param {Map<string, Array<{alg: string, content: string}>>} [hashMap] PURL→hashes map
      * @return {String} formatted sbom Json String with all dependencies
      */
-    createSbomFileFromTextFormat(textGraphList: string, ignoredDeps: [string], opts: any, manifestPath: string): string;
+    createSbomFileFromTextFormat(textGraphList: string, ignoredDeps: [string], opts: {}, manifestPath: string, hashMap?: Map<string, Array<{
+        alg: string;
+        content: string;
+    }>>): string;
     #private;
 }
 export type Java_maven = any;

package/dist/src/providers/java_maven.js

@@ -1,3 +1,4 @@
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -31,12 +32,12 @@ export default class Java_maven extends Base_java {
      * Provide content and content type for maven-maven stack analysis.
      * @param {string} manifest - the manifest path or name
      * @param {{}} [opts={}] - optional various options to pass along the application
-     * @returns {Provided}
+     * @returns {Promise<Provided>}
      */
-    provideStack(manifest, opts = {}) {
+    async provideStack(manifest, opts = {}) {
         return {
             ecosystem: ecosystem_maven,
-            content: this.#createSbomStackAnalysis(manifest, opts),
+            content: await this.#createSbomStackAnalysis(manifest, opts),
             contentType: 'application/vnd.cyclonedx+json'
         };
     }
@@ -81,10 +82,10 @@ export default class Java_maven extends Base_java {
      * Create a Dot Graph dependency tree for a manifest path.
      * @param {string} manifest - path for pom.xml
      * @param {{}} [opts={}] - optional various options to pass along the application
-     * @returns {string} the Dot Graph content
+     * @returns {Promise<string>} the Dot Graph content
      * @private
      */
-    #createSbomStackAnalysis(manifest, opts = {}) {
+    async #createSbomStackAnalysis(manifest, opts = {}) {
         const manifestDir = path.dirname(manifest);
         const mvn = this.selectToolBinary(manifest, opts);
         const mvnArgs = JSON.parse(getCustom('TRUSTIFY_DA_MVN_ARGS', '[]', opts));
@@ -131,20 +132,105 @@ export default class Java_maven extends Base_java {
         if (process.env["TRUSTIFY_DA_DEBUG"] === "true") {
             console.error("Dependency tree that will be used as input for creating the BOM =>" + EOL + EOL + content.toString());
         }
-        let sbom = this.createSbomFileFromTextFormat(content.toString(), ignoredDeps, opts, manifest);
+        const depTreeContent = content.toString();
+        const hashMap = await this._buildMavenHashMap(depTreeContent, opts);
+        let sbom = this.createSbomFileFromTextFormat(depTreeContent, ignoredDeps, opts, manifest, hashMap);
         // delete temp file and directory
         fs.rmSync(tmpDir, { recursive: true, force: true });
         // return dependency graph as string
         return sbom;
     }
+    /** @type {Object<string, string>} Packaging types that produce .jar files despite non-jar packaging names. */
+    static PACKAGING_TO_JAR = { 'bundle': 'jar', 'eclipse-plugin': 'jar' };
     /**
+     * Build a Map of PURL string → CycloneDX hash entries by reading artifact files from the local Maven repository.
+     *
+     * Both the artifact file path and the hash-map key are derived from the
+     * shared {@link Base_java#parseCoordinate} parser: the file path uses the
+     * resolved version and raw classifier, while the key uses the same canonical
+     * PURL builder as {@link Base_java#parseDep}. This guarantees the key always
+     * matches the PURL that {@link Base_java#parseDependencyTree} looks up.
      *
+     * @param {string} depTreeText Raw dependency tree text from mvn dependency:tree
+     * @param {{}} [opts={}] Options bag (may contain TRUSTIFY_DA_MVN_REPO)
+     * @returns {Promise<Map<string, Array<{alg: string, content: string}>>>}
+     */
+    async _buildMavenHashMap(depTreeText, opts = {}) {
+        const m2Repo = getCustom('TRUSTIFY_DA_MVN_REPO', path.join(os.homedir(), '.m2', 'repository'), opts);
+        const hashMap = new Map();
+        const lines = depTreeText.split(EOL);
+        // Track hash coverage so an incomplete .m2 cache (e.g. ephemeral CI
+        // containers or resolve-only phases) surfaces a summary warning instead
+        // of silently producing an SBOM with missing hashes.
+        let attempted = 0;
+        let missed = 0;
+        for (const rawLine of lines) {
+            const trimmed = rawLine.trim();
+            // Strip leading tree-drawing characters (e.g. "\-", "+-", "|") so the
+            // parenthesized-line check sees the coordinate itself. Omitted
+            // duplicate/conflict lines start with these characters after trim(),
+            // then an opening "(" — without stripping, the "(" check never fires.
+            const cleaned = trimmed.replace(/^[|+\\\- ]+/, '');
+            if (!cleaned || cleaned.startsWith('(')) {
+                continue;
+            }
+            const coord = this.parseCoordinate(rawLine);
+            if (!coord.groupId || !coord.artifactId || !coord.packaging) {
+                continue;
+            }
+            if (coord.packaging === 'pom') {
+                continue;
+            }
+            // Key by the exact PURL parseDep() produces, so the lookup in
+            // parseDependencyTree (hashMap.get(to.toString())) always hits.
+            const purl = this._coordinateToPurl(coord).toString();
+            // The same artifact recurs across dependency-tree branches — notably in
+            // multi-module reactor builds, where every module re-lists shared deps.
+            // The digest is deterministic per PURL, so skip the redundant file read
+            // and SHA-256 computation once this PURL is already hashed.
+            if (hashMap.has(purl)) {
+                continue;
+            }
+            const ext = Java_maven.PACKAGING_TO_JAR[coord.packaging] || coord.packaging;
+            const groupPath = coord.groupId.replaceAll('.', path.sep);
+            const fileName = coord.classifier
+                ? `${coord.artifactId}-${coord.version}-${coord.classifier}.${ext}`
+                : `${coord.artifactId}-${coord.version}.${ext}`;
+            const artifactPath = path.join(m2Repo, groupPath, coord.artifactId, coord.version, fileName);
+            attempted++;
+            try {
+                const stream = fs.createReadStream(artifactPath);
+                const hash = crypto.createHash('sha256');
+                for await (const chunk of stream) {
+                    hash.update(chunk);
+                }
+                const digest = hash.digest('hex');
+                hashMap.set(purl, [{ alg: 'SHA-256', content: digest }]);
+            }
+            catch {
+                missed++;
+                if (process.env['TRUSTIFY_DA_DEBUG'] === 'true') {
+                    console.error(`Maven hash: artifact not found at ${artifactPath}, omitting hash`);
+                }
+            }
+        }
+        // Mirror the pip provider's convention (python_controller.js): surface an
+        // unconditional warning when hashes could not be computed, so incomplete
+        // hash coverage is visible even without TRUSTIFY_DA_DEBUG.
+        if (missed > 0) {
+            console.warn(`Maven hash: ${missed} of ${attempted} artifacts could not be read from the local .m2 cache; SBOM will be generated without hashes for those components.`);
+        }
+        return hashMap;
+    }
+    /**
      * @param {String} textGraphList Text graph String of the manifest
      * @param {[String]} ignoredDeps List of ignored dependencies to be omitted from sbom
+     * @param {{}} opts Options
      * @param {String} manifestPath Path to the pom.xml manifest
+     * @param {Map<string, Array<{alg: string, content: string}>>} [hashMap] PURL→hashes map
      * @return {String} formatted sbom Json String with all dependencies
      */
-    createSbomFileFromTextFormat(textGraphList, ignoredDeps, opts, manifestPath) {
+    createSbomFileFromTextFormat(textGraphList, ignoredDeps, opts, manifestPath, hashMap) {
         let lines = textGraphList.split(EOL);
         // get root component
         let root = lines[0];
@@ -153,6 +239,9 @@ export default class Java_maven extends Base_java {
         let sbom = new Sbom();
         sbom.addRoot(rootPurl, license);
         this.parseDependencyTree(root, 0, lines.slice(1), sbom);
+        // Attach Maven artifact hashes as a post-processing step, keeping this
+        // Maven-specific concern out of the shared dependency-tree parser.
+        sbom.attachHashes(hashMap);
         return sbom.filterIgnoredDeps(ignoredDeps).getAsJsonString(opts);
     }
     /**

package/dist/src/providers/python_controller.js

@@ -178,8 +178,11 @@ export default class Python_controller {
             startingTime = new Date();
             console.log("Starting time to get requirements.txt dependency tree = " + startingTime);
         }
+        let installBestEfforts = getCustom("TRUSTIFY_DA_PYTHON_INSTALL_BEST_EFFORTS", "false", this.options);
+        if (installBestEfforts === "true" && this.realEnvironment) {
+            throw new Error("Conflicting settings, TRUSTIFY_DA_PYTHON_INSTALL_BEST_EFFORTS=true requires TRUSTIFY_DA_PYTHON_VIRTUAL_ENV=true");
+        }
         if (!this.realEnvironment) {
-            let installBestEfforts = getCustom("TRUSTIFY_DA_PYTHON_INSTALL_BEST_EFFORTS", "false", this.options);
             if (installBestEfforts === "false") {
                 try {
                     invokeCommand(this.pathToPipBin, ['install', '-r', this.pathToRequirements]);

package/dist/src/providers/rust_cargo.js

@@ -201,12 +201,13 @@ function getSBOM(manifest, opts = {}, includeTransitive) {
     let ignoredDeps = getIgnoredDeps(manifest, metadata);
     let crateType = detectCrateType(metadata);
     let license = readLicenseFromManifest(manifest, metadata);
+    let hashMap = parseCargoLockHashes(manifestDir);
     let sbom;
     if (crateType === CrateType.WORKSPACE_VIRTUAL) {
-        sbom = handleVirtualWorkspace(manifest, metadata, ignoredDeps, includeTransitive, opts, license);
+        sbom = handleVirtualWorkspace(manifest, metadata, ignoredDeps, includeTransitive, opts, license, hashMap);
     }
     else {
-        sbom = handleSingleCrate(metadata, ignoredDeps, includeTransitive, opts, license);
+        sbom = handleSingleCrate(metadata, ignoredDeps, includeTransitive, opts, license, hashMap);
     }
     return sbom;
 }
@@ -244,6 +245,63 @@ function executeCargoMetadata(cargoBin, manifestDir) {
         throw new Error('failed to execute cargo metadata', { cause: error });
     }
 }
+/**
+ * Parses Cargo.lock to extract SHA-256 checksums for each package.
+ * @param {string} manifestDir - directory containing Cargo.toml (Cargo.lock is searched upward)
+ * @returns {Map<string, Array<{alg: string, content: string}>>} map of "name@version" to CycloneDX hashes
+ * @private
+ */
+function parseCargoLockHashes(manifestDir) {
+    let hashMap = new Map();
+    let lockPath = findCargoLock(manifestDir);
+    if (!lockPath) {
+        return hashMap;
+    }
+    try {
+        let content = fs.readFileSync(lockPath, 'utf-8');
+        let parsed = parseToml(content);
+        for (let pkg of (parsed.package || [])) {
+            if (pkg.name && pkg.version && pkg.checksum) {
+                hashMap.set(`${pkg.name}@${pkg.version}`, [{ alg: 'SHA-256', content: pkg.checksum }]);
+            }
+        }
+    }
+    catch (error) {
+        console.warn('Failed to parse Cargo.lock for hashes, SBOM will be generated without hashes');
+    }
+    return hashMap;
+}
+/**
+ * Searches upward from the manifest directory to find the nearest Cargo.lock.
+ * @param {string} manifestDir - starting directory
+ * @returns {string|null} absolute path to Cargo.lock or null if not found
+ * @private
+ */
+function findCargoLock(manifestDir) {
+    let dir = path.resolve(manifestDir);
+    let parent = dir;
+    do {
+        dir = parent;
+        let lockFile = path.join(dir, 'Cargo.lock');
+        if (fs.existsSync(lockFile)) {
+            return lockFile;
+        }
+        let cargoToml = path.join(dir, 'Cargo.toml');
+        if (fs.existsSync(cargoToml)) {
+            try {
+                let content = fs.readFileSync(cargoToml, 'utf-8');
+                if (/\[workspace\]/.test(content)) {
+                    return null;
+                }
+            }
+            catch (_) {
+                // ignore read errors, keep searching
+            }
+        }
+        parent = path.dirname(dir);
+    } while (parent !== dir);
+    return null;
+}
 /**
  * Detects the type of Cargo project from metadata.
  * @param {object} metadata - parsed cargo metadata
@@ -275,7 +333,7 @@ function detectCrateType(metadata) {
  * @returns {string} SBOM json string
  * @private
  */
-function handleSingleCrate(metadata, ignoredDeps, includeTransitive, opts, license) {
+function handleSingleCrate(metadata, ignoredDeps, includeTransitive, opts, license, hashMap) {
     let rootPackageId = metadata.resolve.root;
     let rootPackage = findPackageById(metadata, rootPackageId);
     let rootPurl = toPurl(rootPackage.name, rootPackage.version);
@@ -286,10 +344,10 @@ function handleSingleCrate(metadata, ignoredDeps, includeTransitive, opts, licen
         return sbom.getAsJsonString(opts);
     }
     if (includeTransitive) {
-        addTransitiveDeps(sbom, metadata, rootPackageId, ignoredDeps, new Set(), rootPurl);
+        addTransitiveDeps(sbom, metadata, rootPackageId, ignoredDeps, new Set(), hashMap, rootPurl);
     }
     else {
-        addDirectDeps(sbom, metadata, rootPackageId, rootPurl, ignoredDeps);
+        addDirectDeps(sbom, metadata, rootPackageId, rootPurl, ignoredDeps, hashMap);
     }
     return sbom.getAsJsonString(opts);
 }
@@ -315,7 +373,7 @@ function handleSingleCrate(metadata, ignoredDeps, includeTransitive, opts, licen
  * @returns {string} SBOM json string
  * @private
  */
-function handleVirtualWorkspace(manifest, metadata, ignoredDeps, includeTransitive, opts, license) {
+function handleVirtualWorkspace(manifest, metadata, ignoredDeps, includeTransitive, opts, license, hashMap) {
     let workspaceRoot = metadata.workspace_root;
     let rootName = path.basename(workspaceRoot);
     let workspaceVersion = getWorkspaceVersion(metadata);
@@ -323,7 +381,6 @@ function handleVirtualWorkspace(manifest, metadata, ignoredDeps, includeTransiti
     let sbom = new Sbom();
     sbom.addRoot(rootPurl, license);
     if (includeTransitive) {
-        // Stack analysis: walk all members and their full dependency trees
         let workspaceMembers = metadata.workspace_members || [];
         for (let memberId of workspaceMembers) {
             let memberPackage = findPackageById(metadata, memberId);
@@ -334,11 +391,10 @@ function handleVirtualWorkspace(manifest, metadata, ignoredDeps, includeTransiti
                 ? toPathDepPurl(memberPackage.name, memberPackage.version)
                 : toPurl(memberPackage.name, memberPackage.version);
             sbom.addDependency(rootPurl, memberPurl);
-            addTransitiveDeps(sbom, metadata, memberId, ignoredDeps, new Set(), memberPurl);
+            addTransitiveDeps(sbom, metadata, memberId, ignoredDeps, new Set(), hashMap, memberPurl);
         }
     }
     else {
-        // Component analysis: only [workspace.dependencies] from root Cargo.toml
         let workspaceDeps = getWorkspaceDepsFromManifest(manifest);
         for (let depName of workspaceDeps) {
             if (isDepIgnored(depName, ignoredDeps)) {
@@ -355,7 +411,8 @@ function handleVirtualWorkspace(manifest, metadata, ignoredDeps, includeTransiti
             let depPurl = pkg.source == null
                 ? toPathDepPurl(pkg.name, pkg.version)
                 : toPurl(pkg.name, pkg.version);
-            sbom.addDependency(rootPurl, depPurl);
+            let hashes = hashMap.get(`${pkg.name}@${pkg.version}`);
+            sbom.addDependency(rootPurl, depPurl, undefined, hashes);
         }
     }
     return sbom.getAsJsonString(opts);
@@ -374,7 +431,7 @@ function handleVirtualWorkspace(manifest, metadata, ignoredDeps, includeTransiti
  *   so callers can ensure it matches the purl already added to the SBOM
  * @private
  */
-function addTransitiveDeps(sbom, metadata, packageId, ignoredDeps, visited, startingPurl) {
+function addTransitiveDeps(sbom, metadata, packageId, ignoredDeps, visited, hashMap, startingPurl) {
     if (visited.has(packageId)) {
         return;
     }
@@ -402,8 +459,9 @@ function addTransitiveDeps(sbom, metadata, packageId, ignoredDeps, visited, star
         let depPurl = depPackage.source == null
             ? toPathDepPurl(depPackage.name, depPackage.version)
             : toPurl(depPackage.name, depPackage.version);
-        sbom.addDependency(sourcePurl, depPurl);
-        addTransitiveDeps(sbom, metadata, depId, ignoredDeps, visited);
+        let hashes = hashMap ? hashMap.get(`${depPackage.name}@${depPackage.version}`) : undefined;
+        sbom.addDependency(sourcePurl, depPurl, undefined, hashes);
+        addTransitiveDeps(sbom, metadata, depId, ignoredDeps, visited, hashMap);
     }
 }
 /**
@@ -416,7 +474,7 @@ function addTransitiveDeps(sbom, metadata, packageId, ignoredDeps, visited, star
  * @param {Set<string>} ignoredDeps - set of ignored dependency names
  * @private
  */
-function addDirectDeps(sbom, metadata, packageId, parentPurl, ignoredDeps) {
+function addDirectDeps(sbom, metadata, packageId, parentPurl, ignoredDeps, hashMap) {
     let resolveNode = findResolveNode(metadata, packageId);
     if (!resolveNode) {
         return;
@@ -433,7 +491,8 @@ function addDirectDeps(sbom, metadata, packageId, parentPurl, ignoredDeps) {
         let depPurl = depPackage.source == null
             ? toPathDepPurl(depPackage.name, depPackage.version)
             : toPurl(depPackage.name, depPackage.version);
-        sbom.addDependency(parentPurl, depPurl);
+        let hashes = hashMap ? hashMap.get(`${depPackage.name}@${depPackage.version}`) : undefined;
+        sbom.addDependency(parentPurl, depPurl, undefined, hashes);
     }
 }
 /**

package/dist/src/remediate.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Orchestrates the full remediation pipeline for a single manifest or directory:
+ * discover manifests → scan via DA backend → extract remediations → apply or preview.
+ *
+ * @param {string} targetPath - path to a manifest file or directory
+ * @param {object} [options]
+ * @param {boolean} [options.dryRun=false] - preview changes without modifying files (applies by default)
+ * @param {string} [options.providers] - comma-separated provider list
+ * @param {string} [options.sources] - comma-separated source list
+ * @param {'dependency'|'bundle'} [options.groupBy='dependency'] - report grouping strategy
+ * @returns {Promise<{exitCode: number, output: string}>}
+ */
+export function runRemediation(targetPath: string, options?: {
+    dryRun?: boolean | undefined;
+    providers?: string | undefined;
+    sources?: string | undefined;
+    groupBy?: "bundle" | "dependency" | undefined;
+}): Promise<{
+    exitCode: number;
+    output: string;
+}>;