lurqrun 0.1.6 → 0.1.7

package/dist/upgrade-NQ5IWFZB.js

@@ -0,0 +1,596 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  SURFACE_CLAIM_KINDS
+} from "./chunk-ST2X2GYN.js";
+import {
+  diffSurfaces,
+  runtimeSymbols,
+  starReExports
+} from "./chunk-SHCEBP3J.js";
+import {
+  readManifest,
+  requireTarget,
+  resolveEntryCandidates,
+  subpathWithdrawn
+} from "./chunk-ELGCAM7P.js";
+import {
+  extractUnpacked,
+  fetchManifest,
+  unpackPackage
+} from "./chunk-BV32UNLL.js";
+import {
+  resolveRuntimeEngineConflicts
+} from "./chunk-BUALU27S.js";
+import "./chunk-AHBP533R.js";
+import "./chunk-SJOVFF7B.js";
+import {
+  require_semver
+} from "./chunk-3GHJR7XR.js";
+import "./chunk-MYGSLK44.js";
+import "./chunk-GPTKSNR6.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/surface/upgrade.ts
+init_esm_shims();
+var import_semver2 = __toESM(require_semver(), 1);
+
+// src/surface/requirements.ts
+init_esm_shims();
+var import_semver = __toESM(require_semver(), 1);
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+var REQUIRE_ESM_NODE = "^20.19.0 || >=22.12.0";
+function readRepoRuntime(rootDir) {
+  const runtime = { root: rootDir };
+  try {
+    const manifest = JSON.parse(readFileSync(join(rootDir, "package.json"), "utf8"));
+    if (typeof manifest.engines?.node === "string") runtime.engines = manifest.engines.node;
+  } catch {
+  }
+  for (const name of [".nvmrc", ".node-version"]) {
+    try {
+      const value = readFileSync(join(rootDir, name), "utf8").trim();
+      if (value) {
+        runtime.nodeVersionFile = { name, value };
+        break;
+      }
+    } catch {
+    }
+  }
+  return runtime;
+}
+function requireEsmGuaranteed(runtime) {
+  if (!runtime.engines || !import_semver.default.validRange(runtime.engines)) return false;
+  try {
+    return import_semver.default.subset(runtime.engines, REQUIRE_ESM_NODE);
+  } catch {
+    return false;
+  }
+}
+function judgeRequires(from, to, refs, ctx) {
+  if (from !== "cjs" || to === null || to === "cjs") return null;
+  const required = refs.filter((r) => r.loader === "require");
+  if (!required.length) return null;
+  const bindingFiles = new Set(required.filter((r) => r.via !== "namespace").map((r) => r.file));
+  const requireSites = required.filter((r) => r.via !== "namespace" || !bindingFiles.has(r.file));
+  const broken = /* @__PURE__ */ new Map();
+  const add = (file, line, why) => {
+    if (!broken.has(`${file}:${line}`)) broken.set(`${file}:${line}`, { file, line, why });
+  };
+  if (to === "unexported") {
+    for (const r of requireSites) add(r.file, r.line, "the exports map no longer offers anything to require()");
+  } else if (ctx.asyncModule) {
+    for (const r of requireSites) {
+      add(r.file, r.line, "the ES module uses top-level await, so require() throws ERR_REQUIRE_ASYNC_MODULE on every Node");
+    }
+  } else {
+    for (const r of required) {
+      if (r.via === "default") {
+        for (const c of r.calls ?? []) {
+          if (c.args !== null) add(r.file, c.line, "require() now returns the module namespace, which cannot be called");
+        }
+      } else if ((r.via === "namespace" || r.via === "destructured") && ctx.fromExports && ctx.toExports && !ctx.fromExports.has(r.symbol) && !ctx.toExports.has(r.symbol)) {
+        add(r.file, r.line, `\`${r.symbol}\` is not an export of the ES module, so it reads as undefined`);
+      }
+    }
+  }
+  const olderNode = to === "esm" && !ctx.asyncModule && !requireEsmGuaranteed(ctx.runtime) ? [...new Map(requireSites.map((r) => [`${r.file}:${r.line}`, { file: r.file, line: r.line }])).values()] : [];
+  if (!broken.size && !olderNode.length) return null;
+  return { from, to, broken: [...broken.values()], olderNode };
+}
+function subsetOf(inner, outer) {
+  try {
+    return import_semver.default.subset(inner, outer);
+  } catch {
+    return null;
+  }
+}
+function judgeRequirements(from, to, runtime) {
+  if (!to) return [];
+  return [...engineRequirements(from, to, runtime), ...peerRequirements(from, to, runtime)];
+}
+function engineRequirements(from, to, runtime) {
+  const needs = to.engines?.node;
+  const before = from?.engines?.node;
+  if (!needs || !import_semver.default.validRange(needs) || needs === before) return [];
+  const out = [];
+  const declared = runtime.engines;
+  if (declared && import_semver.default.validRange(declared) && subsetOf(declared, needs) === false) {
+    const alreadyOut = before && import_semver.default.validRange(before) && subsetOf(declared, before) === false;
+    if (!alreadyOut) out.push({ kind: "engines", name: "node", needs, has: `${declared} (package.json engines)` });
+  }
+  const pinned = runtime.nodeVersionFile;
+  if (pinned) {
+    const conflicts = (range) => Boolean(range) && resolveRuntimeEngineConflicts(
+      [{ name: to.name ?? "package", version: null, peerDependencies: null, peerDependenciesMeta: null, engines: { node: range } }],
+      pinned.value
+    ).length > 0;
+    if (conflicts(needs) && !conflicts(before)) {
+      out.push({ kind: "engines", name: "node", needs, has: `${pinned.value} (${pinned.name})` });
+    }
+  }
+  return out;
+}
+function peerRequirements(from, to, runtime) {
+  if (!runtime.root) return [];
+  const out = [];
+  for (const [peer, needs] of Object.entries(to.peerDependencies ?? {})) {
+    if (to.peerDependenciesMeta?.[peer]?.optional || !import_semver.default.validRange(needs)) continue;
+    const before = from?.peerDependencies?.[peer];
+    if (needs === before) continue;
+    const has = projectVersionOf(runtime.root, peer);
+    if (!has) continue;
+    const fits = (range) => {
+      try {
+        return has.exact ? import_semver.default.satisfies(has.version, range) : import_semver.default.intersects(has.version, range);
+      } catch {
+        return true;
+      }
+    };
+    if (fits(needs)) continue;
+    if (before && import_semver.default.validRange(before) && !fits(before)) continue;
+    out.push({ kind: "peer", name: peer, needs, has: `${has.version} (${has.source})` });
+  }
+  return out;
+}
+function projectVersionOf(root, name) {
+  for (let dir = resolve(root); ; dir = dirname(dir)) {
+    try {
+      const { version } = JSON.parse(readFileSync(join(dir, "node_modules", name, "package.json"), "utf8"));
+      if (version && import_semver.default.valid(version)) return { version, exact: true, source: "installed" };
+    } catch {
+    }
+    if (existsSync(join(dir, ".git")) || dirname(dir) === dir) break;
+  }
+  try {
+    const manifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+    const declared = manifest.dependencies?.[name] ?? manifest.devDependencies?.[name];
+    if (declared && import_semver.default.validRange(declared)) return { version: declared, exact: false, source: "package.json" };
+  } catch {
+  }
+  return null;
+}
+
+// src/surface/upgrade.ts
+var NEW_EXPORT_CAP = 40;
+function groupByEntry(refs, pkg) {
+  const byEntry = /* @__PURE__ */ new Map();
+  for (const [sym, uses] of refs.symbols) {
+    for (const use of uses) {
+      if (use.specifier !== pkg && !use.specifier.startsWith(`${pkg}/`)) continue;
+      const sub = use.specifier === pkg ? "" : use.specifier.slice(pkg.length + 1);
+      let symbols = byEntry.get(sub);
+      if (!symbols) byEntry.set(sub, symbols = /* @__PURE__ */ new Map());
+      const list = symbols.get(sym);
+      if (list) list.push(use);
+      else symbols.set(sym, [use]);
+    }
+  }
+  return byEntry;
+}
+function objectPaths(surface) {
+  return new Set(
+    runtimeSymbols(surface).filter((s) => s.kind === "object").map((s) => s.path)
+  );
+}
+function isNamespaceMemberClaim(ref, fromObjects, toObjects) {
+  if (ref.via !== "named-member" || ref.parent === void 0) return false;
+  return fromObjects.has(ref.parent) && toObjects.has(ref.parent);
+}
+function accepts(args, required, max) {
+  return (required === null || args >= required) && (max === null || max === void 0 || args <= max);
+}
+function judgeCalls(change, refs) {
+  const valueRefs = refs.filter((r) => r.via !== "type-only");
+  if (!valueRefs.length || valueRefs.some((r) => r.calls === void 0)) return null;
+  const broken = [];
+  const unmeasured = [];
+  for (const r of valueRefs) {
+    for (const c of r.calls) {
+      if (c.args === null) unmeasured.push({ file: r.file, line: c.line });
+      else if (accepts(c.args, change.from, change.fromMax) && !accepts(c.args, change.to, change.toMax)) {
+        broken.push({ file: r.file, line: c.line, args: c.args });
+      }
+    }
+  }
+  return { broken, unmeasured };
+}
+function compareEntry(from, to, symbols, specifier, isRoot) {
+  if (!from || !to) return { unverified: "entry point not extracted" };
+  if (from.undeclaredReason || to.undeclaredReason) {
+    return { unverified: `no readable surface (${from.undeclaredReason ?? to.undeclaredReason})` };
+  }
+  const diff = diffSurfaces(from, to);
+  if (diff.inconclusive) return { unverified: diff.inconclusive };
+  const toSurface = new Set(runtimeSymbols(to).map((s) => s.path));
+  const bareValue = toSurface.size <= 1 && toSurface.has("default");
+  const objectExports = objectPaths(from);
+  const toObjects = objectPaths(to);
+  const throughNamespaceObject = (r) => isNamespaceMemberClaim(r, objectExports, toObjects);
+  const referenced = new Set(
+    [...symbols.entries()].filter(
+      ([sym, uses]) => sym !== "default" && uses.some(
+        (r) => SURFACE_CLAIM_KINDS.includes(r.via) && !(bareValue && r.via === "namespace") || throughNamespaceObject(r)
+      )
+    ).map(([sym]) => sym)
+  );
+  const tag = isRoot ? {} : { specifier };
+  const renames = new Map(diff.renamed.map((r) => [r.path, r.to]));
+  const symbolsRemoved = diff.removed.filter((s) => referenced.has(s.path) && !toSurface.has(s.path)).map((s) => {
+    const renamedTo = renames.get(s.path);
+    return { symbol: s.path, ...tag, ...renamedTo ? { renamedTo } : {}, refs: symbols.get(s.path) ?? [] };
+  });
+  const stars = starReExports(to);
+  if (symbolsRemoved.length && stars.length) {
+    return {
+      unverified: `re-exports everything from ${stars.join(", ")}, which may still export ${symbolsRemoved.map((s) => s.symbol).join(", ")}`
+    };
+  }
+  return {
+    symbolsRemoved,
+    arityChanged: diff.arityChanged.filter((a) => referenced.has(a.path)).flatMap((a) => {
+      const refs = symbols.get(a.path) ?? [];
+      const judged = judgeCalls(a, refs);
+      if (judged && !judged.broken.length && !judged.unmeasured.length) return [];
+      const { path, ...counts } = a;
+      return [
+        {
+          symbol: path,
+          ...tag,
+          ...counts,
+          refs,
+          ...judged ? { callsBroken: judged.broken, unmeasured: judged.unmeasured } : {}
+        }
+      ];
+    }),
+    // The target's whole surface, not just what it added: a rename that shipped
+    // the new name a major early leaves `diff.added` empty. `default` is never a
+    // useful candidate, and the caller drops anything it just reported removed.
+    candidates: runtimeSymbols(to).filter((s) => s.path !== "default").map((s) => ({ symbol: s.path, kind: s.kind, arity: s.arity })),
+    lostKinds: new Set(diff.removed.filter((s) => referenced.has(s.path)).map((s) => s.kind))
+  };
+}
+async function checkUpgradeOne(target, refs, opts = {}) {
+  if (!refs || refs.symbols.size === 0) return requirementsOnly(target, opts.runtime);
+  const byEntry = groupByEntry(refs, target.package);
+  if (byEntry.size === 0) return requirementsOnly(target, opts.runtime);
+  const loose = [target.fromVersion, target.toVersion].filter((v) => import_semver2.default.validRange(v) && !import_semver2.default.valid(v));
+  if (loose.length) {
+    return { unverified: `expected exact versions, got ${target.fromVersion}..${target.toVersion}` };
+  }
+  const settled = await Promise.allSettled([
+    unpackPackage(target.package, target.fromVersion),
+    unpackPackage(target.package, target.toVersion)
+  ]);
+  try {
+    const failure = settled.find((s) => s.status === "rejected");
+    if (failure) throw failure.reason;
+    const [fromPkg, toPkg] = settled.map((s) => s.value);
+    if (!fromPkg || !toPkg) {
+      const missing = [fromPkg ? null : target.fromVersion, toPkg ? null : target.toVersion].filter(Boolean);
+      return { unverified: `not published on npm: ${missing.map((v) => `${target.package}@${v}`).join(", ")}` };
+    }
+    return await compareVersions(target, refs, byEntry, fromPkg, toPkg, opts);
+  } finally {
+    await Promise.all(
+      settled.map((s) => s.status === "fulfilled" && s.value ? s.value.cleanup() : void 0)
+    );
+  }
+}
+async function requirementsOnly(target, runtime) {
+  if (!runtime?.root) return {};
+  try {
+    const [from, to] = await Promise.all([
+      fetchManifest(target.package, target.fromVersion),
+      fetchManifest(target.package, target.toVersion)
+    ]);
+    const requirements = judgeRequirements(from, to, runtime);
+    if (!requirements.length) return {};
+    return {
+      finding: {
+        package: target.package,
+        fromVersion: target.fromVersion,
+        toVersion: target.toVersion,
+        severity: "warning",
+        symbolsRemoved: [],
+        arityChanged: [],
+        newExports: [],
+        requirements
+      }
+    };
+  } catch {
+    return {};
+  }
+}
+function importingFiles(refs, pkg) {
+  const files = /* @__PURE__ */ new Set();
+  for (const uses of refs.symbols.values()) {
+    for (const r of uses) {
+      if (r.specifier === pkg || r.specifier.startsWith(`${pkg}/`)) files.add(r.file);
+    }
+  }
+  return [...files];
+}
+function runTypeCheck(typeCheck, pkg, fromDir, toDir, files) {
+  if (!typeCheck) return void 0;
+  try {
+    return typeCheck(pkg, fromDir, toDir, files);
+  } catch (err) {
+    return { checked: false, reason: `type check failed: ${String(err).slice(0, 160)}` };
+  }
+}
+function withdrawn(fromDir, toDir, sub) {
+  const fromManifest = readManifest(fromDir);
+  if (!fromManifest || !resolveEntryCandidates(fromDir, fromManifest, sub).length) return false;
+  return subpathWithdrawn(toDir, null, sub);
+}
+async function compareVersions(target, refs, byEntry, fromPkg, toPkg, opts) {
+  const subpaths = [...byEntry.keys()].filter(Boolean);
+  const [from, to] = await Promise.all([
+    extractUnpacked(target.package, fromPkg, subpaths),
+    extractUnpacked(target.package, toPkg, subpaths)
+  ]);
+  const types = runTypeCheck(
+    opts.typeCheck,
+    target.package,
+    fromPkg.pkgDir,
+    toPkg.pkgDir,
+    importingFiles(refs, target.package)
+  );
+  const symbolsRemoved = [];
+  const arityChanged = [];
+  const candidates = [];
+  const lostKinds = /* @__PURE__ */ new Set();
+  const blind = [];
+  const entriesRemoved = [];
+  for (const [sub, symbols] of byEntry) {
+    const specifier = sub ? `${target.package}/${sub}` : target.package;
+    if (sub && withdrawn(fromPkg.pkgDir, toPkg.pkgDir, sub)) {
+      const runtimeRefs = [...symbols.values()].flat().filter((r) => r.via !== "type-only");
+      if (runtimeRefs.length) {
+        entriesRemoved.push({ specifier, refs: runtimeRefs });
+        continue;
+      }
+    }
+    if ([...symbols.values()].flat().every((r) => r.via === "side-effect")) continue;
+    const res = compareEntry(
+      sub ? from.subpathSurfaces?.[sub] : from.surface,
+      sub ? to.subpathSurfaces?.[sub] : to.surface,
+      symbols,
+      specifier,
+      !sub
+    );
+    if ("unverified" in res) {
+      blind.push(byEntry.size === 1 ? res.unverified : `${specifier}: ${res.unverified}`);
+      continue;
+    }
+    symbolsRemoved.push(...res.symbolsRemoved);
+    arityChanged.push(...res.arityChanged);
+    candidates.push(...res.candidates);
+    for (const k of res.lostKinds) lostKinds.add(k);
+  }
+  const exportNames = (s) => s.undeclaredReason || starReExports(s).length ? null : new Set(s.symbols.filter((x) => x.kind !== "type_only").map((x) => x.path));
+  const fromTarget = requireTarget(fromPkg.pkgDir);
+  const toTarget = requireTarget(toPkg.pkgDir);
+  const asyncModule = fromTarget?.format === "cjs" && toTarget?.format === "esm" && toTarget.file ? (await import("./extract-NKGKLIVT.js")).usesTopLevelAwait(toPkg.pkgDir, toTarget.file) : false;
+  const moduleFormat = judgeRequires(
+    fromTarget?.format ?? null,
+    toTarget?.format ?? null,
+    [...byEntry.get("")?.values() ?? []].flat(),
+    {
+      fromExports: exportNames(from.surface),
+      toExports: exportNames(to.surface),
+      runtime: opts.runtime ?? {},
+      asyncModule
+    }
+  );
+  const requirements = judgeRequirements(
+    readManifest(fromPkg.pkgDir),
+    readManifest(toPkg.pkgDir),
+    opts.runtime ?? {}
+  );
+  const unverified = blind.length ? blind.join("; ") : void 0;
+  const typeErrors = types?.checked ? types.introduced : [];
+  const extras = { ...unverified ? { unverified } : {}, ...types ? { types } : {} };
+  if (!symbolsRemoved.length && !arityChanged.length && !typeErrors.length && !entriesRemoved.length && !moduleFormat && !requirements.length) {
+    return extras;
+  }
+  const removedNames = new Set(symbolsRemoved.map((s) => s.symbol));
+  const seen = /* @__PURE__ */ new Set();
+  const newExports = candidates.filter((c) => !removedNames.has(c.symbol) && !seen.has(c.symbol) && seen.add(c.symbol)).sort(
+    (a, b) => Number(lostKinds.has(b.kind)) - Number(lostKinds.has(a.kind)) || a.symbol.localeCompare(b.symbol)
+  ).slice(0, NEW_EXPORT_CAP);
+  return {
+    finding: {
+      package: target.package,
+      fromVersion: target.fromVersion,
+      toVersion: target.toVersion,
+      severity: symbolsRemoved.length || entriesRemoved.length || moduleFormat?.broken.length ? "blocking" : "warning",
+      symbolsRemoved,
+      arityChanged,
+      newExports,
+      ...typeErrors.length ? { typeErrors } : {},
+      ...entriesRemoved.length ? { entriesRemoved } : {},
+      ...moduleFormat ? { moduleFormat } : {},
+      ...requirements.length ? { requirements } : {}
+    },
+    ...extras
+  };
+}
+async function checkUpgrade(targets, references, opts = {}) {
+  const byPkg = new Map(references.map((r) => [r.package, r]));
+  const breaking = [];
+  const ok = [];
+  const unverified = [];
+  const types = [];
+  const runtime = opts.rootDir ? readRepoRuntime(opts.rootDir) : {};
+  for (const t of targets) {
+    try {
+      const res = await checkUpgradeOne(t, byPkg.get(t.package), { typeCheck: opts.typeCheck, runtime });
+      if (res.types) {
+        types.push(
+          res.types.checked ? { package: t.package, checked: true, files: res.types.files } : { package: t.package, checked: false, reason: res.types.reason }
+        );
+      }
+      if (res.finding) breaking.push(res.finding);
+      if (res.unverified) unverified.push({ package: t.package, reason: res.unverified });
+      if (!res.finding && !res.unverified) ok.push(t.package);
+    } catch (err) {
+      unverified.push({ package: t.package, reason: String(err).slice(0, 160) });
+    }
+  }
+  return {
+    // `safe` requires that nothing broke AND nothing was left unchecked.
+    safe: breaking.length === 0 && unverified.length === 0,
+    breaking,
+    ok,
+    unverified,
+    ...opts.typeCheck ? { types } : {}
+  };
+}
+var REPORT_CANDIDATE_CAP = 8;
+var REPORT_LOCATION_CAP = 6;
+function capped(items, cap = REPORT_LOCATION_CAP) {
+  const shown = items.slice(0, cap).join(", ");
+  return items.length > cap ? `${shown} (+${items.length - cap} more)` : shown;
+}
+function locations(refs) {
+  const all = refs.flatMap((r) => [`${r.file}:${r.line}`, ...(r.calls ?? []).map((c) => `${r.file}:${c.line}`)]);
+  return capped([...new Set(all)]) || "(no location)";
+}
+function params(required, max) {
+  if (max === void 0 || max === required) return `${required}`;
+  return max === null ? `${required}+` : `${required}\u2013${max}`;
+}
+function formatUpgradeReport(report, title = "upgrade check") {
+  const out = [`lurq, ${title}`, ""];
+  for (const b of report.breaking.sort((a, z) => a.severity === "blocking" ? -1 : 1)) {
+    const label = b.severity === "blocking" ? "BLOCKING" : "WARNING ";
+    out.push(`${label}  ${b.package}  ${b.fromVersion} \u2192 ${b.toVersion}`);
+    if (b.symbolsRemoved.length) {
+      out.push(`  Removes ${b.symbolsRemoved.length} symbol(s) your code references:`);
+      for (const s of b.symbolsRemoved) {
+        const where = locations(s.refs);
+        const rename = s.renamedTo ? ` \u2192 ${s.renamedTo.join(" | ")}` : "";
+        out.push(`    \xB7 ${s.specifier ?? b.package}.${s.symbol}${rename}    ${where}`);
+      }
+      if (b.symbolsRemoved.some((s) => s.renamedTo)) {
+        out.push(`  \u2192 is a proven rename: both names were the same function at ${b.fromVersion}.`);
+      }
+    }
+    for (const e of b.entriesRemoved ?? []) {
+      out.push(`  Removes entry point ${e.specifier}, which your code imports:`);
+      out.push(`    \xB7 ${locations(e.refs)}`);
+    }
+    if (b.moduleFormat) {
+      const m = b.moduleFormat;
+      out.push(
+        m.to === "esm" ? `  require('${b.package}') now loads an ES module (was CommonJS)` : `  require('${b.package}') no longer resolves: its exports map offers require() nothing`
+      );
+      for (const x of m.broken.slice(0, REPORT_LOCATION_CAP)) out.push(`    \xB7 ${x.file}:${x.line}  ${x.why}`);
+      if (m.broken.length > REPORT_LOCATION_CAP) out.push(`    \xB7 (+${m.broken.length - REPORT_LOCATION_CAP} more)`);
+      if (m.olderNode.length) {
+        out.push(
+          `    \xB7 throws ERR_REQUIRE_ESM on Node before 20.19 / 22.12: ${capped(m.olderNode.map((s) => `${s.file}:${s.line}`))}`
+        );
+      }
+    }
+    for (const r of b.requirements ?? []) {
+      out.push(`  Requires ${r.name} ${r.needs}; this project has ${r.has}`);
+    }
+    for (const a of b.arityChanged) {
+      out.push(
+        `  Arity change: ${a.specifier ?? b.package}.${a.symbol} ${params(a.from, a.fromMax)} \u2192 ${params(a.to, a.toMax)} params`
+      );
+      if (!a.callsBroken) {
+        out.push(`    \xB7 ${locations(a.refs)}`);
+        continue;
+      }
+      for (const c of a.callsBroken.slice(0, REPORT_LOCATION_CAP)) {
+        out.push(`    \xB7 ${c.file}:${c.line} passes ${c.args}`);
+      }
+      if (a.callsBroken.length > REPORT_LOCATION_CAP) {
+        out.push(`    \xB7 (+${a.callsBroken.length - REPORT_LOCATION_CAP} more calls)`);
+      }
+      if (a.unmeasured?.length) {
+        out.push(
+          `    \xB7 not countable (spread, or passed as a value): ${capped(a.unmeasured.map((u) => `${u.file}:${u.line}`))}`
+        );
+      }
+    }
+    if (b.typeErrors?.length) {
+      out.push(`  Type errors this upgrade introduces (${b.typeErrors.length}):`);
+      for (const e of b.typeErrors.slice(0, REPORT_LOCATION_CAP)) {
+        const message = e.message.length > 140 ? `${e.message.slice(0, 139)}\u2026` : e.message;
+        out.push(`    \xB7 ${e.file}:${e.line}  TS${e.code}  ${message}`);
+      }
+      if (b.typeErrors.length > REPORT_LOCATION_CAP) {
+        out.push(`    \xB7 (+${b.typeErrors.length - REPORT_LOCATION_CAP} more)`);
+      }
+    }
+    if (b.symbolsRemoved.some((s) => !s.renamedTo) && b.newExports.length) {
+      const shown = b.newExports.slice(0, REPORT_CANDIDATE_CAP);
+      const more = b.newExports.length - shown.length;
+      out.push(
+        `  New at ${b.toVersion}, candidate replacements: ${shown.map((n) => n.symbol).join(", ")}${more > 0 ? ` (+${more} more)` : ""}`
+      );
+    }
+    out.push("");
+  }
+  if (report.unverified.length) {
+    out.push(`UNVERIFIED  ${report.unverified.length} package(s), not checked, NOT declared safe:`);
+    for (const u of report.unverified) out.push(`    \xB7 ${u.package}: ${u.reason}`);
+    out.push("");
+  }
+  const typed = report.types ?? [];
+  const unchecked = typed.filter(
+    (t) => !t.checked
+  );
+  if (typed.length > unchecked.length) {
+    out.push(`TYPES     checked ${typed.length - unchecked.length} package(s) in the files that import them`);
+  }
+  if (unchecked.length) {
+    out.push(`TYPES     not checked for ${unchecked.length} package(s):`);
+    const byReason = /* @__PURE__ */ new Map();
+    for (const t of unchecked) byReason.set(t.reason, [...byReason.get(t.reason) ?? [], t.package]);
+    for (const [reason, names] of byReason) out.push(`    \xB7 ${names.join(", ")}: ${reason}`);
+  }
+  if (typed.length) out.push("");
+  if (report.ok.length) {
+    out.push(`OK        ${report.ok.length} package(s), no referenced symbols removed`);
+  }
+  if (!report.breaking.length && !report.unverified.length) {
+    out.push("", "No referenced symbols are removed by these upgrades.");
+  }
+  return out.join("\n");
+}
+export {
+  checkUpgrade,
+  checkUpgradeOne,
+  formatUpgradeReport,
+  isNamespaceMemberClaim,
+  judgeCalls
+};