@williamthorsen/nmr 0.16.0 → 0.17.0

package/dist/esm/commands/build.js

@@ -1,122 +1,274 @@
-import { createHash } from "node:crypto";
-import { existsSync, readFileSync, realpathSync } from "node:fs";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { build } from "esbuild";
-import { glob } from "glob";
-const PACKAGE_ICON = "\u{1F4E6}";
-const SKIPPED_ICON = "\u23ED\uFE0F";
-const DEFAULT_ALIASES = { "~/": "." };
-const DEFAULT_ENTRY_GLOBS = ["src/**/*.ts"];
-const DEFAULT_IGNORE = ["**/__tests__/**"];
-const DEFAULT_OUTDIR = "dist/esm/";
-const DEFAULT_CACHE_FILE = "dist/esm/.cache";
-const DEFAULT_FORMAT = "esm";
-const DEFAULT_PLATFORM = "node";
-const DEFAULT_TARGET = "es2022";
-async function buildPackage(packageDir, options = {}) {
-  const aliases = options.aliases ?? DEFAULT_ALIASES;
-  const cacheFile = options.cacheFile ?? DEFAULT_CACHE_FILE;
-  const outputConfig = {
-    format: options.format ?? DEFAULT_FORMAT,
-    platform: options.platform ?? DEFAULT_PLATFORM,
-    target: [options.target ?? DEFAULT_TARGET]
-  };
-  const entryPoints = await glob(options.entryGlobs ?? DEFAULT_ENTRY_GLOBS, {
-    cwd: packageDir,
-    ignore: options.ignore ?? DEFAULT_IGNORE
-  });
-  const dependencies = ["package.json"];
-  const { changed, currentHash } = await detectBuildChanges(
-    packageDir,
-    [...entryPoints, ...dependencies],
-    outputConfig,
-    cacheFile
-  );
-  if (!changed) {
-    return;
-  }
-  await build({
-    absWorkingDir: packageDir,
-    entryPoints,
-    outdir: options.outdir ?? DEFAULT_OUTDIR,
-    bundle: false,
-    sourcemap: false,
-    plugins: [rewriteTsExtensions(packageDir, aliases)],
-    ...outputConfig
-  });
-  await writeBuildCache(packageDir, cacheFile, currentHash);
-}
-async function computeBuildHash(packageDir, files, outputConfig) {
-  const hash = createHash("sha256");
-  for (const file of [...files].sort()) {
-    hash.update(file);
-    hash.update("\0");
-    hash.update(await readFile(path.join(packageDir, file)));
-  }
-  hash.update(JSON.stringify(outputConfig));
-  return hash.digest("hex");
-}
-function resolveAliasImports(code, fileDir, aliasMap, packageDir) {
-  let result = code;
-  for (const [alias, targetDir] of Object.entries(aliasMap)) {
-    const escaped = alias.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
-    const regex = new RegExp(String.raw`(?<=from\s+['"])${escaped}([^'"]+)(?=['"])`, "g");
-    result = result.replace(regex, (_, subpath) => {
-      const absolute = path.resolve(packageDir, targetDir, subpath);
-      const relative = path.relative(fileDir, absolute);
-      return relative.startsWith(".") ? relative : `./${relative}`;
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { glob } from 'glob';
+import * as ts from 'typescript';
+const PACKAGE_ICON = '📦';
+const SKIPPED_ICON = '⏭️';
+const DEFAULT_ENTRY_GLOBS = ['src/**/*.ts'];
+const DEFAULT_IGNORE = ['**/__tests__/**'];
+const DEFAULT_OUTDIR = 'dist/esm/';
+const DEFAULT_CACHE_FILE = 'dist/esm/.cache';
+const SOURCE_ROOT = 'src';
+const MINIMUM_TYPESCRIPT_MAJOR = 5;
+const MINIMUM_TYPESCRIPT_MINOR = 7;
+const TS_EXTENSION = '.ts';
+const JS_EXTENSION = '.js';
+export async function buildPackage(packageDir, options = {}) {
+    assertSupportedTypeScript();
+    const cacheFile = options.cacheFile ?? DEFAULT_CACHE_FILE;
+    const outdir = options.outdir ?? DEFAULT_OUTDIR;
+    const emitConfig = { outdir, declaration: true, rewriteRelativeImportExtensions: true };
+    const entryPoints = await glob(options.entryGlobs ?? DEFAULT_ENTRY_GLOBS, {
+        cwd: packageDir,
+        ignore: options.ignore ?? DEFAULT_IGNORE,
     });
-  }
-  return result;
-}
-function rewriteTsImportExtensions(code) {
-  return code.replaceAll(/(?<=from\s+['"])(\.{1,2}\/[^'"]+)\.ts(?=['"])/g, "$1.js");
-}
-async function detectBuildChanges(packageDir, files, outputConfig, cacheFile) {
-  const packageName = path.basename(packageDir);
-  const cachePath = path.join(packageDir, cacheFile);
-  const previousHash = existsSync(cachePath) ? readFileSync(cachePath, "utf8") : void 0;
-  const currentHash = await computeBuildHash(packageDir, files, outputConfig);
-  if (previousHash === currentHash) {
-    console.info(`${SKIPPED_ICON} ${packageName}: No changes detected. Skipping build.`);
-    return { changed: false, currentHash };
-  }
-  console.info(`${PACKAGE_ICON} ${packageName}: Changes detected.`);
-  return { changed: true, currentHash };
+    const dependencies = ['package.json', ...resolveTsconfigChain(packageDir)];
+    const { changed, currentHash } = await detectBuildChanges(packageDir, [...entryPoints, ...dependencies], emitConfig, cacheFile);
+    if (!changed) {
+        return;
+    }
+    emitPackage(packageDir, entryPoints, outdir);
+    await writeBuildCache(packageDir, cacheFile, currentHash);
+}
+export async function computeBuildHash(packageDir, files, emitConfig) {
+    const hash = createHash('sha256');
+    for (const file of [...files].sort()) {
+        hash.update(file);
+        hash.update('\0');
+        hash.update(await readFile(path.join(packageDir, file)));
+    }
+    hash.update(JSON.stringify(emitConfig));
+    return hash.digest('hex');
+}
+export function resolveTsconfigChain(packageDir, configFileName = 'tsconfig.json') {
+    const resolvedChain = [];
+    const seen = new Set();
+    function walk(configPath) {
+        const normalized = path.resolve(configPath);
+        if (seen.has(normalized)) {
+            return;
+        }
+        seen.add(normalized);
+        resolvedChain.push(normalized);
+        const configFile = ts.readConfigFile(normalized, (fileName) => ts.sys.readFile(fileName));
+        if (configFile.error) {
+            throw new Error(`nmr-compile: failed to read ${normalized}.\n${formatDiagnostics([configFile.error])}`);
+        }
+        for (const entry of normalizeExtendsField(configFile.config)) {
+            const baseConfig = resolveExtendsTarget(entry, normalized);
+            if (baseConfig !== undefined) {
+                walk(baseConfig);
+            }
+        }
+    }
+    walk(path.resolve(packageDir, configFileName));
+    return resolvedChain.map((absolute) => path.relative(packageDir, absolute));
+}
+function emitPackage(packageDir, entryPoints, outdir) {
+    const compilerOptions = synthesizeCompilerOptions(packageDir, outdir);
+    const rootNames = entryPoints.map((entry) => path.resolve(packageDir, entry));
+    const sourceRoot = path.resolve(packageDir, SOURCE_ROOT);
+    const program = ts.createProgram(rootNames, compilerOptions);
+    const emittedFiles = [];
+    const emitResult = program.emit(undefined, (fileName, text, writeByteOrderMark) => {
+        ts.sys.writeFile(fileName, text, writeByteOrderMark);
+        emittedFiles.push(fileName);
+    });
+    if (emitResult.emitSkipped) {
+        throw new Error(`nmr-compile: emit failed.\n${formatDiagnostics(emitResult.diagnostics)}`);
+    }
+    for (const file of emittedFiles) {
+        rewriteOutputSpecifiers(file, compilerOptions, sourceRoot);
+    }
+}
+function synthesizeCompilerOptions(packageDir, outdir) {
+    const configPath = path.join(packageDir, 'tsconfig.json');
+    const configFile = ts.readConfigFile(configPath, (fileName) => ts.sys.readFile(fileName));
+    if (configFile.error) {
+        throw new Error(`nmr-compile: failed to read ${configPath}.\n${formatDiagnostics([configFile.error])}`);
+    }
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, packageDir);
+    if (parsed.errors.length > 0) {
+        throw new Error(`nmr-compile: failed to parse ${configPath}.\n${formatDiagnostics(parsed.errors)}`);
+    }
+    const resolvedOutDir = path.resolve(packageDir, outdir);
+    return {
+        ...parsed.options,
+        noEmit: false,
+        emitDeclarationOnly: false,
+        declaration: true,
+        rewriteRelativeImportExtensions: true,
+        outDir: resolvedOutDir,
+        declarationDir: resolvedOutDir,
+        rootDir: path.resolve(packageDir, SOURCE_ROOT),
+        sourceMap: false,
+        declarationMap: false,
+        noEmitOnError: false,
+    };
+}
+function rewriteOutputSpecifiers(outputFile, compilerOptions, sourceRoot) {
+    if (!isRewritableOutput(outputFile)) {
+        return;
+    }
+    const originalText = readFileSync(outputFile, 'utf8');
+    const sourceFile = ts.createSourceFile(outputFile, originalText, ts.ScriptTarget.Latest, false, scriptKindFor(outputFile));
+    const aliasPrefixes = collectAliasPrefixes(compilerOptions);
+    const sourceContainingFile = mapOutputToSource(outputFile, compilerOptions, sourceRoot);
+    const edits = [];
+    forEachModuleSpecifier(sourceFile, (literal) => {
+        const replacement = resolveSpecifierReplacement(literal.text, sourceContainingFile, compilerOptions, sourceRoot, aliasPrefixes);
+        if (replacement === undefined) {
+            return;
+        }
+        const start = literal.getStart(sourceFile);
+        const quote = originalText[start] ?? '"';
+        edits.push({ start, end: literal.getEnd(), text: `${quote}${replacement}${quote}` });
+    });
+    if (edits.length === 0) {
+        return;
+    }
+    const orderedEdits = [...edits].sort((a, b) => b.start - a.start);
+    let updatedText = originalText;
+    for (const edit of orderedEdits) {
+        updatedText = updatedText.slice(0, edit.start) + edit.text + updatedText.slice(edit.end);
+    }
+    writeFileSync(outputFile, updatedText);
+}
+function resolveSpecifierReplacement(specifier, sourceContainingFile, compilerOptions, sourceRoot, aliasPrefixes) {
+    if (isRelativeSpecifier(specifier)) {
+        const rewritten = swapTypeScriptExtension(specifier);
+        return rewritten === specifier ? undefined : rewritten;
+    }
+    if (!aliasPrefixes.some((prefix) => specifier === prefix || specifier.startsWith(prefix))) {
+        return undefined;
+    }
+    const resolved = ts.resolveModuleName(specifier, sourceContainingFile, compilerOptions, ts.sys).resolvedModule;
+    if (!resolved) {
+        throw new Error(`nmr-compile: could not resolve aliased import '${specifier}' from ${sourceContainingFile}. ` +
+            `Verify the tsconfig 'paths' mapping and that the target file exists.`);
+    }
+    if (!isWithin(sourceRoot, resolved.resolvedFileName)) {
+        return undefined;
+    }
+    const relative = toRelativeSpecifier(path.dirname(sourceContainingFile), resolved.resolvedFileName);
+    return swapTypeScriptExtension(relative);
+}
+function forEachModuleSpecifier(sourceFile, visit) {
+    function walk(node) {
+        const specifier = getModuleSpecifier(node);
+        if (specifier !== undefined) {
+            visit(specifier);
+        }
+        ts.forEachChild(node, walk);
+    }
+    walk(sourceFile);
+}
+function getModuleSpecifier(node) {
+    if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && node.moduleSpecifier !== undefined) {
+        return ts.isStringLiteralLike(node.moduleSpecifier) ? node.moduleSpecifier : undefined;
+    }
+    if (ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference)) {
+        return ts.isStringLiteralLike(node.moduleReference.expression) ? node.moduleReference.expression : undefined;
+    }
+    if (ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument)) {
+        return ts.isStringLiteralLike(node.argument.literal) ? node.argument.literal : undefined;
+    }
+    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+        const [first] = node.arguments;
+        return first !== undefined && ts.isStringLiteralLike(first) ? first : undefined;
+    }
+    return undefined;
+}
+async function detectBuildChanges(packageDir, files, emitConfig, cacheFile) {
+    const packageName = path.basename(packageDir);
+    const cachePath = path.join(packageDir, cacheFile);
+    const previousHash = existsSync(cachePath) ? readFileSync(cachePath, 'utf8') : undefined;
+    const currentHash = await computeBuildHash(packageDir, files, emitConfig);
+    if (previousHash === currentHash) {
+        console.info(`${SKIPPED_ICON} ${packageName}: No changes detected. Skipping build.`);
+        return { changed: false, currentHash };
+    }
+    console.info(`${PACKAGE_ICON} ${packageName}: Changes detected.`);
+    return { changed: true, currentHash };
 }
 async function writeBuildCache(packageDir, cacheFile, hash) {
-  const cachePath = path.join(packageDir, cacheFile);
-  await mkdir(path.dirname(cachePath), { recursive: true });
-  await writeFile(cachePath, hash);
-}
-function rewriteTsExtensions(packageDir, aliasMap) {
-  const aliasBase = realpathSync(packageDir);
-  return {
-    name: "rewrite-ts-extensions",
-    setup(pluginBuild) {
-      pluginBuild.onLoad({ filter: /\.ts$/ }, async (args) => {
-        const fileDir = path.dirname(args.path);
-        let code = await readFile(args.path, "utf8");
-        let shebang = "";
-        if (code.startsWith("#!")) {
-          const newlineIndex = code.indexOf("\n");
-          if (newlineIndex === -1) {
-            return { contents: code, loader: "ts" };
-          }
-          shebang = code.slice(0, newlineIndex + 1);
-          code = code.slice(newlineIndex + 1);
+    const cachePath = path.join(packageDir, cacheFile);
+    await mkdir(path.dirname(cachePath), { recursive: true });
+    await writeFile(cachePath, hash);
+}
+function assertSupportedTypeScript() {
+    const [majorPart, minorPart] = ts.versionMajorMinor.split('.');
+    const major = majorPart === undefined ? 0 : Number(majorPart);
+    const minor = minorPart === undefined ? 0 : Number(minorPart);
+    const tooOld = major < MINIMUM_TYPESCRIPT_MAJOR || (major === MINIMUM_TYPESCRIPT_MAJOR && minor < MINIMUM_TYPESCRIPT_MINOR);
+    if (tooOld) {
+        throw new Error(`nmr-compile requires TypeScript >=${MINIMUM_TYPESCRIPT_MAJOR}.${MINIMUM_TYPESCRIPT_MINOR} for ` +
+            `rewriteRelativeImportExtensions, but found ${ts.version}. Upgrade the 'typescript' peer dependency.`);
+    }
+}
+function collectAliasPrefixes(compilerOptions) {
+    if (compilerOptions.paths === undefined) {
+        return [];
+    }
+    return Object.keys(compilerOptions.paths).map((pattern) => pattern.replace(/\*$/, ''));
+}
+function formatDiagnostics(diagnostics) {
+    return ts.formatDiagnosticsWithColorAndContext(diagnostics, {
+        getCurrentDirectory: () => process.cwd(),
+        getCanonicalFileName: (fileName) => fileName,
+        getNewLine: () => ts.sys.newLine,
+    });
+}
+function isRewritableOutput(file) {
+    return file.endsWith('.d.ts') || file.endsWith('.js');
+}
+function normalizeExtendsField(config) {
+    if (config === null || typeof config !== 'object' || !('extends' in config)) {
+        return [];
+    }
+    const extendsField = config.extends;
+    if (typeof extendsField === 'string') {
+        return [extendsField];
+    }
+    if (Array.isArray(extendsField)) {
+        return extendsField.filter((entry) => typeof entry === 'string');
+    }
+    return [];
+}
+function resolveExtendsTarget(extendsEntry, fromConfigPath) {
+    if (isRelativeSpecifier(extendsEntry) || path.isAbsolute(extendsEntry)) {
+        const base = path.resolve(path.dirname(fromConfigPath), extendsEntry);
+        if (ts.sys.fileExists(base)) {
+            return base;
         }
-        code = resolveAliasImports(code, fileDir, aliasMap, aliasBase);
-        code = rewriteTsImportExtensions(code);
-        return { contents: `${shebang}${code}`, loader: "ts" };
-      });
-    }
-  };
-}
-export {
-  buildPackage,
-  computeBuildHash,
-  resolveAliasImports,
-  rewriteTsImportExtensions
-};
+        const withJsonExtension = `${base}.json`;
+        return ts.sys.fileExists(withJsonExtension) ? withJsonExtension : undefined;
+    }
+    const { resolvedModule } = ts.resolveModuleName(extendsEntry, fromConfigPath, { moduleResolution: ts.ModuleResolutionKind.NodeNext, resolveJsonModule: true }, ts.sys);
+    return resolvedModule?.resolvedFileName;
+}
+function isRelativeSpecifier(specifier) {
+    return specifier.startsWith('./') || specifier.startsWith('../');
+}
+function isWithin(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+function mapOutputToSource(outputFile, compilerOptions, sourceRoot) {
+    const outDir = compilerOptions.outDir ?? path.dirname(outputFile);
+    const relativeFromOut = path.relative(outDir, outputFile);
+    const withoutExtension = relativeFromOut.replace(/\.d\.ts$|\.js$/, '');
+    return path.join(sourceRoot, `${withoutExtension}.ts`);
+}
+function toRelativeSpecifier(fromDir, targetFile) {
+    const relative = path.relative(fromDir, targetFile).split(path.sep).join('/');
+    return relative.startsWith('.') ? relative : `./${relative}`;
+}
+function scriptKindFor(file) {
+    return file.endsWith('.d.ts') ? ts.ScriptKind.TS : ts.ScriptKind.JS;
+}
+function swapTypeScriptExtension(specifier) {
+    return specifier.endsWith(TS_EXTENSION) ? `${specifier.slice(0, -TS_EXTENSION.length)}${JS_EXTENSION}` : specifier;
+}

package/dist/esm/commands/ensure-prepublish-hooks.js

@@ -1,76 +1,73 @@
-import { readFileSync, writeFileSync } from "node:fs";
-import path from "node:path";
+import { readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
 import { getWorkspacePackageDirs } from "../context.js";
 import { readPackageJson } from "../helpers/package-json.js";
 import { isObject } from "../helpers/type-guards.js";
-const DEFAULT_HOOK = "npm run build";
-function ensurePrepublishHooks(monorepoRoot, options) {
-  const hookCommand = options.command ?? DEFAULT_HOOK;
-  const packageDirs = getWorkspacePackageDirs(monorepoRoot);
-  const packages = [];
-  for (const packageDir of packageDirs) {
-    const pkg = readPackageJson(packageDir);
-    const packageName = pkg.name ?? path.basename(packageDir);
-    const isPrivate = pkg.private === true;
-    if (isPrivate) {
-      packages.push({
-        packageName,
-        packageDir,
-        isPrivate: true,
-        prepublishOnly: pkg.scripts?.prepublishOnly,
-        action: "ok"
-      });
-      continue;
+export const DEFAULT_HOOK = 'npm run build';
+export function ensurePrepublishHooks(monorepoRoot, options) {
+    const hookCommand = options.command ?? DEFAULT_HOOK;
+    const packageDirs = getWorkspacePackageDirs(monorepoRoot);
+    const packages = [];
+    for (const packageDir of packageDirs) {
+        const pkg = readPackageJson(packageDir);
+        const packageName = pkg.name ?? path.basename(packageDir);
+        const isPrivate = pkg.private === true;
+        if (isPrivate) {
+            packages.push({
+                packageName,
+                packageDir,
+                isPrivate: true,
+                prepublishOnly: pkg.scripts?.prepublishOnly,
+                action: 'ok',
+            });
+            continue;
+        }
+        const existing = pkg.scripts?.prepublishOnly;
+        if (existing) {
+            packages.push({
+                packageName,
+                packageDir,
+                isPrivate: false,
+                prepublishOnly: existing,
+                action: 'ok',
+            });
+            continue;
+        }
+        if (options.fix) {
+            const action = options.dryRun ? 'would-fix' : 'fixed';
+            if (!options.dryRun) {
+                addPrepublishOnly(packageDir, hookCommand);
+            }
+            packages.push({
+                packageName,
+                packageDir,
+                isPrivate: false,
+                prepublishOnly: undefined,
+                action,
+            });
+        }
+        else {
+            packages.push({
+                packageName,
+                packageDir,
+                isPrivate: false,
+                prepublishOnly: undefined,
+                action: 'missing',
+            });
+        }
     }
-    const existing = pkg.scripts?.prepublishOnly;
-    if (existing) {
-      packages.push({
-        packageName,
-        packageDir,
-        isPrivate: false,
-        prepublishOnly: existing,
-        action: "ok"
-      });
-      continue;
-    }
-    if (options.fix) {
-      const action = options.dryRun ? "would-fix" : "fixed";
-      if (!options.dryRun) {
-        addPrepublishOnly(packageDir, hookCommand);
-      }
-      packages.push({
-        packageName,
-        packageDir,
-        isPrivate: false,
-        prepublishOnly: void 0,
-        action
-      });
-    } else {
-      packages.push({
-        packageName,
-        packageDir,
-        isPrivate: false,
-        prepublishOnly: void 0,
-        action: "missing"
-      });
-    }
-  }
-  const hasFailures = packages.some((p) => p.action === "missing");
-  return { packages, hasFailures };
+    const hasFailures = packages.some((p) => p.action === 'missing');
+    return { packages, hasFailures };
 }
 function addPrepublishOnly(packageDir, command) {
-  const filePath = path.join(packageDir, "package.json");
-  const raw = readFileSync(filePath, "utf8");
-  const parsed = JSON.parse(raw);
-  if (!isObject(parsed)) {
-    throw new TypeError(`Invalid package.json in ${packageDir}: expected an object`);
-  }
-  const scripts = isObject(parsed.scripts) ? parsed.scripts : {};
-  scripts.prepublishOnly = command;
-  parsed.scripts = scripts;
-  writeFileSync(filePath, JSON.stringify(parsed, null, 2) + "\n", "utf8");
+    const filePath = path.join(packageDir, 'package.json');
+    const raw = readFileSync(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!isObject(parsed)) {
+        throw new TypeError(`Invalid package.json in ${packageDir}: expected an object`);
+    }
+    const scripts = isObject(parsed.scripts) ? parsed.scripts : {};
+    scripts.prepublishOnly = command;
+    parsed.scripts = scripts;
+    writeFileSync(filePath, JSON.stringify(parsed, null, 2) + '\n', 'utf8');
 }
-export {
-  DEFAULT_HOOK,
-  ensurePrepublishHooks
-};

package/dist/esm/commands/report-overrides.js

@@ -1,15 +1,12 @@
 import { getPnpmOverrides, readPackageJson } from "../helpers/package-json.js";
-function reportOverrides(monorepoRoot) {
-  const pkg = readPackageJson(monorepoRoot);
-  const overrides = getPnpmOverrides(pkg);
-  if (!overrides || Object.keys(overrides).length === 0) {
-    return;
-  }
-  console.warn("\u{1F512} WARN: pnpm overrides are active! Check whether these are still needed:");
-  for (const [name, version] of Object.entries(overrides)) {
-    console.warn(`- ${name} \u2192 ${version}`);
-  }
+export function reportOverrides(monorepoRoot) {
+    const pkg = readPackageJson(monorepoRoot);
+    const overrides = getPnpmOverrides(pkg);
+    if (!overrides || Object.keys(overrides).length === 0) {
+        return;
+    }
+    console.warn('🔒 WARN: pnpm overrides are active! Check whether these are still needed:');
+    for (const [name, version] of Object.entries(overrides)) {
+        console.warn(`- ${name} → ${version}`);
+    }
 }
-export {
-  reportOverrides
-};