lurqrun 0.1.7 → 0.1.8

package/dist/{remote-YGCXYI4V.js → remote-FN6225AH.js}

@@ -2,31 +2,41 @@ import { createRequire as __lurqCreateRequire } from 'node:module'; const requir
 import {
   MissingKeyError,
   RemoteError,
+  acknowledgePublicMcpChange,
   apiKey,
   callTool,
   endpoint,
   fetchUpgradePlan,
+  getAlerts,
   getPolicy,
   getPolicyDecisions,
   getPolicyHistory,
+  listMcpPins,
+  pinMcpServer,
   putPolicy,
   reportUpgradeRuns,
+  unpinMcpServer,
   uploadMcpScan
-} from "./chunk-4ZYCIMY4.js";
-import "./chunk-Y5GI7RL3.js";
-import "./chunk-GPTKSNR6.js";
+} from "./chunk-OTJFHESY.js";
+import "./chunk-J6XQ7OPZ.js";
+import "./chunk-72Y2FDVS.js";
 import "./chunk-I3M2KJXB.js";
 export {
   MissingKeyError,
   RemoteError,
+  acknowledgePublicMcpChange,
   apiKey,
   callTool,
   endpoint,
   fetchUpgradePlan,
+  getAlerts,
   getPolicy,
   getPolicyDecisions,
   getPolicyHistory,
+  listMcpPins,
+  pinMcpServer,
   putPolicy,
   reportUpgradeRuns,
+  unpinMcpServer,
   uploadMcpScan
 };

package/dist/rename-OS6JYBZQ.js

@@ -0,0 +1,204 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/fix/rename.ts
+init_esm_shims();
+var REWRITABLE = /* @__PURE__ */ new Set(["named", "destructured"]);
+var CANDIDATE_LIMIT = 20;
+function isRootSpecifier(ref, pkg) {
+  return ref.specifier === pkg;
+}
+function editsFor(refs, to, pkg) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const list = byFile.get(ref.file);
+    if (list) list.push(ref);
+    else byFile.set(ref.file, [ref]);
+  }
+  const edits = [];
+  const files = [];
+  const refusedFiles = [];
+  for (const [file, fileRefs] of byFile) {
+    const fileEdits = [];
+    let refused = null;
+    for (const ref of fileRefs) {
+      if (!isRootSpecifier(ref, pkg)) continue;
+      if (ref.via === "type-only") continue;
+      if (!REWRITABLE.has(ref.via)) {
+        refused = `reached as ${ref.via}, where the export name is not what the code writes`;
+        break;
+      }
+      if (ref.shadowed) {
+        refused = `${ref.local ?? ref.symbol} is declared more than once`;
+        break;
+      }
+      if (ref.nameStart === void 0 || ref.nameEnd === void 0) {
+        refused = "no recorded position for the import";
+        break;
+      }
+      fileEdits.push({ file, start: ref.nameStart, end: ref.nameEnd, text: to, was: ref.symbol });
+      if (ref.aliased) continue;
+      const local = ref.local ?? ref.symbol;
+      for (const use of ref.calls ?? []) {
+        if (use.start === void 0 || use.end === void 0) {
+          refused = `a use of ${local} has no recorded position`;
+          break;
+        }
+        fileEdits.push({ file, start: use.start, end: use.end, text: to, was: local });
+      }
+      if (refused) break;
+    }
+    if (refused) refusedFiles.push({ file, reason: refused });
+    else if (fileEdits.length > 0) {
+      files.push(file);
+      edits.push(...fileEdits);
+    }
+  }
+  return { edits, files, refusedFiles };
+}
+function dedupe(edits) {
+  const seen = /* @__PURE__ */ new Set();
+  return edits.filter((e) => {
+    const key = `${e.file}:${e.start}-${e.end}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function renameFindings(breaking, opts) {
+  const findings = [];
+  const refused = [];
+  const version = `${breaking.package}@${breaking.fromVersion ?? "?"} \u2192 ${breaking.toVersion ?? "?"}`;
+  for (const removed of breaking.symbolsRemoved) {
+    const to = removed.renamedTo ?? [];
+    const code = `renamed-export:${breaking.package}:${removed.symbol}`;
+    const files = [...new Set(removed.refs.map((r) => r.file))];
+    if (to.length === 0) {
+      if (files.length === 0 || breaking.newExports.length === 0) continue;
+      const candidates = breaking.newExports.slice(0, CANDIDATE_LIMIT);
+      findings.push({
+        domain: "package",
+        code: `removed-export:${breaking.package}:${removed.symbol}`,
+        severity: breaking.severity,
+        detail: `${removed.symbol} does not exist in ${version}, and the package does not say what replaced it`,
+        evidence: `${breaking.toVersion} exports that ${breaking.fromVersion} did not: ${candidates.map((e) => e.symbol).join(", ")}`,
+        fix: {
+          summary: `replace ${removed.symbol} using the exports ${breaking.toVersion} actually ships`,
+          task: {
+            instruction: `${removed.symbol} was removed from ${breaking.package} in ${breaking.toVersion}. Rewrite each use with the export that matches what the code does with it. Do not invent a name: use one from the list below, or report that none fits.`,
+            files,
+            evidence: candidates.map(
+              (e) => `${e.symbol}: ${e.kind}${e.arity === null ? "" : `, ${e.arity} parameter(s)`}`
+            )
+          },
+          verify: ["typecheck", "tests"]
+        }
+      });
+      continue;
+    }
+    if (to.length > 1) {
+      refused.push({
+        symbol: removed.symbol,
+        to,
+        reason: "more than one surviving name; a choice, not a rewrite"
+      });
+      findings.push({
+        domain: "package",
+        code,
+        severity: breaking.severity,
+        detail: `${removed.symbol} was removed in ${version}; the package exports ${to.join(" and ")} from the same declaration, so which one replaces it is a judgement`,
+        evidence: `${version}: same-declaration survivors ${to.join(", ")}`,
+        fix: {
+          summary: `replace ${removed.symbol} with whichever of ${to.join(" or ")} the code means`,
+          task: {
+            instruction: `${removed.symbol} no longer exists in ${breaking.package} ${breaking.toVersion ?? "the target version"}. Replace each use with ${to.join(" or ")}, whichever matches how the value is used.`,
+            files: [...new Set(removed.refs.map((r) => r.file))],
+            evidence: [`${breaking.toVersion ?? "target"} exports: ${to.join(", ")}`]
+          },
+          verify: ["typecheck", "tests"]
+        }
+      });
+      continue;
+    }
+    const target = to[0];
+    const proof = `${version}: ${removed.symbol} and ${target} were exported from one declaration at ${breaking.fromVersion ?? "the source version"}`;
+    const manualTask = (taskFiles, extra = []) => ({
+      instruction: `Rename ${removed.symbol} to ${target} where it is imported from ${breaking.package}.`,
+      files: taskFiles,
+      evidence: [`${target} exists at ${breaking.toVersion ?? "the target version"}`, ...extra]
+    });
+    const {
+      edits: collected,
+      files: editedFiles,
+      refusedFiles
+    } = editsFor(removed.refs, target, opts.packageName);
+    const edits = dedupe(collected);
+    if (edits.length > 0) {
+      findings.push({
+        domain: "package",
+        code,
+        severity: breaking.severity,
+        detail: `${removed.symbol} was renamed to ${target} in ${version}: ${edits.length} occurrence(s) in ${editedFiles.length} file(s)`,
+        file: editedFiles[0],
+        evidence: `${proof}, and ${target} still exists`,
+        fix: {
+          summary: `rename ${removed.symbol} to ${target}`,
+          edits,
+          verify: ["typecheck", "tests"]
+        }
+      });
+    }
+    if (refusedFiles.length > 0) {
+      for (const r of refusedFiles)
+        refused.push({ symbol: removed.symbol, to, file: r.file, reason: r.reason });
+      findings.push({
+        domain: "package",
+        code: `${code}:manual`,
+        severity: breaking.severity,
+        detail: `${removed.symbol} was renamed to ${target} in ${version}, but ${refusedFiles.length} file(s) need a person: ${refusedFiles.map((r) => `${r.file} (${r.reason})`).join("; ")}`,
+        file: refusedFiles[0].file,
+        evidence: proof,
+        fix: {
+          summary: `rename ${removed.symbol} to ${target} in ${refusedFiles.length} file(s) lurq will not touch`,
+          // The reasons are already in `detail`; repeating them as evidence put
+          // them under the "use one of these" label meant for real exports.
+          task: manualTask(refusedFiles.map((r) => r.file)),
+          verify: ["typecheck", "tests"]
+        }
+      });
+    }
+    if (edits.length === 0 && refusedFiles.length === 0) {
+      const reason = "nothing in this project references it at the package root";
+      refused.push({ symbol: removed.symbol, to, reason });
+      findings.push({
+        domain: "package",
+        code,
+        severity: breaking.severity,
+        detail: `${removed.symbol} was renamed to ${target} in ${version}, but lurq will not rewrite it here: ${reason}`,
+        evidence: proof,
+        fix: {
+          summary: `rename ${removed.symbol} to ${target} by hand`,
+          task: manualTask([...new Set(removed.refs.map((r) => r.file))]),
+          verify: ["typecheck", "tests"]
+        }
+      });
+    }
+  }
+  return { findings, refused };
+}
+function renamePlan(report) {
+  const findings = [];
+  const refused = [];
+  for (const breaking of report.breaking) {
+    const plan = renameFindings(breaking, { packageName: breaking.package });
+    findings.push(...plan.findings);
+    refused.push(...plan.refused);
+  }
+  return { findings, refused };
+}
+export {
+  renameFindings,
+  renamePlan
+};

package/dist/{reportRuns-CKQQYLY4.js → reportRuns-O4X7ZFTX.js}

@@ -1,4 +1,7 @@
 import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  RUN_TRIGGERS
+} from "./chunk-2GAYNIHG.js";
 import {
   init_esm_shims
 } from "./chunk-I3M2KJXB.js";
@@ -6,6 +9,11 @@ import {
 // src/cli/reportRuns.ts
 init_esm_shims();
 var MAX_RUNS = 100;
+function triggerFromEvent(event) {
+  if (!event) return null;
+  if (event === "workflow_dispatch" || event === "repository_dispatch") return "dispatch";
+  return RUN_TRIGGERS.find((t) => t === event) ?? "other";
+}
 function findingRefs(finding) {
   return [
     ...finding.symbolsRemoved.flatMap((s) => s.refs),
@@ -26,7 +34,8 @@ function buildRunReports(report, targets, ctx) {
       fromVersion: target?.fromVersion ?? "",
       toVersion: target?.toVersion ?? "",
       status: "checked",
-      runUrl: ctx.runUrl
+      runUrl: ctx.runUrl,
+      trigger: ctx.trigger
     };
   };
   const rows = [];
@@ -56,7 +65,11 @@ function runContextFromEnv(env = process.env) {
   if (!repoFullName) return null;
   const server = env.GITHUB_SERVER_URL?.trim() || "https://github.com";
   const runId = env.GITHUB_RUN_ID?.trim();
-  return { repoFullName, runUrl: runId ? `${server}/${repoFullName}/actions/runs/${runId}` : "" };
+  return {
+    repoFullName,
+    runUrl: runId ? `${server}/${repoFullName}/actions/runs/${runId}` : "",
+    trigger: triggerFromEvent(env.GITHUB_EVENT_NAME?.trim())
+  };
 }
 export {
   buildRunReports,

package/dist/safeFetch-COERXGFN.js

@@ -0,0 +1,19 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  ResponseTooLargeError,
+  SAFE_FETCH_DEFAULTS,
+  UnsafeUrlError,
+  createSafeFetch,
+  publicHttpsOnly,
+  sharedSafeFetch
+} from "./chunk-J3U2CPSK.js";
+import "./chunk-3D2MPGOQ.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  ResponseTooLargeError,
+  SAFE_FETCH_DEFAULTS,
+  UnsafeUrlError,
+  createSafeFetch,
+  publicHttpsOnly,
+  sharedSafeFetch
+};

package/dist/{sandbox-MEZLAODF.js → sandbox-SAPSRKEI.js}

@@ -1,16 +1,16 @@
 import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
 import {
   getSandbox
-} from "./chunk-I2JUKN6Z.js";
+} from "./chunk-RG3YLU6E.js";
 import "./chunk-C6GLE626.js";
 import "./chunk-GE37NVLN.js";
 import {
   storeVerificationRun
-} from "./chunk-6L3U7DZ5.js";
-import "./chunk-LYMPYETA.js";
+} from "./chunk-NYZU5NCW.js";
+import "./chunk-4JHDSVIN.js";
 import "./chunk-GRJXQBQZ.js";
 import "./chunk-WHX2ZFCG.js";
-import "./chunk-GPTKSNR6.js";
+import "./chunk-72Y2FDVS.js";
 import {
   init_esm_shims
 } from "./chunk-I3M2KJXB.js";

package/dist/sarif-WLVJFJ7U.js

@@ -0,0 +1,125 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  deterministic,
+  positionAt
+} from "./chunk-BM3LF5T6.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/fix/sarif.ts
+init_esm_shims();
+var LEVEL = {
+  blocking: "error",
+  warning: "warning",
+  info: "note"
+};
+var RULE_TEXT = {
+  "renamed-export": "An export this code imports was renamed by the package itself, which proves the replacement.",
+  "removed-export": "An export this code imports no longer exists, and the package does not say what replaced it."
+};
+var ruleClassOf = (code) => code.split(":")[0] || code;
+var regionOf = (text, edit) => {
+  const start = positionAt(text, edit.start);
+  const end = positionAt(text, edit.end);
+  return {
+    startLine: start.line,
+    startColumn: start.column,
+    endLine: end.line,
+    endColumn: end.column
+  };
+};
+function filesOf(f) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const e of f.fix?.edits ?? []) {
+    const list = byFile.get(e.file);
+    if (list) list.push(e);
+    else byFile.set(e.file, [e]);
+  }
+  if (byFile.size > 0) return [...byFile].map(([file, edits]) => ({ file, edits }));
+  const named = f.fix?.task?.files ?? (f.file ? [f.file] : []);
+  return [...new Set(named)].map((file) => ({ file, edits: [] }));
+}
+function toSarif(findings, opts) {
+  const results = [];
+  const seenRules = /* @__PURE__ */ new Set();
+  for (const f of findings) {
+    seenRules.add(ruleClassOf(f.code));
+    const places = filesOf(f);
+    if (places.length === 0) {
+      results.push({
+        ruleId: ruleClassOf(f.code),
+        level: LEVEL[f.severity],
+        message: { text: f.detail },
+        partialFingerprints: { lurqCode: f.code },
+        properties: { fixable: deterministic(f), ...f.evidence ? { evidence: f.evidence } : {} }
+      });
+      continue;
+    }
+    for (const { file, edits } of places) {
+      const text = edits.length > 0 ? opts.read(file) : null;
+      const region = text !== null && edits[0] ? regionOf(text, edits[0]) : null;
+      results.push({
+        ruleId: ruleClassOf(f.code),
+        level: LEVEL[f.severity],
+        message: { text: f.detail },
+        locations: [
+          {
+            physicalLocation: {
+              artifactLocation: { uri: file, uriBaseId: "%SRCROOT%" },
+              ...region ? { region } : {}
+            }
+          }
+        ],
+        // Same finding, same file, across runs — even if the line moved.
+        partialFingerprints: { lurqCode: `${f.code}@${file}` },
+        properties: {
+          fixable: deterministic(f),
+          ...f.evidence ? { evidence: f.evidence } : {},
+          ...f.fix?.task ? { agentInstruction: f.fix.task.instruction } : {}
+        },
+        ...text !== null && edits.length > 0 ? {
+          fixes: [
+            {
+              description: { text: f.fix.summary },
+              artifactChanges: [
+                {
+                  artifactLocation: { uri: file, uriBaseId: "%SRCROOT%" },
+                  replacements: edits.map((e) => ({
+                    deletedRegion: regionOf(text, e),
+                    insertedContent: { text: e.text }
+                  }))
+                }
+              ]
+            }
+          ]
+        } : {}
+      });
+    }
+  }
+  return {
+    $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "lurq",
+            informationUri: "https://lurq.run",
+            version: opts.version,
+            rules: [...seenRules].sort().map((id) => ({
+              id,
+              name: id,
+              shortDescription: { text: RULE_TEXT[id] ?? `lurq finding: ${id}` }
+            }))
+          }
+        },
+        results
+      }
+    ]
+  };
+}
+export {
+  ruleClassOf,
+  toSarif
+};

package/dist/server-OLTY3NYT.js

@@ -0,0 +1,59 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  SERVE_NEEDS_DATABASE,
+  buildMcpServer,
+  exactVersion,
+  npmName,
+  startMcpServer
+} from "./chunk-3676XOBU.js";
+import "./chunk-B2UUYRBX.js";
+import "./chunk-NEZNAPPN.js";
+import "./chunk-FDFPMBCA.js";
+import "./chunk-KP5ZDDPE.js";
+import "./chunk-BN3NM47Q.js";
+import "./chunk-BJT2LHAR.js";
+import "./chunk-XLXPVN3Y.js";
+import "./chunk-P6MIKSPY.js";
+import "./chunk-D3K6IZVR.js";
+import "./chunk-6EQ3ARXA.js";
+import "./chunk-SHCEBP3J.js";
+import "./chunk-LEGPB7DO.js";
+import "./chunk-Q5VPF4WI.js";
+import "./chunk-EQCXENKZ.js";
+import "./chunk-64ZF7KO4.js";
+import "./chunk-QSL6QN5X.js";
+import "./chunk-NYZU5NCW.js";
+import "./chunk-2WD4QAH4.js";
+import "./chunk-DSROTZ3Z.js";
+import "./chunk-TUXQ32WE.js";
+import "./chunk-BUALU27S.js";
+import "./chunk-QUIMQ7YL.js";
+import "./chunk-6DM6UQFD.js";
+import "./chunk-EYAKM6YN.js";
+import "./chunk-D3VTZS7V.js";
+import "./chunk-4ESO33J6.js";
+import "./chunk-NPVN2THM.js";
+import "./chunk-VLRHFMGJ.js";
+import "./chunk-VGCDRK3S.js";
+import "./chunk-ONDVTXUO.js";
+import "./chunk-4JHDSVIN.js";
+import "./chunk-GM5Y555O.js";
+import "./chunk-2GAYNIHG.js";
+import "./chunk-KYKSZ3XZ.js";
+import "./chunk-A3TYI2TF.js";
+import "./chunk-HWFX4BC4.js";
+import "./chunk-6L67QMCP.js";
+import "./chunk-3GHJR7XR.js";
+import "./chunk-GRJXQBQZ.js";
+import "./chunk-WHX2ZFCG.js";
+import "./chunk-LUAKDHLZ.js";
+import "./chunk-MYGSLK44.js";
+import "./chunk-72Y2FDVS.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  SERVE_NEEDS_DATABASE,
+  buildMcpServer,
+  exactVersion,
+  npmName,
+  startMcpServer
+};

package/dist/{surface-V62GE554.js → surface-7MHE3RL7.js}

@@ -2,6 +2,17 @@ import { createRequire as __lurqCreateRequire } from 'node:module'; const requir
 import {
   formatError
 } from "./chunk-MHUEVBVO.js";
+import {
+  fetchAndExtract
+} from "./chunk-FVYFV5HA.js";
+import {
+  getPackagesWithSurface
+} from "./chunk-DSROTZ3Z.js";
+import "./chunk-D3VTZS7V.js";
+import {
+  getPackageVersions
+} from "./chunk-NPVN2THM.js";
+import "./chunk-VLRHFMGJ.js";
 import {
   bumpSurfaceAttempt,
   dropSurfaceQueue,
@@ -12,24 +23,13 @@ import {
   isExtractionCached,
   storeSurface,
   surfaceRef
-} from "./chunk-LO35HLQZ.js";
-import {
-  fetchAndExtract
-} from "./chunk-BV32UNLL.js";
-import {
-  getPackagesWithSurface
-} from "./chunk-M6NYEXCW.js";
-import "./chunk-AHBP533R.js";
-import "./chunk-SJOVFF7B.js";
-import {
-  getPackageVersions
-} from "./chunk-NH5I4KHH.js";
-import "./chunk-VLRHFMGJ.js";
-import "./chunk-LYMPYETA.js";
+} from "./chunk-ONDVTXUO.js";
+import "./chunk-4JHDSVIN.js";
+import "./chunk-KYKSZ3XZ.js";
 import {
   logger
 } from "./chunk-MYGSLK44.js";
-import "./chunk-GPTKSNR6.js";
+import "./chunk-72Y2FDVS.js";
 import {
   init_esm_shims
 } from "./chunk-I3M2KJXB.js";
@@ -104,7 +104,9 @@ async function drainSurfaceQueue(db, opts = {}) {
 async function backfillSurfaces(db, opts = {}) {
   const limit = opts.limit ?? 500;
   const s = { scanned: 0, queuedLatest: 0, queuedPrevious: 0 };
-  const missing = await getPackagesMissingGraphSurface(db, limit, { byDownloads: opts.byDownloads });
+  const missing = await getPackagesMissingGraphSurface(db, limit, {
+    byDownloads: opts.byDownloads
+  });
   for (const row of missing) {
     s.scanned++;
     await enqueueSurface(db, row.name, row.version).then(

package/dist/{surface-YL6O67W3.js → surface-JS2XU3U3.js}

@@ -13,10 +13,11 @@ import {
   previousVersion,
   specKey,
   storeSurface,
+  surfaceQueueDepth,
   surfaceRef
-} from "./chunk-LO35HLQZ.js";
-import "./chunk-LYMPYETA.js";
-import "./chunk-GPTKSNR6.js";
+} from "./chunk-ONDVTXUO.js";
+import "./chunk-4JHDSVIN.js";
+import "./chunk-72Y2FDVS.js";
 import "./chunk-I3M2KJXB.js";
 export {
   bumpSurfaceAttempt,
@@ -32,5 +33,6 @@ export {
   previousVersion,
   specKey,
   storeSurface,
+  surfaceQueueDepth,
   surfaceRef
 };

package/dist/{surfaceHandlers-X2IZKA3E.js → surfaceHandlers-4B6TMZ34.js}

@@ -4,13 +4,13 @@ import {
   handleResolveSurface,
   loadStored,
   rowsToSurface
-} from "./chunk-DB2VF5UD.js";
+} from "./chunk-BJT2LHAR.js";
 import "./chunk-SHCEBP3J.js";
-import "./chunk-LO35HLQZ.js";
-import "./chunk-HWBBVLOT.js";
-import "./chunk-LYMPYETA.js";
+import "./chunk-ONDVTXUO.js";
+import "./chunk-4JHDSVIN.js";
+import "./chunk-6L67QMCP.js";
 import "./chunk-MYGSLK44.js";
-import "./chunk-GPTKSNR6.js";
+import "./chunk-72Y2FDVS.js";
 import "./chunk-I3M2KJXB.js";
 export {
   handleDiffSurface,

package/dist/{typecheck-X7U5ELMR.js → typecheck-NGOKNAJY.js}

@@ -33,11 +33,15 @@ function typeChecker(ts, rootDir, opts = {}) {
   const caches = /* @__PURE__ */ new Map();
   const parse = (configPath) => {
     if (!configs.has(configPath)) {
-      const parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, {
-        ...ts.sys,
-        onUnRecoverableConfigFileDiagnostic: () => {
+      const parsed = ts.getParsedCommandLineOfConfigFile(
+        configPath,
+        {},
+        {
+          ...ts.sys,
+          onUnRecoverableConfigFileDiagnostic: () => {
+          }
         }
-      });
+      );
       configs.set(configPath, parsed ?? null);
     }
     return configs.get(configPath);
@@ -65,7 +69,9 @@ function typeChecker(ts, rootDir, opts = {}) {
       const after = build(ts, group.parsed, pkg, toDir, installedVersion, shared, true);
       if ("reason" in after) return { checked: false, reason: after.reason };
       const missingBefore = unresolvedTypeImports(ts, before);
-      const newlyMissing = [...unresolvedTypeImports(ts, after)].filter((s) => !missingBefore.has(s));
+      const newlyMissing = [...unresolvedTypeImports(ts, after)].filter(
+        (s) => !missingBefore.has(s)
+      );
       if (newlyMissing.length) {
         return {
           checked: false,
@@ -130,7 +136,8 @@ function unresolvedTypeImports(ts, built) {
   for (const sf of built.program.getSourceFiles()) {
     if (!sf.isDeclarationFile || !built.overlaid(sf.fileName)) continue;
     for (const { fileName: spec } of ts.preProcessFile(sf.text, true, true).importedFiles) {
-      if (!ts.resolveModuleName(spec, sf.fileName, options, built.host).resolvedModule) out.add(spec);
+      if (!ts.resolveModuleName(spec, sf.fileName, options, built.host).resolvedModule)
+        out.add(spec);
     }
   }
   return out;
@@ -153,11 +160,16 @@ function importersOf(ts, program, targets) {
   const key = (p) => ts.sys.useCaseSensitiveFileNames ? resolve(p) : resolve(p).toLowerCase();
   const wanted = new Set(targets.map(key));
   const options = program.getCompilerOptions();
-  const cache = ts.createModuleResolutionCache(program.getCurrentDirectory(), (f) => key(f), options);
+  const cache = ts.createModuleResolutionCache(
+    program.getCurrentDirectory(),
+    (f) => key(f),
+    options
+  );
   const out = [];
   for (const sf of program.getSourceFiles()) {
     if (out.length >= HOP_CAP) break;
-    if (sf.isDeclarationFile || sf.fileName.includes("/node_modules/") || wanted.has(key(sf.fileName))) continue;
+    if (sf.isDeclarationFile || sf.fileName.includes("/node_modules/") || wanted.has(key(sf.fileName)))
+      continue;
     const { importedFiles } = ts.preProcessFile(sf.text, true, true);
     const imports = importedFiles.some(({ fileName: spec }) => {
       const hit = ts.resolveModuleName(spec, sf.fileName, options, ts.sys, cache).resolvedModule;
@@ -178,7 +190,9 @@ function overlayHost(ts, options, pkg, pkgDir, installedVersion, cache) {
   };
   const marker = `/node_modules/${pkg}`;
   const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const pnpmStore = installedVersion ? new RegExp(`^(.*)/node_modules/\\.pnpm/${escape(pkg.replace("/", "+"))}@${escape(installedVersion)}(?:[_(][^/]*)?$`) : null;
+  const pnpmStore = installedVersion ? new RegExp(
+    `^(.*)/node_modules/\\.pnpm/${escape(pkg.replace("/", "+"))}@${escape(installedVersion)}(?:[_(][^/]*)?$`
+  ) : null;
   const ownInstall = (prefix) => {
     if (!prefix.includes("/node_modules/")) return true;
     const store = pnpmStore?.exec(prefix);