@_linked/cli 1.46.2 → 1.47.0

package/lib/esm/localize/prune.js

@@ -1,703 +0,0 @@
-/**
- * Pruning -- stop a checkout's own `node_modules` holding a second copy of
- * something the app already provides. On by default after every install in a
- * checkout and on every `--relink`; `--no-prune` (`{prune: false}`) skips it.
- *
- * `shouldPrune(opts)` is the one place that default lives.
- *
- * Why it is needed. `npm install` inside a checkout (localize.ts, step 3)
- * installs what the CHECKOUT's lockfile says: its own copy of every
- * dependency, often older than the app's. Node resolves a module from the
- * importer's REAL path and takes the first `node_modules` it meets going up,
- * so a localized `A` that imports `B` gets `A/node_modules/B` -- a registry
- * copy -- and never the localized `B`; and a framework package that holds a
- * registry of classes (or React) loads once per copy. Measured with three
- * localized `@_linked/*` packages: plain Node and `tsx` loaded three copies of
- * the same core.
- *
- * What it does. For every localized checkout, each package at the top of its
- * `node_modules` that is a CANDIDATE in that checkout (below) is removed when
- * the app provides it -- `<appRoot>/node_modules/<name>` exists -- at a
- * version that satisfies every range that resolves to that copy: the
- * checkout's own declaration and that of every installed package that would
- * load it. Node's upward search then finds the app's copy instead. Nothing
- * else in the checkout moves.
- *
- * The candidates start from `providedPackages` (provided.ts) -- the one rule
- * the run-time check and Vite's dedupe use too -- and are taken PER CHECKOUT:
- *
- * - a **localized sibling** -- always counts as provided, whatever the range,
- *   because the live checkout is the point of localizing it. A range it does
- *   not satisfy is said out loud, never acted on;
- * - one of **this checkout's own runtime dependencies** (`dependencies`,
- *   `peerDependencies`, `optionalDependencies`) that the rule provides -- the
- *   app has it at a version satisfying every localized checkout's range;
- * - `react` and `react-dom`.
- *
- * Nothing else is touched -- this checkout's devDependency stays even when
- * another checkout depends on the same package at runtime, so the checkout's
- * tooling does not come to depend on the app's. A runtime dependency the rule
- * leaves out because a localized range misses the app's version is kept and
- * reported, like any other copy kept below.
- *
- * Never removed, candidate or not:
- *
- * - a copy whose ranges the app's version does not satisfy;
- * - a copy whose own dependencies would resolve to something else from the
- *   app's copy than they do from the checkout (`contextChange` below): the
- *   checkout keeps its own copies of whatever failed the guard, and removing
- *   the copy would mix the two -- measured as a checkout's `tsc` seeing two
- *   React type sets;
- * - a copy that ships its own types while the checkout also holds an
- *   `@types/` stub for it (`staleTypes` below): TypeScript would take the stub
- *   once the copy is gone;
- * - anything in a checkout that is not under the app root, because then the
- *   upward search never reaches the app's `node_modules` and the removed
- *   package would simply be missing;
- * - anything in a checkout recorded with `prune: false` (localized with
- *   `--no-prune`).
- *
- * Kept copies are reported once per checkout, as a summary; `--list` gives
- * each one's reason. A removal can make another copy removable, so a prune
- * repeats until a pass removes nothing.
- *
- * A package with a `bin` is NOT exempt. Measured in a checkout under an app
- * root with its own `@_linked/cli` removed: `npx linked build`,
- * `npm exec linked -- --help`, a script running `npm exec linked` and a script
- * running a bare `linked` all resolved `linked` to the app root's copy,
- * because npm puts every ancestor's `node_modules/.bin` on the PATH. The
- * removed package's links in the checkout's `node_modules/.bin` are removed
- * with it, so nothing dangles.
- *
- * It never runs npm and never touches the checkout's `package.json` or
- * `package-lock.json`. `npm install` in the checkout puts the copies back;
- * `ensure` (ensure.ts) is the install-then-prune step every in-checkout
- * install goes through, and the run-time check (`checkOneCopy`) takes them out
- * again before `linked start` and friends.
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import { isInside, isSymlink, readJson } from './fsops.js';
-import semver from 'semver';
-import { providedPackages } from './provided.js';
-/** The rule (`providedPackages`, provided.ts) over `entries`, plus every entry (sibling). */
-export function candidatesFor(entries, deps) {
-    const rule = providedPackages(deps.appRoot, Object.keys(entries));
-    return {
-        names: new Set([...rule.names, ...Object.keys(entries)]),
-        skipped: new Map(rule.skipped.map((s) => [s.name, s])),
-    };
-}
-/**
- * Does the app's installed `version` satisfy `range`? `null` means "cannot
- * tell" -- a dist-tag, `file:`, `npm:`, `workspace:`, a git URL, or a version
- * that is not one -- and every caller then keeps the copy. The failure mode is
- * therefore always the safe one: a copy kept that could have gone, never a
- * copy removed that was needed.
- *
- * npm's own `semver` decides, so prereleases follow npm's rule: `1.3.0-beta.1`
- * satisfies a range only when one of its comparators names a prerelease on
- * the same `major.minor.patch`.
- */
-export function satisfies(version, range) {
-    if (typeof version !== 'string' || typeof range !== 'string')
-        return null;
-    if (semver.valid(version) === null)
-        return null;
-    if (semver.validRange(range) === null)
-        return null;
-    return semver.satisfies(version, range);
-}
-/** Pruning is on unless a caller says `{prune: false}`. */
-export function shouldPrune(opts = {}) {
-    return opts.prune !== false;
-}
-/** Is pruning on for this recorded checkout? `--no-prune` at localize/adopt records `prune: false`. */
-export function prunesEntry(entry) {
-    return entry.prune !== false;
-}
-const REQUIRE_FIELDS = [
-    'dependencies',
-    'peerDependencies',
-    'optionalDependencies',
-];
-const DECLARE_FIELDS = [
-    'dependencies',
-    'devDependencies',
-    'peerDependencies',
-    'optionalDependencies',
-];
-/** Candidates in every checkout, declared or not: a second React breaks hooks whoever loads it. */
-const ALWAYS_CANDIDATES = new Set(['react', 'react-dom']);
-/** prune repeats until a pass removes nothing, at most this many passes. */
-export const MAX_PRUNE_PASSES = 5;
-export function newPruneCache() {
-    return { indexes: new Map(), builds: 0 };
-}
-/**
- * Decide, for every recorded checkout and every candidate copy in its
- * `node_modules`, whether pruning removes it -- without removing anything.
- * `pruneProvided` applies it; the run-time check (`checkOneCopy`) and
- * `--list` call it on its own, which is why it has to be cheap: a copy whose
- * checkout's own range rules it out is decided from that `package.json`
- * alone, and every other range comes from one requirement index per
- * `node_modules`, built at most once per call.
- *
- * Candidates are PER OWNER: a copy is a candidate in checkout O when the rule
- * provides it AND it is a localized sibling, `react`/`react-dom`, or one of
- * O's own runtime dependencies (`dependencies`, `peerDependencies`,
- * `optionalDependencies`). O's devDependencies are O's tooling, whatever
- * another checkout declares at runtime.
- */
-export function planPrune(entries, deps, scope = {}, cache = newPruneCache(), candidates = candidatesFor(entries, deps)) {
-    var _a;
-    const plan = { remove: [], keep: [], outside: [] };
-    const appRoot = realOrSelf(deps.appRoot);
-    const only = scope.deps ? new Set(scope.deps) : null;
-    for (const [name, entry] of Object.entries(entries)) {
-        if (scope.owners && !scope.owners.includes(name))
-            continue;
-        if (!prunesEntry(entry))
-            continue;
-        const pkgDir = path.join(deps.appRoot, entry.path);
-        if (!fs.existsSync(path.join(pkgDir, 'package.json')))
-            continue;
-        if (!isInside(realOrSelf(pkgDir), appRoot)) {
-            plan.outside.push({ name, path: entry.path });
-            continue;
-        }
-        const pkg = (_a = readJson(path.join(pkgDir, 'package.json'))) !== null && _a !== void 0 ? _a : {};
-        const runtime = new Set(REQUIRE_FIELDS.flatMap((f) => { var _a; return Object.keys((_a = pkg[f]) !== null && _a !== void 0 ? _a : {}); }));
-        // The names that can be a decision here, looked up directly rather than
-        // by listing node_modules (thousands of entries per checkout): this
-        // checkout's candidates, and what the rule skipped that it declares.
-        const names = new Set();
-        for (const n of candidates.names) {
-            if (entries[n] || ALWAYS_CANDIDATES.has(n) || runtime.has(n))
-                names.add(n);
-        }
-        for (const n of candidates.skipped.keys()) {
-            if (declared(pkg, DECLARE_FIELDS, n) !== undefined)
-                names.add(n);
-        }
-        names.delete(name);
-        const ctx = { name, entry, pkg, names, entries, candidates, only, deps };
-        for (const nm of nodeModulesRoots(pkgDir, entry)) {
-            for (const d of decideIn(nm, ctx, cache)) {
-                (d.action === 'remove' ? plan.remove : plan.keep).push(d);
-            }
-        }
-    }
-    return plan;
-}
-/**
- * @param entries  the localized packages: every one counts as a sibling
- * @param opts  unused beyond `prune`, which callers check with `shouldPrune`
- * @param deps  `{appRoot, log, warn}`
- * @param scope  prune only some checkouts / names (the run-time check)
- *
- * A removal can make another copy removable -- the copy that went was the one
- * asking a range the app misses, or the one a sibling copy's dependency
- * resolved to -- so it plans and removes again until a pass removes nothing
- * (at most `MAX_PRUNE_PASSES`): one call converges. A checkout recorded with
- * `prune: false` is never touched.
- */
-export function pruneProvided(entries, opts, deps, scope = {}, cache = newPruneCache()) {
-    const removed = [];
-    let kept = [];
-    const candidates = candidatesFor(entries, deps);
-    for (let pass = 0; pass < MAX_PRUNE_PASSES; pass++) {
-        const passScope = pass === 0 ? scope : { owners: scope.owners };
-        const plan = planPrune(entries, deps, passScope, cache, candidates);
-        if (pass === 0) {
-            for (const o of plan.outside) {
-                deps.log(`[localize] ${o.name}: ${o.path} is outside the app root, so Node cannot reach the app's ` +
-                    `node_modules from it — its own dependencies are left as they are.`);
-            }
-        }
-        for (const d of plan.remove) {
-            fs.rmSync(d.dir, { recursive: true, force: true });
-            removeEmptyScope(d.nm, d.dep);
-            removeBinLinksInto(d.nm, d.dir);
-            removed.push(d);
-        }
-        kept = plan.keep;
-        if (!plan.remove.length)
-            break;
-    }
-    report(removed, kept, deps);
-    return { removed, kept };
-}
-/**
- * Is `dep` -- declared by a checkout at `range` -- something the app provides,
- * so that its absence from the checkout's own `node_modules` is not a
- * dependency gone missing? `--relink` asks this before reinstalling a
- * checkout, so a copy pruned on purpose does not trigger a reinstall on every
- * postinstall. `pkg` is the checkout's `package.json`: only what would be a
- * candidate in THAT checkout counts. With `checkout`, a copy the prune would
- * keep for a stub `@types/` package there (`staleTypes`) is not provided: its
- * absence is a dependency gone missing, and the reinstall puts it back.
- */
-export function isProvidedByApp(dep, range, entries, candidates, deps, pkg, checkout) {
-    const app = appCopy(dep, deps);
-    if (!app)
-        return false;
-    if (entries[dep])
-        return true;
-    if (!candidates.names.has(dep))
-        return false;
-    if (pkg &&
-        !ALWAYS_CANDIDATES.has(dep) &&
-        declared(pkg, REQUIRE_FIELDS, dep) === undefined)
-        return false;
-    if (range !== undefined && satisfies(app.version, range) !== true)
-        return false;
-    // Pruned or not, a copy the prune would keep because of a stub `@types/`
-    // package is one the checkout needs: absent, it is missing. The app's copy
-    // stands in for the one that is gone.
-    if (checkout &&
-        shipsOwnTypes(app.real, readJson(path.join(app.real, 'package.json'))) &&
-        staleTypes(path.join(checkout.dir, 'node_modules'), dep, null))
-        return false;
-    return true;
-}
-function decideIn(nm, ctx, cache) {
-    const out = [];
-    const { name: owner, entry, pkg, names, entries, candidates, only, deps } = ctx;
-    for (const dep of [...names].sort()) {
-        if (only && !only.has(dep))
-            continue;
-        const skip = candidates.skipped.get(dep);
-        const inRule = candidates.names.has(dep);
-        const sibling = Boolean(entries[dep]);
-        const dir = path.join(nm, dep);
-        const nested = readJson(path.join(dir, 'package.json'));
-        if (!nested)
-            continue;
-        const app = appCopy(dep, deps);
-        if (!app)
-            continue; // the app does not provide it, so this copy is the only one
-        if (realOrSelf(dir) === app.real)
-            continue; // already the app's copy
-        const base = {
-            ownerName: owner,
-            owner: entry.path,
-            dep,
-            dir,
-            where: path.relative(deps.appRoot, dir),
-            nm,
-            version: nested.version,
-            app: app.version,
-            sibling,
-        };
-        if (!inRule) {
-            // The rule leaves it out: a localized checkout asks a range the app
-            // misses. Said for a checkout that declares it; a copy it only has
-            // transitively is none of its business.
-            if (declared(pkg, DECLARE_FIELDS, dep) === undefined)
-                continue;
-            out.push(Object.assign(Object.assign({}, base), { action: 'keep', reason: 'range', unmet: skip.asks }));
-            continue;
-        }
-        const own = declared(pkg, DECLARE_FIELDS, dep);
-        const ownAsk = own === undefined ? [] : [{ from: owner, range: own }];
-        if (sibling) {
-            // Always removed: the live checkout is the point of localizing it. A
-            // range it misses is drift, said out loud and never acted on.
-            const ranges = [...ownAsk, ...requirementIndex(nm, cache).asks(dep)];
-            out.push(Object.assign(Object.assign({}, base), { action: 'remove', unmet: ranges.filter((r) => satisfies(app.version, r.range) === false) }));
-            continue;
-        }
-        // The checkout's own range first: when it rules the copy out, no index is needed.
-        if (own !== undefined && satisfies(app.version, own) !== true) {
-            out.push(Object.assign(Object.assign({}, base), { action: 'keep', reason: 'range', unmet: ownAsk }));
-            continue;
-        }
-        const unmet = requirementIndex(nm, cache)
-            .asks(dep)
-            .filter((r) => satisfies(app.version, r.range) !== true);
-        if (unmet.length) {
-            out.push(Object.assign(Object.assign({}, base), { action: 'keep', reason: 'range', unmet }));
-            continue;
-        }
-        const types = shipsOwnTypes(dir, nested) ? staleTypes(nm, dep, dir) : null;
-        if (types) {
-            out.push(Object.assign(Object.assign({}, base), { action: 'keep', reason: 'types', unmet: [], types }));
-            continue;
-        }
-        const context = contextChange(dir, app.real, nested);
-        if (context) {
-            out.push(Object.assign(Object.assign({}, base), { action: 'keep', reason: 'context', unmet: [], context }));
-            continue;
-        }
-        out.push(Object.assign(Object.assign({}, base), { action: 'remove', unmet: [] }));
-    }
-    return out;
-}
-/**
- * Would removing the copy at `copyDir` change what ITS OWN dependencies
- * resolve to? Removing it hands its importers the app's copy, which resolves
- * its dependencies from the app root -- while the checkout keeps its own copy
- * of everything that failed the guard. Measured: a checkout kept its
- * `react`/`@types/react` 18 (its range), lost `prism-react-renderer` (in
- * range), and the app's copy of that resolved `react` -- and with it the
- * types -- to the app's 19: the checkout's own `tsc` saw both React type sets
- * and failed. So the copy stays when any of its `dependencies`,
- * `peerDependencies` or `optionalDependencies` (and the `@types/` package
- * TypeScript would take for it) resolves, from the copy's place in the
- * checkout, to a different package than from the app's copy: a different real
- * path that is not the same `name@version`, or nothing at all from the app's.
- * The same version at another path is the same code, so it does not count; a
- * dependency the checkout cannot resolve either is no change.
- */
-function contextChange(copyDir, appReal, pkg) {
-    var _a;
-    const names = new Set();
-    for (const f of REQUIRE_FIELDS) {
-        for (const d of Object.keys((_a = pkg[f]) !== null && _a !== void 0 ? _a : {})) {
-            names.add(d);
-            names.add(typesPackageFor(d));
-        }
-    }
-    for (const d of names) {
-        const here = resolveFrom(copyDir, d);
-        if (!here)
-            continue;
-        const there = resolveFrom(appReal, d);
-        if (!there)
-            return { dep: d, here: here.version, app: null };
-        if (here.real !== there.real && here.version !== there.version)
-            return { dep: d, here: here.version, app: there.version };
-    }
-    return undefined;
-}
-/**
- * Would TypeScript, resolving `dep` from the checkout that owns `nm` once the
- * copy at `<nm>/<dep>` (`removing`; `null` when it is already gone) is
- * removed, land on an `@types/` stub before it reaches any other copy of
- * `dep`? TypeScript looks, in each `node_modules` going up, for `<dep>` and
- * then for `@types/<dep>`, and takes the first it finds. So with the copy gone
- * a checkout that still holds `@types/<dep>` -- typically as some other
- * package's dependency -- gets that stub, not the app's copy's own types.
- * Measured: the app's `minimatch` moved to 9.0.9, satisfying cli's `^9.0.4`,
- * the checkout's own `minimatch` 9 was removed, and cli's `tsc` resolved
- * `minimatch` to the checkout's `@types/minimatch@3.0.5` (depcheck →
- * multimatch → @types/minimatch): `TS2724 '"minimatch"' has no exported member
- * named 'minimatch'`.
- *
- * Callers ask only when the copy ships its own types: one that does not had
- * TypeScript take the same stub before the removal as after.
- */
-function staleTypes(nm, dep, removing) {
-    const typesName = typesPackageFor(dep);
-    if (typesName === dep)
-        return null;
-    for (let dir = path.dirname(nm);;) {
-        if (path.basename(dir) !== 'node_modules') {
-            const here = path.join(dir, 'node_modules');
-            const other = path.join(here, dep);
-            if (other !== removing && fs.existsSync(path.join(other, 'package.json')))
-                return null; // another copy of dep comes first
-            const stub = readJson(path.join(here, typesName, 'package.json'));
-            if (stub)
-                return { name: typesName, version: String(stub.version) };
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            return null;
-        dir = parent;
-    }
-}
-/**
- * Does the package at `dir` carry its own type declarations? `types` /
- * `typings`, `typesVersions`, a `types` condition anywhere in `exports`, or an
- * `index.d.ts` next to its `package.json` -- where TypeScript looks for them.
- */
-export function shipsOwnTypes(dir, pkg) {
-    if (!pkg)
-        return false;
-    if (pkg.types || pkg.typings || pkg.typesVersions)
-        return true;
-    if (hasTypesCondition(pkg.exports))
-        return true;
-    return fs.existsSync(path.join(dir, 'index.d.ts'));
-}
-function hasTypesCondition(exp) {
-    if (!exp || typeof exp !== 'object')
-        return false;
-    if (Array.isArray(exp))
-        return exp.some(hasTypesCondition);
-    return Object.entries(exp).some(([k, v]) => k === 'types' || hasTypesCondition(v));
-}
-/** `react` → `@types/react`; `@scope/name` → `@types/scope__name`; an `@types/` name is itself. */
-function typesPackageFor(name) {
-    if (name.startsWith('@types/'))
-        return name;
-    return `@types/${name.startsWith('@') ? name.slice(1).replace('/', '__') : name}`;
-}
-/** Node's upward search for `name` from the directory `from`: the first `node_modules/<name>`. */
-function resolveFrom(from, name) {
-    for (let dir = from;;) {
-        if (path.basename(dir) !== 'node_modules') {
-            const candidate = path.join(dir, 'node_modules', name);
-            const pkg = readJson(path.join(candidate, 'package.json'));
-            if (pkg)
-                return { real: realOrSelf(candidate), version: String(pkg.version) };
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            return null;
-        dir = parent;
-    }
-}
-/** The package's directory, and the `node_modules` directories between `nm` and it (its own included). */
-function locate(nm, i) {
-    if (!i.located) {
-        const segs = i.rel.split('/');
-        const dir = path.join(nm, ...segs);
-        const between = [path.join(dir, 'node_modules')];
-        for (let k = 0; k < segs.length; k++) {
-            if (segs[k] === 'node_modules')
-                between.push(path.join(nm, ...segs.slice(0, k + 1)));
-        }
-        i.located = { dir, between };
-    }
-    return i.located;
-}
-function requirementIndex(nm, cache) {
-    var _a;
-    let index = cache.indexes.get(nm);
-    if (!index) {
-        cache.builds++;
-        const byDep = (_a = fromHiddenLockfile(nm)) !== null && _a !== void 0 ? _a : fromWalk(nm);
-        index = {
-            asks(dep) {
-                var _a;
-                const out = [];
-                for (const { installed, range } of (_a = byDep.get(dep)) !== null && _a !== void 0 ? _a : []) {
-                    if (installed.name === dep)
-                        continue;
-                    const { dir, between } = locate(nm, installed);
-                    if (!fs.existsSync(path.join(dir, 'package.json')))
-                        continue;
-                    if (between.some((d) => fs.existsSync(path.join(d, dep))))
-                        continue;
-                    out.push({ from: `${installed.name}@${installed.version}`, range });
-                }
-                return out;
-            },
-        };
-        cache.indexes.set(nm, index);
-    }
-    return index;
-}
-/** Record what the package at `rel` (below `nm`) requires. */
-function addRequirer(byDep, rel, pkg) {
-    var _a;
-    const at = rel.lastIndexOf('/node_modules/');
-    const installed = {
-        name: at === -1 ? rel : rel.slice(at + '/node_modules/'.length),
-        version: pkg.version,
-        rel,
-    };
-    const seen = new Set();
-    for (const f of REQUIRE_FIELDS) {
-        for (const [dep, range] of Object.entries((_a = pkg[f]) !== null && _a !== void 0 ? _a : {})) {
-            if (typeof range !== 'string' || seen.has(dep))
-                continue;
-            seen.add(dep);
-            let list = byDep.get(dep);
-            if (!list)
-                byDep.set(dep, (list = []));
-            list.push({ installed, range });
-        }
-    }
-}
-const NODE_MODULES_PREFIX = 'node_modules/';
-function fromHiddenLockfile(nm) {
-    const lock = readJson(path.join(nm, '.package-lock.json'));
-    if (!(lock === null || lock === void 0 ? void 0 : lock.packages) || typeof lock.packages !== 'object')
-        return null;
-    const byDep = new Map();
-    for (const [key, meta] of Object.entries(lock.packages)) {
-        if (!key.startsWith(NODE_MODULES_PREFIX) || !meta || meta.link)
-            continue;
-        addRequirer(byDep, key.slice(NODE_MODULES_PREFIX.length), meta);
-    }
-    return byDep;
-}
-function fromWalk(nm) {
-    const byDep = new Map();
-    const walk = (dir, prefix) => {
-        for (const name of topLevelPackages(dir)) {
-            const pkgDir = path.join(dir, name);
-            if (isSymlink(pkgDir))
-                continue; // resolves from its real path, which is not here
-            const rel = prefix + name;
-            const pkg = readJson(path.join(pkgDir, 'package.json'));
-            if (pkg)
-                addRequirer(byDep, rel, pkg);
-            const inner = path.join(pkgDir, 'node_modules');
-            if (fs.existsSync(inner))
-                walk(inner, `${rel}/node_modules/`);
-        }
-    };
-    walk(nm, '');
-    return byDep;
-}
-function report(removed, kept, deps) {
-    var _a, _b;
-    const byOwner = new Map();
-    for (const r of removed)
-        byOwner.set(r.owner, [...((_a = byOwner.get(r.owner)) !== null && _a !== void 0 ? _a : []), r]);
-    for (const [owner, list] of byOwner) {
-        deps.log(`[localize] ${owner}: removed its own copies of what the app provides — ` +
-            list
-                .map((r) => `${r.dep}@${r.version} (app: ${r.sibling ? `localized, ${r.app}` : r.app})`)
-                .join(', '));
-        for (const r of list) {
-            for (const d of r.unmet) {
-                deps.warn(`[localize] ${owner}: ${d.from} asks ${r.dep}@${d.range}; the localized checkout is ${r.app}. ` +
-                    `It is used anyway — that is what localizing it means — but the range is now fiction.`);
-            }
-        }
-    }
-    const keptBy = new Map();
-    for (const k of kept)
-        keptBy.set(k.owner, [...((_b = keptBy.get(k.owner)) !== null && _b !== void 0 ? _b : []), k]);
-    for (const [owner, list] of keptBy) {
-        const one = list.length === 1;
-        deps.warn(`[localize] ${owner}: kept ${list.length} own ${one ? 'copy' : 'copies'} the app's cannot ` +
-            `replace: ${summarizeKept(list)} — so the app loads ${one ? 'it' : 'them'} twice. ` +
-            `\`linked localize --list\` says why.`);
-    }
-}
-const SUMMARY_LIMIT = 8;
-/** `react@18.3.1 (app 19.2.0), prism-react-renderer@2.4.1 (its react would change), … and 4 more` */
-export function summarizeKept(list) {
-    const shown = list.slice(0, SUMMARY_LIMIT).map(keptShort);
-    const more = list.length - shown.length;
-    return shown.join(', ') + (more > 0 ? `, … and ${more} more` : '');
-}
-function keptShort(k) {
-    if (k.reason === 'types')
-        return `${k.dep}@${k.version} (TypeScript would take ${k.types.name}@${k.types.version})`;
-    return k.reason === 'context'
-        ? `${k.dep}@${k.version} (its ${k.context.dep} would change)`
-        : `${k.dep}@${k.version} (app ${k.app})`;
-}
-/** The full reason a copy stays, for `--list`. */
-export function explainKept(k) {
-    if (k.reason === 'types') {
-        const t = k.types;
-        return (`${k.where}@${k.version}: it ships its own types and the checkout also has ${t.name}@${t.version} — ` +
-            `removing it would make TypeScript take that stub instead of the app's ${k.dep}@${k.app}`);
-    }
-    if (k.reason === 'context') {
-        const c = k.context;
-        return (`${k.where}@${k.version}: from the checkout its ${c.dep} is ${c.here}, from the app's copy ` +
-            `${c.app === null ? 'nothing' : c.app} — removing it would change what it loads`);
-    }
-    return (`${k.where}@${k.version}: ` +
-        k.unmet.map((u) => `${u.from} asks ${k.dep}@${u.range}`).join(', ') +
-        `, and the app has ${k.dep}@${k.app}` +
-        (k.unmet.some((u) => satisfies(k.app, u.range) === null)
-            ? ' (or the range is one localize cannot read)'
-            : ''));
-}
-function declared(pkg, fields, dep) {
-    var _a;
-    for (const f of fields)
-        if (((_a = pkg[f]) === null || _a === void 0 ? void 0 : _a[dep]) !== undefined)
-            return pkg[f][dep];
-    return undefined;
-}
-/** The app's own copy of `dep`: `<appRoot>/node_modules/<dep>`, followed through a link. */
-function appCopy(dep, deps) {
-    const dir = path.join(deps.appRoot, 'node_modules', dep);
-    const pkg = readJson(path.join(dir, 'package.json'));
-    if (!(pkg === null || pkg === void 0 ? void 0 : pkg.version))
-        return null;
-    return { version: pkg.version, real: realOrSelf(dir) };
-}
-/** The package dir's `node_modules`, and the clone root's when the package is a monorepo subdir. */
-export function nodeModulesRoots(pkgDir, entry) {
-    const roots = [path.join(pkgDir, 'node_modules')];
-    if (entry.subdir) {
-        const rel = path.normalize(entry.subdir);
-        if (pkgDir.endsWith(path.sep + rel))
-            roots.push(path.join(pkgDir.slice(0, -(rel.length + 1)), 'node_modules'));
-    }
-    return roots.filter((d) => fs.existsSync(d));
-}
-/** Package names directly under a `node_modules`, scoped ones as `@scope/name`. */
-function topLevelPackages(nm) {
-    const out = [];
-    let items;
-    try {
-        items = fs.readdirSync(nm, { withFileTypes: true });
-    }
-    catch (_a) {
-        return out;
-    }
-    for (const item of items) {
-        if (item.name.startsWith('.'))
-            continue;
-        if (item.name.startsWith('@')) {
-            let inner = [];
-            try {
-                inner = fs.readdirSync(path.join(nm, item.name));
-            }
-            catch (_b) {
-                /* not a directory */
-            }
-            for (const sub of inner)
-                if (!sub.startsWith('.'))
-                    out.push(`${item.name}/${sub}`);
-        }
-        else {
-            out.push(item.name);
-        }
-    }
-    return out;
-}
-/** Links in `<nm>/.bin` that pointed into a package just removed: dangling now. */
-function removeBinLinksInto(nm, removedDir) {
-    const bin = path.join(nm, '.bin');
-    let names;
-    try {
-        names = fs.readdirSync(bin);
-    }
-    catch (_a) {
-        return;
-    }
-    for (const name of names) {
-        const link = path.join(bin, name);
-        if (!isSymlink(link))
-            continue;
-        const target = path.resolve(bin, fs.readlinkSync(link));
-        if (isInside(target, removedDir))
-            fs.unlinkSync(link);
-    }
-}
-function removeEmptyScope(nm, dep) {
-    if (!dep.startsWith('@'))
-        return;
-    const scope = path.join(nm, dep.split('/')[0]);
-    try {
-        if (!fs.readdirSync(scope).length)
-            fs.rmdirSync(scope);
-    }
-    catch (_a) {
-        /* already gone */
-    }
-}
-export function realOrSelf(p) {
-    try {
-        return fs.realpathSync(p);
-    }
-    catch (_a) {
-        return p;
-    }
-}
-//# sourceMappingURL=prune.js.map