From 3ee477fc5b22cbeef956e9616a22b8465091c079 Mon Sep 17 00:00:00 2001 From: Alistair Smith Date: Tue, 9 Sep 2025 21:42:01 -0700 Subject: [PATCH] fix: scanner on update, install, remove, uninstall and add, and introduce the `pm scan` command (#22193) Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com> Co-authored-by: Dylan Conway --- cmake/Sources.json | 5 +- cmake/targets/BuildBun.cmake | 1 + packages/bun-types/shell.d.ts | 4 +- src/cli/package_manager_command.zig | 7 +- src/cli/scan_command.zig | 76 + src/install/PackageManager.zig | 7 +- .../PackageManager/CommandLineArguments.zig | 30 + .../PackageManager/PackageManagerEnqueue.zig | 3 - .../PackageManager/install_with_manager.zig | 144 +- .../PackageManager/scanner-entry-globals.d.ts | 2 + src/install/PackageManager/scanner-entry.ts | 92 + .../PackageManager/security_scanner.zig | 1224 +++-- src/install/hoisted_install.zig | 3 +- src/install/isolated_install.zig | 84 +- src/install/lockfile.zig | 7 +- src/install/lockfile/Tree.zig | 17 + src/output.zig | 18 +- ...nner-matrix-with-node-modules.test.ts.snap | 3271 +++++++++++++ ...r-matrix-without-node-modules.test.ts.snap | 4205 +++++++++++++++++ .../bun-install-security-provider.test.ts | 8 +- test/cli/install/bun-pm-scan.test.ts | 676 +++ .../bun-security-scanner-matrix-runner.ts | 526 +++ ...y-scanner-matrix-with-node-modules.test.ts | 8 + ...canner-matrix-without-node-modules.test.ts | 5 + .../bun-update-security-edge-cases.test.ts | 456 ++ .../bun-update-security-provider.test.ts | 150 + .../bun-update-security-scan-all.test.ts | 392 ++ .../bun-update-security-simple.test.ts | 109 + test/cli/install/dummy.registry.ts | 1 - test/cli/install/generate-scanner-tarballs.ts | 72 + test/cli/install/is-even-1.0.0.tgz | Bin 0 -> 2163 bytes test/cli/install/is-odd-1.0.0.tgz | Bin 0 -> 2502 bytes test/cli/install/left-pad-1.3.0.tgz | Bin 0 -> 3619 bytes test/cli/install/simple-dummy-registry.ts | 175 + .../test-security-scanner-1.0.0-clean.tgz | Bin 0 -> 692 bytes .../test-security-scanner-1.0.0-fatal.tgz | Bin 0 -> 760 bytes .../test-security-scanner-1.0.0-warn.tgz | Bin 0 -> 755 bytes test/js/bun/test/jest.d.ts | 14 +- test/js/web/fetch/utf8-bom.test.ts | 2 +- 39 files changed, 11287 insertions(+), 507 deletions(-) create mode 100644 src/cli/scan_command.zig create mode 100644 src/install/PackageManager/scanner-entry-globals.d.ts create mode 100644 src/install/PackageManager/scanner-entry.ts create mode 100644 test/cli/install/__snapshots__/bun-security-scanner-matrix-with-node-modules.test.ts.snap create mode 100644 test/cli/install/__snapshots__/bun-security-scanner-matrix-without-node-modules.test.ts.snap create mode 100644 test/cli/install/bun-pm-scan.test.ts create mode 100644 test/cli/install/bun-security-scanner-matrix-runner.ts create mode 100644 test/cli/install/bun-security-scanner-matrix-with-node-modules.test.ts create mode 100644 test/cli/install/bun-security-scanner-matrix-without-node-modules.test.ts create mode 100644 test/cli/install/bun-update-security-edge-cases.test.ts create mode 100644 test/cli/install/bun-update-security-provider.test.ts create mode 100644 test/cli/install/bun-update-security-scan-all.test.ts create mode 100644 test/cli/install/bun-update-security-simple.test.ts create mode 100644 test/cli/install/generate-scanner-tarballs.ts create mode 100644 test/cli/install/is-even-1.0.0.tgz create mode 100644 test/cli/install/is-odd-1.0.0.tgz create mode 100644 test/cli/install/left-pad-1.3.0.tgz create mode 100644 test/cli/install/simple-dummy-registry.ts create mode 100644 test/cli/install/test-security-scanner-1.0.0-clean.tgz create mode 100644 test/cli/install/test-security-scanner-1.0.0-fatal.tgz create mode 100644 test/cli/install/test-security-scanner-1.0.0-warn.tgz diff --git a/cmake/Sources.json b/cmake/Sources.json index d8376845f1..cd86d86989 100644 --- a/cmake/Sources.json +++ b/cmake/Sources.json @@ -13,7 +13,10 @@ }, { "output": "JavaScriptSources.txt", - "paths": ["src/js/**/*.{js,ts}"] + "paths": [ + "src/js/**/*.{js,ts}", + "src/install/PackageManager/scanner-entry.ts" + ] }, { "output": "JavaScriptCodegenSources.txt", diff --git a/cmake/targets/BuildBun.cmake b/cmake/targets/BuildBun.cmake index 9907dd0605..f6c5ef7e99 100644 --- a/cmake/targets/BuildBun.cmake +++ b/cmake/targets/BuildBun.cmake @@ -636,6 +636,7 @@ register_command( SOURCES ${BUN_ZIG_SOURCES} ${BUN_ZIG_GENERATED_SOURCES} + ${CWD}/src/install/PackageManager/scanner-entry.ts # Is there a better way to do this? ) set_property(TARGET bun-zig PROPERTY JOB_POOL compile_pool) diff --git a/packages/bun-types/shell.d.ts b/packages/bun-types/shell.d.ts index 7624e81b9f..278ce91127 100644 --- a/packages/bun-types/shell.d.ts +++ b/packages/bun-types/shell.d.ts @@ -58,7 +58,7 @@ declare module "bun" { * // "bun" * ``` */ - function env(newEnv?: Record): $; + function env(newEnv?: Record | NodeJS.Dict | undefined): $; /** * @@ -106,7 +106,7 @@ declare module "bun" { * expect(stdout.toString()).toBe("LOL!"); * ``` */ - env(newEnv: Record | undefined): this; + env(newEnv: Record | NodeJS.Dict | undefined): this; /** * By default, the shell will write to the current process's stdout and stderr, as well as buffering that output. diff --git a/src/cli/package_manager_command.zig b/src/cli/package_manager_command.zig index 1a569636c7..8bd3e92678 100644 --- a/src/cli/package_manager_command.zig +++ b/src/cli/package_manager_command.zig @@ -1,5 +1,6 @@ const NodeModulesFolder = Lockfile.Tree.Iterator(.node_modules).Next; pub const PackCommand = @import("./pack_command.zig").PackCommand; +pub const ScanCommand = @import("./scan_command.zig").ScanCommand; const ByName = struct { dependencies: []const Dependency, @@ -92,6 +93,7 @@ pub const PackageManagerCommand = struct { \\ \\Commands: \\ + \\ bun pm scan scan all packages in lockfile for security vulnerabilities \\ bun pm pack create a tarball of the current workspace \\ ├ --dry-run do everything except for writing the tarball to disk \\ ├ --destination the directory the tarball will be saved in @@ -157,7 +159,10 @@ pub const PackageManagerCommand = struct { try pm.setupGlobalDir(ctx); } - if (strings.eqlComptime(subcommand, "pack")) { + if (strings.eqlComptime(subcommand, "scan")) { + try ScanCommand.execWithManager(ctx, pm, cwd); + Global.exit(0); + } else if (strings.eqlComptime(subcommand, "pack")) { try PackCommand.execWithManager(ctx, pm); Global.exit(0); } else if (strings.eqlComptime(subcommand, "whoami")) { diff --git a/src/cli/scan_command.zig b/src/cli/scan_command.zig new file mode 100644 index 0000000000..85cbddcce5 --- /dev/null +++ b/src/cli/scan_command.zig @@ -0,0 +1,76 @@ +pub const ScanCommand = struct { + pub fn exec(ctx: Command.Context) !void { + const cli = try PackageManager.CommandLineArguments.parse(ctx.allocator, .scan); + + const manager, const cwd = PackageManager.init(ctx, cli, .scan) catch |err| { + if (err == error.MissingPackageJSON) { + Output.errGeneric("No package.json found. 'bun pm scan' requires a lockfile to analyze dependencies.", .{}); + Output.note("Run \"bun install\" first to generate a lockfile", .{}); + Global.exit(1); + } + return err; + }; + defer ctx.allocator.free(cwd); + + try execWithManager(ctx, manager, cwd); + } + + pub fn execWithManager(ctx: Command.Context, manager: *PackageManager, original_cwd: []const u8) !void { + if (manager.options.security_scanner == null) { + Output.prettyErrorln("error: no security scanner configured", .{}); + Output.pretty( + \\ + \\To use 'bun pm scan', configure a security scanner in bunfig.toml: + \\ [install.security] + \\ scanner = "package_name" + \\ + \\Security scanners can be npm packages that export a scanner object. + \\ + , .{}); + Global.exit(1); + } + + Output.prettyError(comptime Output.prettyFmt("bun pm scan v" ++ Global.package_json_version_with_sha ++ "\n", true), .{}); + Output.flush(); + + const load_lockfile = manager.lockfile.loadFromCwd(manager, ctx.allocator, ctx.log, true); + if (load_lockfile == .not_found) { + Output.errGeneric("Lockfile not found. Run 'bun install' first to generate a lockfile.", .{}); + Global.exit(1); + } + if (load_lockfile == .err) { + Output.errGeneric("Error loading lockfile: {s}", .{@errorName(load_lockfile.err.value)}); + Global.exit(1); + } + + const security_scan_results = security_scanner.performSecurityScanForAll(manager, ctx, original_cwd) catch |err| { + Output.errGeneric("Could not perform security scan ({s})", .{@errorName(err)}); + Global.exit(1); + }; + + if (security_scan_results) |results| { + defer { + var results_mut = results; + results_mut.deinit(); + } + + security_scanner.printSecurityAdvisories(manager, &results); + + if (results.hasAdvisories()) { + Global.exit(1); + } else { + Output.pretty("No advisories found\n", .{}); + } + } + + Global.exit(0); + } +}; + +const security_scanner = @import("../install/PackageManager/security_scanner.zig"); +const Command = @import("../cli.zig").Command; +const PackageManager = @import("../install/install.zig").PackageManager; + +const bun = @import("bun"); +const Global = bun.Global; +const Output = bun.Output; diff --git a/src/install/PackageManager.zig b/src/install/PackageManager.zig index 6424abef2b..7dfd03a639 100644 --- a/src/install/PackageManager.zig +++ b/src/install/PackageManager.zig @@ -1,5 +1,4 @@ cache_directory_: ?std.fs.Dir = null, - cache_directory_path: stringZ = "", temp_dir_: ?std.fs.Dir = null, temp_dir_path: stringZ = "", @@ -155,6 +154,7 @@ pub const Subcommand = enum { audit, info, why, + scan, // bin, // hash, @@ -580,7 +580,10 @@ pub fn init( if (comptime Environment.isWindows) { _ = Path.pathToPosixBuf(u8, top_level_dir_no_trailing_slash, &cwd_buf); } else { - @memcpy(cwd_buf[0..top_level_dir_no_trailing_slash.len], top_level_dir_no_trailing_slash); + // Avoid memcpy alias when source and dest are the same + if (cwd_buf[0..].ptr != top_level_dir_no_trailing_slash.ptr) { + bun.copy(u8, cwd_buf[0..top_level_dir_no_trailing_slash.len], top_level_dir_no_trailing_slash); + } } var original_package_json_path_buf = bun.handleOom(std.ArrayListUnmanaged(u8).initCapacity(ctx.allocator, top_level_dir_no_trailing_slash.len + "/package.json".len + 1)); diff --git a/src/install/PackageManager/CommandLineArguments.zig b/src/install/PackageManager/CommandLineArguments.zig index 40b5cce93e..69bbe53d3f 100644 --- a/src/install/PackageManager/CommandLineArguments.zig +++ b/src/install/PackageManager/CommandLineArguments.zig @@ -702,6 +702,35 @@ pub fn printHelp(subcommand: Subcommand) void { Output.pretty(outro_text, .{}); Output.flush(); }, + .scan => { + const intro_text = + \\ + \\Usage: bun pm scan [flags] + \\ + \\ Scan all packages in lockfile for security vulnerabilities. + \\ + \\Flags: + ; + + const outro_text = + \\ + \\ + \\Examples: + \\ Scan all packages for vulnerabilities + \\ bun pm scan + \\ + \\ Output results as JSON + \\ bun pm scan --json + \\ + \\Full documentation is available at https://bun.com/docs/cli/pm#scan. + \\ + ; + + Output.pretty(intro_text, .{}); + clap.simpleHelp(pm_params); + Output.pretty(outro_text, .{}); + Output.flush(); + }, } } @@ -727,6 +756,7 @@ pub fn parse(allocator: std.mem.Allocator, comptime subcommand: Subcommand) !Com // are not included in the help text .audit => shared_params ++ audit_params, .info => info_params, + .scan => pm_params, // scan uses the same params as pm command }; var diag = clap.Diagnostic{}; diff --git a/src/install/PackageManager/PackageManagerEnqueue.zig b/src/install/PackageManager/PackageManagerEnqueue.zig index a24bb80cc5..b69aadf0fb 100644 --- a/src/install/PackageManager/PackageManagerEnqueue.zig +++ b/src/install/PackageManager/PackageManagerEnqueue.zig @@ -253,9 +253,6 @@ pub fn enqueuePackageForDownload( if (task_queue.found_existing) return; - // Skip tarball download when prefetch_resolved_tarballs is disabled (e.g., --lockfile-only) - if (!this.options.do.prefetch_resolved_tarballs) return; - const is_required = this.lockfile.buffers.dependencies.items[dependency_id].behavior.isRequired(); if (try this.generateNetworkTaskForTarball( diff --git a/src/install/PackageManager/install_with_manager.zig b/src/install/PackageManager/install_with_manager.zig index c5114032e3..a39f120192 100644 --- a/src/install/PackageManager/install_with_manager.zig +++ b/src/install/PackageManager/install_with_manager.zig @@ -566,8 +566,37 @@ pub fn installWithManager( manager.verifyResolutions(log_level); - if (manager.subcommand == .add and manager.options.security_scanner != null) { - try security_scanner.performSecurityScanAfterResolution(manager); + if (manager.options.security_scanner != null) { + const is_subcommand_to_run_scanner = manager.subcommand == .add or manager.subcommand == .update or manager.subcommand == .install or manager.subcommand == .remove; + + if (is_subcommand_to_run_scanner) { + if (security_scanner.performSecurityScanAfterResolution(manager, ctx, original_cwd) catch |err| { + switch (err) { + error.SecurityScannerInWorkspace => { + Output.pretty("Security scanner cannot be a dependency of a workspace package. It must be a direct dependency of the root package.\n", .{}); + }, + else => {}, + } + + Global.exit(1); + }) |results| { + defer { + var results_mut = results; + results_mut.deinit(); + } + + security_scanner.printSecurityAdvisories(manager, &results); + + if (results.hasFatalAdvisories()) { + Output.pretty("Installation aborted due to fatal security advisories\n", .{}); + Global.exit(1); + } else if (results.hasWarnings()) { + if (!security_scanner.promptForWarnings()) { + Global.exit(1); + } + } + } + } } } @@ -691,53 +720,8 @@ pub fn installWithManager( return; } - var path_buf: bun.PathBuffer = undefined; - var workspace_filters: std.ArrayListUnmanaged(WorkspaceFilter) = .{}; - // only populated when subcommand is `.install` - if (manager.subcommand == .install and manager.options.filter_patterns.len > 0) { - try workspace_filters.ensureUnusedCapacity(manager.allocator, manager.options.filter_patterns.len); - for (manager.options.filter_patterns) |pattern| { - try workspace_filters.append(manager.allocator, try WorkspaceFilter.init(manager.allocator, pattern, original_cwd, &path_buf)); - } - } - defer workspace_filters.deinit(manager.allocator); - - var install_root_dependencies = workspace_filters.items.len == 0; - if (!install_root_dependencies) { - const pkg_names = manager.lockfile.packages.items(.name); - - const abs_root_path = abs_root_path: { - if (comptime !Environment.isWindows) { - break :abs_root_path strings.withoutTrailingSlash(FileSystem.instance.top_level_dir); - } - - var abs_path = Path.pathToPosixBuf(u8, FileSystem.instance.top_level_dir, &path_buf); - break :abs_root_path strings.withoutTrailingSlash(abs_path[Path.windowsVolumeNameLen(abs_path)[0]..]); - }; - - for (workspace_filters.items) |filter| { - const pattern, const path_or_name = switch (filter) { - .name => |pattern| .{ pattern, pkg_names[0].slice(manager.lockfile.buffers.string_bytes.items) }, - .path => |pattern| .{ pattern, abs_root_path }, - .all => { - install_root_dependencies = true; - continue; - }, - }; - - switch (bun.glob.walk.matchImpl(manager.allocator, pattern, path_or_name)) { - .match, .negate_match => install_root_dependencies = true, - - .negate_no_match => { - // always skip if a pattern specifically says "!" - install_root_dependencies = false; - break; - }, - - .no_match => {}, - } - } - } + const workspace_filters, const install_root_dependencies = (try getWorkspaceFilters(manager, original_cwd)); + defer manager.allocator.free(workspace_filters); const install_summary: PackageInstall.Summary = install_summary: { if (!manager.options.do.install_packages) { @@ -751,16 +735,18 @@ pub fn installWithManager( => break :install_summary try installHoistedPackages( manager, ctx, - workspace_filters.items, + workspace_filters, install_root_dependencies, log_level, + null, ), .isolated => break :install_summary installIsolatedPackages( manager, ctx, install_root_dependencies, - workspace_filters.items, + workspace_filters, + null, ) catch |err| switch (err) { error.OutOfMemory => bun.outOfMemory(), }, @@ -992,6 +978,62 @@ fn printBlockedPackagesInfo(summary: *const PackageInstall.Summary, global: bool } } +pub fn getWorkspaceFilters(manager: *PackageManager, original_cwd: []const u8) !struct { + []const WorkspaceFilter, + bool, +} { + const path_buf = bun.path_buffer_pool.get(); + defer bun.path_buffer_pool.put(path_buf); + + var workspace_filters: std.ArrayListUnmanaged(WorkspaceFilter) = .{}; + // only populated when subcommand is `.install` + if (manager.subcommand == .install and manager.options.filter_patterns.len > 0) { + try workspace_filters.ensureUnusedCapacity(manager.allocator, manager.options.filter_patterns.len); + for (manager.options.filter_patterns) |pattern| { + try workspace_filters.append(manager.allocator, try WorkspaceFilter.init(manager.allocator, pattern, original_cwd, path_buf[0..])); + } + } + + var install_root_dependencies = workspace_filters.items.len == 0; + if (!install_root_dependencies) { + const pkg_names = manager.lockfile.packages.items(.name); + + const abs_root_path = abs_root_path: { + if (comptime !Environment.isWindows) { + break :abs_root_path strings.withoutTrailingSlash(FileSystem.instance.top_level_dir); + } + + var abs_path = Path.pathToPosixBuf(u8, FileSystem.instance.top_level_dir, path_buf); + break :abs_root_path strings.withoutTrailingSlash(abs_path[Path.windowsVolumeNameLen(abs_path)[0]..]); + }; + + for (workspace_filters.items) |filter| { + const pattern, const path_or_name = switch (filter) { + .name => |pattern| .{ pattern, pkg_names[0].slice(manager.lockfile.buffers.string_bytes.items) }, + .path => |pattern| .{ pattern, abs_root_path }, + .all => { + install_root_dependencies = true; + continue; + }, + }; + + switch (bun.glob.walk.matchImpl(manager.allocator, pattern, path_or_name)) { + .match, .negate_match => install_root_dependencies = true, + + .negate_no_match => { + // always skip if a pattern specifically says "!" + install_root_dependencies = false; + break; + }, + + .no_match => {}, + } + } + } + + return .{ workspace_filters.items, install_root_dependencies }; +} + const security_scanner = @import("./security_scanner.zig"); const std = @import("std"); const installHoistedPackages = @import("../hoisted_install.zig").installHoistedPackages; diff --git a/src/install/PackageManager/scanner-entry-globals.d.ts b/src/install/PackageManager/scanner-entry-globals.d.ts new file mode 100644 index 0000000000..5d70eb5e1d --- /dev/null +++ b/src/install/PackageManager/scanner-entry-globals.d.ts @@ -0,0 +1,2 @@ +declare const __PACKAGES_JSON__: Bun.Security.Package[]; +declare const __SUPPRESS_ERROR__: boolean; diff --git a/src/install/PackageManager/scanner-entry.ts b/src/install/PackageManager/scanner-entry.ts new file mode 100644 index 0000000000..79264c45ca --- /dev/null +++ b/src/install/PackageManager/scanner-entry.ts @@ -0,0 +1,92 @@ +import fs from "node:fs"; + +const scannerModuleName = "__SCANNER_MODULE__"; +const packages = __PACKAGES_JSON__; +const suppressError = __SUPPRESS_ERROR__; + +type IPCMessage = + | { type: "result"; advisories: Bun.Security.Advisory[] } + | { type: "error"; code: "MODULE_NOT_FOUND"; module: string } + | { type: "error"; code: "INVALID_VERSION"; message: string } + | { type: "error"; code: "SCAN_FAILED"; message: string }; + +const IPC_PIPE_FD = 3; + +function writeAndExit(message: IPCMessage): never { + const data = JSON.stringify(message); + + for (let remaining = data; remaining.length > 0; ) { + const written = fs.writeSync(IPC_PIPE_FD, remaining); + + if (written === 0) { + console.error("Failed to write to IPC pipe"); + process.exit(1); + } + remaining = remaining.slice(written); + } + + fs.closeSync(IPC_PIPE_FD); + + process.exit(message.type === "error" ? 1 : 0); +} + +let scanner: Bun.Security.Scanner; + +try { + scanner = (await import(scannerModuleName)).scanner; +} catch (error) { + if (typeof error === "object" && error !== null && "code" in error && error.code === "ERR_MODULE_NOT_FOUND") { + if (!suppressError) { + const msg = `\x1b[31merror: \x1b[0mFailed to import security scanner: \x1b[1m'${scannerModuleName}'`; + console.error(msg); + } + + writeAndExit({ + type: "error", + code: "MODULE_NOT_FOUND", + module: scannerModuleName, + }); + } else { + writeAndExit({ + type: "error", + code: "SCAN_FAILED", + message: error instanceof Error ? error.message : String(error), + }); + } +} + +try { + if (typeof scanner !== "object" || scanner === null || typeof scanner.version !== "string") { + throw new Error("Security scanner must export a 'scanner' object with a version property"); + } + + if (scanner.version !== "1") { + writeAndExit({ + type: "error", + code: "INVALID_VERSION", + message: `Security scanner must be version 1, got version ${scanner.version}`, + }); + } + + if (typeof scanner.scan !== "function") { + throw new Error(`scanner.scan is not a function, got ${typeof scanner.scan}`); + } + + const result = await scanner.scan({ packages }); + + if (!Array.isArray(result)) { + throw new Error("Security scanner must return an array of advisories"); + } + + writeAndExit({ type: "result", advisories: result }); +} catch (error) { + if (!suppressError) { + console.error(error); + } + + writeAndExit({ + type: "error", + code: "SCAN_FAILED", + message: error instanceof Error ? error.message : "Unknown error occurred", + }); +} diff --git a/src/install/PackageManager/security_scanner.zig b/src/install/PackageManager/security_scanner.zig index 8aa24ef3b2..f1ad798378 100644 --- a/src/install/PackageManager/security_scanner.zig +++ b/src/install/PackageManager/security_scanner.zig @@ -3,22 +3,349 @@ const PackagePath = struct { dep_path: []DependencyID, }; -pub fn performSecurityScanAfterResolution(manager: *PackageManager) !void { - const security_scanner = manager.options.security_scanner orelse return; +pub const SecurityAdvisoryLevel = enum { fatal, warn }; - if (manager.options.dry_run or !manager.options.do.install_packages) return; - if (manager.update_requests.len == 0) { - Output.prettyErrorln("No update requests to scan", .{}); +pub const SecurityAdvisory = struct { + level: SecurityAdvisoryLevel, + package: []const u8, + url: ?[]const u8, + description: ?[]const u8, + pkg_path: ?[]const PackageID = null, +}; + +pub const SecurityScanResults = struct { + advisories: []SecurityAdvisory, + fatal_count: usize, + warn_count: usize, + packages_scanned: usize, + duration_ms: i64, + security_scanner: []const u8, + allocator: std.mem.Allocator, + + pub fn deinit(this: *SecurityScanResults) void { + for (this.advisories) |advisory| { + this.allocator.free(advisory.package); + if (advisory.description) |desc| this.allocator.free(desc); + if (advisory.url) |url| this.allocator.free(url); + if (advisory.pkg_path) |path| this.allocator.free(path); + } + this.allocator.free(this.advisories); + } + + pub fn hasFatalAdvisories(this: *const SecurityScanResults) bool { + return this.fatal_count > 0; + } + + pub fn hasWarnings(this: *const SecurityScanResults) bool { + return this.warn_count > 0; + } + + pub fn hasAdvisories(this: *const SecurityScanResults) bool { + return this.advisories.len > 0; + } +}; + +pub fn doPartialInstallOfSecurityScanner( + manager: *PackageManager, + ctx: bun.cli.Command.Context, + log_level: bun.install.PackageManager.Options.LogLevel, + security_scanner_pkg_id: PackageID, + original_cwd: []const u8, +) !void { + const workspace_filters, const install_root_dependencies = try InstallWithManager.getWorkspaceFilters(manager, original_cwd); + defer manager.allocator.free(workspace_filters); + + if (!manager.options.do.install_packages) { return; } - if (manager.options.log_level == .verbose) { - Output.prettyErrorln("[SecurityProvider] Running at '{s}'", .{security_scanner}); + if (security_scanner_pkg_id == invalid_package_id) { + Output.errGeneric("Cannot perform partial install: security scanner package ID is invalid", .{}); + return error.InvalidPackageID; } - const start_time = std.time.milliTimestamp(); - var pkg_dedupe: std.AutoArrayHashMap(PackageID, void) = .init(bun.default_allocator); - defer pkg_dedupe.deinit(); + const packages_to_install: ?[]const PackageID = &[_]PackageID{security_scanner_pkg_id}; + + const summary = switch (manager.options.node_linker) { + .hoisted, + // TODO + .auto, + => try HoistedInstall.installHoistedPackages( + manager, + ctx, + workspace_filters, + install_root_dependencies, + log_level, + packages_to_install, + ), + + .isolated => try IsolatedInstall.installIsolatedPackages( + manager, + ctx, + install_root_dependencies, + workspace_filters, + packages_to_install, + ), + }; + + if (bun.Environment.isDebug) { + bun.Output.debugWarn("Partial install summary - success: {d}, fail: {d}, skipped: {d}", .{ summary.success, summary.fail, summary.skipped }); + } + + if (summary.fail > 0) { + Output.errGeneric("Failed to install security scanner package (failed: {d}, success: {d})", .{ summary.fail, summary.success }); + return error.PartialInstallFailed; + } + + if (summary.success == 0 and summary.skipped == 0) { + Output.errGeneric("No packages were installed during security scanner installation", .{}); + return error.NoPackagesInstalled; + } +} + +pub const ScanAttemptResult = union(enum) { + success: SecurityScanResults, + needs_install: PackageID, + @"error": anyerror, +}; + +const ScannerFinder = struct { + manager: *PackageManager, + scanner_name: []const u8, + + pub fn findInRootDependencies(this: ScannerFinder) ?PackageID { + const pkgs = this.manager.lockfile.packages.slice(); + const pkg_dependencies = pkgs.items(.dependencies); + const pkg_resolutions = pkgs.items(.resolution); + const string_buf = this.manager.lockfile.buffers.string_bytes.items; + + const root_pkg_id: PackageID = 0; + const root_deps = pkg_dependencies[root_pkg_id]; + + for (root_deps.begin()..root_deps.end()) |_dep_id| { + const dep_id: DependencyID = @intCast(_dep_id); + const dep_pkg_id = this.manager.lockfile.buffers.resolutions.items[dep_id]; + + if (dep_pkg_id == invalid_package_id) continue; + + const dep_res = pkg_resolutions[dep_pkg_id]; + if (dep_res.tag != .npm) continue; + + const dep_name = this.manager.lockfile.buffers.dependencies.items[dep_id].name; + if (std.mem.eql(u8, dep_name.slice(string_buf), this.scanner_name)) { + return dep_pkg_id; + } + } + + return null; + } + + pub fn validateNotInWorkspaces(this: ScannerFinder) !void { + const pkgs = this.manager.lockfile.packages.slice(); + const pkg_deps = pkgs.items(.dependencies); + const pkg_res = pkgs.items(.resolution); + const string_buf = this.manager.lockfile.buffers.string_bytes.items; + + for (0..pkgs.len) |pkg_idx| { + if (pkg_res[pkg_idx].tag != .workspace) continue; + + const deps = pkg_deps[pkg_idx]; + for (deps.begin()..deps.end()) |_dep_id| { + const dep_id: DependencyID = @intCast(_dep_id); + const dep = this.manager.lockfile.buffers.dependencies.items[dep_id]; + + if (std.mem.eql(u8, dep.name.slice(string_buf), this.scanner_name)) { + Output.errGeneric("Security scanner '{s}' cannot be a dependency of a workspace package. It must be a direct dependency of the root package.", .{this.scanner_name}); + return error.SecurityScannerInWorkspace; + } + } + } + } +}; + +pub fn performSecurityScanAfterResolution(manager: *PackageManager, command_ctx: bun.cli.Command.Context, original_cwd: []const u8) !?SecurityScanResults { + const security_scanner = manager.options.security_scanner orelse return null; + + if (manager.options.dry_run or !manager.options.do.install_packages) return null; + + // For remove/uninstall, scan all remaining packages after removal + // For other commands, scan all if no update requests, otherwise scan update packages + const scan_all = manager.subcommand == .remove or manager.update_requests.len == 0; + const result = try attemptSecurityScan(manager, security_scanner, scan_all, command_ctx, original_cwd); + + switch (result) { + .success => |scan_results| return scan_results, + .needs_install => |pkg_id| { + Output.prettyln("Attempting to install security scanner from npm...", .{}); + try doPartialInstallOfSecurityScanner(manager, command_ctx, manager.options.log_level, pkg_id, original_cwd); + Output.prettyln("Security scanner installed successfully.", .{}); + + const retry_result = try attemptSecurityScanWithRetry(manager, security_scanner, scan_all, command_ctx, original_cwd, true); + switch (retry_result) { + .success => |scan_results| return scan_results, + else => return error.SecurityScannerRetryFailed, + } + }, + .@"error" => |err| return err, + } +} + +pub fn performSecurityScanForAll(manager: *PackageManager, command_ctx: bun.cli.Command.Context, original_cwd: []const u8) !?SecurityScanResults { + const security_scanner = manager.options.security_scanner orelse return null; + + const result = try attemptSecurityScan(manager, security_scanner, true, command_ctx, original_cwd); + switch (result) { + .success => |scan_results| return scan_results, + .needs_install => |pkg_id| { + Output.prettyln("Attempting to install security scanner from npm...", .{}); + try doPartialInstallOfSecurityScanner(manager, command_ctx, manager.options.log_level, pkg_id, original_cwd); + Output.prettyln("Security scanner installed successfully.", .{}); + + const retry_result = try attemptSecurityScanWithRetry(manager, security_scanner, true, command_ctx, original_cwd, true); + switch (retry_result) { + .success => |scan_results| return scan_results, + .needs_install => { + // Should not happen after retry - we just installed it + Output.errGeneric("Security scanner still required installation after partial install. This is probably a bug in Bun. Please report it to https://github.com/oven-sh/bun/issues", .{}); + return error.SecurityScannerRetryFailed; + }, + .@"error" => |err| return err, + } + }, + .@"error" => |err| return err, + } +} + +pub fn printSecurityAdvisories(manager: *PackageManager, results: *const SecurityScanResults) void { + if (!results.hasAdvisories()) return; + + const pkgs = manager.lockfile.packages.slice(); + const pkg_names = pkgs.items(.name); + const string_buf = manager.lockfile.buffers.string_bytes.items; + + for (results.advisories) |advisory| { + Output.print("\n", .{}); + + switch (advisory.level) { + .fatal => { + Output.pretty(" FATAL: {s}\n", .{advisory.package}); + }, + .warn => { + Output.pretty(" WARNING: {s}\n", .{advisory.package}); + }, + } + + if (advisory.pkg_path) |pkg_path| { + if (pkg_path.len > 1) { + Output.pretty(" via ", .{}); + for (pkg_path[0 .. pkg_path.len - 1], 0..) |ancestor_id, idx| { + if (idx > 0) Output.pretty(" › ", .{}); + const ancestor_name = pkg_names[ancestor_id].slice(string_buf); + Output.pretty("{s}", .{ancestor_name}); + } + Output.pretty(" › {s}\n", .{advisory.package}); + } else { + Output.pretty(" (direct dependency)\n", .{}); + } + } + + if (advisory.description) |desc| { + if (desc.len > 0) { + Output.pretty(" {s}\n", .{desc}); + } + } + if (advisory.url) |url| { + if (url.len > 0) { + Output.pretty(" {s}\n", .{url}); + } + } + } + + Output.print("\n", .{}); + const total = results.fatal_count + results.warn_count; + if (total == 1) { + if (results.fatal_count == 1) { + Output.pretty("1 advisory (1 fatal)\n", .{}); + } else { + Output.pretty("1 advisory (1 warning)\n", .{}); + } + } else { + if (results.fatal_count > 0 and results.warn_count > 0) { + Output.pretty("{d} advisories ({d} fatal, {d} warning{s})\n", .{ total, results.fatal_count, results.warn_count, if (results.warn_count == 1) "" else "s" }); + } else if (results.fatal_count > 0) { + Output.pretty("{d} advisories ({d} fatal)\n", .{ total, results.fatal_count }); + } else { + Output.pretty("{d} advisories ({d} warning{s})\n", .{ total, results.warn_count, if (results.warn_count == 1) "" else "s" }); + } + } +} + +pub fn promptForWarnings() bool { + const can_prompt = Output.isStdinTTY(); + + if (!can_prompt) { + Output.pretty("\nSecurity warnings found. Cannot prompt for confirmation (no TTY).\n", .{}); + Output.pretty("Installation cancelled.\n", .{}); + return false; + } + + Output.pretty("\nSecurity warnings found. Continue anyway? [y/N] ", .{}); + Output.flush(); + + var stdin = std.io.getStdIn(); + const unbuffered_reader = stdin.reader(); + var buffered = std.io.bufferedReader(unbuffered_reader); + var reader = buffered.reader(); + + const first_byte = reader.readByte() catch { + Output.pretty("\nInstallation cancelled.\n", .{}); + return false; + }; + + const should_continue = switch (first_byte) { + '\n' => false, + '\r' => blk: { + const next_byte = reader.readByte() catch { + break :blk false; + }; + break :blk next_byte == '\n' and false; + }, + 'y', 'Y' => blk: { + const next_byte = reader.readByte() catch { + break :blk false; + }; + if (next_byte == '\n') { + break :blk true; + } else if (next_byte == '\r') { + const second_byte = reader.readByte() catch { + break :blk false; + }; + break :blk second_byte == '\n'; + } + break :blk false; + }, + else => blk: { + while (reader.readByte()) |b| { + if (b == '\n' or b == '\r') break; + } else |_| {} + break :blk false; + }, + }; + + if (!should_continue) { + Output.pretty("\nInstallation cancelled.\n", .{}); + return false; + } + + Output.pretty("\nContinuing with installation...\n\n", .{}); + return true; +} + +const PackageCollector = struct { + manager: *PackageManager, + dedupe: std.AutoArrayHashMap(PackageID, void), + queue: std.fifo.LinearFifo(QueueItem, .Dynamic), + package_paths: std.AutoArrayHashMap(PackageID, PackagePath), const QueueItem = struct { pkg_id: PackageID, @@ -26,238 +353,317 @@ pub fn performSecurityScanAfterResolution(manager: *PackageManager) !void { pkg_path: std.ArrayList(PackageID), dep_path: std.ArrayList(DependencyID), }; - var ids_queue: std.fifo.LinearFifo(QueueItem, .Dynamic) = .init(bun.default_allocator); - defer ids_queue.deinit(); - var package_paths = std.AutoArrayHashMap(PackageID, PackagePath).init(manager.allocator); - defer { - var iter = package_paths.iterator(); + pub fn init(manager: *PackageManager) PackageCollector { + return .{ + .manager = manager, + .dedupe = std.AutoArrayHashMap(PackageID, void).init(bun.default_allocator), + .queue = std.fifo.LinearFifo(QueueItem, .Dynamic).init(bun.default_allocator), + .package_paths = std.AutoArrayHashMap(PackageID, PackagePath).init(manager.allocator), + }; + } + + pub fn deinit(this: *PackageCollector) void { + this.dedupe.deinit(); + this.queue.deinit(); + + var iter = this.package_paths.iterator(); while (iter.next()) |entry| { - manager.allocator.free(entry.value_ptr.pkg_path); - manager.allocator.free(entry.value_ptr.dep_path); + this.manager.allocator.free(entry.value_ptr.pkg_path); + this.manager.allocator.free(entry.value_ptr.dep_path); } - package_paths.deinit(); + this.package_paths.deinit(); } - const pkgs = manager.lockfile.packages.slice(); - const pkg_names = pkgs.items(.name); - const pkg_resolutions = pkgs.items(.resolution); - const pkg_dependencies = pkgs.items(.dependencies); + pub fn collectAllPackages(this: *PackageCollector) !void { + const pkgs = this.manager.lockfile.packages.slice(); + const pkg_dependencies = pkgs.items(.dependencies); + const pkg_resolutions = pkgs.items(.resolution); - for (manager.update_requests) |req| { - for (0..pkgs.len) |_update_pkg_id| { - const update_pkg_id: PackageID = @intCast(_update_pkg_id); + const root_pkg_id: PackageID = 0; + const root_deps = pkg_dependencies[root_pkg_id]; - if (update_pkg_id != req.package_id) { - continue; - } + for (root_deps.begin()..root_deps.end()) |_dep_id| { + const dep_id: DependencyID = @intCast(_dep_id); + const dep_pkg_id = this.manager.lockfile.buffers.resolutions.items[dep_id]; - if (pkg_resolutions[update_pkg_id].tag != .npm) { - continue; - } + if (dep_pkg_id == invalid_package_id) continue; - var update_dep_id: DependencyID = invalid_dependency_id; - var parent_pkg_id: PackageID = invalid_package_id; + const dep_res = pkg_resolutions[dep_pkg_id]; + if (dep_res.tag != .npm) continue; - for (0..pkgs.len) |_pkg_id| update_dep_id: { - const pkg_id: PackageID = @intCast(_pkg_id); + if ((try this.dedupe.getOrPut(dep_pkg_id)).found_existing) continue; - const pkg_res = pkg_resolutions[pkg_id]; + var pkg_path_buf = std.ArrayList(PackageID).init(this.manager.allocator); + try pkg_path_buf.append(root_pkg_id); + try pkg_path_buf.append(dep_pkg_id); - if (pkg_res.tag != .root and pkg_res.tag != .workspace) { - continue; - } + var dep_path_buf = std.ArrayList(DependencyID).init(this.manager.allocator); + try dep_path_buf.append(dep_id); - const pkg_deps = pkg_dependencies[pkg_id]; - for (pkg_deps.begin()..pkg_deps.end()) |_dep_id| { - const dep_id: DependencyID = @intCast(_dep_id); - - const dep_pkg_id = manager.lockfile.buffers.resolutions.items[dep_id]; - - if (dep_pkg_id == invalid_package_id) { - continue; - } - - if (dep_pkg_id != update_pkg_id) { - continue; - } - - update_dep_id = dep_id; - parent_pkg_id = pkg_id; - break :update_dep_id; - } - } - - if (update_dep_id == invalid_dependency_id) { - continue; - } - - if ((try pkg_dedupe.getOrPut(update_pkg_id)).found_existing) { - continue; - } - - var initial_pkg_path = std.ArrayList(PackageID).init(manager.allocator); - // If this is a direct dependency from root, start with root package - if (parent_pkg_id != invalid_package_id) { - try initial_pkg_path.append(parent_pkg_id); - } - try initial_pkg_path.append(update_pkg_id); - var initial_dep_path = std.ArrayList(DependencyID).init(manager.allocator); - try initial_dep_path.append(update_dep_id); - - try ids_queue.writeItem(.{ - .pkg_id = update_pkg_id, - .dep_id = update_dep_id, - .pkg_path = initial_pkg_path, - .dep_path = initial_dep_path, + try this.queue.writeItem(.{ + .pkg_id = dep_pkg_id, + .dep_id = dep_id, + .pkg_path = pkg_path_buf, + .dep_path = dep_path_buf, }); } } - // For new packages being added via 'bun add', we just scan the update requests directly - // since they haven't been added to the lockfile yet + pub fn collectUpdatePackages(this: *PackageCollector) !void { + const pkgs = this.manager.lockfile.packages.slice(); + const pkg_resolutions = pkgs.items(.resolution); + const pkg_dependencies = pkgs.items(.dependencies); - var json_buf = std.ArrayList(u8).init(manager.allocator); - var writer = json_buf.writer(); - defer json_buf.deinit(); + for (this.manager.update_requests) |req| { + for (0..pkgs.len) |_update_pkg_id| { + const update_pkg_id: PackageID = @intCast(_update_pkg_id); + if (update_pkg_id != req.package_id) continue; + if (pkg_resolutions[update_pkg_id].tag != .npm) continue; - const string_buf = manager.lockfile.buffers.string_bytes.items; + var update_dep_id: DependencyID = invalid_dependency_id; + var parent_pkg_id: PackageID = invalid_package_id; - try writer.writeAll("[\n"); + for (0..pkgs.len) |_pkg_id| update_dep_id: { + const pkg_id: PackageID = @intCast(_pkg_id); + const pkg_res = pkg_resolutions[pkg_id]; + if (pkg_res.tag != .root) continue; - var first = true; + const pkg_deps = pkg_dependencies[pkg_id]; + for (pkg_deps.begin()..pkg_deps.end()) |_dep_id| { + const dep_id: DependencyID = @intCast(_dep_id); + const dep_pkg_id = this.manager.lockfile.buffers.resolutions.items[dep_id]; + if (dep_pkg_id == invalid_package_id) continue; + if (dep_pkg_id != update_pkg_id) continue; - while (ids_queue.readItem()) |item| { - defer item.pkg_path.deinit(); - defer item.dep_path.deinit(); + update_dep_id = dep_id; + parent_pkg_id = pkg_id; + break :update_dep_id; + } + } - const pkg_id = item.pkg_id; - const dep_id = item.dep_id; + if (update_dep_id == invalid_dependency_id) continue; + if ((try this.dedupe.getOrPut(update_pkg_id)).found_existing) continue; - const pkg_path_copy = try manager.allocator.alloc(PackageID, item.pkg_path.items.len); - @memcpy(pkg_path_copy, item.pkg_path.items); + var initial_pkg_path = std.ArrayList(PackageID).init(this.manager.allocator); + if (parent_pkg_id != invalid_package_id) { + try initial_pkg_path.append(parent_pkg_id); + } + try initial_pkg_path.append(update_pkg_id); - const dep_path_copy = try manager.allocator.alloc(DependencyID, item.dep_path.items.len); - @memcpy(dep_path_copy, item.dep_path.items); + var initial_dep_path = std.ArrayList(DependencyID).init(this.manager.allocator); + try initial_dep_path.append(update_dep_id); - try package_paths.put(pkg_id, .{ - .pkg_path = pkg_path_copy, - .dep_path = dep_path_copy, - }); - - const pkg_name = pkg_names[pkg_id]; - const pkg_res = pkg_resolutions[pkg_id]; - const dep_version = manager.lockfile.buffers.dependencies.items[dep_id].version; - - if (!first) try writer.writeAll(",\n"); - - try writer.print( - \\ {{ - \\ "name": {}, - \\ "version": "{s}", - \\ "requestedRange": {}, - \\ "tarball": {} - \\ }} - , .{ bun.fmt.formatJSONStringUTF8(pkg_name.slice(string_buf), .{}), pkg_res.value.npm.version.fmt(string_buf), bun.fmt.formatJSONStringUTF8(dep_version.literal.slice(string_buf), .{}), bun.fmt.formatJSONStringUTF8(pkg_res.value.npm.url.slice(string_buf), .{}) }); - - first = false; - - // then go through it's dependencies and queue them up if - // valid and first time we've seen them - const pkg_deps = pkg_dependencies[pkg_id]; - - for (pkg_deps.begin()..pkg_deps.end()) |_next_dep_id| { - const next_dep_id: DependencyID = @intCast(_next_dep_id); - - const next_pkg_id = manager.lockfile.buffers.resolutions.items[next_dep_id]; - if (next_pkg_id == invalid_package_id) { - continue; + try this.queue.writeItem(.{ + .pkg_id = update_pkg_id, + .dep_id = update_dep_id, + .pkg_path = initial_pkg_path, + .dep_path = initial_dep_path, + }); } - - const next_pkg_res = pkg_resolutions[next_pkg_id]; - if (next_pkg_res.tag != .npm) { - continue; - } - - if ((try pkg_dedupe.getOrPut(next_pkg_id)).found_existing) { - continue; - } - - var extended_pkg_path = std.ArrayList(PackageID).init(manager.allocator); - try extended_pkg_path.appendSlice(item.pkg_path.items); - try extended_pkg_path.append(next_pkg_id); - - var extended_dep_path = std.ArrayList(DependencyID).init(manager.allocator); - try extended_dep_path.appendSlice(item.dep_path.items); - try extended_dep_path.append(next_dep_id); - - try ids_queue.writeItem(.{ - .pkg_id = next_pkg_id, - .dep_id = next_dep_id, - .pkg_path = extended_pkg_path, - .dep_path = extended_dep_path, - }); } } - try writer.writeAll("\n]"); + pub fn processQueue(this: *PackageCollector) !void { + const pkgs = this.manager.lockfile.packages.slice(); + const pkg_resolutions = pkgs.items(.resolution); + const pkg_dependencies = pkgs.items(.dependencies); - var code_buf = std.ArrayList(u8).init(manager.allocator); - defer code_buf.deinit(); - var code_writer = code_buf.writer(); + while (this.queue.readItem()) |item| { + defer item.pkg_path.deinit(); + defer item.dep_path.deinit(); - try code_writer.print( - \\let scanner; - \\const scannerModuleName = '{s}'; - \\const packages = {s}; - \\ - \\try {{ - \\ scanner = (await import(scannerModuleName)).scanner; - \\}} catch (error) {{ - \\ const msg = `\x1b[31merror: \x1b[0mFailed to import security scanner: \x1b[1m'${{scannerModuleName}}'\x1b[0m - if you use a security scanner from npm, please run '\x1b[36mbun install\x1b[0m' before adding other packages.`; - \\ console.error(msg); - \\ process.exit(1); - \\}} - \\ - \\try {{ - \\ if (typeof scanner !== 'object' || scanner === null || typeof scanner.version !== 'string') {{ - \\ throw new Error("Security scanner must export a 'scanner' object with a version property"); - \\ }} - \\ - \\ if (scanner.version !== '1') {{ - \\ throw new Error('Security scanner must be version 1'); - \\ }} - \\ - \\ if (typeof scanner.scan !== 'function') {{ - \\ throw new Error('scanner.scan is not a function, got ' + typeof scanner.scan); - \\ }} - \\ - \\ const result = await scanner.scan({{ packages }}); - \\ - \\ if (!Array.isArray(result)) {{ - \\ throw new Error('Security scanner must return an array of advisories'); - \\ }} - \\ - \\ const fs = require('fs'); - \\ const data = JSON.stringify({{advisories: result}}); - \\ for (let remaining = data; remaining.length > 0;) {{ - \\ const written = fs.writeSync(3, remaining); - \\ if (written === 0) process.exit(1); - \\ remaining = remaining.slice(written); - \\ }} - \\ fs.closeSync(3); - \\ - \\ process.exit(0); - \\}} catch (error) {{ - \\ console.error(error); - \\ process.exit(1); - \\}} - , .{ security_scanner, json_buf.items }); + const pkg_id = item.pkg_id; + _ = item.dep_id; // Could be useful in the future for dependency-specific processing + + const pkg_path_copy = try this.manager.allocator.alloc(PackageID, item.pkg_path.items.len); + @memcpy(pkg_path_copy, item.pkg_path.items); + + const dep_path_copy = try this.manager.allocator.alloc(DependencyID, item.dep_path.items.len); + @memcpy(dep_path_copy, item.dep_path.items); + + try this.package_paths.put(pkg_id, .{ + .pkg_path = pkg_path_copy, + .dep_path = dep_path_copy, + }); + + const pkg_deps = pkg_dependencies[pkg_id]; + for (pkg_deps.begin()..pkg_deps.end()) |_next_dep_id| { + const next_dep_id: DependencyID = @intCast(_next_dep_id); + const next_pkg_id = this.manager.lockfile.buffers.resolutions.items[next_dep_id]; + + if (next_pkg_id == invalid_package_id) continue; + + const next_pkg_res = pkg_resolutions[next_pkg_id]; + if (next_pkg_res.tag != .npm) continue; + + if ((try this.dedupe.getOrPut(next_pkg_id)).found_existing) continue; + + var extended_pkg_path = std.ArrayList(PackageID).init(this.manager.allocator); + try extended_pkg_path.appendSlice(item.pkg_path.items); + try extended_pkg_path.append(next_pkg_id); + + var extended_dep_path = std.ArrayList(DependencyID).init(this.manager.allocator); + try extended_dep_path.appendSlice(item.dep_path.items); + try extended_dep_path.append(next_dep_id); + + try this.queue.writeItem(.{ + .pkg_id = next_pkg_id, + .dep_id = next_dep_id, + .pkg_path = extended_pkg_path, + .dep_path = extended_dep_path, + }); + } + } + } +}; + +const JSONBuilder = struct { + manager: *PackageManager, + collector: *PackageCollector, + + pub fn buildPackageJSON(this: JSONBuilder) ![]const u8 { + var json_buf = std.ArrayList(u8).init(this.manager.allocator); + var writer = json_buf.writer(); + + const pkgs = this.manager.lockfile.packages.slice(); + const pkg_names = pkgs.items(.name); + const pkg_resolutions = pkgs.items(.resolution); + const string_buf = this.manager.lockfile.buffers.string_bytes.items; + + try writer.writeAll("[\n"); + + var first = true; + var iter = this.collector.package_paths.iterator(); + while (iter.next()) |entry| { + const pkg_id = entry.key_ptr.*; + const paths = entry.value_ptr.*; + + const dep_id = if (paths.dep_path.len > 0) paths.dep_path[paths.dep_path.len - 1] else invalid_dependency_id; + + const pkg_name = pkg_names[pkg_id]; + const pkg_res = pkg_resolutions[pkg_id]; + + if (!first) try writer.writeAll(",\n"); + + if (dep_id == invalid_dependency_id) { + try writer.print( + \\ {{ + \\ "name": {}, + \\ "version": "{s}", + \\ "requestedRange": "{s}", + \\ "tarball": {} + \\ }} + , .{ + bun.fmt.formatJSONStringUTF8(pkg_name.slice(string_buf), .{}), + pkg_res.value.npm.version.fmt(string_buf), + pkg_res.value.npm.version.fmt(string_buf), + bun.fmt.formatJSONStringUTF8(pkg_res.value.npm.url.slice(string_buf), .{}), + }); + } else { + const dep_version = this.manager.lockfile.buffers.dependencies.items[dep_id].version; + try writer.print( + \\ {{ + \\ "name": {}, + \\ "version": "{s}", + \\ "requestedRange": {}, + \\ "tarball": {} + \\ }} + , .{ + bun.fmt.formatJSONStringUTF8(pkg_name.slice(string_buf), .{}), + pkg_res.value.npm.version.fmt(string_buf), + bun.fmt.formatJSONStringUTF8(dep_version.literal.slice(string_buf), .{}), + bun.fmt.formatJSONStringUTF8(pkg_res.value.npm.url.slice(string_buf), .{}), + }); + } + + first = false; + } + + try writer.writeAll("\n]"); + return json_buf.toOwnedSlice(); + } +}; + +// Security scanner subprocess entry point - uses IPC protocol for communication +// Note: scanner-entry.ts must be in JavaScriptSources.txt for the build +// scanner-entry.d.ts is NOT included in the build (type definitions only) +const scanner_entry_source = @embedFile("./scanner-entry.ts"); + +fn attemptSecurityScan(manager: *PackageManager, security_scanner: []const u8, scan_all: bool, command_ctx: bun.cli.Command.Context, original_cwd: []const u8) !ScanAttemptResult { + return attemptSecurityScanWithRetry(manager, security_scanner, scan_all, command_ctx, original_cwd, false); +} + +fn attemptSecurityScanWithRetry(manager: *PackageManager, security_scanner: []const u8, scan_all: bool, command_ctx: bun.cli.Command.Context, original_cwd: []const u8, is_retry: bool) !ScanAttemptResult { + if (manager.options.log_level == .verbose) { + Output.prettyErrorln("[SecurityProvider] Running at '{s}'", .{security_scanner}); + Output.prettyErrorln("[SecurityProvider] top_level_dir: '{s}'", .{FileSystem.instance.top_level_dir}); + Output.prettyErrorln("[SecurityProvider] original_cwd: '{s}'", .{original_cwd}); + } + const start_time = std.time.milliTimestamp(); + + const finder = ScannerFinder{ .manager = manager, .scanner_name = security_scanner }; + try finder.validateNotInWorkspaces(); + + // After a partial install, the package might exist but not be in the lockfile yet + // In that case, we'll get null here but should still try to run the scanner + const security_scanner_pkg_id = finder.findInRootDependencies(); + // Suppress JavaScript error output unless in verbose mode + const suppress_error_output = manager.options.log_level != .verbose; + + var collector = PackageCollector.init(manager); + defer collector.deinit(); + + if (scan_all) { + try collector.collectAllPackages(); + } else { + try collector.collectUpdatePackages(); + } + + try collector.processQueue(); + + const json_builder = JSONBuilder{ .manager = manager, .collector = &collector }; + const json_data = try json_builder.buildPackageJSON(); + defer manager.allocator.free(json_data); + + var code = std.ArrayList(u8).init(manager.allocator); + defer code.deinit(); + + var temp_source: []const u8 = scanner_entry_source; + + const scanner_placeholder = "__SCANNER_MODULE__"; + if (std.mem.indexOf(u8, temp_source, scanner_placeholder)) |index| { + try code.appendSlice(temp_source[0..index]); + try code.appendSlice(security_scanner); + try code.appendSlice(temp_source[index + scanner_placeholder.len ..]); + temp_source = code.items; + } + + const packages_placeholder = "__PACKAGES_JSON__"; + if (std.mem.indexOf(u8, temp_source, packages_placeholder)) |index| { + var new_code = std.ArrayList(u8).init(manager.allocator); + try new_code.appendSlice(temp_source[0..index]); + try new_code.appendSlice(json_data); + try new_code.appendSlice(temp_source[index + packages_placeholder.len ..]); + code.deinit(); + code = new_code; + temp_source = code.items; + } + + const suppress_placeholder = "__SUPPRESS_ERROR__"; + if (std.mem.indexOf(u8, temp_source, suppress_placeholder)) |index| { + var new_code = std.ArrayList(u8).init(manager.allocator); + try new_code.appendSlice(temp_source[0..index]); + try new_code.appendSlice(if (suppress_error_output) "true" else "false"); + try new_code.appendSlice(temp_source[index + suppress_placeholder.len ..]); + code.deinit(); + code = new_code; + } var scanner = SecurityScanSubprocess.new(.{ .manager = manager, - .code = try manager.allocator.dupe(u8, code_buf.items), - .json_data = try manager.allocator.dupe(u8, json_buf.items), + .code = try manager.allocator.dupe(u8, code.items), + .json_data = try manager.allocator.dupe(u8, json_data), .ipc_data = undefined, .stderr_data = undefined, }); @@ -280,19 +686,10 @@ pub fn performSecurityScanAfterResolution(manager: *PackageManager) !void { manager.sleepUntil(&closure, &@TypeOf(closure).isDone); - const packages_scanned = pkg_dedupe.count(); - try scanner.handleResults(&package_paths, start_time, packages_scanned, security_scanner); + const packages_scanned = collector.dedupe.count(); + return try scanner.handleResults(&collector.package_paths, start_time, packages_scanned, security_scanner, security_scanner_pkg_id, command_ctx, original_cwd, is_retry); } -const SecurityAdvisoryLevel = enum { fatal, warn }; - -const SecurityAdvisory = struct { - level: SecurityAdvisoryLevel, - package: []const u8, - url: ?[]const u8, - description: ?[]const u8, -}; - pub const SecurityScanSubprocess = struct { manager: *PackageManager, code: []const u8, @@ -315,9 +712,8 @@ pub const SecurityScanSubprocess = struct { const pipe_result = bun.sys.pipe(); const pipe_fds = switch (pipe_result) { - .err => |err| { - Output.errGeneric("Failed to create IPC pipe: {s}", .{@tagName(err.getErrno())}); - Global.exit(1); + .err => { + return error.IPCPipeFailed; }, .result => |fds| fds, }; @@ -336,11 +732,13 @@ pub const SecurityScanSubprocess = struct { this.manager.allocator.free(bun.span(argv[3].?)); } + const spawn_cwd = FileSystem.instance.top_level_dir; + const spawn_options = bun.spawn.SpawnOptions{ .stdout = .inherit, .stderr = .inherit, .stdin = .inherit, - .cwd = FileSystem.instance.top_level_dir, + .cwd = spawn_cwd, .extra_fds = &.{.{ .pipe = pipe_fds[1] }}, .windows = if (Environment.isWindows) .{ .loop = jsc.EventLoopHandle.init(&this.manager.event_loop), @@ -366,9 +764,8 @@ pub const SecurityScanSubprocess = struct { process.setExitHandler(this); switch (process.watchOrReap()) { - .err => |err| { - Output.errGeneric("Failed to watch security scanner process: {}", .{err}); - Global.exit(1); + .err => { + return error.ProcessWatchFailed; }, .result => {}, } @@ -426,22 +823,25 @@ pub const SecurityScanSubprocess = struct { } } - pub fn handleResults(this: *SecurityScanSubprocess, package_paths: *std.AutoArrayHashMap(PackageID, PackagePath), start_time: i64, packages_scanned: usize, security_scanner: []const u8) !void { + pub fn handleResults(this: *SecurityScanSubprocess, package_paths: *std.AutoArrayHashMap(PackageID, PackagePath), start_time: i64, packages_scanned: usize, security_scanner: []const u8, security_scanner_pkg_id: ?PackageID, command_ctx: bun.cli.Command.Context, original_cwd: []const u8, is_retry: bool) !ScanAttemptResult { + _ = command_ctx; // Reserved for future use + _ = original_cwd; // Reserved for future use defer { this.ipc_data.deinit(); this.stderr_data.deinit(); } - const status = this.exit_status orelse bun.spawn.Status{ .exited = .{ .code = 0 } }; + if (this.exit_status == null) { + Output.errGeneric("Security scanner terminated without an exit status. This is a bug in Bun.", .{}); + return error.SecurityScannerProcessFailedWithoutExitStatus; + } + + const status = this.exit_status.?; if (this.ipc_data.items.len == 0) { switch (status) { .exited => |exit| { - if (exit.code != 0) { - Output.errGeneric("Security scanner exited with code {d} without sending data", .{exit.code}); - } else { - Output.errGeneric("Security scanner exited without sending any data", .{}); - } + Output.errGeneric("Security scanner exited with code {d} without sending data", .{exit.code}); }, .signaled => |sig| { Output.errGeneric("Security scanner terminated by signal {s} without sending data", .{@tagName(sig)}); @@ -450,9 +850,119 @@ pub const SecurityScanSubprocess = struct { Output.errGeneric("Security scanner terminated abnormally without sending data", .{}); }, } - Global.exit(1); + return error.NoSecurityScanData; } + const json_source = logger.Source{ + .contents = this.ipc_data.items, + .path = bun.fs.Path.init("ipc-message.json"), + }; + + var temp_log = logger.Log.init(this.manager.allocator); + defer temp_log.deinit(); + + const json_expr = bun.json.parseUTF8(&json_source, &temp_log, this.manager.allocator) catch |err| { + Output.errGeneric("Security scanner sent invalid JSON: {s}", .{@errorName(err)}); + if (this.ipc_data.items.len < 1000) { + Output.errGeneric("Response: {s}", .{this.ipc_data.items}); + } + return error.InvalidIPCMessage; + }; + + if (json_expr.data != .e_object) { + Output.errGeneric("Security scanner IPC message must be a JSON object", .{}); + return error.InvalidIPCFormat; + } + + const obj = json_expr.data.e_object; + const type_expr = obj.get("type") orelse { + Output.errGeneric("Security scanner IPC message missing 'type' field", .{}); + return error.MissingIPCType; + }; + + const type_str = type_expr.asString(this.manager.allocator) orelse { + Output.errGeneric("Security scanner IPC 'type' must be a string", .{}); + return error.InvalidIPCType; + }; + + if (std.mem.eql(u8, type_str, "error")) { + const code_expr = obj.get("code") orelse { + Output.errGeneric("Security scanner error missing 'code' field", .{}); + return error.MissingErrorCode; + }; + + const code_str = code_expr.asString(this.manager.allocator) orelse { + Output.errGeneric("Security scanner error 'code' must be a string", .{}); + return error.InvalidErrorCode; + }; + + const error_code = std.meta.stringToEnum(enum { + MODULE_NOT_FOUND, + INVALID_VERSION, + SCAN_FAILED, + }, code_str); + + switch (error_code orelse { + Output.errGeneric("Unknown security scanner error code: {s}", .{code_str}); + return error.UnknownErrorCode; + }) { + .MODULE_NOT_FOUND => { + // If this is a retry after partial install, we need to handle it differently + // The scanner might have been installed but the lockfile wasn't updated + if (is_retry) { + // Check if the scanner is an npm package name (not a file path) + const is_package_name = bun.resolver.isPackagePath(security_scanner); + + if (is_package_name) { + // For npm packages, after install they should be resolvable + // If not, there was a real problem with the installation + Output.errGeneric("Security scanner '{s}' could not be found after installation attempt.\n If this is a local file, please check that the file exists and the path is correct.", .{security_scanner}); + return error.SecurityScannerNotFound; + } else { + // For local files, the error is expected - they can't be installed + Output.errGeneric("Security scanner '{s}' is configured in bunfig.toml but the file could not be found.\n Please check that the file exists and the path is correct.", .{security_scanner}); + return error.SecurityScannerNotFound; + } + } + + // First attempt - only try to install if we have a package ID + if (security_scanner_pkg_id) |pkg_id| { + return ScanAttemptResult{ .needs_install = pkg_id }; + } else { + // No package ID means it's not in dependencies + const is_package_name = bun.resolver.isPackagePath(security_scanner); + + if (is_package_name) { + Output.errGeneric("Security scanner '{s}' is configured in bunfig.toml but is not installed.\n To install it, run: bun add --dev {s}", .{ security_scanner, security_scanner }); + } else { + Output.errGeneric("Security scanner '{s}' is configured in bunfig.toml but the file could not be found.\n Please check that the file exists and the path is correct.", .{security_scanner}); + } + return error.SecurityScannerNotInDependencies; + } + }, + .INVALID_VERSION => { + if (obj.get("message")) |msg| { + if (msg.asString(this.manager.allocator)) |msg_str| { + Output.errGeneric("Security scanner error: {s}", .{msg_str}); + } + } + return error.InvalidScannerVersion; + }, + .SCAN_FAILED => { + if (obj.get("message")) |msg| { + if (msg.asString(this.manager.allocator)) |msg_str| { + Output.errGeneric("Security scanner failed: {s}", .{msg_str}); + } + } + return error.ScannerFailed; + }, + } + } else if (!std.mem.eql(u8, type_str, "result")) { + Output.errGeneric("Unknown security scanner message type: {s}", .{type_str}); + return error.UnknownMessageType; + } + + // if we got here then we got a result message so we can continue like normal const duration = std.time.milliTimestamp() - start_time; if (this.manager.options.log_level == .verbose) { @@ -480,115 +990,113 @@ pub const SecurityScanSubprocess = struct { } } - try handleSecurityAdvisories(this.manager, this.ipc_data.items, package_paths); + const advisories_expr = obj.get("advisories") orelse { + Output.errGeneric("Security scanner result missing 'advisories' field", .{}); + return error.MissingAdvisoriesField; + }; + + const advisories = try parseSecurityAdvisoriesFromExpr(this.manager, advisories_expr, package_paths); if (!status.isOK()) { switch (status) { .exited => |exited| { if (exited.code != 0) { Output.errGeneric("Security scanner failed with exit code: {d}", .{exited.code}); - Global.exit(1); + return error.SecurityScannerFailed; } }, .signaled => |signal| { Output.errGeneric("Security scanner was terminated by signal: {s}", .{@tagName(signal)}); - Global.exit(1); + return error.SecurityScannerTerminated; }, else => { Output.errGeneric("Security scanner failed", .{}); - Global.exit(1); + return error.SecurityScannerFailed; }, } } + + var fatal_count: usize = 0; + var warn_count: usize = 0; + for (advisories) |advisory| { + switch (advisory.level) { + .fatal => fatal_count += 1, + .warn => warn_count += 1, + } + } + + return ScanAttemptResult{ .success = SecurityScanResults{ + .advisories = advisories, + .fatal_count = fatal_count, + .warn_count = warn_count, + .packages_scanned = packages_scanned, + .duration_ms = duration, + .security_scanner = security_scanner, + .allocator = this.manager.allocator, + } }; } }; -fn handleSecurityAdvisories(manager: *PackageManager, ipc_data: []const u8, package_paths: *std.AutoArrayHashMap(PackageID, PackagePath)) !void { - if (ipc_data.len == 0) return; - - const json_source = logger.Source{ - .contents = ipc_data, - .path = bun.fs.Path.init("security-advisories.json"), - }; - - var temp_log = logger.Log.init(manager.allocator); - defer temp_log.deinit(); - - const json_expr = bun.json.parseUTF8(&json_source, &temp_log, manager.allocator) catch |err| { - Output.errGeneric("Security scanner returned invalid JSON: {s}", .{@errorName(err)}); - if (ipc_data.len < 1000) { - // If the response is reasonably small, show it to help debugging - Output.errGeneric("Response: {s}", .{ipc_data}); - } - if (temp_log.errors > 0) { - temp_log.print(Output.errorWriter()) catch {}; - } - Global.exit(1); - }; - +fn parseSecurityAdvisoriesFromExpr(manager: *PackageManager, advisories_expr: bun.js_parser.Expr, package_paths: *std.AutoArrayHashMap(PackageID, PackagePath)) ![]SecurityAdvisory { var advisories_list = std.ArrayList(SecurityAdvisory).init(manager.allocator); defer advisories_list.deinit(); - if (json_expr.data != .e_object) { - Output.errGeneric("Security scanner response must be a JSON object, got: {s}", .{@tagName(json_expr.data)}); - Global.exit(1); - } - - const obj = json_expr.data.e_object; - - const advisories_expr = obj.get("advisories") orelse { - Output.errGeneric("Security scanner response missing required 'advisories' field", .{}); - Global.exit(1); - }; - if (advisories_expr.data != .e_array) { Output.errGeneric("Security scanner 'advisories' field must be an array, got: {s}", .{@tagName(advisories_expr.data)}); - Global.exit(1); + return error.InvalidAdvisoriesFormat; } const array = advisories_expr.data.e_array; for (array.items.slice(), 0..) |item, i| { if (item.data != .e_object) { Output.errGeneric("Security advisory at index {d} must be an object, got: {s}", .{ i, @tagName(item.data) }); - Global.exit(1); + return error.InvalidAdvisoryFormat; } const item_obj = item.data.e_object; const name_expr = item_obj.get("package") orelse { Output.errGeneric("Security advisory at index {d} missing required 'package' field", .{i}); - Global.exit(1); + return error.MissingPackageField; }; - const name_str = name_expr.asString(manager.allocator) orelse { + const name_str_temp = name_expr.asString(manager.allocator) orelse { Output.errGeneric("Security advisory at index {d} 'package' field must be a string", .{i}); - Global.exit(1); + return error.InvalidPackageField; }; - if (name_str.len == 0) { + if (name_str_temp.len == 0) { Output.errGeneric("Security advisory at index {d} 'package' field cannot be empty", .{i}); - Global.exit(1); + return error.EmptyPackageField; } + // Duplicate the string since asString returns temporary memory + const name_str = try manager.allocator.dupe(u8, name_str_temp); const desc_str: ?[]const u8 = if (item_obj.get("description")) |desc_expr| blk: { - if (desc_expr.asString(manager.allocator)) |str| break :blk str; + if (desc_expr.asString(manager.allocator)) |str| { + // Duplicate the string since asString returns temporary memory + break :blk try manager.allocator.dupe(u8, str); + } if (desc_expr.data == .e_null) break :blk null; Output.errGeneric("Security advisory at index {d} 'description' field must be a string or null", .{i}); - Global.exit(1); + return error.InvalidDescriptionField; } else null; const url_str: ?[]const u8 = if (item_obj.get("url")) |url_expr| blk: { - if (url_expr.asString(manager.allocator)) |str| break :blk str; + if (url_expr.asString(manager.allocator)) |str| { + // Duplicate the string since asString returns temporary memory + break :blk try manager.allocator.dupe(u8, str); + } if (url_expr.data == .e_null) break :blk null; Output.errGeneric("Security advisory at index {d} 'url' field must be a string or null", .{i}); - Global.exit(1); + return error.InvalidUrlField; } else null; const level_expr = item_obj.get("level") orelse { Output.errGeneric("Security advisory at index {d} missing required 'level' field", .{i}); - Global.exit(1); + return error.MissingLevelField; }; const level_str = level_expr.asString(manager.allocator) orelse { Output.errGeneric("Security advisory at index {d} 'level' field must be a string", .{i}); - Global.exit(1); + return error.InvalidLevelField; }; const level = if (std.mem.eql(u8, level_str, "fatal")) SecurityAdvisoryLevel.fatal @@ -596,147 +1104,47 @@ fn handleSecurityAdvisories(manager: *PackageManager, ipc_data: []const u8, pack SecurityAdvisoryLevel.warn else { Output.errGeneric("Security advisory at index {d} 'level' field must be 'fatal' or 'warn', got: '{s}'", .{ i, level_str }); - Global.exit(1); + return error.InvalidLevelValue; }; + // Look up the package path for this advisory + var pkg_path: ?[]const PackageID = null; + const pkgs = manager.lockfile.packages.slice(); + const pkg_names = pkgs.items(.name); + const string_buf = manager.lockfile.buffers.string_bytes.items; + + for (pkg_names, 0..) |pkg_name, j| { + if (std.mem.eql(u8, pkg_name.slice(string_buf), name_str)) { + const pkg_id: PackageID = @intCast(j); + if (package_paths.get(pkg_id)) |paths| { + // Duplicate the path so it outlives the package_paths HashMap + pkg_path = try manager.allocator.dupe(PackageID, paths.pkg_path); + } + break; + } + } + const advisory = SecurityAdvisory{ .level = level, .package = name_str, .url = url_str, .description = desc_str, + .pkg_path = pkg_path, }; try advisories_list.append(advisory); } - if (advisories_list.items.len > 0) { - var has_fatal = false; - var has_warn = false; - - for (advisories_list.items) |advisory| { - Output.print("\n", .{}); - - switch (advisory.level) { - .fatal => { - has_fatal = true; - Output.pretty(" FATAL: {s}\n", .{advisory.package}); - }, - .warn => { - has_warn = true; - Output.pretty(" WARN: {s}\n", .{advisory.package}); - }, - } - - const pkgs = manager.lockfile.packages.slice(); - const pkg_names = pkgs.items(.name); - const string_buf = manager.lockfile.buffers.string_bytes.items; - - var found_pkg_id: ?PackageID = null; - for (pkg_names, 0..) |pkg_name, i| { - if (std.mem.eql(u8, pkg_name.slice(string_buf), advisory.package)) { - found_pkg_id = @intCast(i); - break; - } - } - - if (found_pkg_id) |pkg_id| { - if (package_paths.get(pkg_id)) |paths| { - if (paths.pkg_path.len > 1) { - Output.pretty(" via ", .{}); - for (paths.pkg_path[0 .. paths.pkg_path.len - 1], 0..) |ancestor_id, idx| { - if (idx > 0) Output.pretty(" › ", .{}); - const ancestor_name = pkg_names[ancestor_id].slice(string_buf); - Output.pretty("{s}", .{ancestor_name}); - } - Output.pretty(" › {s}\n", .{advisory.package}); - } else { - Output.pretty(" (direct dependency)\n", .{}); - } - } - } - - if (advisory.description) |desc| { - if (desc.len > 0) { - Output.pretty(" {s}\n", .{desc}); - } - } - if (advisory.url) |url| { - if (url.len > 0) { - Output.pretty(" {s}\n", .{url}); - } - } - } - - if (has_fatal) { - Output.pretty("\nbun install aborted due to fatal security advisories\n", .{}); - Global.exit(1); - } else if (has_warn) { - const can_prompt = Output.enable_ansi_colors_stdout; - - if (can_prompt) { - Output.pretty("\nSecurity warnings found. Continue anyway? [y/N] ", .{}); - Output.flush(); - - var stdin = std.io.getStdIn(); - const unbuffered_reader = stdin.reader(); - var buffered = std.io.bufferedReader(unbuffered_reader); - var reader = buffered.reader(); - - const first_byte = reader.readByte() catch { - Output.pretty("\nInstallation cancelled.\n", .{}); - Global.exit(1); - }; - - const should_continue = switch (first_byte) { - '\n' => false, - '\r' => blk: { - const next_byte = reader.readByte() catch { - break :blk false; - }; - break :blk next_byte == '\n' and false; - }, - 'y', 'Y' => blk: { - const next_byte = reader.readByte() catch { - break :blk false; - }; - if (next_byte == '\n') { - break :blk true; - } else if (next_byte == '\r') { - const second_byte = reader.readByte() catch { - break :blk false; - }; - break :blk second_byte == '\n'; - } - break :blk false; - }, - else => blk: { - while (reader.readByte()) |b| { - if (b == '\n' or b == '\r') break; - } else |_| {} - break :blk false; - }, - }; - - if (!should_continue) { - Output.pretty("\nInstallation cancelled.\n", .{}); - Global.exit(1); - } - - Output.pretty("\nContinuing with installation...\n\n", .{}); - } else { - Output.pretty("\nSecurity warnings found. Cannot prompt for confirmation (no TTY).\n", .{}); - Output.pretty("Installation cancelled.\n", .{}); - Global.exit(1); - } - } - } + return try advisories_list.toOwnedSlice(); } +const HoistedInstall = @import("../hoisted_install.zig"); +const InstallWithManager = @import("./install_with_manager.zig"); +const IsolatedInstall = @import("../isolated_install.zig"); const std = @import("std"); const bun = @import("bun"); const Environment = bun.Environment; -const Global = bun.Global; const Output = bun.Output; const jsc = bun.jsc; const logger = bun.logger; diff --git a/src/install/hoisted_install.zig b/src/install/hoisted_install.zig index e2113ea316..456921494c 100644 --- a/src/install/hoisted_install.zig +++ b/src/install/hoisted_install.zig @@ -4,13 +4,14 @@ pub fn installHoistedPackages( workspace_filters: []const WorkspaceFilter, install_root_dependencies: bool, log_level: PackageManager.Options.LogLevel, + packages_to_install: ?[]const PackageID, ) !PackageInstall.Summary { bun.analytics.Features.hoisted_bun_install += 1; const original_trees = this.lockfile.buffers.trees; const original_tree_dep_ids = this.lockfile.buffers.hoisted_dependencies; - try this.lockfile.filter(this.log, this, install_root_dependencies, workspace_filters); + try this.lockfile.filter(this.log, this, install_root_dependencies, workspace_filters, packages_to_install); defer { this.lockfile.buffers.trees = original_trees; diff --git a/src/install/isolated_install.zig b/src/install/isolated_install.zig index 2782428232..9020d50503 100644 --- a/src/install/isolated_install.zig +++ b/src/install/isolated_install.zig @@ -6,6 +6,7 @@ pub fn installIsolatedPackages( command_ctx: Command.Context, install_root_dependencies: bool, workspace_filters: []const WorkspaceFilter, + packages_to_install: ?[]const PackageID, ) OOM!PackageInstall.Summary { bun.analytics.Features.isolated_bun_install += 1; @@ -168,38 +169,65 @@ pub fn installIsolatedPackages( ); peer_dep_ids.clearRetainingCapacity(); - for (dep_ids_sort_buf.items) |dep_id| { - if (Tree.isFilteredDependencyOrWorkspace( - dep_id, - entry.pkg_id, - workspace_filters, - install_root_dependencies, - manager, - lockfile, - )) { - continue; + + queue_deps: { + if (packages_to_install) |packages| { + if (node_id == .root) { // TODO: print an error when scanner is actually a dependency of a workspace (we should not support this) + for (dep_ids_sort_buf.items) |dep_id| { + const pkg_id = resolutions[dep_id]; + if (pkg_id == invalid_package_id) { + continue; + } + + for (packages) |package_to_install| { + if (package_to_install == pkg_id) { + node_dependencies[node_id.get()].appendAssumeCapacity(.{ .dep_id = dep_id, .pkg_id = pkg_id }); + try node_queue.writeItem(.{ + .parent_id = node_id, + .dep_id = dep_id, + .pkg_id = pkg_id, + }); + break; + } + } + } + break :queue_deps; + } } - const pkg_id = resolutions[dep_id]; - const dep = dependencies[dep_id]; + for (dep_ids_sort_buf.items) |dep_id| { + if (Tree.isFilteredDependencyOrWorkspace( + dep_id, + entry.pkg_id, + workspace_filters, + install_root_dependencies, + manager, + lockfile, + )) { + continue; + } - // TODO: handle duplicate dependencies. should be similar logic - // like we have for dev dependencies in `hoistDependency` + const pkg_id = resolutions[dep_id]; + const dep = dependencies[dep_id]; - if (!dep.behavior.isPeer()) { - // simple case: - // - add it as a dependency - // - queue it - node_dependencies[node_id.get()].appendAssumeCapacity(.{ .dep_id = dep_id, .pkg_id = pkg_id }); - try node_queue.writeItem(.{ - .parent_id = node_id, - .dep_id = dep_id, - .pkg_id = pkg_id, - }); - continue; + // TODO: handle duplicate dependencies. should be similar logic + // like we have for dev dependencies in `hoistDependency` + + if (!dep.behavior.isPeer()) { + // simple case: + // - add it as a dependency + // - queue it + node_dependencies[node_id.get()].appendAssumeCapacity(.{ .dep_id = dep_id, .pkg_id = pkg_id }); + try node_queue.writeItem(.{ + .parent_id = node_id, + .dep_id = dep_id, + .pkg_id = pkg_id, + }); + continue; + } + + try peer_dep_ids.append(dep_id); } - - try peer_dep_ids.append(dep_id); } next_peer: for (peer_dep_ids.items) |peer_dep_id| { @@ -652,7 +680,6 @@ pub fn installIsolatedPackages( // add the pending task count upfront manager.incrementPendingTasks(@intCast(store.entries.len)); - for (0..store.entries.len) |_entry_id| { const entry_id: Store.Entry.Id = .from(@intCast(_entry_id)); @@ -805,6 +832,7 @@ pub fn installIsolatedPackages( const dep_id = node_dep_ids[node_id.get()]; const dep = lockfile.buffers.dependencies.items[dep_id]; + switch (pkg_res_tag) { .npm => { manager.enqueuePackageForDownload( diff --git a/src/install/lockfile.zig b/src/install/lockfile.zig index 572b33ca10..5927975445 100644 --- a/src/install/lockfile.zig +++ b/src/install/lockfile.zig @@ -865,7 +865,7 @@ pub fn resolve( lockfile: *Lockfile, log: *logger.Log, ) Tree.SubtreeError!void { - return lockfile.hoist(log, .resolvable, {}, {}, {}); + return lockfile.hoist(log, .resolvable, {}, {}, {}, {}); } pub fn filter( @@ -874,8 +874,9 @@ pub fn filter( manager: *PackageManager, install_root_dependencies: bool, workspace_filters: []const WorkspaceFilter, + packages_to_install: ?[]const PackageID, ) Tree.SubtreeError!void { - return lockfile.hoist(log, .filter, manager, install_root_dependencies, workspace_filters); + return lockfile.hoist(log, .filter, manager, install_root_dependencies, workspace_filters, packages_to_install); } /// Sets `buffers.trees` and `buffers.hoisted_dependencies` @@ -886,6 +887,7 @@ pub fn hoist( manager: if (method == .filter) *PackageManager else void, install_root_dependencies: if (method == .filter) bool else void, workspace_filters: if (method == .filter) []const WorkspaceFilter else void, + packages_to_install: if (method == .filter) ?[]const PackageID else void, ) Tree.SubtreeError!void { const allocator = lockfile.allocator; var slice = lockfile.packages.slice(); @@ -902,6 +904,7 @@ pub fn hoist( .manager = manager, .install_root_dependencies = install_root_dependencies, .workspace_filters = workspace_filters, + .packages_to_install = packages_to_install, }; try (Tree{}).processSubtree( diff --git a/src/install/lockfile/Tree.zig b/src/install/lockfile/Tree.zig index b3b8d7e19a..e0ef9438a1 100644 --- a/src/install/lockfile/Tree.zig +++ b/src/install/lockfile/Tree.zig @@ -246,6 +246,7 @@ pub fn Builder(comptime method: BuilderMethod) type { sort_buf: std.ArrayListUnmanaged(DependencyID) = .{}, workspace_filters: if (method == .filter) []const WorkspaceFilter else void = if (method == .filter) &.{}, install_root_dependencies: if (method == .filter) bool else void, + packages_to_install: if (method == .filter) ?[]const PackageID else void, pub fn maybeReportError(this: *@This(), comptime fmt: string, args: anytype) void { this.log.addErrorFmt(null, logger.Loc.Empty, this.allocator, fmt, args) catch {}; @@ -492,6 +493,22 @@ pub fn processSubtree( )) { continue; } + + if (builder.packages_to_install) |packages_to_install| { + if (parent_pkg_id == 0) { + var found = false; + for (packages_to_install) |package_to_install| { + if (pkg_id == package_to_install) { + found = true; + break; + } + } + + if (!found) { + continue; + } + } + } } const hoisted: HoistDependencyResult = hoisted: { diff --git a/src/output.zig b/src/output.zig index bfc76e39c7..7b5a2d33f7 100644 --- a/src/output.zig +++ b/src/output.zig @@ -6,6 +6,10 @@ threadlocal var source_set: bool = false; var stderr_stream: Source.StreamType = undefined; var stdout_stream: Source.StreamType = undefined; var stdout_stream_set = false; + +// Track which stdio descriptors are TTYs (0=stdin, 1=stdout, 2=stderr) +pub export var bun_stdio_tty: [3]i32 = .{ 0, 0, 0 }; + pub var terminal_size: std.posix.winsize = .{ .row = 0, .col = 0, @@ -119,8 +123,6 @@ pub const Source = struct { return colorDepth() != .none; } - export var bun_stdio_tty: [3]i32 = .{ 0, 0, 0 }; - const WindowsStdio = struct { const w = bun.windows; @@ -431,6 +433,18 @@ pub var is_github_action = false; pub var stderr_descriptor_type = OutputStreamDescriptor.unknown; pub var stdout_descriptor_type = OutputStreamDescriptor.unknown; +pub inline fn isStdoutTTY() bool { + return bun_stdio_tty[1] != 0; +} + +pub inline fn isStderrTTY() bool { + return bun_stdio_tty[2] != 0; +} + +pub inline fn isStdinTTY() bool { + return bun_stdio_tty[0] != 0; +} + pub inline fn isEmojiEnabled() bool { return enable_ansi_colors; } diff --git a/test/cli/install/__snapshots__/bun-security-scanner-matrix-with-node-modules.test.ts.snap b/test/cli/install/__snapshots__/bun-security-scanner-matrix-with-node-modules.test.ts.snap new file mode 100644 index 0000000000..830dea7cc7 --- /dev/null +++ b/test/cli/install/__snapshots__/bun-security-scanner-matrix-with-node-modules.test.ts.snap @@ -0,0 +1,3271 @@ +// Bun Snapshot v1, https://bun.sh/docs/test/snapshots + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0001 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0001 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0002 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0002 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0003 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0003 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0004 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0004 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0005 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0005 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0006 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0006 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0007 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0007 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0008 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0008 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0009 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0009 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0010 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0010 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0011 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0011 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0012 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0012 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0013 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0013 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0014 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0014 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0015 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0015 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0016 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0016 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0017 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0017 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0018 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0018 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0019 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0019 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0020 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0020 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0021 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0021 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0022 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0022 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0023 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0023 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0024 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0024 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0025 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0025 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0026 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0026 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0027 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0027 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0028 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0028 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0029 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0029 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0030 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0030 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0031 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0031 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0032 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0032 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0033 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0033 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0034 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0034 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0035 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0035 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0036 (with modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0036 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0037 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0037 (with modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0038 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0038 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0039 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0039 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0040 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0040 (with modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0041 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0041 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0042 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0042 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0043 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0043 (with modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0044 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0044 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0045 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0045 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0046 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0046 (with modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0047 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0047 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0048 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0048 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0049 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0049 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0050 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0050 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0051 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0051 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0052 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0052 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0053 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0053 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0054 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0054 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0055 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0055 (with modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0056 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0056 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0057 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0057 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0058 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0058 (with modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0059 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0059 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0060 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0060 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0061 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0061 (with modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0062 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0062 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0063 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0063 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0064 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0064 (with modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0065 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0065 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0066 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0066 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0067 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0067 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0068 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0068 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0069 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0069 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0070 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0070 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0071 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0071 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0072 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0072 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0073 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0073 (with modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0074 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0074 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0075 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0075 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0076 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0076 (with modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0077 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0077 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0078 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0078 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0079 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0079 (with modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0080 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0080 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0081 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0081 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0082 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0082 (with modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0083 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0083 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0084 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0084 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0085 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0085 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0086 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0086 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0087 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0087 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0088 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0088 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0089 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0089 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0090 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0090 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0091 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0091 (with modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0092 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0092 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0093 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0093 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0094 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0094 (with modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0095 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0095 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0096 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0096 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0097 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0097 (with modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0098 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0098 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0099 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0099 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0100 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0100 (with modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0101 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0101 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0102 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0102 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0103 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0103 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0104 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0104 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0105 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0105 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0106 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0106 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0107 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0107 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0108 (with modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0108 (with modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0109 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0109 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0110 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0110 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0111 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0111 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0112 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0112 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0113 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0113 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0114 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0114 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0115 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0115 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0116 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0116 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0117 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0117 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0118 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0118 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0119 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0119 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0120 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0120 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0121 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0121 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0122 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0122 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0123 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0123 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0124 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0124 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0125 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0125 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0126 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0126 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0127 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0127 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0128 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0128 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0129 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0129 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0130 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0130 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0131 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0131 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0132 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0132 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0133 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0133 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0134 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0134 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0135 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0135 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0136 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0136 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0137 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0137 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0138 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0138 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0139 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0139 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0140 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0140 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0141 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0141 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0142 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0142 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0143 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0143 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0144 (with modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0144 (with modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0145 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0145 (with modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0146 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0146 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0147 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0147 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0148 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0148 (with modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0149 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0149 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0150 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0150 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0151 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0151 (with modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0152 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0152 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0153 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0153 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0154 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0154 (with modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0155 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0155 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0156 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0156 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0157 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0157 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0158 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0158 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0159 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0159 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0160 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0160 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0161 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0161 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0162 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0162 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0163 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0163 (with modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0164 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0164 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0165 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0165 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0166 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0166 (with modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0167 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0167 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0168 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0168 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0169 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0169 (with modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0170 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0170 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0171 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0171 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0172 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0172 (with modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0173 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0173 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0174 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0174 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0175 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0175 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0176 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0176 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0177 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0177 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0178 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0178 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0179 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0179 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0180 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0180 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0181 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0181 (with modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0182 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0182 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0183 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0183 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0184 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0184 (with modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0185 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0185 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0186 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0186 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0187 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0187 (with modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0188 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0188 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0189 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0189 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0190 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0190 (with modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0191 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0191 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0192 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0192 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0193 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0193 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0194 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0194 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0195 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0195 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0196 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0196 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0197 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0197 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0198 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0198 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0199 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0199 (with modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0200 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0200 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0201 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0201 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0202 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0202 (with modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0203 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0203 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0204 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0204 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0205 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0205 (with modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0206 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0206 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0207 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0207 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0208 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0208 (with modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0209 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0209 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0210 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0210 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0211 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0211 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0212 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0212 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0213 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0213 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0214 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0214 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0215 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0215 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0216 (with modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0216 (with modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0217 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0217 (with modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0218 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0218 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0219 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0219 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0220 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0220 (with modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0221 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0221 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0222 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0222 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0223 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0223 (with modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0224 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0224 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0225 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0225 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0226 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0226 (with modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0227 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0227 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0228 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0228 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0229 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0229 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0230 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0230 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0231 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0231 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0232 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0232 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0233 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0233 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0234 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0234 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0235 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0235 (with modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0236 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0236 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0237 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0237 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0238 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0238 (with modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0239 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0239 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0240 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0240 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0241 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0241 (with modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0242 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0242 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0243 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0243 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0244 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0244 (with modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0245 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0245 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0246 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0246 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0247 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0247 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0248 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0248 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0249 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0249 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0250 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0250 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0251 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0251 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0252 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0252 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0253 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0253 (with modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0254 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0254 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0255 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0255 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0256 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0256 (with modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0257 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0257 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0258 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0258 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0259 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0259 (with modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0260 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0260 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0261 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0261 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0262 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0262 (with modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0263 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0263 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0264 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0264 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0265 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0265 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0266 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0266 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0267 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0267 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0268 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0268 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0269 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0269 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0270 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0270 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0271 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0271 (with modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0272 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0272 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0273 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0273 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0274 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0274 (with modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0275 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0275 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0276 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0276 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0277 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0277 (with modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0278 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0278 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0279 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0279 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0280 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0280 (with modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0281 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0281 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0282 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0282 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0283 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0283 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0284 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0284 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0285 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0285 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0286 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0286 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0287 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0287 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0288 (with modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0288 (with modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0289 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0289 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0290 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0290 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0291 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0291 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0292 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0292 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0293 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0293 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0294 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0294 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0295 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0295 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0296 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0296 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0297 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0297 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0298 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0298 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0299 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0299 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0300 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0300 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0301 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0301 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0302 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0302 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0303 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0303 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0304 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0304 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0305 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0305 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0306 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0306 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0307 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0307 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0308 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0308 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0309 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0309 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0310 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0310 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0311 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0311 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0312 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0312 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0313 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0313 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0314 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0314 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0315 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0315 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0316 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0316 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0317 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0317 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0318 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0318 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0319 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0319 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0320 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0320 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0321 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0321 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0322 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0322 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0323 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0323 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0324 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0324 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0325 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0325 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0326 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0326 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0327 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0327 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0328 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0328 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0329 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0329 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0330 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0330 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0331 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0331 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0332 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0332 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0333 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0333 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0334 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0334 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0335 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0335 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0336 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0336 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0337 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0337 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0338 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0338 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0339 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0339 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0340 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0340 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0341 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0341 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0342 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0342 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0343 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0343 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0344 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0344 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0345 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0345 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0346 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0346 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0347 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0347 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0348 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0348 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0349 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0349 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0350 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0350 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0351 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0351 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0352 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0352 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0353 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0353 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0354 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0354 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0355 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0355 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0356 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0356 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0357 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0357 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0358 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0358 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0359 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0359 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0360 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0360 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0361 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0361 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0362 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0362 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0363 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0363 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0364 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0364 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0365 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0365 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0366 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0366 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0367 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0367 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0368 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0368 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0369 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0369 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0370 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0370 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0371 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0371 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0372 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0372 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0373 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0373 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0374 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0374 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0375 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0375 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0376 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0376 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0377 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0377 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0378 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0378 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0379 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0379 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0380 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0380 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0381 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0381 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0382 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0382 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0383 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0383 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0384 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0384 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0385 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0385 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0386 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0386 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0387 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0387 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0388 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0388 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0389 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0389 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0390 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0390 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0391 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0391 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0392 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0392 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0393 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0393 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0394 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0394 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0395 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0395 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0396 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0396 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0397 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0397 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0398 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0398 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0399 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0399 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0400 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0400 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0401 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0401 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0402 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0402 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0403 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0403 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0404 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0404 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0405 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0405 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0406 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0406 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0407 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0407 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0408 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0408 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0409 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0409 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0410 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0410 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0411 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0411 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0412 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0412 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0413 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0413 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0414 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0414 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0415 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0415 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0416 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0416 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0417 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0417 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0418 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0418 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0419 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0419 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0420 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0420 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0421 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0421 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0422 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0422 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0423 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0423 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0424 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0424 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0425 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0425 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0426 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0426 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0427 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0427 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0428 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0428 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0429 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0429 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0430 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0430 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0431 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0431 (with modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0432 (with modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0432 (with modules): requested-tarballs: remove with args 1`] = `[]`; diff --git a/test/cli/install/__snapshots__/bun-security-scanner-matrix-without-node-modules.test.ts.snap b/test/cli/install/__snapshots__/bun-security-scanner-matrix-without-node-modules.test.ts.snap new file mode 100644 index 0000000000..29e4fc844e --- /dev/null +++ b/test/cli/install/__snapshots__/bun-security-scanner-matrix-without-node-modules.test.ts.snap @@ -0,0 +1,4205 @@ +// Bun Snapshot v1, https://bun.sh/docs/test/snapshots + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0001 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0001 (without modules): requested-tarballs: install 1`] = ` +[ + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0002 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0002 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0003 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0003 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0004 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0004 (without modules): requested-tarballs: install 1`] = ` +[ + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0005 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0005 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0006 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0006 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0007 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0007 (without modules): requested-tarballs: install 1`] = ` +[ + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0008 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0008 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0009 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0009 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0010 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0010 (without modules): requested-tarballs: install 1`] = ` +[ + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0011 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0011 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0012 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0012 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0013 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0013 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0014 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0014 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0015 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0015 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0016 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0016 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0017 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0017 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0018 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun install "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0018 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0019 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0019 (without modules): requested-tarballs: install 1`] = ` +[ + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0020 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0020 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0021 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0021 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0022 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0022 (without modules): requested-tarballs: install 1`] = ` +[ + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0023 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0023 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0024 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0024 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0025 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0025 (without modules): requested-tarballs: install 1`] = ` +[ + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0026 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0026 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0027 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0027 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0028 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0028 (without modules): requested-tarballs: install 1`] = ` +[ + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0029 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0029 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0030 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0030 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0031 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0031 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0032 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0032 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0033 (without modules): requested-packages: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0033 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0034 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0034 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0035 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0035 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0036 (without modules): requested-packages: install 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun install "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0036 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0037 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0037 (without modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0038 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0038 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0039 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0039 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0040 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0040 (without modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0041 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0041 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0042 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0042 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0043 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0043 (without modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0044 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0044 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0045 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0045 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0046 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0046 (without modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0047 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0047 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0048 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0048 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0049 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0049 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0050 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0050 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0051 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0051 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0052 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0052 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0053 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0053 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0054 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0054 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0055 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0055 (without modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0056 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0056 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0057 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0057 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0058 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0058 (without modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0059 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0059 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0060 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0060 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0061 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0061 (without modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0062 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0062 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0063 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0063 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0064 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0064 (without modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0065 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0065 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0066 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0066 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0067 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0067 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0068 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0068 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0069 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0069 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0070 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0070 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0071 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0071 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0072 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0072 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0073 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0073 (without modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0074 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0074 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0075 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0075 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0076 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0076 (without modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0077 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0077 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0078 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0078 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0079 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0079 (without modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0080 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0080 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0081 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0081 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0082 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0082 (without modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0083 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0083 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0084 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0084 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0085 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0085 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0086 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0086 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0087 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0087 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0088 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0088 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0089 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0089 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0090 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0090 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0091 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0091 (without modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0092 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0092 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0093 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0093 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0094 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0094 (without modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0095 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0095 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0096 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0096 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0097 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0097 (without modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0098 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0098 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0099 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0099 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0100 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0100 (without modules): requested-tarballs: install 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0101 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0101 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0102 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0102 (without modules): requested-tarballs: install 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0103 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0103 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0104 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0104 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0105 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0105 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0106 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0106 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0107 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0107 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0108 (without modules): requested-packages: install 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun install "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0108 (without modules): requested-tarballs: install 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0109 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0109 (without modules): requested-tarballs: update without args 1`] = ` +[ + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0110 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0110 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0111 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0111 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0112 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0112 (without modules): requested-tarballs: update without args 1`] = ` +[ + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0113 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0113 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0114 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0114 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0115 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0115 (without modules): requested-tarballs: update without args 1`] = ` +[ + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0116 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0116 (without modules): requested-tarballs: update without args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0117 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0117 (without modules): requested-tarballs: update without args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0118 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0118 (without modules): requested-tarballs: update without args 1`] = ` +[ + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0119 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0119 (without modules): requested-tarballs: update without args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0120 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0120 (without modules): requested-tarballs: update without args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0121 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0121 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0122 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0122 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0123 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0123 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0124 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0124 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0125 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0125 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0126 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0126 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0127 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0127 (without modules): requested-tarballs: update without args 1`] = ` +[ + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0128 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0128 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0129 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0129 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0130 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0130 (without modules): requested-tarballs: update without args 1`] = ` +[ + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0131 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0131 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0132 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0132 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0133 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0133 (without modules): requested-tarballs: update without args 1`] = ` +[ + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0134 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0134 (without modules): requested-tarballs: update without args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0135 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0135 (without modules): requested-tarballs: update without args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0136 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0136 (without modules): requested-tarballs: update without args 1`] = ` +[ + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0137 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0137 (without modules): requested-tarballs: update without args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0138 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0138 (without modules): requested-tarballs: update without args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0139 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0139 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0140 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0140 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0141 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0141 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0142 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0142 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0143 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0143 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0144 (without modules): requested-packages: update without args 1`] = ` +[ + "left-pad", +] +`; + +exports[`bun update "no args" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0144 (without modules): requested-tarballs: update without args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0145 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0145 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0146 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0146 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0147 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0147 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0148 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0148 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0149 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0149 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0150 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0150 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0151 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0151 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0152 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0152 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0153 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0153 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0154 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0154 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0155 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0155 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0156 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0156 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0157 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0157 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0158 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0158 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0159 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0159 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0160 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0160 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0161 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0161 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0162 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0162 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0163 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0163 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0164 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0164 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0165 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0165 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0166 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0166 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0167 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0167 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0168 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0168 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0169 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0169 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0170 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0170 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0171 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0171 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0172 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0172 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0173 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0173 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0174 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0174 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0175 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0175 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0176 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0176 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0177 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0177 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0178 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0178 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0179 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0179 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0180 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0180 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0181 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0181 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0182 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0182 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0183 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0183 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0184 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0184 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0185 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0185 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0186 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0186 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0187 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0187 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0188 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0188 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0189 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0189 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0190 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0190 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0191 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0191 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0192 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0192 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0193 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0193 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0194 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0194 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0195 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0195 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0196 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0196 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0197 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0197 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0198 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0198 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0199 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0199 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0200 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0200 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0201 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0201 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0202 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0202 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0203 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0203 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0204 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0204 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0205 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0205 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0206 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0206 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0207 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0207 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0208 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0208 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0209 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0209 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0210 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0210 (without modules): requested-tarballs: update with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0211 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0211 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0212 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0212 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0213 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0213 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0214 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0214 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0215 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0215 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0216 (without modules): requested-packages: update with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun update "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0216 (without modules): requested-tarballs: update with args 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0217 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0217 (without modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0218 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0218 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0219 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0219 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0220 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0220 (without modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0221 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0221 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0222 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0222 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0223 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0223 (without modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0224 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0224 (without modules): requested-tarballs: add 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0225 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0225 (without modules): requested-tarballs: add 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0226 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0226 (without modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0227 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0227 (without modules): requested-tarballs: add 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0228 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0228 (without modules): requested-tarballs: add 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0229 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0229 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0230 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0230 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0231 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0231 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0232 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0232 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0233 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0233 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0234 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0234 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0235 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0235 (without modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0236 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0236 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0237 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0237 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0238 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0238 (without modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0239 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0239 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0240 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0240 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0241 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0241 (without modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0242 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0242 (without modules): requested-tarballs: add 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0243 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0243 (without modules): requested-tarballs: add 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0244 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0244 (without modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0245 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0245 (without modules): requested-tarballs: add 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0246 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0246 (without modules): requested-tarballs: add 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0247 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0247 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0248 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0248 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0249 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0249 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0250 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0250 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0251 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0251 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0252 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0252 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0253 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: none) 0253 (without modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0254 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0254 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0255 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0255 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0256 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: none) 0256 (without modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0257 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0257 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0258 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0258 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0259 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: none) 0259 (without modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0260 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0260 (without modules): requested-tarballs: add 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0261 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0261 (without modules): requested-tarballs: add 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0262 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: none) 0262 (without modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0263 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0263 (without modules): requested-tarballs: add 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0264 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0264 (without modules): requested-tarballs: add 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0265 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0265 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0266 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0266 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0267 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0267 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0268 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0268 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0269 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0269 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0270 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0270 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0271 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: none) 0271 (without modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0272 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0272 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0273 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0273 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0274 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: none) 0274 (without modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0275 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0275 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0276 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0276 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0277 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: none) 0277 (without modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0278 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0278 (without modules): requested-tarballs: add 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0279 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0279 (without modules): requested-tarballs: add 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0280 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: none) 0280 (without modules): requested-tarballs: add 1`] = ` +[ + "/is-even-1.0.0.tgz", + "/is-odd-1.0.0.tgz", + "/left-pad-1.3.0.tgz", + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0281 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0281 (without modules): requested-tarballs: add 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0282 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0282 (without modules): requested-tarballs: add 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0283 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0283 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0284 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0284 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0285 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0285 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0286 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0286 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0287 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0287 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0288 (without modules): requested-packages: add 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun add "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0288 (without modules): requested-tarballs: add 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0290 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0290 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0291 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0291 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0293 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0293 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0294 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0294 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0296 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0296 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0297 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0297 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0299 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0299 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0300 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0300 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0301 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0301 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0302 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0302 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0303 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0303 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0304 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0304 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0305 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0305 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0306 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun remove "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0306 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0308 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0308 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0309 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0309 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0311 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0311 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0312 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun remove "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0312 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0314 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0314 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0315 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0315 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0317 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0317 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0318 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0318 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0319 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0319 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0320 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0320 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0321 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0321 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0322 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0322 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0323 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0323 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0324 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun remove "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0324 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0326 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0326 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0327 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0327 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0329 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0329 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0330 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0330 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0332 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0332 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0333 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0333 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0335 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "test-security-scanner", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0335 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0336 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "test-security-scanner", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0336 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0337 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0337 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0338 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0338 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0339 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0339 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0340 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0340 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0341 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0341 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0342 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0342 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0344 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0344 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0345 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0345 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0347 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0347 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0348 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0348 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0350 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0350 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0351 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0351 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0353 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "test-security-scanner", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0353 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0354 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "test-security-scanner", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0354 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0355 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0355 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0356 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0356 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0357 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0357 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0358 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0358 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0359 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0359 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0360 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun remove "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0360 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0362 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0362 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0363 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0363 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0365 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0365 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0366 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0366 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0368 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0368 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0369 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0369 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0371 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0371 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0372 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0372 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0373 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0373 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0374 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0374 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0375 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0375 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0376 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0376 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0377 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0377 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0378 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun uninstall "is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0378 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0380 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0380 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0381 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0381 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0383 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0383 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0384 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0384 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0386 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0386 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0387 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0387 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0389 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0389 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0390 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", + "test-security-scanner", +] +`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0390 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0391 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0391 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0392 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0392 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0393 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0393 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0394 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0394 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0395 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0395 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0396 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "left-pad", +] +`; + +exports[`bun uninstall "is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0396 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0398 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: warn) 0398 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0399 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: true) (advisories: fatal) 0399 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0401 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: warn) 0401 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0402 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: local) (bun.lock exists: false) (advisories: fatal) 0402 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0404 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: warn) 0404 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0405 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0405 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0407 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "test-security-scanner", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: warn) 0407 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0408 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "test-security-scanner", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0408 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0409 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0409 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0410 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0410 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0411 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0411 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0412 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0412 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0413 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0413 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0414 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=hoisted (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0414 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0416 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: warn) 0416 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0417 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: true) (advisories: fatal) 0417 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0419 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: warn) 0419 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0420 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: local) (bun.lock exists: false) (advisories: fatal) 0420 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0422 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: warn) 0422 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0423 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: true) (advisories: fatal) 0423 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0425 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "test-security-scanner", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: warn) 0425 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0426 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", + "test-security-scanner", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm) (bun.lock exists: false) (advisories: fatal) 0426 (without modules): requested-tarballs: remove with args 1`] = ` +[ + "/test-security-scanner-1.0.0.tgz", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0427 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: none) 0427 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0428 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: warn) 0428 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0429 (without modules): requested-packages: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: true) (advisories: fatal) 0429 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0430 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: none) 0430 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0431 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: warn) 0431 (without modules): requested-tarballs: remove with args 1`] = `[]`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0432 (without modules): requested-packages: remove with args 1`] = ` +[ + "is-even", + "is-odd", +] +`; + +exports[`bun uninstall "left-pad,is-even" --linker=isolated (scanner: npm.bunfigonly) (bun.lock exists: false) (advisories: fatal) 0432 (without modules): requested-tarballs: remove with args 1`] = `[]`; diff --git a/test/cli/install/bun-install-security-provider.test.ts b/test/cli/install/bun-install-security-provider.test.ts index 9645815ad2..1af1180500 100644 --- a/test/cli/install/bun-install-security-provider.test.ts +++ b/test/cli/install/bun-install-security-provider.test.ts @@ -71,7 +71,7 @@ function test( }); if (options.fails) { - expect(out).toContain("bun install aborted due to fatal security advisories"); + expect(out).toContain("Installation aborted due to fatal security advisories"); } await options.expect?.({ out, err }); @@ -139,7 +139,9 @@ describe("Security Scanner Edge Cases", () => { bunfigScanner: "./non-existent-scanner.ts", expectedExitCode: 1, expect: ({ err }) => { - expect(err).toContain("Failed to import security scanner"); + expect(err).toContain( + "Security scanner './non-existent-scanner.ts' is configured in bunfig.toml but the file could not be found.\n Please check that the file exists and the path is correct.", + ); }, }); @@ -147,7 +149,7 @@ describe("Security Scanner Edge Cases", () => { scanner: `throw new Error("Module failed to load");`, expectedExitCode: 1, expect: ({ err }) => { - expect(err).toContain("Failed to import security scanner"); + expect(err).toContain("Security scanner failed: Module failed to load"); }, }); diff --git a/test/cli/install/bun-pm-scan.test.ts b/test/cli/install/bun-pm-scan.test.ts new file mode 100644 index 0000000000..581e4c6f18 --- /dev/null +++ b/test/cli/install/bun-pm-scan.test.ts @@ -0,0 +1,676 @@ +import { describe, expect, test } from "bun:test"; +import { bunEnv, bunExe, tempDirWithFiles, tmpdirSync } from "harness"; +import { join } from "path"; + +describe("bun pm scan", () => { + describe("configuration", () => { + test("shows error when no security scanner configured", async () => { + const dir = tempDirWithFiles("scan-no-config", { + "package.json": JSON.stringify({ name: "test", dependencies: { "left-pad": "^1.0.0" } }), + "bun.lockb": "", + }); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + + expect(exitCode).toBe(1); + expect(stderr).toContain("error: no security scanner configured"); + }); + + test("shows error when lockfile doesn't exist", async () => { + const dir = tempDirWithFiles("scan-no-lockfile", { + "package.json": JSON.stringify({ name: "test", dependencies: {} }), + "bunfig.toml": `[install.security]\nscanner = "test-scanner"`, + }); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + + expect(exitCode).toBe(1); + expect(stderr).toContain("Lockfile not found"); + expect(stderr).toContain("Run 'bun install' first"); + }); + + test("shows error when package.json doesn't exist", async () => { + const dir = tmpdirSync(); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + + expect(exitCode).toBe(1); + expect(stderr).toContain("No package.json was found"); + }); + }); + + describe("scanner execution", () => { + test("scanner receives correct package format", async () => { + const dir = tempDirWithFiles("scan-package-format", { + "package.json": JSON.stringify({ + name: "test-app", + dependencies: { + express: "^4.0.0", + }, + }), + "bunfig.toml": `[install.security]\nscanner = "./scanner.js"`, + "scanner.js": ` + module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + // Log the packages we receive + console.error("PACKAGES:", JSON.stringify(payload.packages)); + + // Verify format + if (!Array.isArray(payload.packages)) { + throw new Error("packages should be an array"); + } + + for (const pkg of payload.packages) { + if (!pkg.name || !pkg.version || !pkg.requestedRange || !pkg.tarball) { + throw new Error("Invalid package format"); + } + } + + return []; + } + } + }; + `, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + + expect(stderr).toContain("PACKAGES:"); + expect(exitCode).toBe(0); + expect(stdout).toContain("No advisories found"); + }); + + test("scanner version validation", async () => { + const dir = tempDirWithFiles("scan-version-check", { + "package.json": JSON.stringify({ name: "test", dependencies: { "left-pad": "^1.0.0" } }), + "scanner.js": ` + module.exports = { + scanner: { + version: "2", // Wrong version + scan: async () => [] + } + }; + `, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + + // Add config after install + await Bun.write(join(dir, "bunfig.toml"), `[install.security]\nscanner = "./scanner.js"`); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + + expect(exitCode).toBe(1); + expect(stderr).toContain("Security scanner must be version 1"); + }); + }); + + describe("vulnerability detection", () => { + test("detects fatal vulnerabilities", async () => { + const dir = tempDirWithFiles("scan-fatal", { + "package.json": JSON.stringify({ + name: "test-app", + dependencies: { lodash: "^4.0.0" }, + }), + "scanner.js": ` + module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + return [{ + package: "lodash", + level: "fatal", + description: "Prototype pollution vulnerability", + url: "https://example.com/CVE-2024-1234" + }]; + } + } + }; + `, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + await Bun.write(join(dir, "bunfig.toml"), `[install.security]\nscanner = "./scanner.js"`); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + + expect(exitCode).toBe(1); + expect(stdout).toContain("FATAL: lodash"); + expect(stdout).toContain("Prototype pollution vulnerability"); + expect(stdout).toContain("https://example.com/CVE-2024-1234"); + expect(stdout).toMatch(/1 advisory \(.*1 fatal.*\)/); + }); + + test("detects warning vulnerabilities", async () => { + const dir = tempDirWithFiles("scan-warn", { + "package.json": JSON.stringify({ + name: "test-app", + dependencies: { axios: "^0.21.0" }, + }), + "scanner.js": ` + module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + return [{ + package: "axios", + level: "warn", + description: "Inefficient regular expression", + url: "https://example.com/advisory/123" + }]; + } + } + }; + `, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + await Bun.write(join(dir, "bunfig.toml"), `[install.security]\nscanner = "./scanner.js"`); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + + expect(exitCode).toBe(1); // Still exits with 1 for warnings + expect(stdout).toContain("WARNING: axios"); + expect(stdout).toContain("Inefficient regular expression"); + expect(stdout).toMatch(/1 advisory \(.*1 warning.*\)/); + }); + + test("handles mixed vulnerabilities", async () => { + const dir = tempDirWithFiles("scan-mixed", { + "package.json": JSON.stringify({ + name: "test-app", + dependencies: { + lodash: "^4.0.0", + axios: "^0.21.0", + express: "^4.0.0", + }, + }), + "scanner.js": ` + module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + const results = []; + for (const pkg of payload.packages) { + if (pkg.name === "lodash") { + results.push({ + package: "lodash", + level: "fatal", + description: "Critical vulnerability" + }); + } + if (pkg.name === "axios") { + results.push({ + package: "axios", + level: "warn", + description: "Minor issue" + }); + } + if (pkg.name === "express") { + results.push({ + package: "express", + level: "warn", + description: "Another minor issue" + }); + } + } + return results; + } + } + }; + `, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + await Bun.write(join(dir, "bunfig.toml"), `[install.security]\nscanner = "./scanner.js"`); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + + expect(exitCode).toBe(1); + expect(stdout).toContain("FATAL: lodash"); + expect(stdout).toContain("WARNING: axios"); + expect(stdout).toContain("WARNING: express"); + expect(stdout).toMatch(/3 advisories \(.*1 fatal.*2 warnings.*\)/); + }); + + test("no vulnerabilities found", async () => { + const dir = tempDirWithFiles("scan-clean", { + "package.json": JSON.stringify({ + name: "test-app", + dependencies: { lodash: "^4.0.0" }, + }), + "bunfig.toml": `[install.security]\nscanner = "./scanner.js"`, + "scanner.js": ` + module.exports = { + scanner: { + version: "1", + scan: async () => [] + } + }; + `, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + + expect(exitCode).toBe(0); + expect(stdout).toContain("No advisories found"); + }); + }); + + describe("dependency paths", () => { + test("shows correct path for direct dependencies", async () => { + const dir = tempDirWithFiles("scan-direct-dep", { + "package.json": JSON.stringify({ + name: "my-app", + dependencies: { express: "^4.0.0" }, + }), + "scanner.js": ` + module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + const results = []; + for (const pkg of payload.packages) { + if (pkg.name === "express") { + results.push({ + package: "express", + level: "fatal", + description: "Test vulnerability" + }); + } + } + return results; + } + } + }; + `, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + await Bun.write(join(dir, "bunfig.toml"), `[install.security]\nscanner = "./scanner.js"`); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + + expect(stdout).toContain("FATAL: express"); + expect(stdout).toContain("via my-app › express"); + }); + + test("shows correct path for transitive dependencies", async () => { + const dir = tempDirWithFiles("scan-transitive-dep", { + "package.json": JSON.stringify({ + name: "my-app", + dependencies: { express: "^4.0.0" }, + }), + "scanner.js": ` + module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + const results = []; + for (const pkg of payload.packages) { + // body-parser is a dependency of express + if (pkg.name === "body-parser") { + results.push({ + package: "body-parser", + level: "warn", + description: "Transitive vulnerability" + }); + } + } + return results; + } + } + }; + `, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + await Bun.write(join(dir, "bunfig.toml"), `[install.security]\nscanner = "./scanner.js"`); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + + // body-parser might not actually be a dependency of express + // So we check if we found it in the scan + if (stdout.includes("WARNING: body-parser")) { + expect(stdout).toContain("via my-app › express › body-parser"); + } else { + // If body-parser wasn't found, the test passes since we can't verify transitive deps + expect(exitCode).toBeDefined(); + } + }); + }); + + describe("error handling", () => { + test("handles scanner crash", async () => { + const dir = tempDirWithFiles("scan-crash", { + "package.json": JSON.stringify({ + name: "test", + dependencies: { "left-pad": "^1.0.0" }, + }), + "scanner.js": ` + module.exports = { + scanner: { + version: "1", + scan: async function() { + process.exit(42); // Crash + } + } + }; + `, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + await Bun.write(join(dir, "bunfig.toml"), `[install.security]\nscanner = "./scanner.js"`); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + + expect(exitCode).toBe(1); + expect(stderr).toContain("Security scanner exited with code 42"); + }); + + test("handles invalid JSON from scanner", async () => { + const dir = tempDirWithFiles("scan-bad-json", { + "package.json": JSON.stringify({ + name: "test", + dependencies: { "left-pad": "^1.0.0" }, + }), + "scanner.js": ` + module.exports = { + scanner: { + version: "1", + scan: async function() { + // Return something that's not an array + return { not: "an array" }; + } + } + }; + `, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + await Bun.write(join(dir, "bunfig.toml"), `[install.security]\nscanner = "./scanner.js"`); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + + expect(exitCode).toBe(1); + expect(stderr).toContain("Security scanner must return an array"); + }); + + test("handles missing required fields in advisory", async () => { + const dir = tempDirWithFiles("scan-missing-fields", { + "package.json": JSON.stringify({ + name: "test", + dependencies: { lodash: "^4.0.0" }, + }), + "scanner.js": ` + module.exports = { + scanner: { + version: "1", + scan: async function() { + return [{ + package: "lodash" + // Missing 'level' field + }]; + } + } + }; + `, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + await Bun.write(join(dir, "bunfig.toml"), `[install.security]\nscanner = "./scanner.js"`); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + + expect(exitCode).toBe(1); + expect(stderr).toContain("missing required 'level' field"); + }); + }); + + describe("output formatting", () => { + test("singular vs plural in summary", async () => { + const dir = tempDirWithFiles("scan-singular", { + "package.json": JSON.stringify({ + name: "test", + dependencies: { "left-pad": "^1.0.0" }, + }), + "scanner.js": ` + module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + const results = []; + for (const pkg of payload.packages) { + if (pkg.name === "left-pad") { + results.push({ + package: "left-pad", + level: "fatal", + description: "Test" + }); + } + } + return results; + } + } + }; + `, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + await Bun.write(join(dir, "bunfig.toml"), `[install.security]\nscanner = "./scanner.js"`); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const stdout = await proc.stdout.text(); + + // Should say "1 advisory" not "1 advisories" + expect(stdout).toContain("1 advisory ("); + expect(stdout).not.toContain("1 advisories"); + }); + + test("shows timing for slow scans", async () => { + const dir = tempDirWithFiles("scan-slow", { + "package.json": JSON.stringify({ + name: "test", + dependencies: { "left-pad": "^1.0.0" }, + }), + "scanner.js": ` + module.exports = { + scanner: { + version: "1", + scan: async function() { + // Simulate slow scan + await new Promise(resolve => setTimeout(resolve, 1200)); + return []; + } + } + }; + `, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + await Bun.write(join(dir, "bunfig.toml"), `[install.security]\nscanner = "./scanner.js"`); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: { ...bunEnv, BUN_DEBUG_QUIET_LOGS: "0" }, // Enable timing output + }); + + const [stdout, stderr] = await Promise.all([proc.stdout.text(), proc.stderr.text()]); + + // Should show timing information for scans > 1 second + expect(stderr).toMatch(/Scanning \d+ package[s]? took \d+ms/); + }); + }); + + describe("differences from bun add/install", () => { + test("does not show 'installation aborted' message", async () => { + const dir = tempDirWithFiles("scan-no-abort-msg", { + "package.json": JSON.stringify({ + name: "test", + dependencies: { lodash: "^4.0.0" }, + }), + "scanner.js": ` + module.exports = { + scanner: { + version: "1", + scan: async function() { + return [{ + package: "lodash", + level: "fatal", + description: "Critical" + }]; + } + } + }; + `, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + await Bun.write(join(dir, "bunfig.toml"), `[install.security]\nscanner = "./scanner.js"`); + + const proc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr] = await Promise.all([proc.stdout.text(), proc.stderr.text()]); + + // Should NOT contain the installation aborted message + expect(stdout).not.toContain("installation aborted"); + expect(stdout).not.toContain("Installation aborted"); + expect(stderr).not.toContain("installation aborted"); + expect(stderr).not.toContain("Installation aborted"); + }); + }); +}); diff --git a/test/cli/install/bun-security-scanner-matrix-runner.ts b/test/cli/install/bun-security-scanner-matrix-runner.ts new file mode 100644 index 0000000000..a24e9fd9a0 --- /dev/null +++ b/test/cli/install/bun-security-scanner-matrix-runner.ts @@ -0,0 +1,526 @@ +import { bunEnv, bunExe, runBunInstall, tempDirWithFiles } from "harness"; +import { rm } from "node:fs/promises"; +import { join } from "node:path"; +import { isCI } from "../../harness"; +import { getRegistry, SimpleRegistry, startRegistry, stopRegistry } from "./simple-dummy-registry"; + +const CI_SAMPLE_PERCENT = 10; // only 10% of tests will run in CI because this matrix generates so many tests + +const redSubprocessPrefix = "\x1b[31m [SUBPROC]\x1b[0m"; +const redDebugPrefix = "\x1b[31m [DEBUG]\x1b[0m"; +const redShellPrefix = "\x1b[31m [SHELL] $\x1b[0m"; + +function getTestName(testId: string, hasExistingNodeModules: boolean) { + return `${testId} (${hasExistingNodeModules ? "with modules" : "without modules"})` as const; +} +type TestName = ReturnType; + +// prettier-ignore +// These tests are failing for other reasons outside of the security scanner. +// You should leave a comment above pointing to a GitHub issue for reference, so these +// don't get totally lost. +const TESTS_TO_SKIP: Set = new Set([ + // https://github.com/oven-sh/bun/issues/22255 + "0289 (without modules)", "0292 (without modules)", "0295 (without modules)", "0298 (without modules)", "0307 (without modules)", "0310 (without modules)", "0313 (without modules)", "0316 (without modules)", // remove "is-even" + "0325 (without modules)", "0328 (without modules)", "0331 (without modules)", "0334 (without modules)", "0343 (without modules)", "0346 (without modules)", "0349 (without modules)", "0352 (without modules)", // remove "left-pad,is-even" + "0361 (without modules)", "0364 (without modules)", "0367 (without modules)", "0370 (without modules)", "0379 (without modules)", "0382 (without modules)", "0385 (without modules)", "0388 (without modules)", // uninstall "is-even" + "0397 (without modules)", "0400 (without modules)", "0403 (without modules)", "0406 (without modules)", "0415 (without modules)", "0418 (without modules)", "0421 (without modules)", "0424 (without modules)", // uninstall "left-pad,is-even" +]); + +interface SecurityScannerTestOptions { + command: "install" | "update" | "add" | "remove" | "uninstall"; + args: string[]; + hasExistingNodeModules: boolean; + linker: "hoisted" | "isolated"; + scannerType: "local" | "npm" | "npm.bunfigonly"; + scannerReturns: "none" | "warn" | "fatal"; + shouldFail: boolean; + + hasLockfile: boolean; + scannerSyncronouslyThrows: boolean; +} + +const DO_TEST_DEBUG = process.env.SCANNER_TEST_DEBUG === "true"; + +async function globEverything(dir: string) { + return await Array.fromAsync( + new Bun.Glob("**/*").scan({ cwd: dir, dot: true, followSymlinks: false, onlyFiles: false }), + ); +} + +let registryUrl: string; + +async function runSecurityScannerTest(options: SecurityScannerTestOptions) { + const registry = getRegistry(); + + if (!registry) { + throw new Error("Registry not found"); + } + + registry.clearRequestLog(); + registry.setScannerBehavior(options.scannerReturns ?? "none"); + + const { + command, + args, + hasExistingNodeModules, + hasLockfile, + linker, + scannerType, + scannerReturns, + shouldFail, + scannerSyncronouslyThrows, + } = options; + + const expectedExitCode = shouldFail ? 1 : 0; + + const scannerCode = + scannerType === "local" || scannerType === "npm" + ? `export const scanner = { + version: "1", + scan: async function(payload) { + console.error("SCANNER_RAN: " + payload.packages.length + " packages"); + + ${scannerSyncronouslyThrows ? "throw new Error('Scanner error!');" : ""} + + const results = []; + ${ + scannerReturns === "warn" + ? ` + if (payload.packages.length > 0) { + results.push({ + package: payload.packages[0].name, + level: "warn", + description: "Test warning" + }); + }` + : "" + } + ${ + scannerReturns === "fatal" + ? ` + if (payload.packages.length > 0) { + results.push({ + package: payload.packages[0].name, + level: "fatal", + description: "Test fatal error" + }); + }` + : "" + } + return results; + } + }` + : `throw new Error("Should not have been loaded")`; + + // Base files for the test directory + const files: Record = { + "package.json": JSON.stringify( + { + name: "test-app", + version: "1.0.0", + dependencies: { + "left-pad": "1.3.0", + + // For remove/uninstall commands, add the packages we're trying to remove + ...(command === "remove" || command === "uninstall" + ? { + "is-even": "1.0.0", + "is-odd": "1.0.0", + } + : {}), + + // For npm scanner, add it to dependencies so it gets installed + ...(scannerType === "npm" + ? { + "test-security-scanner": "1.0.0", + } + : {}), + }, + }, + null, + "\t", + ), + }; + + if (scannerType === "local") { + files["scanner.js"] = scannerCode; + } + + const dir = tempDirWithFiles("scanner-matrix", files); + + const scannerPath = scannerType === "local" ? "./scanner.js" : "test-security-scanner"; + + // First write bunfig WITHOUT scanner for pre-install + await Bun.write( + join(dir, "bunfig.toml"), + `[install] +cache.disable = true +linker = "${linker}" +registry = "${registryUrl}/"`, + ); + + const shouldDoInitialInstall = hasExistingNodeModules || hasLockfile; + if (hasExistingNodeModules || hasLockfile) { + if (DO_TEST_DEBUG) console.log(redShellPrefix, `${bunExe()} install`); + await runBunInstall(bunEnv, dir); + } + + if (shouldDoInitialInstall && !hasExistingNodeModules) { + if (DO_TEST_DEBUG) console.log(redShellPrefix, `rm -rf ${dir}/node_modules`); + await rm(join(dir, "node_modules"), { recursive: true }); + } + + if (shouldDoInitialInstall && !hasLockfile) { + if (DO_TEST_DEBUG) console.log(redShellPrefix, `rm ${dir}/bun.lock`); + await rm(join(dir, "bun.lock")); + } + + ////////////////////////// POST SETUP DONE ////////////////////////// + + const cmd = [bunExe(), command, ...args]; + + if (DO_TEST_DEBUG) { + console.log(redDebugPrefix, "SETUP DONE"); + console.log("-------------------------------- THE REAL TEST IS ABOUT TO HAPPEN --------------------------------"); + console.log(redShellPrefix, cmd.join(" ")); + } + + registry.clearRequestLog(); + + // write the full bunfig WITH scanner configuration + await Bun.write( + join(dir, "bunfig.toml"), + `[install] +cache.disable = true +linker = "${linker}" +registry = "${registryUrl}/" + +[install.security] +scanner = "${scannerPath}"`, + ); + + if (DO_TEST_DEBUG) { + console.log(`[DEBUG] Test directory: ${dir}`); + console.log(`[DEBUG] Command: ${cmd.join(" ")}`); + console.log(`[DEBUG] Scanner type: ${scannerType}`); + console.log(`[DEBUG] Scanner returns: ${scannerReturns}`); + console.log(`[DEBUG] Has existing node_modules: ${hasExistingNodeModules}`); + console.log(`[DEBUG] Linker: ${linker}`); + console.log(""); + console.log("Files in test directory:"); + const files = await globEverything(dir); + for (const file of files) { + console.log(` ${file}`); + } + console.log(""); + console.log("bunfig.toml contents:"); + console.log(await Bun.file(join(dir, "bunfig.toml")).text()); + console.log(""); + console.log("package.json contents:"); + console.log(await Bun.file(join(dir, "package.json")).text()); + console.log(""); + console.log("To run the command manually:"); + console.log(`cd ${dir} && ${cmd.join(" ")}`); + } + + await using proc = Bun.spawn({ + cmd, + cwd: dir, + stdout: "pipe", + stderr: "pipe", + stdin: "pipe", + env: bunEnv, + }); + + let errAndOut = ""; + + if (DO_TEST_DEBUG) { + const write = (chunk: Uint8Array, stream: NodeJS.WriteStream, decoder: TextDecoder) => { + const str = decoder.decode(chunk); + + errAndOut += str; + + const lines = str.split("\n"); + for (const line of lines) { + stream.write(redSubprocessPrefix); + stream.write(" "); + stream.write(line); + stream.write("\n"); + } + }; + + const outDecoder = new TextDecoder(); + const stdoutWriter = new WritableStream>({ + write: chunk => write(chunk, process.stdout, outDecoder), + close: () => void process.stdout.write(outDecoder.decode()), + }); + + const errDecoder = new TextDecoder(); + const stderrWriter = new WritableStream>({ + write: chunk => write(chunk, process.stderr, errDecoder), + close: () => void process.stderr.write(errDecoder.decode()), + }); + + await Promise.all([proc.stdout.pipeTo(stdoutWriter), proc.stderr.pipeTo(stderrWriter)]); + } else { + const [stdout, stderr] = await Promise.all([proc.stdout.text(), proc.stderr.text()]); + errAndOut = stdout + stderr; + } + + const exitCode = await proc.exited; + + if (exitCode !== expectedExitCode) { + console.log("Command:", cmd.join(" ")); + console.log("Expected exit code:", expectedExitCode, "Got:", exitCode); + console.log("Test directory:", dir); + console.log("Files in test dir:", await globEverything(dir)); + console.log("Registry:", registryUrl); + console.log(); + console.log("bunfig:"); + console.log(await Bun.file(join(dir, "bunfig.toml")).text()); + console.log(); + } + + expect(exitCode).toBe(expectedExitCode); + + // If the scanner is from npm and there are no node modules when the test "starts" + // then we should expect Bun to do the partial install first of all + if (scannerType === "npm" && !hasExistingNodeModules) { + expect(errAndOut).toContain("Attempting to install security scanner from npm"); + expect(errAndOut).toContain("Security scanner installed successfully"); + } + + if (scannerType === "npm.bunfigonly") { + expect(errAndOut).toContain(""); + } + + if (scannerType !== "npm.bunfigonly" && !scannerSyncronouslyThrows) { + expect(errAndOut).toContain("SCANNER_RAN"); + + if (scannerReturns === "warn") { + expect(errAndOut).toContain("WARNING:"); + expect(errAndOut).toContain("Test warning"); + } else if (scannerReturns === "fatal") { + expect(errAndOut).toContain("FATAL:"); + expect(errAndOut).toContain("Test fatal error"); + } + } + + if (scannerType !== "npm.bunfigonly" && !hasExistingNodeModules) { + switch (scannerReturns) { + case "fatal": + case "warn": { + // When there are fatal advisories OR warnings (with no TTY to prompt), + // the installation is cancelled and packages should NOT be installed + expect(await Bun.file(join(dir, "node_modules", "left-pad", "package.json")).exists()).toBe(false); + break; + } + + case "none": { + // When there are no security issues, packages should be installed normally + + switch (command) { + case "remove": + case "uninstall": { + for (const arg of args) { + switch (linker) { + case "hoisted": { + expect(await Bun.file(join(dir, "node_modules", arg, "package.json")).exists()).toBe(false); + break; + } + + case "isolated": { + const versionInRegistry = SimpleRegistry.packages[arg][0]; + const path = join( + dir, + "node_modules", + ".bun", + `${arg}@${versionInRegistry}`, + "node_modules", + arg, + "package.json", + ); + expect(await Bun.file(path).exists()).toBe(false); + break; + } + } + } + break; + } + + default: { + for (const arg of args) { + switch (linker) { + case "hoisted": { + expect(await Bun.file(join(dir, "node_modules", arg, "package.json")).exists()).toBe(true); + break; + } + + case "isolated": { + const versionInRegistry = SimpleRegistry.packages[arg][0]; + const path = join( + dir, + "node_modules", + ".bun", + `${arg}@${versionInRegistry}`, + "node_modules", + arg, + "package.json", + ); + expect(await Bun.file(path).exists()).toBe(true); + break; + } + } + } + break; + } + } + + break; + } + } + } + + const requestedPackages = registry.getRequestedPackages(); + const requestedTarballs = registry.getRequestedTarballs(); + + // when we have no node modules and the scanner comes from npm, we must first install the scanner + // but, if we expext the scanner to report failure then we should ONLY see the scanner tarball requested, no others + if (scannerType === "npm" && !hasExistingNodeModules && (scannerReturns === "fatal" || scannerReturns === "warn")) { + const doWeExpectToAlwaysTryToResolve = + // If there is no lockfile, we will resolve packages + !hasLockfile || + // Unless we are updating + (command === "update" && args.length === 0) || + // Unless there are arguments, but it's chill because one of the arguments is the security + // scanner, so we would expect to be resolving + args.includes("test-security-scanner"); + + if (doWeExpectToAlwaysTryToResolve) { + expect(requestedPackages).toContain("test-security-scanner"); + } else { + expect(requestedPackages).not.toContain("test-security-scanner"); + } + + // we should have ONLY requested the security scanner at this point + expect(requestedTarballs).toEqual(["/test-security-scanner-1.0.0.tgz"]); + } + + const sortedPackages = [...requestedPackages].sort(); + const sortedTarballs = [...requestedTarballs].sort(); + + if (command === "install") { + expect(sortedPackages).toMatchSnapshot("requested-packages: install"); + expect(sortedTarballs).toMatchSnapshot("requested-tarballs: install"); + } else if (command === "add") { + expect(sortedPackages).toMatchSnapshot("requested-packages: add"); + expect(sortedTarballs).toMatchSnapshot("requested-tarballs: add"); + } else if (command === "update") { + if (args.length > 0) { + expect(sortedPackages).toMatchSnapshot("requested-packages: update with args"); + expect(sortedTarballs).toMatchSnapshot("requested-tarballs: update with args"); + } else { + expect(sortedPackages).toMatchSnapshot("requested-packages: update without args"); + expect(sortedTarballs).toMatchSnapshot("requested-tarballs: update without args"); + } + } else if (command === "remove" || command === "uninstall") { + if (args.length > 0) { + expect(sortedPackages).toMatchSnapshot("requested-packages: remove with args"); + expect(sortedTarballs).toMatchSnapshot("requested-tarballs: remove with args"); + } else { + expect(sortedPackages).toMatchSnapshot("requested-packages: remove without args"); + expect(sortedTarballs).toMatchSnapshot("requested-tarballs: remove without args"); + } + } else { + expect(sortedPackages).toMatchSnapshot("requested-packages: unknown command"); + expect(sortedTarballs).toMatchSnapshot("requested-tarballs: unknown command"); + } +} + +export function runSecurityScannerTests(selfModuleName: string, hasExistingNodeModules: boolean) { + let i = 0; + + const bunTest = Bun.jest(selfModuleName); + + const { describe, beforeAll, afterAll } = bunTest; + + beforeAll(async () => { + registryUrl = await startRegistry(DO_TEST_DEBUG); + }); + + afterAll(() => { + stopRegistry(); + }); + + describe.each(["install", "update", "add", "remove", "uninstall"] as const)("bun %s", command => { + describe.each([ + { args: [], name: "no args" }, + { args: ["is-even"], name: "is-even" }, + { args: ["left-pad", "is-even"], name: "left-pad,is-even" }, + ])("$name", ({ args }) => { + describe.each(["hoisted", "isolated"] as const)("--linker=%s", linker => { + describe.each(["local", "npm", "npm.bunfigonly"] as const)("(scanner: %s)", scannerType => { + describe.each([true, false] as const)("(bun.lock exists: %p)", hasLockfile => { + describe.each(["none", "warn", "fatal"] as const)("(advisories: %s)", scannerReturns => { + if ((command === "add" || command === "uninstall" || command === "remove") && args.length === 0) { + // TODO(@alii): Test this case: + // - Exit code 1 + // - No changes to disk + // - Scanner does not run + return; + } + + const testName = getTestName(String(++i).padStart(4, "0"), hasExistingNodeModules); + + if (TESTS_TO_SKIP.has(testName)) { + return test.skip(testName, async () => { + // TODO + }); + } + + if (isCI) { + if (command === "uninstall") { + return test.skip(testName, async () => { + // Same as `remove`, optimising for CI time here + }); + } + + const random = Math.random(); + + if (random < (100 - CI_SAMPLE_PERCENT) / 100) { + return test.skip(testName, async () => { + // skipping this one for CI + }); + } + } + + // npm.bunfigonly is the case where a scanner is a valid npm package name identifier + // but is not referenced in package.json anywhere and is not in the lockfile, so the only knowledge + // of this package's existence is the fact that it was defined in as the value in bunfig.toml + // Therefore, we should fail because we don't know where to install it from + const shouldFail = + scannerType === "npm.bunfigonly" || scannerReturns === "fatal" || scannerReturns === "warn"; + + test(testName, async () => { + await runSecurityScannerTest({ + command, + args, + hasExistingNodeModules, + linker, + scannerType, + scannerReturns, + shouldFail, + hasLockfile, + + // TODO(@alii): Test this case + scannerSyncronouslyThrows: false, + }); + }); + }); + }); + }); + }); + }); + }); +} diff --git a/test/cli/install/bun-security-scanner-matrix-with-node-modules.test.ts b/test/cli/install/bun-security-scanner-matrix-with-node-modules.test.ts new file mode 100644 index 0000000000..06b936c041 --- /dev/null +++ b/test/cli/install/bun-security-scanner-matrix-with-node-modules.test.ts @@ -0,0 +1,8 @@ +import { runSecurityScannerTests } from "./bun-security-scanner-matrix-runner"; + +// CI Time maxes out at 3 minutes per test file. This test takes a little while +// but is useful enough justifying keeping it. This test file runs all the tests +// with an existing node modules folder. See +// ./bun-security-scanner-matrix-without-node-modules.test.ts for tests that run +// without +runSecurityScannerTests(import.meta.path, true); diff --git a/test/cli/install/bun-security-scanner-matrix-without-node-modules.test.ts b/test/cli/install/bun-security-scanner-matrix-without-node-modules.test.ts new file mode 100644 index 0000000000..70d39a5a89 --- /dev/null +++ b/test/cli/install/bun-security-scanner-matrix-without-node-modules.test.ts @@ -0,0 +1,5 @@ +import { runSecurityScannerTests } from "./bun-security-scanner-matrix-runner"; + +// See ./bun-security-scanner-matrix-with-node-modules.test.ts +// for notes on what this is and why it exists +runSecurityScannerTests(import.meta.path, false); diff --git a/test/cli/install/bun-update-security-edge-cases.test.ts b/test/cli/install/bun-update-security-edge-cases.test.ts new file mode 100644 index 0000000000..f814b709a6 --- /dev/null +++ b/test/cli/install/bun-update-security-edge-cases.test.ts @@ -0,0 +1,456 @@ +import { describe, expect, test } from "bun:test"; +import { bunEnv, bunExe, tempDirWithFiles } from "harness"; +import { join } from "path"; + +describe("bun update security edge cases", () => { + test("bun update detects vulnerability in updated version that was safe before", async () => { + // Start with an exact version that's "safe" + const dir = tempDirWithFiles("update-new-vuln", { + "package.json": JSON.stringify({ + name: "test-app", + dependencies: { + "lodash": "4.17.20", // Exact version that's safe + }, + }), + }); + + // First install - should be safe (no scanner yet) + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + + // Now add scanner and update package.json to allow updates + await Bun.write( + join(dir, "package.json"), + JSON.stringify({ + name: "test-app", + dependencies: { + "lodash": "^4.17.0", // Now allow updates + }, + }), + ); + + await Bun.write( + join(dir, "bunfig.toml"), + ` +[install.security] +scanner = "./scanner.js" +`, + ); + + await Bun.write( + join(dir, "scanner.js"), + ` +module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + const results = []; + for (const pkg of payload.packages) { + // Flag lodash 4.17.21 as vulnerable + if (pkg.name === "lodash" && pkg.version === "4.17.21") { + results.push({ + package: "lodash", + level: "fatal", + description: "CVE-2024-XXXX: Prototype pollution in lodash 4.17.21", + url: "https://example.com/CVE-2024-XXXX" + }); + } + } + return results; + } + } +}; +`, + ); + + // Simulate that a newer version (4.17.21) is now available with a vulnerability + // Run update which would get the newer, vulnerable version + const updateProc = Bun.spawn({ + cmd: [bunExe(), "update"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([ + updateProc.stdout.text(), + updateProc.stderr.text(), + updateProc.exited, + ]); + + // The scanner should detect the vulnerability in the updated version + if (stdout.includes("FATAL: lodash")) { + expect(stdout).toContain("FATAL: lodash"); + expect(stdout).toContain("CVE-2024-XXXX"); + expect(stdout).toContain("Installation aborted due to fatal security advisories"); + expect(exitCode).toBe(1); + } else { + // If the version didn't update to 4.17.21+, it should be safe + expect(exitCode).toBe(0); + } + }); + + test("bun update detects vulnerability in the specific updated package", async () => { + const dir = tempDirWithFiles("update-specific-vuln", { + "package.json": JSON.stringify({ + name: "test-app", + dependencies: { + "axios": "0.21.0", // Old version + "lodash": "4.17.20", + }, + }), + "bunfig.toml": ` +[install.security] +scanner = "./scanner.js" +`, + "scanner.js": ` +module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + const results = []; + for (const pkg of payload.packages) { + // axios >=0.21.2 has a vulnerability + if (pkg.name === "axios" && Bun.semver.satisfies(pkg.version, ">=0.21.2")) { + results.push({ + package: "axios", + level: "fatal", + description: "CVE-2023-45857: Axios vulnerable to SSRF in >=0.21.2", + url: "https://nvd.nist.gov/vuln/detail/CVE-2023-45857" + }); + } + } + return results; + } + } +}; +`, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + + // Update only axios - newer version has vulnerability + const updateProc = Bun.spawn({ + cmd: [bunExe(), "update", "axios"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([ + updateProc.stdout.text(), + updateProc.stderr.text(), + updateProc.exited, + ]); + + // Should detect vulnerability in the updated axios + if (stdout.includes("FATAL: axios")) { + expect(stdout).toContain("FATAL: axios"); + expect(stdout).toContain("CVE-2023-45857"); + expect(stdout).toContain("Installation aborted"); + expect(exitCode).toBe(1); + } else { + // If axios didn't update to vulnerable version + expect(exitCode).toBe(0); + } + }); + + test("bun update detects newly discovered vulnerability in existing package", async () => { + // Scenario: A package in lockfile was safe when installed, + // but a vulnerability was discovered later (without version change) + const dir = tempDirWithFiles("update-newly-discovered", { + "package.json": JSON.stringify({ + name: "test-app", + dependencies: { + "express": "4.18.2", // This version exists in lockfile + "lodash": "4.17.21", + }, + }), + // Initially no scanner in bunfig + }); + + // First install without security scanner (simulating before vulnerability was known) + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + + // Now add scanner configuration + await Bun.write( + join(dir, "bunfig.toml"), + ` +[install.security] +scanner = "./scanner.js" +`, + ); + + // Now add scanner that knows about the vulnerability + await Bun.write( + join(dir, "scanner.js"), + ` +module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + console.error("SCANNING_PACKAGES:", payload.packages.map(p => p.name + "@" + p.version).join(", ")); + + const results = []; + for (const pkg of payload.packages) { + // Express 4.18.2 now has a known vulnerability + if (pkg.name === "express" && pkg.version === "4.18.2") { + results.push({ + package: "express", + level: "fatal", + description: "CVE-2024-NEW: Newly discovered vulnerability in express 4.18.2", + url: "https://example.com/CVE-2024-NEW" + }); + } + } + return results; + } + } +}; +`, + ); + + // Run update - should detect the vulnerability in the already-installed package + const updateProc = Bun.spawn({ + cmd: [bunExe(), "update"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([ + updateProc.stdout.text(), + updateProc.stderr.text(), + updateProc.exited, + ]); + + // Should scan and find the vulnerability + expect(stderr).toContain("SCANNING_PACKAGES:"); + expect(stdout).toContain("FATAL: express"); + expect(stdout).toContain("CVE-2024-NEW"); + expect(stdout).toContain("Newly discovered vulnerability"); + expect(exitCode).toBe(1); + }); + + test("bun pm scan detects vulnerability in existing transitive dependency after adding package", async () => { + // Scenario: After adding a new package, running pm scan finds vulnerabilities + // in existing transitive dependencies + const dir = tempDirWithFiles("scan-after-add", { + "package.json": JSON.stringify({ + name: "test-app", + dependencies: { + "express": "^4.0.0", // Has body-parser as transitive dep + }, + }), + "bunfig.toml": ` +[install.security] +scanner = "./scanner.js" +`, + "scanner.js": ` +module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + const results = []; + for (const pkg of payload.packages) { + // body-parser (transitive dep of express) has vulnerability + if (pkg.name === "body-parser") { + results.push({ + package: "body-parser", + level: "fatal", + description: "Previously unknown vulnerability in body-parser", + url: "https://example.com/body-parser-vuln" + }); + } + } + return results; + } + } +}; +`, + }); + + // Install without scanner first + const tempBunfig = join(dir, "bunfig.toml"); + const fs = await import("node:fs/promises"); + await fs.rename(tempBunfig, `${tempBunfig}.bak`); + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + await fs.rename(`${tempBunfig}.bak`, tempBunfig); + + // Add a new package without scanner + await Bun.$`${bunExe()} add lodash`.cwd(dir).env(bunEnv).quiet(); + + // Now run pm scan with scanner to detect vulnerabilities + const scanProc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([ + scanProc.stdout.text(), + scanProc.stderr.text(), + scanProc.exited, + ]); + + // Should detect vulnerability in existing transitive dependency + expect(stdout).toContain("FATAL: body-parser"); + expect(stdout).toContain("via test-app › express › body-parser"); + expect(stdout).toContain("Previously unknown vulnerability"); + expect(exitCode).toBe(1); + }); + + test("bun update with version range change exposes vulnerability", async () => { + // Scenario: package.json is updated to allow newer versions that have vulnerabilities + const dir = tempDirWithFiles("update-range-vuln", { + "package.json": JSON.stringify({ + name: "test-app", + dependencies: { + "minimist": "1.2.5", // Exact version, safe + }, + }), + "bunfig.toml": ` +[install.security] +scanner = "./scanner.js" +`, + "scanner.js": ` +module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + const results = []; + for (const pkg of payload.packages) { + // minimist >=1.2.6 has vulnerability + if (pkg.name === "minimist" && Bun.semver.satisfies(pkg.version, ">=1.2.6")) { + results.push({ + package: "minimist", + level: "fatal", + description: "CVE-2021-44906: Prototype pollution in minimist >=1.2.6", + url: "https://nvd.nist.gov/vuln/detail/CVE-2021-44906" + }); + } + } + return results; + } + } +}; +`, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + + // Update package.json to use caret range + await Bun.write( + join(dir, "package.json"), + JSON.stringify({ + name: "test-app", + dependencies: { + "minimist": "^1.2.5", // Now allows 1.2.6+ + }, + }), + ); + + // Run update - should detect vulnerability in newer allowed version + const updateProc = Bun.spawn({ + cmd: [bunExe(), "update"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([ + updateProc.stdout.text(), + updateProc.stderr.text(), + updateProc.exited, + ]); + + // If it updated to vulnerable version + if (stdout.includes("FATAL: minimist")) { + expect(stdout).toContain("FATAL: minimist"); + expect(stdout).toContain("CVE-2021-44906"); + expect(stdout).toContain("Prototype pollution"); + expect(exitCode).toBe(1); + } else { + expect(exitCode).toBe(0); + } + }); + + test("bun pm scan detects newly discovered vulnerabilities in existing lockfile", async () => { + // Scenario: Running pm scan with updated vulnerability database finds new issues + const dir = tempDirWithFiles("scan-new-vuln-db", { + "package.json": JSON.stringify({ + name: "test-app", + dependencies: { + "lodash": "4.17.21", + "express": "4.18.2", + }, + }), + // Initially no scanner + }); + + // First install without scanner + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + + // Add scanner with updated vulnerability database + await Bun.write(join(dir, "bunfig.toml"), `[install.security]\nscanner = "./scanner.js"`); + await Bun.write( + join(dir, "scanner.js"), + ` +module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + // Simulate updated vulnerability database + const results = []; + for (const pkg of payload.packages) { + if (pkg.name === "lodash" && pkg.version === "4.17.21") { + results.push({ + package: "lodash", + level: "warn", + description: "New vulnerability discovered in lodash 4.17.21", + url: "https://example.com/new-lodash-vuln" + }); + } + if (pkg.name === "express" && pkg.version === "4.18.2") { + results.push({ + package: "express", + level: "fatal", + description: "Critical vulnerability found in express 4.18.2", + url: "https://example.com/new-express-vuln" + }); + } + } + return results; + } + } +}; +`, + ); + + // Run pm scan - should detect newly discovered vulnerabilities + const scanProc = Bun.spawn({ + cmd: [bunExe(), "pm", "scan"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([ + scanProc.stdout.text(), + scanProc.stderr.text(), + scanProc.exited, + ]); + + // Should detect the newly discovered vulnerabilities + expect(stdout).toContain("FATAL: express"); + expect(stdout).toContain("WARNING: lodash"); + expect(stdout).toContain("2 advisories"); + expect(exitCode).toBe(1); + }); +}); diff --git a/test/cli/install/bun-update-security-provider.test.ts b/test/cli/install/bun-update-security-provider.test.ts new file mode 100644 index 0000000000..034d45e791 --- /dev/null +++ b/test/cli/install/bun-update-security-provider.test.ts @@ -0,0 +1,150 @@ +import { afterAll, afterEach, beforeAll, beforeEach, expect, test } from "bun:test"; +import { bunEnv, bunExe } from "harness"; +import { + dummyAfterAll, + dummyAfterEach, + dummyBeforeAll, + dummyBeforeEach, + dummyRegistry, + package_dir, + setHandler, + write, +} from "./dummy.registry.js"; + +beforeAll(dummyBeforeAll); +afterAll(dummyAfterAll); +beforeEach(dummyBeforeEach); +afterEach(dummyAfterEach); + +test("security scanner blocks bun update on fatal advisory", async () => { + const urls: string[] = []; + setHandler( + dummyRegistry(urls, { + "0.1.0": {}, + "0.2.0": {}, + }), + ); + + const scannerCode = ` + export const scanner = { + version: "1", + scan: async ({ packages }) => { + if (packages.length === 0) return []; + return [ + { + package: "moo", + description: "Fatal security issue detected", + level: "fatal", + url: "https://example.com/critical", + }, + ]; + }, + }; + `; + + await write("./scanner.ts", scannerCode); + await write("package.json", { + name: "my-app", + version: "1.0.0", + dependencies: { + moo: "0.1.0", + }, + }); + + // First install without security scanning (to have something to update) + await using installProc = Bun.spawn({ + cmd: [bunExe(), "install", "--no-summary"], + env: bunEnv, + cwd: package_dir, + stdout: "pipe", + stderr: "pipe", + }); + + await installProc.stdout.text(); + await installProc.stderr.text(); + await installProc.exited; + + await write( + "./bunfig.toml", + ` +[install] +saveTextLockfile = false + +[install.security] +scanner = "./scanner.ts" +`, + ); + + await using updateProc = Bun.spawn({ + cmd: [bunExe(), "update", "moo"], + env: bunEnv, + cwd: package_dir, + stdout: "pipe", + stderr: "pipe", + }); + + const [updateOut, updateErr, updateExitCode] = await Promise.all([ + updateProc.stdout.text(), + updateProc.stderr.text(), + updateProc.exited, + ]); + + expect(updateOut).toContain("FATAL: moo"); + expect(updateOut).toContain("Fatal security issue detected"); + expect(updateOut).toContain("Installation aborted due to fatal security advisories"); + + expect(updateExitCode).toBe(1); +}); + +test("security scanner does not run on bun update when disabled", async () => { + const urls: string[] = []; + setHandler( + dummyRegistry(urls, { + "0.1.0": {}, + "0.2.0": {}, + }), + ); + + await write("package.json", { + name: "my-app", + version: "1.0.0", + dependencies: { + moo: "0.1.0", + }, + }); + + // Remove bunfig.toml to ensure no security scanner + await write("bunfig.toml", ""); + + await using installProc = Bun.spawn({ + cmd: [bunExe(), "install", "--no-summary"], + env: bunEnv, + cwd: package_dir, + stdout: "pipe", + stderr: "pipe", + }); + + await installProc.stdout.text(); + await installProc.stderr.text(); + await installProc.exited; + + await using updateProc = Bun.spawn({ + cmd: [bunExe(), "update", "moo"], + env: bunEnv, + cwd: package_dir, + stdout: "pipe", + stderr: "pipe", + }); + + const [updateOut, updateErr, updateExitCode] = await Promise.all([ + updateProc.stdout.text(), + updateProc.stderr.text(), + updateProc.exited, + ]); + + expect(updateOut).not.toContain("Security scanner"); + expect(updateOut).not.toContain("WARN:"); + expect(updateOut).not.toContain("FATAL:"); + + expect(updateExitCode).toBe(0); +}); diff --git a/test/cli/install/bun-update-security-scan-all.test.ts b/test/cli/install/bun-update-security-scan-all.test.ts new file mode 100644 index 0000000000..9b67c2a8a8 --- /dev/null +++ b/test/cli/install/bun-update-security-scan-all.test.ts @@ -0,0 +1,392 @@ +import { describe, expect, test } from "bun:test"; +import { bunEnv, bunExe, tempDirWithFiles } from "harness"; +import { join } from "node:path"; + +describe("bun update security scanning", () => { + test("bun update without arguments scans all packages", async () => { + const dir = tempDirWithFiles("update-scan-all", { + "package.json": JSON.stringify({ + name: "test-app", + dependencies: { + "lodash": "^4.0.0", + "express": "^4.0.0", + }, + }), + "bunfig.toml": ` +[install.security] +scanner = "./scanner.js" +`, + "scanner.js": ` +let callCount = 0; +module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + callCount++; + + // Log what packages we're scanning + const packageNames = payload.packages.map(p => p.name).sort(); + console.error("SCAN_CALL_" + callCount + ":", JSON.stringify(packageNames)); + + const results = []; + for (const pkg of payload.packages) { + if (pkg.name === "lodash") { + results.push({ + package: "lodash", + level: "warn", + description: "Test warning in lodash", + url: "https://example.com/lodash-advisory" + }); + } + if (pkg.name === "express") { + results.push({ + package: "express", + level: "warn", + description: "Test warning in express", + url: "https://example.com/express-advisory" + }); + } + } + return results; + } + } +}; +`, + }); + + // First install to create lockfile (temporarily disable scanner) + const bunfigPath = join(dir, "bunfig.toml"); + const bunfigContent = await Bun.file(bunfigPath).text(); + await Bun.write(bunfigPath, ""); // Remove scanner config + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + await Bun.write(bunfigPath, bunfigContent); // Restore scanner config + + // Now run update without arguments - should scan ALL packages + const updateProc = Bun.spawn({ + cmd: [bunExe(), "update"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([ + updateProc.stdout.text(), + updateProc.stderr.text(), + updateProc.exited, + ]); + + // Should have scanned packages + expect(stderr).toContain("SCAN_CALL_"); + + // Should show vulnerabilities + expect(stdout).toContain("WARNING: lodash"); + expect(stdout).toContain("WARNING: express"); + + // Should exit with code 1 due to warnings requiring confirmation (no TTY) + expect(exitCode).toBe(1); + + // Should show the summary + expect(stdout).toMatch(/2 advisories \(.*2 warning.*\)/); + }); + + test("bun update with specific packages only scans those packages", async () => { + const dir = tempDirWithFiles("update-scan-specific", { + "package.json": JSON.stringify({ + name: "test-app", + dependencies: { + "lodash": "4.17.20", + "express": "4.17.0", + "axios": "0.21.0", + }, + }), + "scanner.js": ` +module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + // Log which packages are being scanned + const packageNames = payload.packages.map(p => p.name); + console.error("SCANNED_PACKAGES:", JSON.stringify(packageNames)); + + const results = []; + for (const pkg of payload.packages) { + if (pkg.name === "lodash") { + results.push({ + package: "lodash", + level: "warn", + description: "Test warning" + }); + } + if (pkg.name === "express") { + results.push({ + package: "express", + level: "fatal", + description: "Should not see this" + }); + } + } + return results; + } + } +}; +`, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + + await Bun.write( + join(dir, "bunfig.toml"), + ` +[install.security] +scanner = "./scanner.js" +`, + ); + + // Update only lodash - should only scan lodash and its dependencies + const updateProc = Bun.spawn({ + cmd: [bunExe(), "update", "lodash"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([ + updateProc.stdout.text(), + updateProc.stderr.text(), + updateProc.exited, + ]); + + // Should have scanned packages + expect(stderr).toContain("SCANNED_PACKAGES:"); + + // Should show warning for lodash + expect(stdout).toMatch(/WARN(ING)?.*lodash/); + + // Should NOT show fatal for express (wasn't updated) + expect(stdout).not.toContain("FATAL: express"); + + // Should exit with 1 for warnings (user needs to confirm) + expect(exitCode).toBe(1); + }); + + test("bun update respects security scanner configuration", async () => { + const dir = tempDirWithFiles("update-no-scanner", { + "package.json": JSON.stringify({ + name: "test-app", + dependencies: { + "lodash": "^4.0.0", + }, + }), + // No bunfig.toml with scanner configuration + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + + // Run update - should succeed without scanning + const updateProc = Bun.spawn({ + cmd: [bunExe(), "update"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([ + updateProc.stdout.text(), + updateProc.stderr.text(), + updateProc.exited, + ]); + + // Should succeed + expect(exitCode).toBe(0); + + // Should not have any security warnings + expect(stdout).not.toContain("WARNING:"); + expect(stdout).not.toContain("FATAL:"); + }); + + test("bun update aborts on fatal vulnerabilities", async () => { + const dir = tempDirWithFiles("update-abort-fatal", { + "package.json": JSON.stringify({ + name: "test-app", + dependencies: { + "lodash": "^4.0.0", + }, + }), + "scanner.js": ` +module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + return [{ + package: "lodash", + level: "fatal", + description: "Critical security vulnerability", + url: "https://example.com/CVE-1234" + }]; + } + } +}; +`, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + + await Bun.write( + join(dir, "bunfig.toml"), + ` +[install.security] +scanner = "./scanner.js" +`, + ); + + const updateProc = Bun.spawn({ + cmd: [bunExe(), "update"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + env: bunEnv, + }); + + const [stdout, stderr, exitCode] = await Promise.all([ + updateProc.stdout.text(), + updateProc.stderr.text(), + updateProc.exited, + ]); + + // Should show the fatal vulnerability + expect(stdout).toContain("FATAL: lodash"); + expect(stdout).toContain("Critical security vulnerability"); + + // Should abort installation + expect(stdout).toContain("Installation aborted due to fatal security advisories"); + + // Should exit with error code + expect(exitCode).toBe(1); + }); + + test.todo("bun update prompts for warnings when TTY available - requires TTY for interactive prompt", async () => { + const dir = tempDirWithFiles("update-prompt-warnings", { + "package.json": JSON.stringify({ + name: "test-app", + dependencies: { + "lodash": "^4.0.0", + }, + }), + "bunfig.toml": ` +[install.security] +scanner = "./scanner.js" +`, + "scanner.js": ` +module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + return [{ + package: "lodash", + level: "warn", + description: "Minor security issue" + }]; + } + } +}; +`, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + + // Run update with stdin to simulate TTY + const updateProc = Bun.spawn({ + cmd: [bunExe(), "update"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + stdin: "pipe", + env: { ...bunEnv, FORCE_COLOR: "1" }, // Force color to simulate TTY + }); + + // Send 'y' to continue + updateProc.stdin.write("y\n"); + updateProc.stdin.end(); + + const [stdout, stderr, exitCode] = await Promise.all([ + updateProc.stdout.text(), + updateProc.stderr.text(), + updateProc.exited, + ]); + + // Should show warning (with or without ANSI codes) + expect(stdout).toMatch(/WARN(ING)?.*lodash/); + + // Should prompt for confirmation + expect(stdout).toContain("Security warnings found"); + expect(stdout).toContain("Continue anyway?"); + + // Should continue after user confirmation + expect(stdout).toContain("Continuing with installation"); + expect(exitCode).toBe(0); + }); + + test("bun update shows dependency paths correctly", async () => { + const dir = tempDirWithFiles("update-dep-paths", { + "package.json": JSON.stringify({ + name: "my-app", + dependencies: { + "express": "^4.0.0", + }, + }), + "scanner.js": ` +module.exports = { + scanner: { + version: "1", + scan: async function(payload) { + const results = []; + for (const pkg of payload.packages) { + // Flag a transitive dependency + if (pkg.name === "body-parser") { + results.push({ + package: "body-parser", + level: "warn", + description: "Transitive vulnerability" + }); + } + } + return results; + } + } +}; +`, + }); + + await Bun.$`${bunExe()} install`.cwd(dir).env(bunEnv).quiet(); + + await Bun.write( + join(dir, "bunfig.toml"), + ` +[install.security] +scanner = "./scanner.js" +`, + ); + + const updateProc = Bun.spawn({ + cmd: [bunExe(), "update"], + cwd: dir, + stdout: "pipe", + stderr: "pipe", + stdin: "pipe", + env: bunEnv, + }); + + // Send 'n' to not continue + updateProc.stdin.write("n\n"); + updateProc.stdin.end(); + + const [stdout] = await Promise.all([updateProc.stdout.text(), updateProc.stderr.text(), updateProc.exited]); + + // Should show the full dependency path + expect(stdout).toContain("WARNING: body-parser"); + expect(stdout).toContain("via my-app › express › body-parser"); + }); +}); diff --git a/test/cli/install/bun-update-security-simple.test.ts b/test/cli/install/bun-update-security-simple.test.ts new file mode 100644 index 0000000000..c9805c3356 --- /dev/null +++ b/test/cli/install/bun-update-security-simple.test.ts @@ -0,0 +1,109 @@ +import { expect, test } from "bun:test"; +import { bunEnv, bunExe, tempDirWithFiles } from "harness"; + +test("security scanner blocks bun update with fatal advisory", async () => { + const dir = tempDirWithFiles("bun-update-security", { + "package.json": JSON.stringify({ + name: "test-app", + version: "1.0.0", + dependencies: { + "left-pad": "1.3.0", // There is a real update to 1.3.1 + }, + }), + "scanner.ts": ` + export const scanner = { + version: "1", + scan: async ({ packages }) => { + console.log("Security scanner received " + packages.length + " packages"); + if (packages.length === 0) return []; + return [ + { + package: packages[0].name, + description: "Security warning for update test", + level: "fatal", + url: "https://example.com/advisory", + }, + ]; + }, + }; + `, + }); + + // First install without scanner + await using installProc = Bun.spawn({ + cmd: [bunExe(), "install"], + env: bunEnv, + cwd: dir, + stdout: "pipe", + stderr: "pipe", + }); + + await installProc.stdout.text(); + await installProc.stderr.text(); + const installCode = await installProc.exited; + expect(installCode).toBe(0); + + // Now add scanner for update + await Bun.write(Bun.pathToFileURL(`${dir}/bunfig.toml`), `[install.security]\nscanner = "./scanner.ts"`); + + await using updateProc = Bun.spawn({ + cmd: [bunExe(), "update", "left-pad", "--latest"], + env: bunEnv, + cwd: dir, + stdout: "pipe", + stderr: "pipe", + stdin: "pipe", + }); + + const [out, exitCode] = await Promise.all([updateProc.stdout.text(), updateProc.exited]); + + expect(out).toContain("Security scanner received"); + expect(out).toContain("FATAL: left-pad"); + expect(out).toContain("Security warning for update test"); + expect(out).toContain("Installation aborted due to fatal security advisories"); + expect(exitCode).toBe(1); +}); + +test("security scanner does not run on bun update when not configured", async () => { + const dir = tempDirWithFiles("bun-update-no-security", { + "package.json": JSON.stringify({ + name: "test-app", + version: "1.0.0", + dependencies: { + "left-pad": "1.3.0", + }, + }), + }); + + await using installProc = Bun.spawn({ + cmd: [bunExe(), "install"], + env: bunEnv, + cwd: dir, + stdout: "pipe", + stderr: "pipe", + }); + + const installCode = await installProc.exited; + expect(installCode).toBe(0); + + await using updateProc = Bun.spawn({ + cmd: [bunExe(), "update", "left-pad", "--latest"], + env: bunEnv, + cwd: dir, + stdout: "pipe", + stderr: "pipe", + }); + + const [out, err, exitCode] = await Promise.all([ + updateProc.stdout.text(), + updateProc.stderr.text(), + updateProc.exited, + ]); + + const combined = out + err; + expect(combined).not.toContain("Security scanner"); + expect(combined).not.toContain("FATAL:"); + expect(combined).not.toContain("WARN:"); + + expect(exitCode).toBe(0); +}); diff --git a/test/cli/install/dummy.registry.ts b/test/cli/install/dummy.registry.ts index 8d8cbba7bc..7693768ad2 100644 --- a/test/cli/install/dummy.registry.ts +++ b/test/cli/install/dummy.registry.ts @@ -165,6 +165,5 @@ if (Bun.main === import.meta.path) { setHandler(dummyRegistry([])); console.log("Running dummy registry!\n\n URL: ", root_url!, "\n", "DIR: ", package_dir!); } else { - // @ts-expect-error ({ expect } = Bun.jest(import.meta.path)); } diff --git a/test/cli/install/generate-scanner-tarballs.ts b/test/cli/install/generate-scanner-tarballs.ts new file mode 100644 index 0000000000..eeafc52cac --- /dev/null +++ b/test/cli/install/generate-scanner-tarballs.ts @@ -0,0 +1,72 @@ +#!/usr/bin/env bun +import { mkdir, mkdtemp } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { dirname, join } from "node:path"; + +const __dirname = dirname(Bun.fileURLToPath(import.meta.url)); + +async function createScannerTarball(behavior: "clean" | "warn" | "fatal") { + const tmpDir = await mkdtemp(join(tmpdir(), `test-security-scanner-${behavior}-`)); + const outputPath = join(__dirname, `test-security-scanner-1.0.0-${behavior}.tgz`); + + try { + await mkdir(`${tmpDir}/package`, { recursive: true }); + + await Bun.write( + `${tmpDir}/package/package.json`, + JSON.stringify({ + name: "test-security-scanner", + version: "1.0.0", + main: "index.js", + type: "module", + }), + ); + + const scannerCode = `export const scanner = { + version: "1", + scan: async function(payload) { + console.error("SCANNER_RAN: " + payload.packages.length + " packages"); + const results = []; + ${ + behavior === "warn" + ? `if (payload.packages.length > 0) { + results.push({ + package: payload.packages[0].name, + level: "warn", + description: "Test warning" + }); + }` + : "" + } + ${ + behavior === "fatal" + ? `if (payload.packages.length > 0) { + results.push({ + package: payload.packages[0].name, + level: "fatal", + description: "Test fatal error" + }); + }` + : "" + } + return results; + } +};`; + + await Bun.write(`${tmpDir}/package/index.js`, scannerCode); + + await Bun.$`tar czf ${outputPath} -C ${tmpDir} package`; + await Bun.$`rm -rf ${tmpDir}`; + + console.log(`Created ${outputPath}`); + } catch (error) { + console.error(`Failed to create scanner tarball for ${behavior}:`, error); + throw error; + } +} + +console.log("Generating scanner tarballs..."); + +await Promise.all([createScannerTarball("clean"), createScannerTarball("warn"), createScannerTarball("fatal")]); + +console.log("All scanner tarballs generated successfully!"); diff --git a/test/cli/install/is-even-1.0.0.tgz b/test/cli/install/is-even-1.0.0.tgz new file mode 100644 index 0000000000000000000000000000000000000000..16aa18f490153a61ce96f2b4bd52f7a81f465d56 GIT binary patch literal 2163 zcmV-(2#oh1iwFP!000006YUx8a@)8uzxfm!yAxX)iTZNvnWRaFk?EK{S@KZwr5=x) zP$VQFApw;Dt?1f3P+y}@)?JX4C6AnsyIk5%jnSCIV!yH2UC{F&{18l8W1c_l_ezRK z-+45f&BKEOpy$!yk$E=T`5Z^iIu1{%!&6h#+A*&tQkEI=f+Fr$)etsW9bp&846?*x+Er_ku=Vx3Q@=}ILp%bTa?A8%9z?g z;!lQK%tI!WG5E|I#xGwq z?H2iXB{ko;HB`-%Ce%cRv)~plVsnNvM9A0qqAfCt2>q|f*lw@m-yClxnP&04K9Ok> z=z4NX+G-osp%hH;j(xDs@&j8gWE!pcBS_O=S<;0v6S|zNHYsWH2WqXB;+e_EfcZ$JM<-f#G>bA0C7 zN%Z|w%ophO8E0{% zY%UvOo-}UCd}phh>7SHd#_Yu;4s_*~YOz?@i27ccWLZX8K~^b+B~s{Fyo5+DL@a|y zeO7Fgd|7TTQ>N2%N_Ag;$Y0; z7b8Qlrc2JE9&)44R!$YmdI?`!%q?qo7d(MSB#tesc!330LAXM@@7wOmGs}AS?wy)h ze*lC6F9_>(72L2g;t0hExKQXdL-Af&Hvx%vNtqXrvcF|KW&3*t$zJ8TW#y~;O?+=O zUcAh+U;*4~?Ui7YuuFJ*D{|)!a;cCr#`I2ayU@i5P5C&}SRgFxJVPr;DXgao0ucda z4}41*1o0wRDp;@>UBGNOktt9!VbCTFw;qv7+8SKVV-_d|A(jY@)B;TJaJ_Ha4gBSe zL_@Ge#lEA7OqFH*1FF@oOcJhDwF>!cwQeAYQm@yc_=~ece81X=iR&+SPlmEZltNO0 z5;8^r}8}u^`3&fOk(w+$eS|3QuIj#<0V{C zE#4}N7Nlb4SubhoIj2eu3in1*>}g;T*CxvIWr#4SLLDz{aKsX@H4#&$Ff** zjL#s#kQHX>$|h;3CvH>mRw?l{OXheqnO%8nStGeJV~uAG(ky2*k#Q^+4?PAM2ucEgzwo(b}c31)PB08EW{2q}mQ#n)TQTqs#?BpEi};smsf zrbK;fpJQ$WmQ}58-UzByguzuFD2;CocOuoOAoiB`(H6_wh>c>syyds7uADDZKAma! z*FT|+H(EUOo4S65Lbl~I6Uh;7R)ne9gdyG~N;%j2J+JHbhc4xbDp~*594@+L;7)Ek zPIrUn*Bq~#rhRBPYk>BgVYsx>I5N?G`=4%T9>zC~vS%rR=y#Fv`ToD%qIS8}J~(Q( zI-R4|5%&MBr=7!x{{Kge5vG&1Yy$f@sjTO&{jfqO`)RF6VVfBYTOyVw*sS1{flA1X zr3}-|G!3u;h-xrN83Q??5}Qu3{$W`Ou;R|~l7R$rtOK5xB`g8+r6s8sMK(%K^ujb% zSUCcvWXMeh!}b9$@dEp3l4m}oz&>Tfonb+-Q!zp!7Q|Ljw96$^c(Ad<`bQW3ka*Ov z$b@lbdXsWF=Gax`5=`kPHz*64W(qAJJ!^PziTH$`%$POL#xYm38a5UxZ^96$2xz=o zBRd+{4=RRzG;*M#C?^}*85~l5P7c+Di%e6pn8{?*60WQXHt;Bt8Jb9<%Zx;7sLDoW zy}kkvDtZ*30<-#IRX--Pw@h}O^ z@qRUzsgZZrOe|8PQx}GVlhGT;cflLNxj*>XJ9dv@#~I>$rv`7l(dpn~1c>1~{m~^1 zPQdA3!cSiRxCZWD&V6?{gn@5)XXic7MVQy`_AZXS{%d%Jbo~Jaw1<(5Oh*GCfdwni z9TKxM*YBR<)OqFgywPRNI`Kw*;(0Rg!GUwfA9>x2p5w#$g?~O6x+wk_+4jBuiH}m; zGq*poQ7Xc~{TU}PJau|K5@k6TsJ&16L3eO|>3gqFM{qjm9lHp8<)UWJtDc*SLZiAp z$2+URv2*6Ub`8}4x%d{L<=VlUQ^eQ`Z4w2uxBJBRfBuia`r)c+qb8r8=ZR97DX|M<24>3E4$MEJFh zf=$RpS&I$UI=_{eR}?oy&lHHco_f3T+4dwV_9Tk( zrF4ukuzvqRo?k40-N*~s?sM4Xsw{kew?uP3QxnM-F&7an4OpDWNI@(U27C(foWYD= zvk0Oj95V@A0pi*Q`Ild(M!Vdb5O)MOs; z=slBhB`=GY#B(7D?QbH2;Ti}E_mL?Y0uvF%l8=*ENQGoBaSmtOA&=z>hAiYW>G|sY z$`C|)W9jioAvo=ckX6(Tj3G(r7u_|yzY1+NUoUMF6QSZIk7FjciHUeuT2#pvLUH80 zB7N_+$vByjD!&+pi3~o&s`yd~Q^fS6CKm7siQw)$_1aORfdj1n^~d`Eot`IP zN&;N&T=veokXG)ib!Fw@3@aOFfv;>XD$ydWT&HEkR@bw?s(2N!<0K@JiOB&3iql_De%-EV-HrruIE z{0f&@Q+;)BFZ>B%VE2n<*)5W#(z^YCOh9000~3;;j7Wm~TvbyB*}3I@`bK>0G42x` zK{i}R6crB_0lRG~G)`uy`^EQ#SdNK!-W3m{jiT$&ZDofX1hlNP1a}^7CG4pc0{cLP z4!=8|X=<~x>!L}>-XATpU zh%JluElKdWWm&(%{(eh@c-T_=`(Q@vbv=V1<#HL)|2X7C^&$ zFryF#jDE7kjKx?ULLP8W@_(T_bcORE;CTF(D@_W67Mf?S4HqJT359+tc>Yjon3Cq2 zlP2>yMnK(YNZ2>}HT9(j)}Q^&+l2jnU6V|pR6ci;5Ndi2aTo60w-iROj=3zbtd>}; zB%jS=_|LzgUacKrs@RnE0Rq_;mRyQtAD!i6M%H22bw?SWt3tE zR_627C&K;!HBwlB$m8Bv;DKzic5)|77&0IdH%o!r7qzquX}cu-hEsc((*^+|gpFwhDGr;j+>SfCC|M`&s7EwU`U7afS#vOQTj!nT0M5<_XZ@jr?Au7T=k`tp z$i?Y8y^)PvaSogxaR9^9W~W1}tmZjNKOp&_)jzu!xUWw~aN6&*9h`jSpk&Qg9mlXj zrCOb)+bu!6*=@ddG*%y}3@idO(!rZkho*>M6aQKxx8EZ*TK(Q=fWs1MIT)=`-?&4k z1kHgvB!ip``rVR6=0uFXCW3f9$50_t!-hu?gvRGXXH5{=PP2ow&^^5k_t}s4seklm zeIieP#Q7FHK3)H-&&>UAtyZre9UL4q=>E4}Z9LZh@9|XjcP!Y?E`k5@z#kA_A`YQF zuuZTDc1xR|Ydi>~Vp)4wWWki@y%$z`E!ZX%j!LzBaZeb}pBC zd@)2q5@U)~NzjVg^XIt_a$oFz3-Be!t?bls+nh0DlLU4biv{)tKvV9V@sVgw_0xP8 zhrxqeE|z8WIvsXZJ&N73dhCJSZuMH-cCXv*Jg{uL+wZdn)@?I#RY_vWBe3#Y>FB|* z{P`y-KUWy527Dr_Ypm*vp0LFfvmJ{r1VAOdHcw@gJeY|=mK z0st2&gXddfD$qyZc%npAAy0U8Mg;!VGVOFoXd3cZt~z7ks5Z;A%*R=if}Uqg6}Z)WEjnh5hRgMtc*PQ z4gSW-z;wdNS}eu6nDDTfO`nOzoc+0GpQ`c!@I;Qoh^qNdA}Z!g;t!Lak4tx3S|FQv zMq$8SV@`Y?WFrFv81NKx4xh}>`pt+ch`*`=xyT3RdyWWVMeg;{&cXN9%0=b()`I`v zlG^>IDI9o5x+5e7h-P`}WDA3|jf(5X~$fUk~ z7gy5fT7|8$YOksuUH$0jhh^HW>b=f>7A4dF&HaNnyL*58Bz-K=|9-Eh^uKTS?0&n| zg8p0WZu?&U@1n3$+1h8XzkPPZj=tSyJFhmsV{i6fvDeS`P_xetUOoSQca!07d+%`j zFBNu0`G<}eS*yXegd-*c5wVtKb^cNT{AM_vN8V^GS#7h9YP-XpA^Kq7h5!9e;wS7Y zibcMOLhcR_2*ngSJXMI>2t?;$Aea|Z$T#t%6fTn?b3lm;8Ur?%nJE zU6f{%9U(44TJDJKJyy%9*G%y13hZ6O{kOW!y@e9Qz_&R++qJrDiv2aK92+& zCV@lr6n6*QtwHVAn9igA9VBFL8fXg;%%mUA`0Gmm_3V4Spi2rJLlZ z!$`7?takk~jCmII|J^6h{$={#>h-&q^&c_8{r=CLl;#RMB9AzY!coL0V{R1WPkg)FsHKPF%39ki8yr3HAlsNt`o9_cfTx2pxs& zAQ_-*_PuuZjdFkjUp}SQc&xcR#NfXT9dXVhlN}0?Q6XywV>g@4%$XcceKQcUsZ8V~ zjL2?E?)kCFR+<$fK}bO(a-^|d!2l9pnA(WMWh+uaACQ0p#y8YXi($~th{4iF{w!Wf zZ{^p8_r;G(U(BeSpy$gLl#vNlHj`{+UG4b5bUR^yKuWSxw4PF^#nmgU<|zR12FB_C zBe1@%QBFbQl$H<8%_&^KsSy+1ksKqnoB;?QN(upTNFbZKF-3Pn5eJ53fzYuX`4Gmu zA*&I>R~yW#W5LKI3J5pr(;1(V=i-SE2?OgCGCWQ39y(+8<(C*0d$^&{@wP!iUcWR( zBC;?<<|IGS!gIpJ$J!8R(!K+TiU|IdMy_WPIx>M=X$d$y7IDf2!EdN;i5WE(W*1{o zxW}kI0mah5NPdhglhk?#tzcp@mGjhj0gM(AIp~do6F&^6c$mjg|4drGl_r6?7AZVh=#kK5plh9&lM>ev<8agdJ==AS&wKFkd#$H6P2e= zH<+CxSKSaAC#rgh5G!%0z5DX9q!WP=6#k8MuKY?uu*uV>T1mO!F zQJ=7o4K@}5B8L4M*sKNhdRcsGu`Nn2m$cP@mBi{I2Ga>+O!!zggGlf*Lb%Y=N#a); z_z>Uef>BeVSIVtyn`Zw1<@U3!7u)8OE z2A>>O7Xb!50!%N5(N!fNyFnJru#6nUvdhhV^w5Cs$Xl^o`&G^U%F5pU(e~QPii$vB z#v+&TXr%TNSUfI#M+}+z%0}_%)I^XmL$ag;8XY6#&QFeE_mruRA_N#PCUe9zae@G9 zuEPz99Es6hh^7{+P=y_T(RzGRyG~x#oF=~CY(1`<A>R&wPvFE&f z0YB~e9_={$Zxu+LQT|0Uj~*i0Y+-U1stp|vkqT|Gq?~0V?Ou1JUK}SPZg$mJ7Z+}k z!=}}ar&#~+BrQH4eLX;=>x?%h9L-UsyymY>=Z~8>X7-;>SwB(wx5WPUdz}ySzh1|_ zxBquh?(@If%l{}M|ImF^&1SW}t{O?n$}Q?{LE1KS$}Ob}323hnV$BflC`~Tl)$&ZP z#^V@yjE?m6yGbUxX1D6=MU~D=w||7`tzG3K;Re&M>tl643TxH=D6}4sY~$nj{CLz= z`{QvR14&`3*yP5zLyn|i0iBqj$}H!lWJT>;-i)wCL@lczYN@;(*@x7}9oABMNMhOz zrY6$1Euw)?L5!fMq#3j|K<6Vm!`6A1&RdrfrlhsO`g+)mzKHlB41EEU@f(R7pw-f( ziE5ruXLO0cMWJs>w0b+-8Q(Icq;XTRehgA4N4k-K3#^+- zxrFyIqW%y)!!IdBfVF>frRXnXLT6#xD%nd}PIILp!2Cq%BPLUSS9l5vZBBzN`ixkHUMFZ zH}d6_uBL`Mo1?vHghD%kUR-MD6DS1kn9~%whIj1;Y8Vwh0xoOl(9&O&Nm4^bX+0$r ziJ0v4hK4~~jR@w=2z+UeBHv}D4L*%x4iWeXH``$?0p`Q08tjq2E%1mLRi+VGw#$ip z_dTCX5f&5J-w*fqQvMP5W_>II)`w2opD zCFWlife2hB017FtB>_sSenA4uhgrzv>S3b&xCFCGXsfm!H99`V-{rR369vs0sh+w* zL+sEcXsp&6grcv{un^f?H1iPa-kPwAlcH>7U#a!;H7gC4&Sj`_O&@4!X)GB|5Yo;* zWohT!r%X4Gz^`DvU_0gKGSBsthsz@&SDZ0If1fb_&-Q=RU3wAsUaD*8x4RRx6L^{a_iUyA?S9`vyrzEt)w;j`b2sJBs{iR7 z2T)vH&HSw9M?s}mDK1K;;`YwWKc}*w|LJe(Zo7|V_y0Pr%l_Z)cDwibe-~v@|5bRs zS3Y|;l~XX%Ly9~=Tm;FhGdL%SB8ra7P-fG}QvT=JFEPsi`OhdbmQ? z1wNvDlWjm36b=(l!W;ylM1ngE;szbX$J#K^>2e68rtawgAkXb%g|xu}F)LUy6)9z7 z_6Ky~**p{TxCWYa6FJy6cgD5CD5^X7r7b7R993jMb;=Rut_mrJIxbM1T$oX~lGmbV(c=w3O8D zm)@K`shi01YT)=vdevIxi+=-HK@^G7YU)JAVt5bZ+E)A{^KXN{g%JbX1Zlv pOOC%kr?!0!PM`b{7`2{UV)Xa+5clQ2+?UU_{14M4QRo0h0001(FOC2J literal 0 HcmV?d00001 diff --git a/test/cli/install/simple-dummy-registry.ts b/test/cli/install/simple-dummy-registry.ts new file mode 100644 index 0000000000..6ff470d07b --- /dev/null +++ b/test/cli/install/simple-dummy-registry.ts @@ -0,0 +1,175 @@ +import { Server, file } from "bun"; +import { dirname, join } from "node:path"; + +const __dirname = dirname(Bun.fileURLToPath(import.meta.url)); + +export class SimpleRegistry { + private debugLogs: boolean; + private server: Server | null = null; + private port: number = 0; + public requestedUrls: string[] = []; + private scannerBehavior: "clean" | "warn" | "fatal" = "clean"; + + public static readonly packages: Record = { + "left-pad": ["1.3.0"], + "is-even": ["1.0.0"], + "is-odd": ["1.0.0"], + "test-security-scanner": ["1.0.0"], + }; + + setScannerBehavior(behavior: "none" | "warn" | "fatal") { + // ternary because it was originally called "clean" but I renamed it "none" and didnt want to update the .tgz files. easier this way + this.scannerBehavior = behavior === "none" ? "clean" : behavior; + } + + constructor(debugLogs: boolean) { + this.debugLogs = debugLogs; + } + + async start(): Promise { + const self = this; + + this.server = Bun.serve({ + port: 0, + async fetch(req) { + const url = new URL(req.url); + const pathname = url.pathname; + + self.requestedUrls.push(pathname); + if (self.debugLogs) console.error(`[REGISTRY] ${req.method} ${pathname}`); + + if (pathname.startsWith("/") && !pathname.includes(".tgz")) { + const packageName = decodeURIComponent(pathname.slice(1)); + return self.handleMetadata(packageName); + } + + if (pathname.endsWith(".tgz")) { + const match = pathname.match(/\/(.+)-(\d+\.\d+\.\d+)\.tgz$/); + if (match) { + const [, name, version] = match; + return self.handleTarball(name, version); + } + } + + return new Response("Not found", { status: 404 }); + }, + }); + + this.port = this.server.port!; + return this.port; + } + + stop() { + if (this.server) { + this.server.stop(); + this.server = null; + } + } + + private handleMetadata(packageName: string): Response { + const versions = SimpleRegistry.packages[packageName]; + if (!versions) { + return new Response("Package not found", { status: 404 }); + } + + const metadata = { + name: packageName, + versions: {}, + "dist-tags": { + latest: versions[versions.length - 1], + }, + }; + + for (const version of versions) { + metadata.versions[version] = { + name: packageName, + version: version, + dist: { + tarball: `http://localhost:${this.port}/${packageName}-${version}.tgz`, + }, + dependencies: this.getDependencies(packageName, version), + }; + } + + return new Response(JSON.stringify(metadata), { + headers: { "Content-Type": "application/json" }, + }); + } + + private getDependencies(packageName: string, _version: string) { + if (packageName === "is-even") { + return { "is-odd": "^1.0.0" }; + } + if (packageName === "is-odd") { + return { "is-even": "^1.0.0" }; + } + return {}; + } + + private async handleTarball(name: string, version: string): Promise { + const versions = SimpleRegistry.packages[name]; + + if (!versions || !versions.includes(version)) { + return new Response("Version not found", { status: 404 }); + } + + let tarballPath: string; + if (name === "test-security-scanner") { + tarballPath = join(__dirname, `${name}-${version}-${this.scannerBehavior}.tgz`); + } else { + tarballPath = join(__dirname, `${name}-${version}.tgz`); + } + + try { + const tarballFile = file(tarballPath); + if (!tarballFile.size) { + return new Response("Tarball not found", { status: 404 }); + } + return new Response(tarballFile, { + headers: { + "Content-Type": "application/octet-stream", + }, + }); + } catch (error) { + if (this.debugLogs) console.error(`Failed to serve tarball ${tarballPath}:`, error); + return new Response("Tarball not found", { status: 404 }); + } + } + + getUrl(): string { + return `http://localhost:${this.port}`; + } + + clearRequestLog() { + this.requestedUrls = []; + } + + getRequestedPackages(): string[] { + return this.requestedUrls + .filter(url => !url.includes(".tgz") && url !== "/") + .map(url => decodeURIComponent(url.slice(1))); + } + + getRequestedTarballs(): string[] { + return this.requestedUrls.filter(url => url.endsWith(".tgz")); + } +} + +let registry: SimpleRegistry | null = null; + +export async function startRegistry(debugLogs: boolean): Promise { + registry = new SimpleRegistry(debugLogs); + const port = await registry.start(); + return `http://localhost:${port}`; +} + +export function stopRegistry() { + if (registry) { + registry.stop(); + registry = null; + } +} + +export function getRegistry(): SimpleRegistry | null { + return registry; +} diff --git a/test/cli/install/test-security-scanner-1.0.0-clean.tgz b/test/cli/install/test-security-scanner-1.0.0-clean.tgz new file mode 100644 index 0000000000000000000000000000000000000000..daea934c15e1f3ac24d2865bd3fea5aa0d88f2e6 GIT binary patch literal 692 zcmV;l0!#fLiwFRQ`><#L1MQgIZqqOrhO;4rR*pd&e#+4XTju=OQ9Jb@RFhU|E6`48 z2%*W!%+}F5o#T#HQ}2Uwu7G>v0&u!yg?4M1)O3RSkzB{Wv7Ns5n^?yk8h)Xt%*YRf zkdHA8V{#oUvKS%9bHT<4d$x}WB7kfMJH7!Z$1&Z|jU^RoD74j_TJP%_W34IWe@+VK zI>tPC{QQZrY8VGJgf|U1f|MlBSX04K;X;KZ{r&H{3=R+L>1ER5n+i|Is;rFipM_D| zqMc5QSsf8wGERBOjFnZR_TuHEpFh^(IZRS>7jJ2AkI@q*w)5KuX6oNYWBT_Tj1B1J zFqR3HT>mbDwrsXpIazzpDcVJ3xgN&ECB!aZANH%SgL-AJ`hM5yQ7MIWn_SDmyJ~QF zc6t$PH+q$$gMwFthHA9`VOpc#G+ub z(!X77wHQB@XR5@6EYIB7x#>%SU~#u4V>PCapRV&qKZ41w;8~TVbWj-VJoJ+OQ;ht7 zdZqS&h|l*P_xJx85&ivlF=+q4)J*#S`R@ZW^^g29{S)H2+W#*Cr+B;nw~My6|4Tro z|NKt>+4{GUH}3z5{{FWZu1rqb%q*Fb#d0fVVOKO|e=B_xFgMNgEkM<<#L1MOJRPTMdP4NTKS_q=J3S9vNM1ShdmTEwIbA%O(l)>ab} zLdZ%D&6Xx1aaj@Sf9!owO(p%Zf&iBPEL-s|_R#h7Mv+P9Q~MQ`ST>M7k0wDgXGtF6~C6mOdsezKisH#ARh@f8hje zjfSDev@i;;nNNL(DJ!c=_0{VqzkaU8a~Pz=Bz&OV14f%H+RASon96@0jqo2EgecI> zA(k;LIsZ)rZSJ<&ZZh}SDC=dUnRvT|bRCfbDZ$ar&1m?O$}=wLc!( zjn?Iry;bk-og5c%8S0|Z(dYXb{lW3VL(jvqB4zznp6{5(|D-Uo|C^TJKglzw3`@@c z?E7oyuHR%`?Mn{Zt(XrB<5~0{Hn1i2-$Eeu-%=yv|4;|ce;t_0|1teXN+m4y-y$$c z|6zo;b*cXzJu?31xBE}$zlF%?{*O#k?*EGb>xMzZ!3q4BL+nuBXA$heZ2{n#MX?+B z6;O3`LzI)+3efn*ci^JqJ6u#2Lwe%{w7K4I0sVdg!EzQwK~z-hdv>+DUpueaRnZN+ zfz(|~|8}wFG5?acM2!lWOx)Cg;*Q5-5!30}z~29HFQ7Q7v$ue<#L1MOJRZrU&uO*>6f+4H77Uge2yZR!Lk8B|PSRi##H*#>Cp zR8^G~T*wxj)CnzB#eeL5U$B4M2h4$_Y%t1@2$hPDWE@{#+t&`qK8|)C5a%0dQ6)Pd zglyALJbn30Syz-};=qSGoIrxurfi60h;%7ZT>kNYT~->6TJjjT_%71(F_*QG{e|Oq zG!g_J)dKEcQAU_Um9=%H`s($QUq3g(1x!+68a|TV0VPe!ce2|DX7XQ0WBkX4X)4gm zAeITNIR6U>I+5F<<#_F}QPhh_E8rrs^|!j6Gi^9Jd|#>U9UOk%*Loz1xb`o)mMfnQ zD~)#Rva(a}?VTLwa1rXF(b1Rt8vViX+(WO!sv=?iPL^ZL;(uHiJO2xo;J=w=P$^cN z|LObJ&Ry1|J?(1-$E{co3*&k8A2zTh_1{t;_1{V(<^MDkckUO;|YKkopgp+MSH3%X%DpBf<@ zr!*1FDLT^_>Cmk^SC3v%PeguAI8#UFCJi0#2GMYJ8dQWCd$_EnCO-XS4*kJzZWv9} zTNBTc`5_^Ep7CXlL`rkyB{QkQfNd3RknAHD^-v{Q`|CXi8@4rjI zH2q&NF_!xO@gwDbcBlVr{_6;j>wimr|62}j)mZVWB{dQ%b~~g_m%Gu;c5)L?x76eo lAUt#pX-HT)#EpyTjZy7C^c*B4BqSu}$8W1DtFr(m006+ee6j!l literal 0 HcmV?d00001 diff --git a/test/js/bun/test/jest.d.ts b/test/js/bun/test/jest.d.ts index dde111abb5..3f3d382f38 100644 --- a/test/js/bun/test/jest.d.ts +++ b/test/js/bun/test/jest.d.ts @@ -1 +1,13 @@ -/// +/// + +// Eventually move these to @types/bun somehow +interface ReadableStream { + text(): Promise; + json(): Promise; + blob(): Promise; + bytes(): Promise>; +} + +declare module "bun" { + function jest(path: string): typeof import("bun:test"); +} diff --git a/test/js/web/fetch/utf8-bom.test.ts b/test/js/web/fetch/utf8-bom.test.ts index aa01b447e9..08d5023775 100644 --- a/test/js/web/fetch/utf8-bom.test.ts +++ b/test/js/web/fetch/utf8-bom.test.ts @@ -138,7 +138,7 @@ describe("UTF-8 BOM should be ignored", () => { controller.close(); }, }); - expect(await stream.json()).toEqual({ "hello": "World" } as any); + expect(await stream.json()).toEqual({ "hello": "World" }); }); it("in Bun.readableStreamToFormData()", async () => {