try {

runStartupMemoryCheck();

} catch (error) {

console.error(error instanceof Error ? error.stack : String(error));

console.error(error instanceof Error ? error.message : String(error));

process.exitCode = 1;

}

}

if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {

main().catch(

/** @param {unknown} error */ (error) => {

console.error(error instanceof Error ? error.stack : String(error));

console.error(error instanceof Error ? error.message : String(error));

process.exitCode = 1;

},

);

return value;

}

function usage() {

return `Usage: node scripts/generate-dependency-release-evidence.mjs --output-dir <dir> --release-ref <ref> --npm-dist-tag <tag> [options]

Generates release dependency evidence reports and summary artifacts.

Options:

--root <dir> Repository root

--output-dir <dir> Evidence artifact directory

--release-ref <ref> Release tag or SHA under validation

--npm-dist-tag <tag> npm dist-tag being validated

--base-ref <ref> Dependency change comparison base

--github-output <path> GitHub Actions output file

--github-step-summary <path> GitHub Actions step summary file

-h, --help Show this help

`;

}

export function parseArgs(argv) {

const options = {

rootDir: process.cwd(),

if (arg === "--") {

continue;

}

if (arg === "-h" || arg === "--help") {

return { ...options, help: true };

}

if (arg === "--root") {

options.rootDir = readOptionValue(argv, index, arg);

index += 1;

* Runs the dependency release evidence generator CLI.

*/

export async function main(argv = process.argv.slice(2)) {

await generateDependencyReleaseEvidence(parseArgs(argv));

const options = parseArgs(argv);

if (options.help) {

process.stdout.write(usage());

return 0;

}

await generateDependencyReleaseEvidence(options);

return 0;

}

process.exitCode = exitCode;

},

/** @param {unknown} error */ (error) => {

process.stderr.write(`${error.stack ?? error.message ?? String(error)}\n`);

process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);

process.exitCode = 1;

},

);

return root;

}

function expectNoNodeStack(stderr: string): void {

expect(stderr).not.toContain("Node.js");

expect(stderr).not.toContain("\n at ");

}

afterEach(() => {

for (const root of tempRoots.splice(0)) {

rmSync(root, { recursive: true, force: true });

expect(readdirSync(tempRoot)).toEqual([]);

});

it("reports CLI argument errors without a Node stack trace", () => {

const result = spawnSync(process.execPath, ["scripts/check-cli-startup-memory.mjs", "--wat"], {

cwd: path.resolve(__dirname, "..", ".."),

encoding: "utf8",

});

expect(result.status).toBe(1);

expect(result.stdout).toBe("");

expect(result.stderr.trim()).toBe("Unknown option: --wat");

expectNoNodeStack(result.stderr);

});

it("times out startup probes instead of hanging indefinitely", () => {

if (process.platform !== "darwin" && process.platform !== "linux") {

return;

// Check Gateway Cpu Scenarios tests cover check gateway cpu scenarios script behavior.

import { spawnSync } from "node:child_process";

import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";

import path from "node:path";

import { afterEach, describe, expect, it } from "vitest";

return root;

}

function runCli(...args: string[]) {

return spawnSync(process.execPath, ["scripts/check-gateway-cpu-scenarios.mjs", ...args], {

cwd: path.resolve("."),

encoding: "utf8",

});

}

function expectNoNodeStack(stderr: string) {

expect(stderr).not.toContain("Node.js");

expect(stderr).not.toContain("\n at ");

}

function writeQaSuiteSummary(

outputDir: string,

counts: { failed: number; passed: number; total: number } = { failed: 0, passed: 1, total: 1 },

}

});

it("reports CLI argument errors without a Node stack trace", () => {

const result = runCli("--wat");

expect(result.status).toBe(1);

expect(result.stdout).toBe("");

expect(result.stderr.trim()).toBe("Unknown argument: --wat");

expectNoNodeStack(result.stderr);

});

it("prepares CLI startup artifacts before running the startup bench", async () => {

const outputDir = makeTempRoot();

const startupOutput = path.join(outputDir, "gateway-startup-bench.json");

// Generate Dependency Release Evidence tests cover generate dependency release evidence script behavior.

import { spawnSync } from "node:child_process";

import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";

import { tmpdir } from "node:os";

import path from "node:path";

await writeFile(path.join(dir, fileName), `${JSON.stringify(value, null, 2)}\n`, "utf8");

}

function runCli(...args: string[]) {

return spawnSync(

process.execPath,

["scripts/generate-dependency-release-evidence.mjs", ...args],

{

cwd: path.resolve("."),

encoding: "utf8",

},

);

}

function expectNoNodeStack(stderr: string) {

expect(stderr).not.toContain("Node.js");

expect(stderr).not.toContain("\n at ");

}

describe("generate-dependency-release-evidence", () => {

it("defines the release evidence command list and policy classifications", () => {

expect(DEPENDENCY_EVIDENCE_REPORTS.map(({ command, policy }) => ({ command, policy }))).toEqual(

).toThrow("Expected --github-output <value>.");

});

it("prints CLI help without generating evidence", () => {

const result = runCli("--help");

expect(result.status).toBe(0);

expect(result.stdout).toContain("Usage: node scripts/generate-dependency-release-evidence.mjs");

expect(result.stderr).toBe("");

});

it("reports CLI argument errors without a Node stack trace", () => {

const result = runCli("--wat");

expect(result.status).toBe(1);

expect(result.stdout).toBe("");

expect(result.stderr.trim()).toBe("Unsupported argument: --wat");

expectNoNodeStack(result.stderr);

});

it("falls back to fetching tags when local previous-release resolution misses", () => {

const calls: Array<{ command: string; args: string[] }> = [];

let describeCalls = 0;