@gjsify/cli 0.4.13 → 0.4.14

package/lib/commands/lint.js

@@ -0,0 +1,60 @@
+// `gjsify lint` — wraps biome's `lint` mode.
+//
+// Sibling of `gjsify format`. Spawns biome from node_modules directly
+// (no Node launcher). Default behaviour: report-only. Pass `--write`
+// for biome's safe-fix mode, or use `gjsify fix` for the combined
+// format + safe-lint-fix + organize-imports surface.
+import { resolve } from 'node:path';
+import { BiomeNotFoundError, findBiomeConfig, printBiomeNotFound, runBiome, } from '../utils/biome-resolve.js';
+export const lintCommand = {
+    command: 'lint [paths..]',
+    description: 'Run Biome lint diagnostics (native binary spawn — no Node launcher).',
+    builder: (yargs) => {
+        return yargs
+            .positional('paths', {
+            description: 'Files or directories to lint. Default: `.`',
+            type: 'string',
+            array: true,
+        })
+            .option('write', {
+            description: 'Apply safe lint fixes in place.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('config-path', {
+            description: 'Path to a biome.json. Default: walks up from cwd to find one.',
+            type: 'string',
+            normalize: true,
+        })
+            .option('verbose', {
+            description: 'Echo the resolved biome binary + args before spawning.',
+            type: 'boolean',
+            default: false,
+        });
+    },
+    handler: async (args) => {
+        const cwd = process.cwd();
+        const paths = args.paths?.length
+            ? args.paths
+            : ['.'];
+        const biomeArgs = ['lint'];
+        if (args.write)
+            biomeArgs.push('--write');
+        const configPath = args.configPath ?? findBiomeConfig(cwd) ?? undefined;
+        if (configPath)
+            biomeArgs.push(`--config-path=${resolve(configPath, '..')}`);
+        biomeArgs.push(...paths);
+        try {
+            const code = await runBiome(biomeArgs, { cwd, verbose: args.verbose });
+            process.exitCode = code;
+        }
+        catch (err) {
+            if (err instanceof BiomeNotFoundError) {
+                printBiomeNotFound(err);
+                process.exitCode = 1;
+                return;
+            }
+            throw err;
+        }
+    },
+};

package/lib/commands/test.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from '../types/index.js';
+type Runtime = 'gjs' | 'node';
+interface TestOptions {
+    runtime?: Runtime | 'all';
+    entry?: string;
+    outdir?: string;
+    rebuild?: boolean;
+    build?: boolean;
+    verbose?: boolean;
+}
+export declare const testCommand: Command<unknown, TestOptions>;
+export {};

package/lib/commands/test.js

@@ -0,0 +1,206 @@
+// `gjsify test` — build + run + aggregate per-runtime test suite.
+//
+// Eliminates the `build:test:{gjs,node}` + `test:{gjs,node}` + `test`
+// script boilerplate that ~110 workspace packages repeat. Each package
+// just needs `src/test.mts` aggregating its `@gjsify/unit` suites; this
+// command builds it for GJS + Node and runs each output, aggregating
+// exit codes.
+import { existsSync, statSync, readdirSync } from 'node:fs';
+import { join, dirname, resolve, relative } from 'node:path';
+import { spawn } from 'node:child_process';
+import { Config } from '../config.js';
+import { BuildAction } from '../actions/build.js';
+import { runGjsBundle } from '../utils/run-gjs.js';
+export const testCommand = {
+    command: 'test',
+    description: 'Build + run the package’s `src/test.mts` suite on GJS and Node and aggregate the results. Replaces the per-package `build:test:{gjs,node}` + `test:{gjs,node}` script boilerplate.',
+    builder: (yargs) => {
+        return yargs
+            .option('runtime', {
+            description: 'Target runtime. Default: both.',
+            type: 'string',
+            choices: ['gjs', 'node', 'all'],
+            default: 'all',
+        })
+            .option('entry', {
+            description: 'Path to the test entry. Default: `src/test.mts` (or `gjsify.test.entry`).',
+            type: 'string',
+            normalize: true,
+        })
+            .option('outdir', {
+            description: 'Output directory for the built test bundles. Default: `dist/`.',
+            type: 'string',
+            normalize: true,
+        })
+            .option('rebuild', {
+            description: 'Always rebuild the test bundles, even when they look up-to-date.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('build', {
+            description: 'Build before running. Default: true (use --no-build to skip when bundles already exist).',
+            type: 'boolean',
+            default: true,
+        })
+            .option('verbose', {
+            description: 'Print resolved entry/outdir + per-step timing.',
+            type: 'boolean',
+            default: false,
+        });
+    },
+    handler: async (args) => {
+        const cwd = process.cwd();
+        // Resolve config: gjsify.test.{entry,outdir,runtimes}.
+        const cfg = new Config();
+        const configData = await cfg.forBuild({}).catch(() => ({}));
+        const testCfg = configData.test ?? {};
+        const entry = resolve(cwd, args.entry ?? testCfg.entry ?? 'src/test.mts');
+        const outdir = resolve(cwd, args.outdir ?? testCfg.outdir ?? 'dist');
+        if (!existsSync(entry)) {
+            console.error(`[gjsify test] no test entry at ${relative(cwd, entry)} — ` +
+                `add an \`src/test.mts\` that aggregates your \`@gjsify/unit\` suites, ` +
+                `or set \`gjsify.test.entry\` in package.json.`);
+            process.exit(1);
+        }
+        const requested = args.runtime === 'gjs'
+            ? ['gjs']
+            : args.runtime === 'node'
+                ? ['node']
+                : (testCfg.runtimes && testCfg.runtimes.length > 0 ? testCfg.runtimes : ['gjs', 'node']);
+        const results = [];
+        for (const runtime of requested) {
+            const outfile = join(outdir, `test.${runtime}.mjs`);
+            // Build stage (skip if --no-build OR (not --rebuild AND outfile fresher than src)).
+            if (args.build !== false) {
+                const needsBuild = args.rebuild || !isFresh(outfile, entry, cwd);
+                if (needsBuild) {
+                    const buildStart = Date.now();
+                    if (args.verbose) {
+                        console.log(`[gjsify test] building → ${relative(cwd, outfile)} (—app ${runtime})`);
+                    }
+                    try {
+                        await buildTestBundle(entry, outfile, runtime, args.verbose);
+                        if (args.verbose) {
+                            console.log(`[gjsify test] built ${runtime} in ${Date.now() - buildStart}ms`);
+                        }
+                    }
+                    catch (err) {
+                        console.error(`[gjsify test] build failed for ${runtime}:`, err.message);
+                        results.push({ runtime, ok: false, durationMs: 0, error: 'build failed' });
+                        continue;
+                    }
+                }
+                else if (args.verbose) {
+                    console.log(`[gjsify test] ${runtime}: bundle is up-to-date — skipping build (use --rebuild to force)`);
+                }
+            }
+            else if (!existsSync(outfile)) {
+                console.error(`[gjsify test] --no-build but ${relative(cwd, outfile)} doesn't exist. ` +
+                    `Build first or drop --no-build.`);
+                results.push({ runtime, ok: false, durationMs: 0, error: 'no bundle' });
+                continue;
+            }
+            // Run stage.
+            const runStart = Date.now();
+            try {
+                await runTestBundle(outfile, runtime);
+                results.push({ runtime, ok: true, durationMs: Date.now() - runStart });
+            }
+            catch (err) {
+                results.push({
+                    runtime,
+                    ok: false,
+                    durationMs: Date.now() - runStart,
+                    error: err.message,
+                });
+            }
+        }
+        // Summary + aggregate exit.
+        const summary = results
+            .map((r) => `${r.ok ? '✅' : '❌'} ${r.runtime} (${r.durationMs}ms)${r.error ? ` — ${r.error}` : ''}`)
+            .join('  ');
+        console.log(`[gjsify test] ${summary}`);
+        const anyFailed = results.some((r) => !r.ok);
+        if (anyFailed) {
+            process.exit(1);
+        }
+    },
+};
+/** Build a single test bundle in-process via `BuildAction`. */
+async function buildTestBundle(entry, outfile, runtime, verbose) {
+    const config = new Config();
+    // forBuild's interactive prompts are skipped because we pass through
+    // ArgumentsCamelCase shape with only the relevant fields.
+    const configData = await config.forBuild({
+        entryPoints: [entry],
+        outfile,
+        app: runtime,
+        verbose: verbose ?? false,
+        logLevel: 'warning',
+        exclude: [],
+    });
+    // Override bundler entry-input so gjsify.test.entry doesn't fight with
+    // gjsify.bundler.input. The build action picks `output.file` straight from
+    // the merged config; we set it explicitly here so package.json#main /
+    // bundler.output.file from the surrounding project don't redirect the
+    // bundle elsewhere.
+    configData.library = { ...(configData.library ?? {}) };
+    configData.bundler = {
+        ...(configData.bundler ?? {}),
+        input: [entry],
+        output: { ...(configData.bundler?.output ?? {}), file: outfile },
+    };
+    const action = new BuildAction(configData);
+    await action.start({ app: runtime, library: false });
+}
+/** Run a single test bundle and reject on non-zero exit. */
+async function runTestBundle(outfile, runtime) {
+    if (runtime === 'gjs') {
+        await runGjsBundle(outfile);
+        return;
+    }
+    await new Promise((resolvePromise, reject) => {
+        const child = spawn('node', [outfile], { stdio: 'inherit' });
+        child.on('error', reject);
+        child.on('exit', (code) => {
+            if (code === 0)
+                resolvePromise();
+            else
+                reject(new Error(`node exited with code ${code}`));
+        });
+    });
+}
+/** True when `outfile` exists and is newer than every `.ts`/`.mts` file under the entry's directory tree. */
+function isFresh(outfile, entry, cwd) {
+    if (!existsSync(outfile))
+        return false;
+    const outMtime = statSync(outfile).mtimeMs;
+    const srcRoot = dirname(entry);
+    // Conservative: walk the src tree once. If the package has no `src/`,
+    // fall back to entry-only check.
+    try {
+        const newest = newestMtimeUnder(existsSync(srcRoot) ? srcRoot : entry);
+        return outMtime >= newest;
+    }
+    catch {
+        // On any FS error, force rebuild to stay safe.
+        return false;
+    }
+    void cwd;
+}
+function newestMtimeUnder(path) {
+    const st = statSync(path);
+    if (st.isFile())
+        return st.mtimeMs;
+    let max = st.mtimeMs;
+    for (const entry of readdirSync(path, { withFileTypes: true })) {
+        if (entry.name === 'node_modules' || entry.name === 'dist' || entry.name === 'lib' || entry.name.startsWith('.')) {
+            continue;
+        }
+        const child = join(path, entry.name);
+        const m = newestMtimeUnder(child);
+        if (m > max)
+            max = m;
+    }
+    return max;
+}

package/lib/commands/upgrade.d.ts

@@ -0,0 +1,13 @@
+import type { Command } from "../types/index.js";
+interface UpgradeOptions {
+    latest?: boolean;
+    minor?: boolean;
+    patch?: boolean;
+    filter?: string;
+    dryRun?: boolean;
+    cwd?: string;
+    verbose?: boolean;
+    yes?: boolean;
+}
+export declare const upgradeCommand: Command<unknown, UpgradeOptions>;
+export {};

package/lib/commands/upgrade.js

@@ -0,0 +1,402 @@
+// `gjsify upgrade` — drop-in replacement for `yarn upgrade-interactive`
+// and `npx npm-check-updates`. Two modes:
+//
+//   1. Interactive (default): show outdated packages, prompt user to
+//      select which ones to update (space-separated indices or `a` for
+//      all), then write the new ranges to `package.json`.
+//
+//   2. Non-interactive (`--latest` / `--minor` / `--patch` / `--filter`):
+//      bump matching packages automatically without prompting.
+//
+// Workspace-aware: `workspace:^` / `workspace:~` / `workspace:*` ranges
+// are skipped — those are the gjsify monorepo internal links and `gjsify
+// install` resolves them locally. Only external npm specs get checked
+// against the registry.
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { createInterface } from "node:readline/promises";
+import { parse } from "@gjsify/semver";
+import { DEFAULT_REGISTRY, fetchPackument, parseNpmrc, } from "@gjsify/npm-registry";
+export const upgradeCommand = {
+    command: "upgrade",
+    description: "Check the npm registry for newer versions of declared dependencies and update package.json. Interactive by default; `--latest` / `--minor` / `--patch` switch to non-interactive bulk-update mode.",
+    builder: (yargs) => {
+        return yargs
+            .option("latest", {
+            description: "Non-interactive: bump every dependency to its latest version (allows major).",
+            type: "boolean",
+            default: false,
+        })
+            .option("minor", {
+            description: "Non-interactive: bump every dependency to the latest within the same major (semver-minor + semver-patch).",
+            type: "boolean",
+            default: false,
+        })
+            .option("patch", {
+            description: "Non-interactive: bump every dependency to the latest within the same minor (semver-patch only).",
+            type: "boolean",
+            default: false,
+        })
+            .option("filter", {
+            description: "Only consider packages whose name matches this substring (case-insensitive). Repeatable; comma-separated values are split.",
+            type: "string",
+        })
+            .option("dry-run", {
+            description: "Print the upgrade plan without writing package.json.",
+            type: "boolean",
+            default: false,
+        })
+            .option("cwd", {
+            description: "Project directory. Default: process.cwd().",
+            type: "string",
+        })
+            .option("yes", {
+            alias: "y",
+            description: "Interactive mode: select all without prompting.",
+            type: "boolean",
+            default: false,
+        })
+            .option("verbose", {
+            description: "Print extra resolution details.",
+            type: "boolean",
+            default: false,
+        });
+    },
+    handler: async (args) => {
+        const cwd = resolve(args.cwd ?? process.cwd());
+        const pkgJsonPath = join(cwd, "package.json");
+        if (!existsSync(pkgJsonPath)) {
+            throw new Error(`[gjsify upgrade] no package.json at ${pkgJsonPath}`);
+        }
+        const rawPkg = readFileSync(pkgJsonPath, "utf-8");
+        const pkg = JSON.parse(rawPkg);
+        const filters = args.filter
+            ? args.filter
+                .split(",")
+                .map((s) => s.trim().toLowerCase())
+                .filter(Boolean)
+            : [];
+        const entries = collectExternalDeps(pkg, filters);
+        if (entries.length === 0) {
+            console.log("[gjsify upgrade] no external npm dependencies to check.");
+            return;
+        }
+        const npmrc = await loadNpmrcLight(cwd);
+        const mode = args.latest
+            ? "latest"
+            : args.minor
+                ? "minor"
+                : args.patch
+                    ? "patch"
+                    : "interactive";
+        console.log(`[gjsify upgrade] checking ${entries.length} dependencies against ${npmrc.registry}…`);
+        const candidates = await resolveCandidates(entries, npmrc, args.verbose ?? false, mode);
+        if (candidates.length === 0) {
+            console.log("✅ all dependencies are up to date");
+            return;
+        }
+        printTable(candidates);
+        let selected;
+        if (mode === "interactive" && !args.yes) {
+            selected = await promptSelection(candidates);
+        }
+        else if (args.yes && mode === "interactive") {
+            console.log("[gjsify upgrade] -y / --yes: selecting all");
+            selected = candidates;
+        }
+        else {
+            selected = candidates;
+        }
+        if (selected.length === 0) {
+            console.log("[gjsify upgrade] nothing selected; package.json unchanged.");
+            return;
+        }
+        if (args.dryRun) {
+            console.log(`[gjsify upgrade] --dry-run: would update ${selected.length} dependencies (no write).`);
+            return;
+        }
+        writePackageJson(pkgJsonPath, rawPkg, pkg, selected);
+        console.log(`✏️  updated ${selected.length} dependencies in ${pkgJsonPath}. Run \`gjsify install\` to apply.`);
+    },
+};
+// ─── Resolution ─────────────────────────────────────────────────────────
+const DEP_FIELDS = [
+    "dependencies",
+    "devDependencies",
+    "optionalDependencies",
+    "peerDependencies",
+];
+function collectExternalDeps(pkg, filters) {
+    const out = [];
+    for (const field of DEP_FIELDS) {
+        const map = pkg[field];
+        if (!map || typeof map !== "object")
+            continue;
+        for (const [name, raw] of Object.entries(map)) {
+            if (typeof raw !== "string")
+                continue;
+            if (filters.length && !filters.some((f) => name.toLowerCase().includes(f))) {
+                continue;
+            }
+            // Skip workspace-protocol + file: + link: + git: + http(s): specs.
+            if (raw.startsWith("workspace:") ||
+                raw.startsWith("file:") ||
+                raw.startsWith("link:") ||
+                raw.startsWith("git+") ||
+                raw.startsWith("git:") ||
+                raw.startsWith("http") ||
+                raw.startsWith("npm:") || // e.g. `foo: npm:@scope/foo@^1`
+                raw === "*" ||
+                raw === "latest") {
+                continue;
+            }
+            const { prefix, version } = splitRange(raw);
+            out.push({
+                name,
+                field,
+                currentRange: raw,
+                currentVersion: version,
+                prefix,
+            });
+        }
+    }
+    return out;
+}
+/**
+ * Split `^1.2.3` → { prefix: "^", version: "1.2.3" }. Honors `~`, `>=`,
+ * `>`, `<=`, `<`, `=`. Defaults to "" prefix when the range is just a
+ * literal version.
+ */
+function splitRange(range) {
+    const m = range.match(/^(\^|~|>=|<=|>|<|=)?\s*([0-9].*)$/);
+    if (!m)
+        return { prefix: "", version: null };
+    const prefix = m[1] ?? "";
+    const version = m[2]?.split(/\s|[|&,]/)[0] ?? null; // strip range modifiers (`||`, ` - `, etc.)
+    const parsed = version ? parse(version) : null;
+    return { prefix, version: parsed?.version ?? null };
+}
+async function resolveCandidates(entries, npmrc, verbose, mode) {
+    const results = [];
+    // Parallel fetch with a small concurrency cap.
+    const cap = 8;
+    let cursor = 0;
+    async function worker() {
+        for (;;) {
+            const i = cursor++;
+            if (i >= entries.length)
+                return;
+            const entry = entries[i];
+            try {
+                const packument = await fetchPackument(entry.name, { npmrc });
+                const latest = packument["dist-tags"]?.latest;
+                if (!latest) {
+                    if (verbose)
+                        console.warn(`  ${entry.name}: no dist-tags.latest, skipping`);
+                    continue;
+                }
+                if (!entry.currentVersion) {
+                    if (verbose)
+                        console.warn(`  ${entry.name}: unable to parse current range "${entry.currentRange}"`);
+                    continue;
+                }
+                const diff = classifyDiff(entry.currentVersion, latest);
+                if (diff === "none")
+                    continue;
+                if (mode === "minor" && diff === "major")
+                    continue;
+                if (mode === "patch" && (diff === "major" || diff === "minor"))
+                    continue;
+                results.push({
+                    ...entry,
+                    latestVersion: latest,
+                    diff,
+                });
+            }
+            catch (err) {
+                if (verbose)
+                    console.warn(`  ${entry.name}: fetch failed (${err.message})`);
+            }
+        }
+        void packumentToString;
+    }
+    await Promise.all(Array.from({ length: cap }, () => worker()));
+    results.sort((a, b) => a.name.localeCompare(b.name));
+    return results;
+}
+function classifyDiff(current, latest) {
+    const c = parse(current);
+    const l = parse(latest);
+    if (!c || !l)
+        return "none";
+    if (c.major !== l.major)
+        return l.major > c.major ? "major" : "none";
+    if (c.minor !== l.minor)
+        return l.minor > c.minor ? "minor" : "none";
+    if (c.patch !== l.patch)
+        return l.patch > c.patch ? "patch" : "none";
+    if ((c.prerelease ?? []).join(".") !== (l.prerelease ?? []).join("."))
+        return "prerelease";
+    return "none";
+}
+// ─── Output / Interaction ──────────────────────────────────────────────
+const ANSI = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    red: "\x1b[31m",
+    yellow: "\x1b[33m",
+    green: "\x1b[32m",
+    cyan: "\x1b[36m",
+};
+function colorForDiff(diff) {
+    switch (diff) {
+        case "major":
+            return ANSI.red;
+        case "minor":
+            return ANSI.yellow;
+        case "patch":
+            return ANSI.green;
+        case "prerelease":
+            return ANSI.cyan;
+        default:
+            return "";
+    }
+}
+function printTable(candidates) {
+    const nameW = Math.max(...candidates.map((c) => c.name.length), 4);
+    const curW = Math.max(...candidates.map((c) => c.currentRange.length), 7);
+    const newW = Math.max(...candidates.map((c) => c.latestVersion.length), 6);
+    const idxW = String(candidates.length).length + 2;
+    const head = " ".repeat(idxW) +
+        ANSI.bold +
+        "name".padEnd(nameW) +
+        "  " +
+        "current".padEnd(curW) +
+        "  " +
+        "latest".padEnd(newW) +
+        "  " +
+        "kind" +
+        ANSI.reset;
+    console.log(head);
+    console.log(" ".repeat(idxW) + ANSI.dim + "─".repeat(nameW + curW + newW + 12) + ANSI.reset);
+    for (let i = 0; i < candidates.length; i++) {
+        const c = candidates[i];
+        const idx = `${i + 1}.`.padEnd(idxW);
+        const color = colorForDiff(c.diff);
+        console.log(idx +
+            c.name.padEnd(nameW) +
+            "  " +
+            ANSI.dim +
+            c.currentRange.padEnd(curW) +
+            ANSI.reset +
+            "  " +
+            color +
+            c.latestVersion.padEnd(newW) +
+            ANSI.reset +
+            "  " +
+            color +
+            c.diff +
+            ANSI.reset);
+    }
+}
+async function promptSelection(candidates) {
+    if (!process.stdin.isTTY) {
+        console.log("[gjsify upgrade] non-TTY stdin: pass --latest / --minor / --patch (or --yes for interactive-all) to upgrade non-interactively.");
+        return [];
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        console.log("\nSelect upgrades: comma- or space-separated indices, " +
+            ANSI.bold +
+            "a" +
+            ANSI.reset +
+            " for all, ranges like " +
+            ANSI.bold +
+            "1-3" +
+            ANSI.reset +
+            ", or " +
+            ANSI.bold +
+            "ENTER" +
+            ANSI.reset +
+            " to skip:");
+        const answer = (await rl.question("> ")).trim();
+        if (!answer)
+            return [];
+        if (answer.toLowerCase() === "a" || answer.toLowerCase() === "all")
+            return candidates;
+        const picked = new Set();
+        for (const token of answer.split(/[\s,]+/).filter(Boolean)) {
+            const range = token.match(/^(\d+)-(\d+)$/);
+            if (range) {
+                const a = Number(range[1]);
+                const b = Number(range[2]);
+                for (let i = Math.min(a, b); i <= Math.max(a, b); i++)
+                    picked.add(i - 1);
+            }
+            else if (/^\d+$/.test(token)) {
+                picked.add(Number(token) - 1);
+            }
+        }
+        return [...picked]
+            .filter((i) => i >= 0 && i < candidates.length)
+            .map((i) => candidates[i]);
+    }
+    finally {
+        rl.close();
+    }
+}
+// ─── Write-back ────────────────────────────────────────────────────────
+function writePackageJson(path, rawText, parsed, selected) {
+    // Mutate the parsed object then re-stringify with the original indent.
+    for (const c of selected) {
+        const map = parsed[c.field];
+        if (!map)
+            continue;
+        map[c.name] = c.prefix + c.latestVersion;
+    }
+    const indent = detectIndent(rawText);
+    writeFileSync(path, JSON.stringify(parsed, null, indent) + (rawText.endsWith("\n") ? "\n" : ""), "utf-8");
+}
+function detectIndent(json) {
+    const m = json.match(/^\{\n( +)/);
+    if (m)
+        return m[1].length;
+    return 2;
+}
+// ─── npmrc loader (lightweight, shared shape with install-backend) ─────
+async function loadNpmrcLight(cwd) {
+    let parsed = {
+        registry: DEFAULT_REGISTRY,
+        scopes: {},
+        authTokens: {},
+        basicAuth: {},
+    };
+    // Layered .npmrc lookup (most-specific wins): home → cwd. Same precedence
+    // as install-backend-native, except env-var `npm_config_registry` wins
+    // over file values (matches npm's real semantics, lets the test harness
+    // point at a mock registry without touching `~/.npmrc`).
+    for (const candidate of [join(homedir(), ".npmrc"), join(cwd, ".npmrc")]) {
+        if (!existsSync(candidate))
+            continue;
+        try {
+            const proj = parseNpmrc(readFileSync(candidate, "utf-8"));
+            parsed = {
+                ...parsed,
+                ...proj,
+                scopes: { ...parsed.scopes, ...proj.scopes },
+            };
+        }
+        catch {
+            // ignore malformed .npmrc — same lenient policy as install-backend
+        }
+    }
+    if (process.env.npm_config_registry) {
+        parsed.registry = process.env.npm_config_registry;
+    }
+    return parsed;
+}
+function packumentToString(p) {
+    return `${p.name}@${p["dist-tags"]?.latest ?? "?"}`;
+}