@dennisrepa/elevate 1.7.0 → 1.8.0

package/dist/cli.js

@@ -1,3505 +1,20 @@
 #!/usr/bin/env node
+import {
+  ConfigError,
+  EcosystemFactory,
+  InstallError,
+  VERSION,
+  buildWorkspaceIndex,
+  classifyOrigin,
+  extractPreReleaseTag,
+  isPreReleaseVersion,
+  loadConfig,
+  matchesInternalScope
+} from "./chunk-4YCMSRA6.js";
 
 // src/index.tsx
 import { render } from "ink";
 
-// src/config.ts
-import { existsSync as existsSync16, readFileSync as readFileSync16 } from "fs";
-import { dirname as dirname10, join as join23, resolve as resolve14 } from "path";
-
-// src/domain/version-policy.ts
-import semver2 from "semver";
-
-// src/domain/versions.ts
-import semver from "semver";
-var PRE_RELEASE = /(?:^|[.\-_+]|(?<=\d))(alpha|beta|rc|cr|milestone|preview|snapshot|ea|dev|pre|(?:a|b|m)(?=\d))(?=$|[.\-_+]|\d)/i;
-function isPreReleaseVersion(version) {
-  return PRE_RELEASE.test(version);
-}
-function extractPreReleaseTag(version) {
-  const match = version.match(PRE_RELEASE);
-  if (!match) return void 0;
-  const token = match[1].toLowerCase();
-  if (token === "a") return "ALPHA";
-  if (token === "b") return "BETA";
-  if (token === "m") {
-    const number = version.slice((match.index ?? 0) + match[0].length).match(/^\d+/)?.[0];
-    return `M${number ?? ""}`;
-  }
-  return token.toUpperCase();
-}
-function cleanJavaVersion(version) {
-  const match = version.match(/^v?(\d+(?:\.\d+){0,2})/);
-  if (!match) return null;
-  return semver.coerce(match[1])?.version ?? null;
-}
-function diffVersions(from, to) {
-  const kind = semver.diff(from, to);
-  if (kind === "major" || kind === "premajor") return "major";
-  if (kind === "minor" || kind === "preminor") return "minor";
-  return "patch";
-}
-function rangePrefix(range) {
-  if (range.startsWith("^")) return "^";
-  if (range.startsWith("~")) return "~";
-  return "";
-}
-
-// src/domain/version-policy.ts
-function semverDiff(current, target, normalize) {
-  const to = normalize(target);
-  if (!to || !semver2.valid(current)) return "minor";
-  return semver2.eq(current, to) ? "patch" : diffVersions(current, to);
-}
-var npmVersionPolicy = {
-  normalize: (v) => semver2.valid(v),
-  rewrite: (current, target) => `${rangePrefix(current)}${target}`,
-  diff: (current, target) => semverDiff(current, target, (v) => semver2.valid(v)),
-  allowsManualTargets: true
-};
-var mavenVersionPolicy = {
-  normalize: cleanJavaVersion,
-  rewrite: (_current, target) => target,
-  diff: (current, target) => semverDiff(current, target, cleanJavaVersion),
-  allowsManualTargets: false
-};
-
-// src/adapters/npm/npm-package-manager.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
-
-// src/adapters/shared/checkout.ts
-import { existsSync } from "fs";
-import { dirname, join, resolve } from "path";
-function findCheckoutBoundary(startDir) {
-  let dir = resolve(startDir);
-  for (; ; ) {
-    if (existsSync(join(dir, ".git"))) return dir;
-    const parent = dirname(dir);
-    if (parent === dir) return void 0;
-    dir = parent;
-  }
-}
-
-// src/adapters/shared/process.ts
-import { exec, spawn } from "child_process";
-var UnsafeArgumentError = class extends Error {
-  constructor(argument) {
-    super(
-      `Cannot pass ${JSON.stringify(argument)} to the Windows command shell: it contains one of the characters " % ! ^ & | < > or a line break, which cmd.exe would interpret. If this is part of a directory or file name, rename it or move the project to a path without these characters.`
-    );
-    this.name = "UnsafeArgumentError";
-  }
-};
-var IS_WINDOWS = process.platform === "win32";
-var WINDOWS_UNSAFE = /["%!^&|<>\r\n]/;
-function runCommand(command, args, options) {
-  return new Promise((resolve16, reject) => {
-    const spawnOptions = { cwd: options.cwd, windowsHide: true, env: process.env };
-    let child2;
-    if (IS_WINDOWS) {
-      for (const arg of [command, ...args]) {
-        if (WINDOWS_UNSAFE.test(arg)) {
-          reject(new UnsafeArgumentError(arg));
-          return;
-        }
-      }
-      const commandLine = [command, ...args].map(quoteWindows).join(" ");
-      child2 = spawn(commandLine, { ...spawnOptions, shell: true });
-    } else {
-      child2 = spawn(command, args, spawnOptions);
-    }
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-    child2.stdout.setEncoding("utf8").on("data", (chunk) => stdout += chunk);
-    child2.stderr.setEncoding("utf8").on("data", (chunk) => stderr += chunk);
-    const timer = options.timeoutMs ? setTimeout(() => {
-      timedOut = true;
-      killTree(child2.pid, () => child2.kill());
-    }, options.timeoutMs) : void 0;
-    child2.on("error", (err) => {
-      if (timer) clearTimeout(timer);
-      reject(err);
-    });
-    child2.on("close", (code) => {
-      if (timer) clearTimeout(timer);
-      resolve16({ exitCode: code ?? 1, stdout, stderr, timedOut });
-    });
-  });
-}
-function runShellScript(script, options) {
-  return new Promise((resolve16) => {
-    exec(
-      script,
-      { cwd: options.cwd, timeout: options.timeoutMs, maxBuffer: 64 * 1024 * 1024, windowsHide: true },
-      (error, stdout, stderr) => {
-        const timedOut = Boolean(error?.killed);
-        const exitCode = error ? typeof error.code === "number" ? error.code : 1 : 0;
-        resolve16({ exitCode, stdout, stderr, timedOut });
-      }
-    );
-  });
-}
-function killTree(pid, fallback) {
-  if (!IS_WINDOWS || pid === void 0) {
-    fallback();
-    return;
-  }
-  const killer = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" });
-  killer.on("error", fallback);
-}
-function tail(output, lines = 15) {
-  return output.trim().split(/\r?\n/).slice(-lines).join("\n");
-}
-function quoteWindows(arg) {
-  return /^[\w.:\\/@+-]+$/.test(arg) ? arg : `"${arg}"`;
-}
-
-// src/adapters/npm/npm-package-manager.ts
-var MARKER_FILES = [
-  ["npm", ["package-lock.json", "npm-shrinkwrap.json"]],
-  ["pnpm", ["pnpm-lock.yaml", "pnpm-workspace.yaml"]],
-  ["yarn", ["yarn.lock", ".yarnrc.yml"]],
-  ["bun", ["bun.lock", "bun.lockb"]]
-];
-var UnsupportedPackageManagerError = class extends Error {
-  constructor(detected) {
-    super(
-      `This repository is managed by ${detected.name} (${detected.evidence}). Elevate supports npm and pnpm for Node.js projects; using either here would create a lockfile next to ${detected.name}'s. Nothing was changed.`
-    );
-    this.name = "UnsupportedPackageManagerError";
-  }
-};
-function detectPackageManager(dir) {
-  const boundary = findCheckoutBoundary(dir);
-  let current = resolve2(dir);
-  for (; ; ) {
-    const found = detectIn(current);
-    if (found) return found;
-    const parent = dirname2(current);
-    if (boundary === void 0 || current === boundary || parent === current) break;
-    current = parent;
-  }
-  return { name: "npm", evidence: "no other package manager detected" };
-}
-function detectIn(dir) {
-  const declared = readPackageManagerField(dir);
-  const name = declared?.match(/^(npm|pnpm|yarn|bun)@/)?.[1];
-  if (declared && name) return { name, evidence: `"packageManager": "${declared}" in package.json` };
-  for (const [manager, files] of MARKER_FILES) {
-    const found = files.find((file) => existsSync2(join2(dir, file)));
-    if (found) return { name: manager, evidence: found };
-  }
-  return void 0;
-}
-function assertSupportedPackageManager(rootDir) {
-  const detected = detectPackageManager(rootDir);
-  if (detected.name === "npm" || detected.name === "pnpm") return detected.name;
-  throw new UnsupportedPackageManagerError(detected);
-}
-var PackageManagerNotFoundError = class extends Error {
-  constructor(reason, detected) {
-    super(
-      `pnpm could not be run in this repository (${reason}). This repository is managed by pnpm (${detected.evidence}); install pnpm or enable Corepack (corepack enable). Nothing was changed.`
-    );
-    this.name = "PackageManagerNotFoundError";
-  }
-};
-var VERSION_TIMEOUT_MS = 15e3;
-var verifiedRoots = /* @__PURE__ */ new Set();
-async function ensurePnpmRunnable(rootDir, detected) {
-  const key = resolve2(rootDir);
-  if (verifiedRoots.has(key)) return;
-  let reason;
-  try {
-    const result = await runCommand("pnpm", ["--version"], { cwd: rootDir, timeoutMs: VERSION_TIMEOUT_MS });
-    if (result.timedOut) reason = "pnpm --version timed out";
-    else if (result.exitCode !== 0) {
-      const line = firstLine(result.stderr) || firstLine(result.stdout);
-      reason = `pnpm --version exited with code ${result.exitCode}: ${line}`;
-    }
-  } catch {
-    reason = "command not found";
-  }
-  if (reason !== void 0) throw new PackageManagerNotFoundError(reason, detected);
-  verifiedRoots.add(key);
-}
-async function prepareSupportedPackageManager(rootDir) {
-  const manager = assertSupportedPackageManager(rootDir);
-  if (manager === "pnpm") await ensurePnpmRunnable(rootDir, detectPackageManager(rootDir));
-  return manager;
-}
-function firstLine(text) {
-  return text.split(/\r?\n/).find((l) => l.trim() !== "")?.trim() ?? "";
-}
-function readPackageManagerField(rootDir) {
-  try {
-    const field = JSON.parse(readFileSync(join2(rootDir, "package.json"), "utf8"))?.packageManager;
-    return typeof field === "string" ? field : void 0;
-  } catch {
-    return void 0;
-  }
-}
-
-// src/adapters/npm/npm-discovery.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname3, join as join4, relative, resolve as resolve3 } from "path";
-import mapWorkspaces from "@npmcli/map-workspaces";
-
-// src/adapters/npm/pnpm-workspace.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join3 } from "path";
-import { isMap, isScalar, parse, parseDocument } from "yaml";
-var PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function entries(value) {
-  const map = /* @__PURE__ */ new Map();
-  if (isRecord(value)) {
-    for (const [name, range] of Object.entries(value)) {
-      if (typeof range === "string") map.set(name, range);
-    }
-  }
-  return map;
-}
-function readPnpmWorkspace(rootDir) {
-  const file = join3(rootDir, PNPM_WORKSPACE_FILE);
-  let data;
-  try {
-    data = parse(readFileSync2(file, "utf8"));
-  } catch {
-    return void 0;
-  }
-  if (data !== null && !isRecord(data)) return void 0;
-  const doc = data ?? {};
-  const packages = Array.isArray(doc.packages) ? doc.packages.filter((p) => typeof p === "string") : [];
-  const catalogs = /* @__PURE__ */ new Map();
-  const named = isRecord(doc.catalogs) ? doc.catalogs : {};
-  for (const [name, content] of Object.entries(named)) catalogs.set(name, entries(content));
-  const hasTopLevel = isRecord(doc.catalog);
-  const hasNamedDefault = isRecord(named.default);
-  if (hasTopLevel) catalogs.set("default", entries(doc.catalog));
-  return { file, packages, catalogs, ambiguousDefaultCatalog: hasTopLevel && hasNamedDefault };
-}
-function setCatalogRange(source, catalog, name, newRange) {
-  const doc = parseDocument(source);
-  const holders = catalog === "default" ? [doc.get("catalog", true), doc.getIn(["catalogs", "default"], true)] : [doc.getIn(["catalogs", catalog], true)];
-  for (const holder of holders) {
-    if (!isMap(holder)) continue;
-    const node = holder.get(name, true);
-    if (!isScalar(node) || !node.range) continue;
-    const scalar = node;
-    const [start, end] = scalar.range;
-    const quote = scalar.type === "QUOTE_DOUBLE" ? '"' : scalar.type === "QUOTE_SINGLE" ? "'" : "";
-    return source.slice(0, start) + quote + newRange + quote + source.slice(end);
-  }
-  throw new Error(`No entry for '${name}' in catalog '${catalog}' of ${PNPM_WORKSPACE_FILE}.`);
-}
-
-// src/adapters/npm/npm-discovery.ts
-function readJson(filePath) {
-  try {
-    return JSON.parse(readFileSync3(filePath, "utf8"));
-  } catch {
-    return null;
-  }
-}
-var NpmModuleDiscoveryAdapter = class {
-  /**
-   * The nearest directory, from `startDir` upwards to the boundary, whose
-   * package.json is valid JSON and declares `workspaces`, or that contains a
-   * valid `pnpm-workspace.yaml`.
-   */
-  findRoot(startDir, boundaryDir) {
-    let dir = resolve3(startDir);
-    const boundary = boundaryDir ? resolve3(boundaryDir) : void 0;
-    for (; ; ) {
-      if (readJson(join4(dir, "package.json"))?.workspaces || readPnpmWorkspace(dir)) return dir;
-      const parent = dirname3(dir);
-      if (dir === boundary || parent === dir) return void 0;
-      dir = parent;
-    }
-  }
-  async discover(rootDir) {
-    const rootPkg = readJson(join4(rootDir, "package.json"));
-    const modules = [
-      {
-        id: rootPkg?.name ?? "root",
-        name: rootPkg?.name ?? "Root Workspace (npm)",
-        path: rootDir,
-        relPath: "Root",
-        ecosystem: "npm",
-        isRoot: true,
-        version: typeof rootPkg?.version === "string" ? rootPkg.version : void 0
-      }
-    ];
-    const patterns = detectPackageManager(rootDir).name === "pnpm" ? readPnpmWorkspace(rootDir)?.packages : rootPkg?.workspaces;
-    if (!patterns || Array.isArray(patterns) && patterns.length === 0) return modules;
-    let workspaces;
-    try {
-      workspaces = await mapWorkspaces({ cwd: rootDir, pkg: { ...rootPkg, workspaces: patterns } });
-    } catch {
-      return modules;
-    }
-    for (const [name, path] of workspaces) {
-      const pkg = readJson(join4(path, "package.json"));
-      modules.push({
-        id: name,
-        name,
-        path,
-        relPath: relative(rootDir, path).replace(/\\/g, "/"),
-        ecosystem: "npm",
-        isRoot: false,
-        version: typeof pkg?.version === "string" ? pkg.version : void 0
-      });
-    }
-    modules.sort((a, b) => a.isRoot ? -1 : b.isRoot ? 1 : a.relPath.localeCompare(b.relPath));
-    return modules;
-  }
-};
-
-// src/adapters/npm/npm-registry.ts
-import semver3 from "semver";
-
-// src/domain/origin.ts
-function buildWorkspaceIndex(modules) {
-  const index = /* @__PURE__ */ new Map();
-  for (const module of modules) {
-    if (module.id && module.id !== "empty") index.set(module.id, module);
-  }
-  return index;
-}
-function classifyOrigin(identifier, ecosystem, context) {
-  const module = context.workspace.get(identifier);
-  if (module) {
-    return { kind: "workspace", moduleId: module.id, moduleRelPath: module.relPath };
-  }
-  if (matchesInternalScope(identifier, ecosystem, context.internalScopes)) {
-    return { kind: "private", matchedBy: "internal-scope" };
-  }
-  if (ecosystem === "npm" && context.scopedRegistries) {
-    const scope = npmScopeOf(identifier);
-    const registry = scope ? context.scopedRegistries.get(scope) : void 0;
-    if (registry) return { kind: "private", matchedBy: "scoped-registry", registry };
-  }
-  return { kind: "public" };
-}
-function matchesInternalScope(identifier, ecosystem, internalScopes) {
-  if (ecosystem === "maven") {
-    const groupId = identifier.split(":")[0] ?? "";
-    return internalScopes.some((entry) => {
-      const prefix = entry.replace(/^@/, "").replace(/[.:/]+$/, "");
-      return prefix.length > 0 && (groupId === prefix || groupId.startsWith(`${prefix}.`));
-    });
-  }
-  return internalScopes.some((entry) => {
-    if (entry.startsWith("@")) {
-      const scope = entry.replace(/\/+$/, "");
-      return identifier.startsWith(`${scope}/`);
-    }
-    if (entry.endsWith("*")) return identifier.startsWith(entry.slice(0, -1));
-    return identifier === entry;
-  });
-}
-function npmScopeOf(name) {
-  if (!name.startsWith("@")) return void 0;
-  const slash = name.indexOf("/");
-  return slash > 1 ? name.slice(0, slash) : void 0;
-}
-
-// src/adapters/npm/npm-commands.ts
-function driverFor(dir) {
-  return detectPackageManager(dir).name === "pnpm" ? "pnpm" : "npm";
-}
-var commands = {
-  /** Install after Elevate wrote new ranges. pnpm is told explicitly not to freeze: `CI` would otherwise imply it. */
-  install: (m) => m === "pnpm" ? { command: "pnpm", args: ["install", "--no-frozen-lockfile"] } : { command: "npm", args: ["install"] },
-  /** Restore the installed state after a rollback. */
-  restore: (m) => m === "pnpm" ? { command: "pnpm", args: ["install", "--frozen-lockfile"] } : { command: "npm", args: ["install"] },
-  /** Default verification. */
-  verify: (m) => m === "pnpm" ? { command: "pnpm", args: ["install", "--frozen-lockfile", "--lockfile-only"] } : { command: "npm", args: ["ls"] },
-  view: (m, name, field) => ({ command: m, args: ["view", name, field, "--json"] }),
-  config: (m) => ({ command: m, args: ["config", "list", "--json"] })
-};
-
-// src/adapters/npm/npm-config.ts
-var DEFAULT_REGISTRY = "https://registry.npmjs.org/";
-var PUBLIC_NPM_HOSTS = /* @__PURE__ */ new Set(["registry.npmjs.org", "registry.npmjs.com", "registry.yarnpkg.com", "npm.jsr.io"]);
-var NpmConfigReader = class {
-  cache = /* @__PURE__ */ new Map();
-  /** Returns the registry configuration that applies in `cwd` (cached per directory). */
-  read(cwd) {
-    let pending = this.cache.get(cwd);
-    if (!pending) {
-      pending = loadConfig(cwd);
-      this.cache.set(cwd, pending);
-    }
-    return pending;
-  }
-  /** The registry npm would contact for this package. */
-  async registryFor(packageName, cwd) {
-    const config = await this.read(cwd);
-    const scope = npmScopeOf(packageName);
-    return scope && config.scopedRegistries.get(scope) || config.registry;
-  }
-};
-function isPublicNpmRegistry(url) {
-  try {
-    return PUBLIC_NPM_HOSTS.has(new URL(url).hostname.toLowerCase());
-  } catch {
-    return false;
-  }
-}
-function parseNpmConfig(json) {
-  const scopedRegistries = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(json)) {
-    const match = key.match(/^(@[^:]+):registry$/);
-    if (match && typeof value === "string" && value) scopedRegistries.set(match[1], value);
-  }
-  const registry = typeof json.registry === "string" && json.registry ? json.registry : DEFAULT_REGISTRY;
-  return { registry, scopedRegistries };
-}
-async function loadConfig(cwd) {
-  try {
-    const { command, args } = commands.config(driverFor(cwd));
-    const result = await runCommand(command, args, { cwd, timeoutMs: 15e3 });
-    if (result.exitCode !== 0) return parseNpmConfig({});
-    return parseNpmConfig(JSON.parse(result.stdout));
-  } catch {
-    return parseNpmConfig({});
-  }
-}
-
-// src/adapters/npm/npm-registry.ts
-var LOOKUP_TIMEOUT_MS = 15e3;
-var PACKAGE_NAME = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/i;
-function isValidPackageName(name) {
-  return name.length <= 214 && PACKAGE_NAME.test(name);
-}
-var NpmRegistryAdapter = class {
-  constructor(config = new NpmConfigReader()) {
-    this.config = config;
-  }
-  config;
-  async resolveEndpoint(coordinate, cwd) {
-    const url = await this.config.registryFor(coordinate.identifier, cwd);
-    return { url, isPublic: isPublicNpmRegistry(url) };
-  }
-  async getLatestVersion(coordinate, channel = "stable", cwd = process.cwd()) {
-    if (!isValidPackageName(coordinate.identifier)) return null;
-    if (channel === "stable") {
-      const latest = await this.view(coordinate.identifier, "dist-tags.latest", cwd);
-      if (typeof latest === "string" && semver3.valid(latest) && semver3.prerelease(latest) === null) {
-        return latest;
-      }
-      const releases = (await this.getAllVersions(coordinate, cwd)).filter(
-        (v) => semver3.valid(v) && semver3.prerelease(v) === null
-      );
-      return releases.length > 0 ? semver3.rsort(releases)[0] : null;
-    }
-    const version = await this.view(coordinate.identifier, "version", cwd);
-    return typeof version === "string" && version ? version : null;
-  }
-  async getAllVersions(coordinate, cwd = process.cwd()) {
-    if (!isValidPackageName(coordinate.identifier)) return [];
-    const versions = await this.view(coordinate.identifier, "versions", cwd);
-    const list = Array.isArray(versions) ? versions : versions ? [versions] : [];
-    return list.map(String).reverse();
-  }
-  /** Runs `npm view <name> <field> --json` (`pnpm view` in a pnpm repository); resolves null on any failure. */
-  async view(name, field, cwd) {
-    try {
-      const { command, args } = commands.view(driverFor(cwd), name, field);
-      const result = await runCommand(command, args, {
-        cwd,
-        timeoutMs: LOOKUP_TIMEOUT_MS
-      });
-      if (result.exitCode !== 0 || !result.stdout.trim()) return null;
-      return JSON.parse(result.stdout);
-    } catch {
-      return null;
-    }
-  }
-};
-
-// src/adapters/npm/npm-scanner.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join5 } from "path";
-import semver4 from "semver";
-
-// src/adapters/shared/pool.ts
-async function mapPooled(items, concurrency, fn) {
-  const results = new Array(items.length);
-  let next = 0;
-  async function worker() {
-    while (next < items.length) {
-      const index = next++;
-      results[index] = await fn(items[index]);
-    }
-  }
-  const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => worker());
-  await Promise.all(workers);
-  return results;
-}
-
-// src/adapters/npm/npm-protocols.ts
-function splitRangeProtocol(range) {
-  if (range.startsWith("workspace:")) return { protocol: "workspace", rest: range.slice("workspace:".length) };
-  if (range.startsWith("catalog:")) return { protocol: "catalog", rest: range.slice("catalog:".length) };
-  return { protocol: void 0, rest: range };
-}
-
-// src/adapters/npm/npm-scanner.ts
-var CONCURRENCY = 6;
-var DIFF_ORDER = { major: 0, minor: 1, patch: 2 };
-var NpmDependencyAdapter = class {
-  constructor(registry, config) {
-    this.registry = registry;
-    this.config = config;
-  }
-  registry;
-  config;
-  async scan(module, context) {
-    const manager = await prepareSupportedPackageManager(context.rootDir);
-    const pnpm = manager === "pnpm";
-    let pkg;
-    try {
-      pkg = JSON.parse(readFileSync4(join5(module.path, "package.json"), "utf8"));
-    } catch {
-      return { candidates: [], skipped: [] };
-    }
-    const npmConfig = await this.config.read(context.rootDir);
-    const originContext = {
-      workspace: context.workspace,
-      internalScopes: context.internalScopes,
-      // A scope mapped to a public registry is not internal; only private
-      // mappings mark their scope as private.
-      scopedRegistries: new Map(
-        [...npmConfig.scopedRegistries].filter(([, url]) => !isPublicNpmRegistry(url))
-      )
-    };
-    const workspaceFile = pnpm ? readPnpmWorkspace(context.rootDir) : void 0;
-    const outcomes = await mapPooled(declaredDependencies(pkg), CONCURRENCY, async (dep) => {
-      const origin = classifyOrigin(dep.name, "npm", originContext);
-      if (origin.kind === "workspace") {
-        const target = context.workspace.get(dep.name);
-        if (pnpm && isUpgradableRange(dep.range) && splitRangeProtocol(dep.range).protocol === void 0) {
-          return { skipped: { identifier: dep.name, origin: "workspace", reason: "not-linked", detail: dep.range } };
-        }
-        const candidate = target ? alignmentCandidate(dep, target, origin, pnpm) : null;
-        return candidate ? { candidate } : null;
-      }
-      if (pnpm && splitRangeProtocol(dep.range).protocol === "catalog") {
-        return this.catalogOutcome(dep, origin, context, module.path, workspaceFile);
-      }
-      return this.registryOutcome(dep, origin, context);
-    });
-    const candidates = [];
-    const skipped = [];
-    for (const outcome of outcomes) {
-      if (!outcome) continue;
-      if ("candidate" in outcome) candidates.push(outcome.candidate);
-      else skipped.push(outcome.skipped);
-    }
-    candidates.sort((a, b) => (DIFF_ORDER[a.diff] ?? 3) - (DIFF_ORDER[b.diff] ?? 3));
-    return { candidates, skipped };
-  }
-  /** A `catalog:` dependency: the range comes from pnpm-workspace.yaml and is written back there. */
-  async catalogOutcome(dep, origin, context, modulePath, workspaceFile) {
-    const catalogName = splitRangeProtocol(dep.range).rest || "default";
-    const unresolved = (detail) => ({
-      skipped: { identifier: dep.name, origin: origin.kind, reason: "catalog-unresolved", detail }
-    });
-    if (!workspaceFile) return unresolved("pnpm-workspace.yaml is missing or not valid YAML");
-    if (catalogName === "default" && workspaceFile.ambiguousDefaultCatalog) {
-      return unresolved("catalog 'default' is defined twice (catalog and catalogs.default)");
-    }
-    const catalog = workspaceFile.catalogs.get(catalogName);
-    if (!catalog) return unresolved(`no catalog '${catalogName}'`);
-    const range = catalog.get(dep.name);
-    if (range === void 0) return unresolved(`no entry for '${dep.name}' in catalog '${catalogName}'`);
-    const declaration = {
-      file: workspaceFile.file,
-      kind: "catalog",
-      catalogName,
-      displayPath: "pnpm-workspace.yaml"
-    };
-    const sharedWith = usersOfCatalogEntry(context, modulePath, dep.name, catalogName);
-    return this.registryOutcome({ ...dep, range }, origin, context, {
-      declaration,
-      ...sharedWith.length > 0 ? { sharedWith } : {}
-    });
-  }
-  /** Looks up a private or public dependency in its registry. */
-  async registryOutcome(dep, origin, context, extra = {}) {
-    if (!isUpgradableRange(dep.range)) return null;
-    if (!isValidPackageName(dep.name)) {
-      return { skipped: { identifier: dep.name, origin: origin.kind, reason: "invalid-name" } };
-    }
-    const coordinate = { identifier: dep.name, artifact: dep.name, ecosystem: "npm" };
-    let resolvedOrigin = origin;
-    if (origin.kind === "private") {
-      const endpoint = await this.registry.resolveEndpoint(coordinate, context.rootDir);
-      if (endpoint.isPublic) {
-        return {
-          skipped: {
-            identifier: dep.name,
-            origin: "private",
-            reason: "private-on-public-registry",
-            detail: endpoint.url
-          }
-        };
-      }
-      resolvedOrigin = { ...origin, registry: endpoint.url };
-    }
-    const latest = await this.registry.getLatestVersion(coordinate, context.channel, context.rootDir);
-    if (!latest) {
-      return { skipped: { identifier: dep.name, origin: origin.kind, reason: "lookup-failed" } };
-    }
-    const currentClean = semver4.minVersion(dep.range)?.version;
-    if (!currentClean || !semver4.valid(latest) || !semver4.gt(latest, currentClean)) return null;
-    const tag = semver4.prerelease(latest) ? extractPreReleaseTag(latest) ?? "PRE" : void 0;
-    const diff = diffVersions(currentClean, latest);
-    return {
-      candidate: {
-        coordinate,
-        currentRange: dep.range,
-        currentClean,
-        latest,
-        newRange: `${rangePrefix(dep.range)}${latest}`,
-        diff,
-        scope: dep.scope,
-        selected: diff !== "major",
-        origin: resolvedOrigin,
-        action: "update",
-        isPreRelease: tag !== void 0,
-        preReleaseTag: tag,
-        ...extra
-      }
-    };
-  }
-};
-var DEPENDENCY_SECTIONS = ["dependencies", "optionalDependencies", "devDependencies"];
-function declaredDependencies(pkg) {
-  const deps = /* @__PURE__ */ new Map();
-  for (const section of DEPENDENCY_SECTIONS) {
-    const scope = section === "devDependencies" ? "dev" : "prod";
-    for (const [name, range] of Object.entries(pkg[section] ?? {})) {
-      if (typeof range === "string") deps.set(name, { name, range, scope });
-    }
-  }
-  return [...deps.values()];
-}
-function isUpgradableRange(range) {
-  const trimmed = range.trim();
-  if (trimmed === "" || trimmed === "*" || trimmed.toLowerCase() === "x") return false;
-  return semver4.validRange(trimmed) !== null;
-}
-function alignmentCandidate(dep, target, origin, pnpm = false) {
-  const split = pnpm ? splitRangeProtocol(dep.range) : { protocol: void 0, rest: dep.range };
-  const range = split.protocol === "workspace" ? split.rest : dep.range;
-  const protocol = split.protocol === "workspace" ? "workspace:" : "";
-  const local = target.version;
-  if (!local || !semver4.valid(local) || !isUpgradableRange(range)) return null;
-  if (semver4.satisfies(local, range, { includePrerelease: true })) return null;
-  const currentClean = semver4.minVersion(range)?.version ?? "0.0.0";
-  const diff = diffVersions(currentClean, local);
-  const tag = semver4.prerelease(local) ? extractPreReleaseTag(local) ?? "PRE" : void 0;
-  return {
-    coordinate: { identifier: dep.name, artifact: dep.name, ecosystem: "npm" },
-    currentRange: dep.range,
-    currentClean,
-    latest: local,
-    newRange: `${protocol}${rangePrefix(range)}${local}`,
-    diff,
-    scope: dep.scope,
-    selected: diff !== "major",
-    origin,
-    action: "align",
-    availableVersions: [local],
-    isPreRelease: tag !== void 0,
-    preReleaseTag: tag
-  };
-}
-function usersOfCatalogEntry(context, selfPath, name, catalogName) {
-  const users = [];
-  for (const module of context.workspace.values()) {
-    if (module.path === selfPath) continue;
-    let pkg;
-    try {
-      pkg = JSON.parse(readFileSync4(join5(module.path, "package.json"), "utf8"));
-    } catch {
-      continue;
-    }
-    const dep = declaredDependencies(pkg).find((d) => d.name === name);
-    if (!dep || splitRangeProtocol(dep.range).protocol !== "catalog") continue;
-    if ((splitRangeProtocol(dep.range).rest || "default") !== catalogName) continue;
-    users.push(module.id);
-  }
-  return users;
-}
-
-// src/adapters/npm/npm-updater.ts
-import { readFileSync as readFileSync7, writeFileSync } from "fs";
-import { join as join8, relative as relative2 } from "path";
-
-// src/domain/ports.ts
-var InstallError = class extends Error {
-  constructor(message2, output) {
-    super(message2);
-    this.output = output;
-    this.name = "InstallError";
-  }
-  output;
-};
-
-// src/adapters/npm/npm-lockfile.ts
-import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
-import { join as join6 } from "path";
-function readLockfile(rootDir) {
-  const file = join6(rootDir, "package-lock.json");
-  if (!existsSync3(file)) return void 0;
-  try {
-    return JSON.parse(readFileSync5(file, "utf8"));
-  } catch {
-    return void 0;
-  }
-}
-function findUnlinkedWorkspaceDependencies(lockfile, moduleRelPath, names) {
-  const packages = lockfile.packages ?? {};
-  const prefix = moduleRelPath ? `${moduleRelPath}/` : "";
-  const violations = [];
-  for (const name of names) {
-    const entry = packages[`${prefix}node_modules/${name}`] ?? packages[`node_modules/${name}`];
-    if (!entry) {
-      violations.push(`${name}: not present in package-lock.json`);
-    } else if (!entry.link) {
-      const source = entry.resolved ?? "unknown source";
-      violations.push(`${name}: installed from ${source} instead of linking the workspace package`);
-    }
-  }
-  return violations;
-}
-
-// src/adapters/npm/pnpm-audit.ts
-var AUDIT_TIMEOUT_MS = 6e4;
-var LEVELS = ["info", "low", "moderate", "high", "critical"];
-function unavailable(reason) {
-  return { message: `Vulnerability check unavailable: ${reason}.`, severity: "warn" };
-}
-function parsePnpmAudit(output) {
-  let json;
-  try {
-    json = JSON.parse(output);
-  } catch {
-    return unavailable("pnpm audit returned no result");
-  }
-  const counts = json?.metadata?.vulnerabilities;
-  if (counts && typeof counts === "object") {
-    const parts = [];
-    let total = 0;
-    for (const level of LEVELS) {
-      const n = Number(counts[level]) || 0;
-      total += n;
-      if (n > 0) parts.push(`${n} ${level}`);
-    }
-    if (total === 0) return { message: "No known vulnerabilities found.", severity: "clean" };
-    return {
-      message: `${total} ${total === 1 ? "vulnerability" : "vulnerabilities"} (${parts.join(", ")})`,
-      severity: "warn"
-    };
-  }
-  const errorMessage = json?.error?.message;
-  if (typeof errorMessage === "string" && errorMessage) return unavailable(errorMessage);
-  return unavailable("pnpm audit returned no result");
-}
-
-// src/adapters/npm/pnpm-lockfile.ts
-import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
-import { join as join7 } from "path";
-import { parse as parse2 } from "yaml";
-var SECTIONS = ["dependencies", "devDependencies", "optionalDependencies"];
-function readPnpmLockfile(rootDir) {
-  const file = join7(rootDir, "pnpm-lock.yaml");
-  if (!existsSync4(file)) return { kind: "missing" };
-  let data;
-  try {
-    data = parse2(readFileSync6(file, "utf8"));
-  } catch {
-    return { kind: "unreadable" };
-  }
-  if (typeof data !== "object" || data === null || Array.isArray(data)) return { kind: "unreadable" };
-  const lockfileVersion = String(data.lockfileVersion ?? "");
-  if (!/^9(\.|$)/.test(lockfileVersion)) return { kind: "unsupported", lockfileVersion };
-  const importers = data.importers ?? {};
-  if (typeof importers !== "object" || Array.isArray(importers)) return { kind: "unreadable" };
-  return { kind: "ok", importers };
-}
-function findUnlinkedPnpmDependencies(lockfile, moduleRelPath, names) {
-  switch (lockfile.kind) {
-    case "missing":
-      return ["pnpm-lock.yaml is missing; workspace links cannot be verified"];
-    case "unreadable":
-      return ["pnpm-lock.yaml could not be read; workspace links cannot be verified"];
-    case "unsupported":
-      return [
-        `pnpm-lock.yaml has lockfileVersion '${lockfile.lockfileVersion}', which Elevate cannot read; workspace links cannot be verified`
-      ];
-  }
-  const importer = lockfile.importers[moduleRelPath === "" ? "." : moduleRelPath] ?? {};
-  const violations = [];
-  for (const name of names) {
-    let entry;
-    for (const section of SECTIONS) {
-      entry = importer[section]?.[name];
-      if (entry) break;
-    }
-    if (!entry) violations.push(`${name}: not present in pnpm-lock.yaml`);
-    else if (!String(entry.version).startsWith("link:")) {
-      violations.push(`${name}: resolved to ${entry.version} instead of linking the workspace package`);
-    }
-  }
-  return violations;
-}
-
-// src/adapters/npm/npm-updater.ts
-var INSTALL_TIMEOUT_MS = 10 * 6e4;
-function failureDetails(manager, result) {
-  return manager === "pnpm" ? tail(`${result.stdout}
-${result.stderr}`) : tail(result.stderr || result.stdout);
-}
-var NpmUpdaterAdapter = class {
-  affectedFiles(module, rootDir) {
-    if (detectPackageManager(rootDir).name === "pnpm") {
-      return [
-        join8(module.path, "package.json"),
-        join8(rootDir, "package.json"),
-        join8(rootDir, "pnpm-lock.yaml"),
-        join8(rootDir, "pnpm-workspace.yaml")
-      ];
-    }
-    return [
-      join8(module.path, "package.json"),
-      join8(rootDir, "package.json"),
-      join8(rootDir, "package-lock.json"),
-      join8(rootDir, "npm-shrinkwrap.json")
-    ];
-  }
-  async applyUpdates(module, rootDir, updates, onProgress) {
-    let manager;
-    try {
-      manager = await prepareSupportedPackageManager(rootDir);
-    } catch (err) {
-      if (err instanceof UnsupportedPackageManagerError || err instanceof PackageManagerNotFoundError) {
-        throw new InstallError(err.message);
-      }
-      throw err;
-    }
-    const catalogUpdates = updates.filter((u) => u.declaration?.kind === "catalog");
-    const manifestUpdates = updates.filter((u) => u.declaration?.kind !== "catalog");
-    const pkgPath = join8(module.path, "package.json");
-    let manifest;
-    if (manifestUpdates.length > 0 || catalogUpdates.length === 0) {
-      try {
-        const source = readFileSync7(pkgPath, "utf8");
-        manifest = { source, pkg: JSON.parse(source) };
-      } catch {
-        throw new InstallError(`Cannot read package.json in ${module.path}.`);
-      }
-    }
-    if (manifest) {
-      onProgress("Writing new versions to package.json\u2026");
-      for (const item of manifestUpdates) {
-        const name = item.coordinate.artifact;
-        for (const section of DEPENDENCY_SECTIONS) {
-          if (typeof manifest.pkg[section]?.[name] === "string") manifest.pkg[section][name] = item.newRange;
-        }
-      }
-      writeFileSync(pkgPath, serializeLike(manifest.source, manifest.pkg), "utf8");
-    }
-    if (catalogUpdates.length > 0) {
-      onProgress("Writing new versions to pnpm-workspace.yaml\u2026");
-      writeCatalogRanges(catalogUpdates);
-    }
-    const install = commands.install(manager);
-    onProgress(`Running ${manager} install\u2026`);
-    const result = await runCommand(install.command, install.args, { cwd: rootDir, timeoutMs: INSTALL_TIMEOUT_MS });
-    if (result.exitCode !== 0) {
-      const reason = result.timedOut ? `${manager} install timed out` : `${manager} install failed`;
-      throw new InstallError(reason, failureDetails(manager, result));
-    }
-    const lockName = manager === "pnpm" ? "pnpm-lock.yaml" : "package-lock.json";
-    onProgress(`Checking workspace links in ${lockName}\u2026`);
-    const integrityViolations = verifyAlignedLinks(manager, module, rootDir, updates);
-    if (manager === "pnpm") {
-      const audit2 = integrityViolations.length > 0 ? void 0 : await runPnpmAudit(rootDir);
-      return {
-        updatedCount: updates.length,
-        auditMessage: audit2?.message ?? "",
-        auditSeverity: audit2?.severity ?? "clean",
-        fundingMessage: void 0,
-        integrityViolations
-      };
-    }
-    const combined = `${result.stdout}
-${result.stderr}`;
-    const audit = parseAuditSummary(combined);
-    const fundingMatch = combined.match(/(\d+ packages? (?:is|are) looking for funding)/i);
-    return {
-      updatedCount: updates.length,
-      auditMessage: audit.message,
-      auditSeverity: audit.severity,
-      fundingMessage: fundingMatch ? fundingMatch[0] : void 0,
-      integrityViolations
-    };
-  }
-  async resync(_module, rootDir, onProgress) {
-    const name = detectPackageManager(rootDir).name;
-    if (name !== "npm" && name !== "pnpm") return;
-    const restore = commands.restore(name);
-    onProgress(`Restoring node_modules (${name} install)\u2026`);
-    const result = await runCommand(restore.command, restore.args, { cwd: rootDir, timeoutMs: INSTALL_TIMEOUT_MS });
-    if (result.exitCode !== 0) {
-      throw new InstallError(
-        `${name} install failed while restoring the previous state`,
-        name === "pnpm" ? failureDetails(name, result) : tail(result.stderr)
-      );
-    }
-  }
-};
-function writeCatalogRanges(updates) {
-  const sources = /* @__PURE__ */ new Map();
-  for (const item of updates) {
-    const declaration = item.declaration;
-    try {
-      let source = sources.get(declaration.file) ?? readFileSync7(declaration.file, "utf8");
-      source = setCatalogRange(source, declaration.catalogName ?? "default", item.coordinate.artifact, item.newRange);
-      sources.set(declaration.file, source);
-    } catch (err) {
-      throw new InstallError(err instanceof Error ? err.message : `Cannot update ${declaration.displayPath}.`);
-    }
-  }
-  for (const [file, source] of sources) writeFileSync(file, source, "utf8");
-}
-async function runPnpmAudit(rootDir) {
-  try {
-    const result = await runCommand("pnpm", ["audit", "--json"], { cwd: rootDir, timeoutMs: AUDIT_TIMEOUT_MS });
-    if (result.timedOut) return unavailable(`pnpm audit timed out after ${AUDIT_TIMEOUT_MS / 1e3} seconds`);
-    return parsePnpmAudit(result.stdout);
-  } catch {
-    return unavailable("pnpm audit returned no result");
-  }
-}
-var VULNERABILITY_LINE = /^(?:found\s+)?(\d+)\s+(?:(?:info|low|moderate|high|critical)\s+severity\s+)?vulnerabilit(?:y|ies)\b.*$/i;
-function parseAuditSummary(output) {
-  for (const line of output.split(/\r?\n/)) {
-    const match = line.trim().match(VULNERABILITY_LINE);
-    if (match && Number(match[1]) > 0) return { message: line.trim(), severity: "warn" };
-  }
-  return { message: "No known vulnerabilities found.", severity: "clean" };
-}
-function verifyAlignedLinks(manager, module, rootDir, updates) {
-  const aligned = updates.filter((u) => u.origin.kind === "workspace").map((u) => u.coordinate.identifier);
-  if (aligned.length === 0) return [];
-  const moduleRelPath = relative2(rootDir, module.path).replace(/\\/g, "/");
-  if (manager === "pnpm") return findUnlinkedPnpmDependencies(readPnpmLockfile(rootDir), moduleRelPath, aligned);
-  const lockfile = readLockfile(rootDir);
-  if (!lockfile) return ["package-lock.json is missing; workspace links cannot be verified"];
-  return findUnlinkedWorkspaceDependencies(lockfile, moduleRelPath, aligned);
-}
-function serializeLike(original, value) {
-  const indent = original.match(/^[ \t]+(?=")/m)?.[0] ?? "  ";
-  const newline = original.includes("\r\n") ? "\r\n" : "\n";
-  const body = JSON.stringify(value, null, indent).replace(/\n/g, newline);
-  return original.endsWith("\n") ? body + newline : body;
-}
-
-// src/adapters/npm/npm-verifier.ts
-var VERIFY_TIMEOUT_MS = 10 * 6e4;
-var NpmVerificationAdapter = class {
-  async verify(_module, rootDir, options = {}) {
-    let manager = "npm";
-    if (!options.customScript) {
-      try {
-        manager = await prepareSupportedPackageManager(rootDir);
-      } catch (err) {
-        if (err instanceof UnsupportedPackageManagerError || err instanceof PackageManagerNotFoundError) {
-          return { status: "warn", details: err.message, label: options.customLabel || "Dependency verification" };
-        }
-        throw err;
-      }
-    }
-    const defaultLabel = manager === "pnpm" ? "Lockfile consistency (pnpm install --frozen-lockfile)" : "Dependency tree integrity (npm ls)";
-    const label = options.customLabel || options.customScript || defaultLabel;
-    const verify = commands.verify(manager);
-    const result = options.customScript ? await runShellScript(options.customScript, { cwd: rootDir, timeoutMs: VERIFY_TIMEOUT_MS }) : await runCommand(verify.command, verify.args, { cwd: rootDir, timeoutMs: VERIFY_TIMEOUT_MS });
-    if (result.exitCode === 0) {
-      const details = manager === "pnpm" && !options.customScript ? "pnpm-lock.yaml is up to date with all package.json files." : "All dependencies are installed and consistent.";
-      return { status: "clean", details, label };
-    }
-    const output = manager === "pnpm" && !options.customScript ? tail(`${result.stdout}
-${result.stderr}`) : tail(result.stderr || result.stdout);
-    return { status: "warn", details: result.timedOut ? "Verification timed out." : output, label };
-  }
-};
-
-// src/adapters/npm/npm-strategy.ts
-var NpmEcosystemStrategy = class {
-  ecosystem = "npm";
-  displayName = "Node / npm";
-  packageManagerFor(rootDir) {
-    return detectPackageManager(rootDir).name;
-  }
-  displayNameFor(rootDir) {
-    return detectPackageManager(rootDir).name === "pnpm" ? "Node / pnpm" : "Node / npm";
-  }
-  icon = "\u{1F4E6}";
-  manifestFile = "package.json";
-  versioning = npmVersionPolicy;
-  discovery = new NpmModuleDiscoveryAdapter();
-  registry = new NpmRegistryAdapter();
-  reader = new NpmDependencyAdapter(this.registry, this.registry.config);
-  updater = new NpmUpdaterAdapter();
-  verifier = new NpmVerificationAdapter();
-  getTabLabels(counts, t) {
-    return {
-      all: t.tabs.all(counts.total),
-      prod: t.tabs.dependencies(counts.prodCount),
-      dev: t.tabs.devDependencies(counts.devCount)
-    };
-  }
-};
-
-// src/adapters/cargo/cargo-strategy.ts
-import semver10 from "semver";
-
-// src/adapters/cargo/cargo-discovery.ts
-import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync8 } from "fs";
-import { dirname as dirname4, join as join9, relative as relative3, resolve as resolve4 } from "path";
-
-// src/adapters/cargo/cargo-command.ts
-var CargoUnavailableError = class extends Error {
-  constructor() {
-    super("Cargo is not available: no `cargo` on the PATH. Install Rust (https://rustup.rs).");
-    this.name = "CargoUnavailableError";
-  }
-};
-async function runCargo(args, options) {
-  let result;
-  try {
-    result = await runCommand("cargo", args, options);
-  } catch (err) {
-    if (err.code === "ENOENT") throw new CargoUnavailableError();
-    throw err;
-  }
-  if (looksLikeMissingCommand(result) && !await cargoStarts(options.cwd)) throw new CargoUnavailableError();
-  return result;
-}
-function looksLikeMissingCommand(result) {
-  return process.platform === "win32" && result.exitCode !== 0 && !result.stdout.trim() && !/^error/m.test(result.stderr);
-}
-async function cargoStarts(cwd) {
-  try {
-    return (await runCommand("cargo", ["--version"], { cwd, timeoutMs: 3e4 })).exitCode === 0;
-  } catch {
-    return false;
-  }
-}
-function cargoErrors(output) {
-  const lines = output.split(/\r?\n/);
-  const errors = lines.filter((l) => /^error(\[E\d+\])?:/.test(l));
-  const summary = (errors.length > 0 ? errors : lines.filter((l) => l.trim()).slice(-10)).slice(0, 12);
-  if (/toolchain '.+' is not installed/.test(output)) {
-    summary.push("Install it with `rustup toolchain install` (the project pins it in rust-toolchain.toml).");
-  }
-  return summary.join("\n");
-}
-
-// src/adapters/cargo/cargo-metadata.ts
-var CargoMetadataError = class extends Error {
-  constructor(message2, dir) {
-    super(message2);
-    this.dir = dir;
-    this.name = "CargoMetadataError";
-  }
-  dir;
-};
-async function loadMetadata(dir) {
-  const result = await runCargo(["metadata", "--no-deps", "--format-version", "1"], { cwd: dir, timeoutMs: 6e4 });
-  if (result.exitCode !== 0) {
-    throw new CargoMetadataError(`cargo metadata failed in ${dir}: ${cargoErrors(result.stderr || result.stdout)}`, dir);
-  }
-  try {
-    return JSON.parse(result.stdout);
-  } catch {
-    throw new CargoMetadataError(`cargo metadata printed no JSON in ${dir}.`, dir);
-  }
-}
-
-// src/adapters/cargo/cargo-discovery.ts
-var IGNORED = /* @__PURE__ */ new Set(["target", "node_modules", "vendor", "dist", "build", "out", "src"]);
-var norm = (path) => resolve4(path).replace(/\\/g, "/");
-function findManifests(root) {
-  const found = [];
-  const walk = (dir, depth) => {
-    let entries2;
-    try {
-      entries2 = readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    if (entries2.some((e) => e.isFile() && e.name === "Cargo.toml")) found.push(join9(dir, "Cargo.toml"));
-    for (const entry of entries2) {
-      if (entry.isDirectory() && !entry.name.startsWith(".") && !IGNORED.has(entry.name)) walk(join9(dir, entry.name), depth + 1);
-    }
-  };
-  walk(root, 0);
-  return found.sort((a, b) => a.split(/[\\/]/).length - b.split(/[\\/]/).length || a.localeCompare(b));
-}
-var declaresWorkspace = (dir) => {
-  try {
-    return /^\s*\[workspace[\].]/m.test(readFileSync8(join9(dir, "Cargo.toml"), "utf8"));
-  } catch {
-    return false;
-  }
-};
-var CargoModuleDiscoveryAdapter = class {
-  problems = [];
-  diagnostics() {
-    return [...this.problems];
-  }
-  /** The nearest ancestor declaring `[workspace]`; failing that, the nearest directory with a manifest. */
-  findRoot(startDir, boundaryDir) {
-    const boundary = boundaryDir ? resolve4(boundaryDir) : void 0;
-    const chain = [];
-    for (let dir = resolve4(startDir); ; ) {
-      chain.push(dir);
-      const parent = dirname4(dir);
-      if (dir === boundary || parent === dir) break;
-      dir = parent;
-    }
-    return chain.find(declaresWorkspace) ?? chain.find((d) => existsSync5(join9(d, "Cargo.toml")));
-  }
-  async discover(rootDir) {
-    const covered = /* @__PURE__ */ new Set();
-    const modules = [];
-    const errors = [];
-    this.problems = [];
-    for (const manifest of findManifests(rootDir)) {
-      if (covered.has(norm(manifest))) continue;
-      try {
-        const metadata = await loadMetadata(dirname4(manifest));
-        for (const pkg of metadata.packages) {
-          covered.add(norm(pkg.manifest_path));
-          const path = dirname4(pkg.manifest_path);
-          const relPath = relative3(rootDir, path).replace(/\\/g, "/");
-          modules.push({
-            id: pkg.name,
-            name: pkg.name,
-            path,
-            relPath: relPath === "" ? "Root" : relPath,
-            ecosystem: "cargo",
-            isRoot: relPath === "",
-            version: pkg.version,
-            aggregatorDir: resolve4(metadata.workspace_root)
-          });
-        }
-      } catch (err) {
-        if (err instanceof CargoUnavailableError) throw err;
-        if (err instanceof CargoMetadataError) {
-          errors.push(err);
-          this.problems.push(err.message);
-        } else throw err;
-      }
-    }
-    if (modules.length === 0 && errors.length > 0) throw errors[0];
-    modules.sort((a, b) => a.isRoot ? -1 : b.isRoot ? 1 : a.relPath.localeCompare(b.relPath));
-    const taken = /* @__PURE__ */ new Set();
-    for (const module of modules) {
-      if (taken.has(module.id)) module.id = `${module.name} (${module.relPath})`;
-      taken.add(module.id);
-    }
-    return modules;
-  }
-};
-
-// src/adapters/cargo/cargo-config.ts
-import { existsSync as existsSync6, readFileSync as readFileSync9 } from "fs";
-import { homedir } from "os";
-import { dirname as dirname5, isAbsolute, join as join10, resolve as resolve5 } from "path";
-import { getStaticTOMLValue, parseTOML } from "toml-eslint-parser";
-var CRATES_IO = "registry+https://github.com/rust-lang/crates.io-index";
-var PUBLIC_HOSTS = /* @__PURE__ */ new Set(["index.crates.io", "static.crates.io", "crates.io", "github.com"]);
-var UnsupportedSourceError = class extends Error {
-  constructor(detail) {
-    super(`Cargo is configured to use a package source Elevate cannot read (${detail}). No lookup was made.`);
-    this.name = "UnsupportedSourceError";
-  }
-};
-function isPublicIndex(index) {
-  try {
-    const url = new URL(index.replace(/^(sparse|registry)\+/, ""));
-    return PUBLIC_HOSTS.has(url.hostname.toLowerCase()) && (url.hostname !== "github.com" || url.pathname.includes("crates.io-index"));
-  } catch {
-    return false;
-  }
-}
-function merge(base, top) {
-  const out = { ...base };
-  for (const [key, value] of Object.entries(top)) {
-    const existing = out[key];
-    out[key] = value && typeof value === "object" && !Array.isArray(value) && existing && typeof existing === "object" && !Array.isArray(existing) ? merge(existing, value) : value;
-  }
-  return out;
-}
-function loadFile(file, depth = 0) {
-  let table;
-  try {
-    table = getStaticTOMLValue(parseTOML(readFileSync9(file, "utf8")));
-  } catch {
-    return {};
-  }
-  const includes = table.include;
-  delete table.include;
-  if (!Array.isArray(includes) || depth > 4) return table;
-  let included = {};
-  for (const entry of includes) {
-    const path = typeof entry === "string" ? entry : entry?.path;
-    if (typeof path === "string") included = merge(included, loadFile(isAbsolute(path) ? path : resolve5(dirname5(file), path), depth + 1));
-  }
-  return merge(included, table);
-}
-var CargoConfigReader = class {
-  env;
-  cache = /* @__PURE__ */ new Map();
-  constructor(options = {}) {
-    this.env = options.env ?? process.env;
-  }
-  /** The configuration as Cargo would merge it for `cwd`: nearest file first, CARGO_HOME last. */
-  config(cwd) {
-    const start = resolve5(cwd);
-    let cached = this.cache.get(start);
-    if (cached) return cached;
-    const files = [];
-    for (let dir = start; ; ) {
-      for (const name of ["config.toml", "config"]) {
-        const file = join10(dir, ".cargo", name);
-        if (existsSync6(file)) {
-          files.push(file);
-          break;
-        }
-      }
-      const parent = dirname5(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-    const home2 = this.env.CARGO_HOME ?? join10(homedir(), ".cargo");
-    for (const name of ["config.toml", "config"]) {
-      const file = join10(home2, name);
-      if (existsSync6(file) && !files.includes(file)) {
-        files.push(file);
-        break;
-      }
-    }
-    cached = files.reduceRight((acc, file) => merge(acc, loadFile(file)), {});
-    this.cache.set(start, cached);
-    return cached;
-  }
-  /** `[source.*]` comes from files only: Cargo ignores `CARGO_SOURCE_*` variables (checked with Cargo 1.97). */
-  sourceField(config, source, field) {
-    const value = config.source?.[source]?.[field];
-    return typeof value === "string" ? value : void 0;
-  }
-  /**
-   * The index a lookup goes to. `registry` is the index URL of an alternative
-   * registry as Cargo reports it, or undefined for crates.io.
-   */
-  async resolve(registry, cwd) {
-    const config = this.config(cwd);
-    let name = registry === void 0 ? "crates-io" : this.sourceNamed(config, registry);
-    let index = registry ?? CRATES_IO;
-    const seen = /* @__PURE__ */ new Set();
-    while (name !== void 0) {
-      if (seen.has(name)) throw new UnsupportedSourceError(`replacement cycle at '${name}'`);
-      seen.add(name);
-      const next = this.sourceField(config, name, "replace-with");
-      if (next === void 0) break;
-      for (const kind of ["directory", "local-registry", "git"]) {
-        if (this.sourceField(config, next, kind) !== void 0) throw new UnsupportedSourceError(`'${next}' is a ${kind} source`);
-      }
-      const target = this.sourceField(config, next, "registry");
-      if (target !== void 0) {
-        index = target;
-        name = next;
-        if (this.sourceField(config, next, "replace-with") === void 0) break;
-        continue;
-      }
-      if (this.sourceField(config, next, "replace-with") === void 0) {
-        throw new UnsupportedSourceError(`'${next}' has no registry`);
-      }
-      name = next;
-    }
-    return { index, isPublic: isPublicIndex(index) };
-  }
-  /** Name of the `[source.*]` table whose registry is `url`, if any. */
-  sourceNamed(config, url) {
-    return Object.keys(config.source ?? {}).find((n) => this.sourceField(config, n, "registry") === url);
-  }
-};
-
-// src/version.ts
-import { createRequire } from "module";
-var VERSION = true ? "1.7.0" : fromPackage();
-
-// src/adapters/cargo/cargo-index.ts
-var RegistryAuthRequiredError = class extends Error {
-  constructor(index) {
-    super(`The registry ${index} requires authentication. Elevate does not handle registry credentials.`);
-    this.index = index;
-    this.name = "RegistryAuthRequiredError";
-  }
-  index;
-};
-var CrateNotFoundError = class extends Error {
-  constructor(crate, index) {
-    super(`'${crate}' is not in the registry ${index}.`);
-    this.crate = crate;
-    this.index = index;
-    this.name = "CrateNotFoundError";
-  }
-  crate;
-  index;
-};
-var UnsupportedIndexError = class extends Error {
-  constructor(index) {
-    super(`The registry index ${index} is not a sparse index; Elevate cannot read it.`);
-    this.index = index;
-    this.name = "UnsupportedIndexError";
-  }
-  index;
-};
-var CRATES_IO_SPARSE = "https://index.crates.io/";
-var CRATES_IO_GIT = "registry+https://github.com/rust-lang/crates.io-index";
-function indexPath(name) {
-  const n = name.toLowerCase();
-  if (n.length <= 2) return `${n.length}/${n}`;
-  if (n.length === 3) return `3/${n[0]}/${n}`;
-  return `${n.slice(0, 2)}/${n.slice(2, 4)}/${n}`;
-}
-function parseIndex(text) {
-  const versions = [];
-  for (const raw of text.split(/\r?\n/)) {
-    if (!raw.trim()) continue;
-    try {
-      const entry = JSON.parse(raw);
-      if (typeof entry.vers !== "string") continue;
-      versions.push({ version: entry.vers, yanked: entry.yanked === true, rustVersion: entry.rust_version });
-    } catch {
-    }
-  }
-  return versions;
-}
-function sparseRoot(index) {
-  if (index === CRATES_IO_GIT) return CRATES_IO_SPARSE;
-  if (index.startsWith("sparse+")) {
-    const url = index.slice("sparse+".length);
-    return url.endsWith("/") ? url : `${url}/`;
-  }
-  throw new UnsupportedIndexError(index);
-}
-var userAgent = () => `elevate/${VERSION} (+https://github.com/DennisRepa/Elevate)`;
-function networkReason(err) {
-  const cause = err?.cause?.message;
-  return cause ?? (err instanceof Error ? err.message : String(err));
-}
-var CargoIndexClient = class {
-  constructor(fetchFn = fetch, env = process.env) {
-    this.fetchFn = fetchFn;
-    this.env = env;
-  }
-  fetchFn;
-  env;
-  memo = /* @__PURE__ */ new Map();
-  /** All versions of a crate in oldest-first file order. Memoised per index and crate. */
-  versions(index, crate) {
-    const key = `${index}
-${crate.toLowerCase()}`;
-    let pending = this.memo.get(key);
-    if (!pending) {
-      pending = this.load(index, crate);
-      this.memo.set(key, pending);
-    }
-    return pending;
-  }
-  async load(index, crate) {
-    const url = `${sparseRoot(index)}${indexPath(crate)}`;
-    let response;
-    try {
-      response = await this.fetchFn(url, { headers: { "user-agent": userAgent() } });
-    } catch (err) {
-      throw new Error(`Cannot reach ${url}: ${networkReason(err)}${this.proxyHint()}`);
-    }
-    if (response.status === 401 || response.status === 403) throw new RegistryAuthRequiredError(index);
-    if (response.status === 404) throw new CrateNotFoundError(crate, index);
-    if (!response.ok) throw new Error(`Registry answered ${response.status} for ${url}.`);
-    return parseIndex(await response.text());
-  }
-  /**
-   * Node's fetch ignores HTTP(S)_PROXY unless NODE_USE_ENV_PROXY=1 is set when
-   * the process starts (measured with Node 22.23; it cannot be switched on later).
-   */
-  proxyHint() {
-    const proxied = this.env.HTTPS_PROXY || this.env.https_proxy || this.env.HTTP_PROXY || this.env.http_proxy;
-    if (!proxied || this.env.NODE_USE_ENV_PROXY === "1") return "";
-    return " A proxy is configured, but Node does not use it for registry lookups unless you start Elevate with NODE_USE_ENV_PROXY=1.";
-  }
-};
-
-// src/adapters/cargo/cargo-registry.ts
-import semver6 from "semver";
-
-// src/adapters/cargo/cargo-versions.ts
-import semver5 from "semver";
-var rust = (v) => semver5.coerce(v)?.version;
-function eligibleVersions(versions, options) {
-  const project = options.rustVersion ? rust(options.rustVersion) : void 0;
-  return versions.filter((v) => !v.yanked && semver5.valid(v.version)).filter((v) => options.channel === "all" || semver5.prerelease(v.version) === null).filter((v) => {
-    const needs = v.rustVersion ? rust(v.rustVersion) : void 0;
-    return !(project && needs && semver5.gt(needs, project));
-  }).map((v) => v.version).sort(semver5.rcompare);
-}
-function selectVersion(versions, options) {
-  const candidates = versions.filter((v) => !v.yanked && semver5.valid(v.version)).filter((v) => options.channel === "all" || semver5.prerelease(v.version) === null).sort((a, b) => semver5.rcompare(a.version, b.version));
-  const project = options.rustVersion ? rust(options.rustVersion) : void 0;
-  let blocked;
-  for (const candidate of candidates) {
-    const needs = candidate.rustVersion ? rust(candidate.rustVersion) : void 0;
-    if (project && needs && semver5.gt(needs, project)) {
-      blocked ??= { version: candidate.version, requires: candidate.rustVersion };
-      continue;
-    }
-    return { version: candidate.version, ...blocked ? { blockedByMsrv: blocked } : {} };
-  }
-  return { version: void 0, ...blocked ? { blockedByMsrv: blocked } : {} };
-}
-
-// src/adapters/cargo/cargo-registry.ts
-var CargoRegistryAdapter = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  deps;
-  async resolveEndpoint(coordinate, cwd) {
-    const { index, isPublic } = await this.deps.endpoint(coordinate.registry, cwd);
-    return { url: index, isPublic };
-  }
-  async getLatestVersion(coordinate, channel = "stable", cwd = process.cwd()) {
-    return selectVersion(await this.load(coordinate, cwd), { channel }).version ?? null;
-  }
-  /** Published, not yanked, newest first. Lookup errors propagate so they are not mistaken for "no versions". */
-  async getAllVersions(coordinate, cwd = process.cwd()) {
-    return (await this.load(coordinate, cwd)).filter((v) => !v.yanked && semver6.valid(v.version)).map((v) => v.version).sort(semver6.rcompare);
-  }
-  async load(coordinate, cwd) {
-    const { index } = await this.deps.endpoint(coordinate.registry, cwd);
-    return this.deps.index.versions(index, coordinate.artifact);
-  }
-};
-
-// src/adapters/cargo/cargo-requirement.ts
-import semver7 from "semver";
-var SIMPLE = /^(\^|~|=)?\s*(\d+(?:\.\d+){0,2})$/;
-function toSemverRange(requirement) {
-  const parts = requirement.split(",").map((p) => p.trim());
-  if (parts.some((p) => p === "")) return null;
-  const converted = parts.map((part) => {
-    const bare = part.match(/^\d/);
-    return bare ? `^${part}` : part;
-  });
-  return semver7.validRange(converted.join(" ")) ? converted.join(" ") : null;
-}
-function satisfiesRequirement(requirement, version) {
-  const range = toSemverRange(requirement);
-  return range !== null && semver7.satisfies(version, range, { includePrerelease: false });
-}
-function isUpgradableRequirement(requirement) {
-  return SIMPLE.test(requirement.trim());
-}
-function requirementFloor(requirement) {
-  const range = toSemverRange(requirement);
-  return range ? semver7.minVersion(range)?.version ?? null : null;
-}
-function rewriteRequirement(current, target) {
-  const match = current.trim().match(SIMPLE);
-  if (!match) return target;
-  if (semver7.prerelease(target)) return `${match[1] ?? ""}${target}`;
-  const precision = match[2].split(".").length;
-  const [major, minor, patch] = target.split(/[-+]/)[0].split(".");
-  const written = [major, minor, patch].slice(0, precision).join(".");
-  return `${match[1] ?? ""}${written}`;
-}
-function cargoDiff(from, to) {
-  const a = semver7.parse(from);
-  const b = semver7.parse(to);
-  if (!a || !b) return "minor";
-  if (a.major > 0 || b.major > a.major) {
-    if (b.major !== a.major) return "major";
-    return b.minor !== a.minor ? "minor" : "patch";
-  }
-  if (a.minor > 0) {
-    if (b.minor !== a.minor) return "major";
-    return "minor";
-  }
-  return "major";
-}
-
-// src/adapters/cargo/cargo-scanner.ts
-import { readFileSync as readFileSync11 } from "fs";
-import { join as join11, relative as relative4 } from "path";
-import semver8 from "semver";
-
-// src/adapters/cargo/cargo-toml.ts
-import { parseTOML as parseTOML2 } from "toml-eslint-parser";
-var SECTIONS2 = {
-  dependencies: "dependencies",
-  "dev-dependencies": "dev-dependencies",
-  dev_dependencies: "dev-dependencies",
-  "build-dependencies": "build-dependencies",
-  build_dependencies: "build-dependencies"
-};
-function parseCargoManifest(source) {
-  const root = parseTOML2(source).body[0];
-  const leaves = [];
-  const keyPath = (key) => key.keys.map((k) => k.type === "TOMLBare" ? k.name : k.value);
-  const visitPair = (prefix, pair) => {
-    const path = [...prefix, ...keyPath(pair.key)];
-    leaves.push({ path, node: pair.value });
-    if (pair.value.type === "TOMLInlineTable") for (const inner of pair.value.body) visitPair(path, inner);
-  };
-  for (const element of root.body) {
-    if (element.type === "TOMLKeyValue") visitPair([], element);
-    else if (element.type === "TOMLTable") {
-      const header = keyPath(element.key);
-      for (const pair of element.body) visitPair(header, pair);
-      leaves.push({ path: header, node: element });
-    }
-  }
-  const byKey = /* @__PURE__ */ new Map();
-  for (const { path, node } of leaves) {
-    const located = locateSection(path);
-    if (!located || located.rest.length === 0) continue;
-    const [key, field] = located.rest;
-    const id = `${located.inWorkspace}|${located.target ?? ""}|${located.section}|${key}`;
-    let decl = byKey.get(id);
-    if (!decl) {
-      decl = { key, section: located.section, target: located.target, inWorkspace: located.inWorkspace, inherited: false };
-      byKey.set(id, decl);
-    }
-    if (located.rest.length === 1 && node.type === "TOMLValue" && node.kind === "string") {
-      decl.version = literalOf(node);
-    } else if (field === "version" && located.rest.length === 2 && node.type === "TOMLValue" && node.kind === "string") {
-      decl.version = literalOf(node);
-    } else if (field === "workspace" && located.rest.length === 2 && node.value === true) {
-      decl.inherited = true;
-    } else if (field === "package" && located.rest.length === 2 && node.type === "TOMLValue") {
-      decl.package = String(node.value);
-    }
-  }
-  return [...byKey.values()];
-}
-function literalOf(node) {
-  return { value: node.value, start: node.range[0] + 1, end: node.range[1] - 1 };
-}
-function locateSection(path) {
-  let i = 0;
-  let target;
-  let inWorkspace = false;
-  if (path[0] === "workspace" && path[1] === "dependencies") {
-    return { section: "dependencies", inWorkspace: true, target, rest: path.slice(2) };
-  }
-  if (path[0] === "target" && path.length >= 3) {
-    target = path[1];
-    i = 2;
-  }
-  const section = SECTIONS2[path[i] ?? ""];
-  if (!section) return void 0;
-  return { section, inWorkspace, target, rest: path.slice(i + 1) };
-}
-
-// src/adapters/cargo/cargo-lockfile.ts
-import { existsSync as existsSync7, readFileSync as readFileSync10 } from "fs";
-import { getStaticTOMLValue as getStaticTOMLValue2, parseTOML as parseTOML3 } from "toml-eslint-parser";
-function readLockedVersions(lockFile) {
-  const locked = /* @__PURE__ */ new Map();
-  if (!existsSync7(lockFile)) return locked;
-  try {
-    const data = getStaticTOMLValue2(parseTOML3(readFileSync10(lockFile, "utf8")));
-    for (const pkg of data.package ?? []) locked.set(pkg.name, [...locked.get(pkg.name) ?? [], pkg.version]);
-  } catch {
-  }
-  return locked;
-}
-
-// src/adapters/cargo/cargo-scanner.ts
-var CONCURRENCY2 = 6;
-var DIFF_ORDER2 = { major: 0, minor: 1, patch: 2 };
-var CargoDependencyAdapter = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  deps;
-  async scan(module, context) {
-    const metadata = await this.deps.loadMetadata(module.aggregatorDir ?? module.path);
-    const pkg = metadata.packages.find((p) => samePath(join11(p.manifest_path, ".."), module.path));
-    if (!pkg) return { candidates: [], skipped: [] };
-    const own = readDeclarations(pkg.manifest_path);
-    const locks = readLockedVersions(join11(metadata.workspace_root, "Cargo.lock"));
-    const rootManifest = join11(metadata.workspace_root, "Cargo.toml");
-    const root = readDeclarations(rootManifest);
-    const groups = groupDependencies(pkg.dependencies);
-    const outcomes = await mapPooled(groups, CONCURRENCY2, async (group) => {
-      const primary = group.find((d) => d.kind === null) ?? group[0];
-      const key = primary.rename ?? primary.name;
-      const decl = findDeclaration(own, key, primary);
-      const located = locate(decl, root, key, context.rootDir, pkg.manifest_path, rootManifest);
-      const scope = group.every((d) => d.kind === "dev") ? "dev" : "prod";
-      const qualifier = primary.target ?? (primary.kind === "build" ? "build" : void 0);
-      const common = { scope, qualifier };
-      if (primary.source === null && primary.path) {
-        const target = [...context.workspace.values()].find((m) => samePath(m.path, primary.path));
-        return target ? alignment(primary, target, located, common) : null;
-      }
-      if (!primary.source || primary.source.startsWith("git+")) return null;
-      const outcome = await this.registryOutcome(primary, located, pkg, metadata, locks, common, context);
-      const other = group.find((d) => d !== primary && !sameRequirement(d.req, primary.req));
-      if (outcome && "candidate" in outcome && other) {
-        outcome.note = {
-          identifier: primary.name,
-          origin: outcome.candidate.origin.kind,
-          reason: "declaration-mismatch",
-          detail: `${sectionOf(other)} requires ${other.req}; it is not changed`
-        };
-      }
-      return outcome;
-    });
-    const candidates = [];
-    const skipped = [];
-    for (const outcome of outcomes) {
-      if (!outcome) continue;
-      if ("candidate" in outcome) {
-        candidates.push(outcome.candidate);
-        if (outcome.note) skipped.push(outcome.note);
-      } else skipped.push(outcome.skipped);
-    }
-    candidates.sort((a, b) => (DIFF_ORDER2[a.diff] ?? 3) - (DIFF_ORDER2[b.diff] ?? 3));
-    return { candidates, skipped };
-  }
-  async registryOutcome(dep, located, pkg, metadata, locks, common, context) {
-    const literal = located?.version.value ?? dep.req;
-    if (!isUpgradableRequirement(literal)) return null;
-    if (!located || !sameRequirement(located.version.value, dep.req)) {
-      return { skipped: { identifier: dep.name, origin: "public", reason: "declaration-mismatch", detail: `${literal} in the manifest, ${dep.req} for Cargo` } };
-    }
-    let origin = { kind: "public" };
-    if (dep.registry) origin = { kind: "private", matchedBy: "scoped-registry", registry: dep.registry };
-    else if (matchesInternalScope(dep.name, "cargo", context.internalScopes)) origin = { kind: "private", matchedBy: "internal-scope" };
-    const endpoint = await this.deps.endpoint(dep.registry ?? void 0, context.rootDir);
-    if (origin.kind === "private" && endpoint.isPublic) {
-      return { skipped: { identifier: dep.name, origin: "private", reason: "private-on-public-registry", detail: endpoint.index } };
-    }
-    let versions;
-    try {
-      versions = await this.deps.index.versions(endpoint.index, dep.name);
-    } catch (err) {
-      return { skipped: { identifier: dep.name, origin: origin.kind, reason: "lookup-failed", detail: err instanceof Error ? err.message : String(err) } };
-    }
-    const chosen = selectVersion(versions, { channel: context.channel, rustVersion: pkg.rust_version ?? void 0 });
-    const floor = requirementFloor(literal);
-    if (!chosen.version) {
-      if (chosen.blockedByMsrv && floor) {
-        const { version, requires } = chosen.blockedByMsrv;
-        return { skipped: { identifier: dep.name, origin: origin.kind, reason: "incompatible-rust-version", detail: ` (${version} needs Rust ${requires})` } };
-      }
-      return { skipped: { identifier: dep.name, origin: origin.kind, reason: "lookup-failed", detail: "no usable version in the registry" } };
-    }
-    const latest = chosen.version;
-    if (!floor || !semver8.gt(latest, floor)) {
-      const held = chosen.blockedByMsrv;
-      if (floor && held && semver8.gt(held.version, floor)) {
-        return { skipped: { identifier: dep.name, origin: origin.kind, reason: "incompatible-rust-version", detail: ` (${held.version} needs Rust ${held.requires})` } };
-      }
-      return yankedLock(dep, literal, origin, versions, locks);
-    }
-    const newRange = rewriteRequirement(literal, latest);
-    if (newRange === literal) return lockOutcome(dep, literal, origin, versions, pkg, metadata, locks, common, context);
-    const tag = semver8.prerelease(latest) ? extractPreReleaseTag(latest) ?? "PRE" : void 0;
-    const diff = cargoDiff(floor, latest);
-    const candidate = {
-      coordinate: { identifier: dep.name, artifact: dep.name, ecosystem: "cargo", ...dep.registry ? { registry: dep.registry } : {} },
-      currentRange: literal,
-      currentClean: floor,
-      latest,
-      newRange,
-      diff,
-      scope: common.scope,
-      selected: diff !== "major",
-      origin,
-      action: "update",
-      declaration: located.declaration,
-      isPreRelease: tag !== void 0,
-      preReleaseTag: tag,
-      ...common.qualifier ? { qualifier: common.qualifier } : {},
-      ...located.inherited ? { sharedWith: sharersOf(metadata, pkg, dep.rename ?? dep.name) } : {}
-    };
-    return { candidate };
-  }
-};
-function lockOutcome(dep, requirement, origin, versions, pkg, metadata, locks, common, context) {
-  const locked = (locks.get(dep.name) ?? []).filter((v) => satisfiesRequirement(requirement, v)).sort(semver8.rcompare)[0];
-  if (!locked) return null;
-  const options = { channel: context.channel, rustVersion: pkg.rust_version ?? void 0 };
-  const allowed = versions.filter((v) => satisfiesRequirement(requirement, v.version));
-  const newer = eligibleVersions(allowed, options).filter((v) => semver8.gt(v, locked));
-  const latest = newer[0];
-  if (!latest) return yankedLock(dep, requirement, origin, versions, locks);
-  const lockFile = join11(metadata.workspace_root, "Cargo.lock");
-  return {
-    candidate: {
-      coordinate: { identifier: dep.name, artifact: dep.name, ecosystem: "cargo", ...dep.registry ? { registry: dep.registry } : {} },
-      currentRange: locked,
-      currentClean: locked,
-      latest,
-      newRange: latest,
-      diff: cargoDiff(locked, latest),
-      scope: common.scope,
-      // A release the requirement allows is compatible by definition, so it is safe to preselect.
-      selected: true,
-      origin,
-      action: "lock",
-      declaration: { file: lockFile, kind: "lockfile", displayPath: display(context.rootDir, lockFile) },
-      availableVersions: newer,
-      ...common.qualifier ? { qualifier: common.qualifier } : {}
-    }
-  };
-}
-function yankedLock(dep, requirement, origin, versions, locks) {
-  const locked = (locks.get(dep.name) ?? []).filter((v) => satisfiesRequirement(requirement, v)).sort(semver8.rcompare)[0];
-  if (!locked || !versions.some((v) => v.yanked && v.version === locked)) return null;
-  return { skipped: { identifier: dep.name, origin: origin.kind, reason: "locked-version-yanked", detail: locked } };
-}
-function alignment(dep, target, located, common) {
-  const local = target.version;
-  if (!located || !local || !semver8.valid(local)) return null;
-  const literal = located.version.value;
-  if (!isUpgradableRequirement(literal) || satisfiesRequirement(literal, local)) return null;
-  const floor = requirementFloor(literal) ?? "0.0.0";
-  const diff = cargoDiff(floor, local);
-  const tag = semver8.prerelease(local) ? extractPreReleaseTag(local) ?? "PRE" : void 0;
-  return {
-    candidate: {
-      coordinate: { identifier: dep.name, artifact: dep.name, ecosystem: "cargo" },
-      currentRange: literal,
-      currentClean: floor,
-      latest: local,
-      newRange: rewriteRequirement(literal, local),
-      diff,
-      scope: common.scope,
-      selected: diff !== "major",
-      origin: { kind: "workspace", moduleId: target.id, moduleRelPath: target.relPath },
-      action: "align",
-      declaration: located.declaration,
-      availableVersions: [local],
-      isPreRelease: tag !== void 0,
-      preReleaseTag: tag,
-      ...common.qualifier ? { qualifier: common.qualifier } : {}
-    }
-  };
-}
-function groupDependencies(deps) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const dep of deps) {
-    const id = `${dep.rename ?? dep.name}`;
-    groups.set(id, [...groups.get(id) ?? [], dep]);
-  }
-  return [...groups.values()];
-}
-function readDeclarations(manifestPath) {
-  try {
-    return parseCargoManifest(readFileSync11(manifestPath, "utf8"));
-  } catch {
-    return [];
-  }
-}
-var sectionOf = (dep) => dep.kind === "dev" ? "dev-dependencies" : dep.kind === "build" ? "build-dependencies" : "dependencies";
-function findDeclaration(decls, key, dep) {
-  const candidates = decls.filter((d) => !d.inWorkspace && d.key === key);
-  return candidates.find((d) => d.section === sectionOf(dep) && (d.target ?? null) === dep.target) ?? candidates[0];
-}
-function locate(decl, root, key, repoRoot, manifestPath, rootManifest) {
-  if (!decl) return void 0;
-  if (decl.inherited) {
-    const shared = root.find((d) => d.inWorkspace && d.key === key);
-    if (!shared?.version) return void 0;
-    return {
-      version: shared.version,
-      inherited: true,
-      declaration: { file: rootManifest, kind: "dependency-management", displayPath: display(repoRoot, rootManifest) }
-    };
-  }
-  if (!decl.version) return void 0;
-  return {
-    version: decl.version,
-    inherited: false,
-    declaration: { file: manifestPath, kind: "dependency", displayPath: display(repoRoot, manifestPath) }
-  };
-}
-function sharersOf(metadata, self, key) {
-  return metadata.packages.filter((p) => p !== self).filter((p) => readDeclarations(p.manifest_path).some((d) => d.key === key && d.inherited)).map((p) => p.name);
-}
-var display = (repoRoot, file) => relative4(repoRoot, file).replace(/\\/g, "/");
-var samePath = (a, b) => relative4(a, b) === "";
-function sameRequirement(literal, req) {
-  const a = toSemverRange(literal);
-  const b = toSemverRange(req);
-  return a !== null && b !== null && semver8.validRange(a) === semver8.validRange(b);
-}
-
-// src/adapters/cargo/cargo-updater.ts
-import { existsSync as existsSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync2 } from "fs";
-import { join as join12, resolve as resolve6 } from "path";
-import semver9 from "semver";
-
-// src/adapters/shared/xml.ts
-import { SaxesParser } from "saxes";
-var XmlParseError = class extends Error {
-  constructor(message2, file) {
-    super(file ? `${file}: ${message2}` : message2);
-    this.file = file;
-    this.name = "XmlParseError";
-  }
-  file;
-};
-function parseXml(source, file) {
-  const parser = new SaxesParser({ position: true });
-  const stack = [];
-  const openEnds = [];
-  let root;
-  let failure;
-  parser.on("error", (err) => {
-    failure ??= err;
-  });
-  parser.on("opentag", (tag) => {
-    const attributes = {};
-    for (const [key, value] of Object.entries(tag.attributes)) {
-      attributes[key] = typeof value === "string" ? value : value.value;
-    }
-    const element = {
-      name: localName(tag.name),
-      attributes,
-      children: [],
-      text: ""
-    };
-    const parent = stack[stack.length - 1];
-    if (parent) parent.children.push(element);
-    else root ??= element;
-    stack.push(element);
-    openEnds.push(parser.position);
-  });
-  parser.on("closetag", (tag) => {
-    const element = stack.pop();
-    const openEnd = openEnds.pop();
-    if (!element || openEnd === void 0 || tag.isSelfClosing) return;
-    const closeEnd = parser.position;
-    const closeStart = source.lastIndexOf("</", closeEnd - 1);
-    if (closeStart >= openEnd) {
-      element.contentRange = { start: openEnd, end: closeStart };
-    }
-  });
-  parser.on("text", (text) => {
-    const current = stack[stack.length - 1];
-    if (current) current.text += text;
-  });
-  parser.on("cdata", (data) => {
-    const current = stack[stack.length - 1];
-    if (current) current.text += data;
-  });
-  try {
-    parser.write(source).close();
-  } catch (err) {
-    failure ??= err;
-  }
-  if (failure) throw new XmlParseError(failure.message, file);
-  if (!root) throw new XmlParseError("document has no root element", file);
-  return root;
-}
-function child(element, name) {
-  return element?.children.find((c) => c.name === name);
-}
-function children(element, name) {
-  return element ? element.children.filter((c) => c.name === name) : [];
-}
-function childAt(element, ...path) {
-  let current = element;
-  for (const name of path) current = child(current, name);
-  return current;
-}
-function childText(element, name) {
-  const value = child(element, name)?.text.trim();
-  return value ? value : void 0;
-}
-var StaleEditError = class extends Error {
-  constructor(message2) {
-    super(message2);
-    this.name = "StaleEditError";
-  }
-};
-function applyTextEdits(source, edits) {
-  const splices = edits.map((edit) => {
-    const range = edit.element.contentRange;
-    if (!range) {
-      throw new StaleEditError(`<${edit.element.name}> has no editable text content.`);
-    }
-    const raw = source.slice(range.start, range.end);
-    const leading = raw.length - raw.trimStart().length;
-    const value = raw.trim();
-    if (value !== edit.expected) {
-      throw new StaleEditError(
-        `<${edit.element.name}> contains '${value}', expected '${edit.expected}'. The file changed since it was scanned.`
-      );
-    }
-    const start = range.start + leading;
-    return { start, end: start + value.length, replacement: edit.replacement };
-  });
-  splices.sort((a, b) => b.start - a.start);
-  for (let i = 1; i < splices.length; i++) {
-    if (splices[i].end > splices[i - 1].start) {
-      throw new StaleEditError("Overlapping edits on the same element.");
-    }
-  }
-  let result = source;
-  for (const splice of splices) {
-    result = result.slice(0, splice.start) + splice.replacement + result.slice(splice.end);
-  }
-  return result;
-}
-function escapeXml(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function serializeXml(element, indent = "") {
-  const attrs = Object.entries(element.attributes).map(([key, value]) => ` ${key}="${escapeXml(value).replace(/"/g, "&quot;")}"`).join("");
-  if (element.children.length === 0) {
-    return `${indent}<${element.name}${attrs}>${escapeXml(element.text.trim())}</${element.name}>`;
-  }
-  const inner = element.children.map((c) => serializeXml(c, `${indent}  `)).join("\n");
-  return `${indent}<${element.name}${attrs}>
-${inner}
-${indent}</${element.name}>`;
-}
-function localName(qualified) {
-  const colon = qualified.indexOf(":");
-  return colon >= 0 ? qualified.slice(colon + 1) : qualified;
-}
-
-// src/adapters/shared/text-edit.ts
-function applyRangeEdits(source, edits) {
-  for (const edit of edits) {
-    const found = source.slice(edit.start, edit.end);
-    if (found !== edit.expected) {
-      throw new StaleEditError(`Found '${found}', expected '${edit.expected}'. The file changed since it was scanned.`);
-    }
-  }
-  const ordered = [...edits].sort((a, b) => b.start - a.start);
-  for (let i = 1; i < ordered.length; i++) {
-    if (ordered[i].end > ordered[i - 1].start) throw new StaleEditError("Overlapping edits on the same text.");
-  }
-  let result = source;
-  for (const edit of ordered) result = result.slice(0, edit.start) + edit.replacement + result.slice(edit.end);
-  return result;
-}
-
-// src/adapters/cargo/cargo-updater.ts
-var UPDATE_TIMEOUT_MS = 10 * 6e4;
-var workspaceDir = (module, rootDir) => module.aggregatorDir ?? module.path ?? rootDir;
-var CargoUpdaterAdapter = class {
-  affectedFiles(module, rootDir, updates) {
-    const files = new Set(updates.map((u) => resolve6(u.declaration?.file ?? join12(module.path, "Cargo.toml"))));
-    files.add(join12(workspaceDir(module, rootDir), "Cargo.lock"));
-    return [...files];
-  }
-  async applyUpdates(module, rootDir, updates, onProgress) {
-    const dir = workspaceDir(module, rootDir);
-    const lockFile = join12(dir, "Cargo.lock");
-    const lockedBefore = readLockedVersions(lockFile);
-    const lockUpdates = updates.filter((u) => u.action === "lock");
-    updates = updates.filter((u) => u.action !== "lock");
-    this.checkLockUpdates(lockUpdates, lockFile, lockedBefore);
-    const byFile = /* @__PURE__ */ new Map();
-    for (const update of updates) {
-      const file = resolve6(update.declaration?.file ?? join12(module.path, "Cargo.toml"));
-      byFile.set(file, [...byFile.get(file) ?? [], update]);
-    }
-    const writes = [];
-    for (const [file, fileUpdates] of byFile) {
-      onProgress(`Preparing ${fileUpdates.length} change(s) in ${file}\u2026`);
-      const source = readFileSync12(file, "utf8");
-      const decls = parseCargoManifest(source);
-      const edits = [];
-      for (const update of fileUpdates) {
-        const inWorkspace = update.declaration?.kind === "dependency-management";
-        const name = update.coordinate.identifier;
-        const found = decls.filter(
-          (d) => d.inWorkspace === inWorkspace && (d.package ?? d.key) === name && d.version?.value === update.currentRange
-        );
-        if (found.length === 0) {
-          throw new InstallError(`${file}: cannot find the version of ${name} (${update.currentRange}) any more; rescan the module.`);
-        }
-        for (const d of found) {
-          edits.push({ start: d.version.start, end: d.version.end, expected: d.version.value, replacement: update.newRange });
-        }
-      }
-      try {
-        writes.push({ file, content: applyRangeEdits(source, edits) });
-      } catch (err) {
-        if (err instanceof StaleEditError) throw new InstallError(`${file}: ${err.message}`);
-        throw err;
-      }
-    }
-    onProgress("Writing Cargo.toml files\u2026");
-    for (const write of writes) writeFileSync2(write.file, write.content, "utf8");
-    const registryUpdates = updates.filter((u) => u.action === "update");
-    if (existsSync8(lockFile) && registryUpdates.length > 0) {
-      await this.refreshLock(dir, lockFile, lockedBefore, registryUpdates, onProgress);
-    }
-    for (const update of lockUpdates) {
-      const name = update.coordinate.identifier;
-      onProgress(`Locking ${name} at ${update.latest}\u2026`);
-      await this.cargoUpdate(dir, ["-p", `${name}@${update.currentClean}`, "--precise", update.latest]);
-    }
-    const parts = [];
-    if (updates.length > 0) {
-      parts.push(`Updated ${updates.length} requirement(s) in ${writes.length} Cargo.toml file(s)${existsSync8(lockFile) ? "; Cargo.lock refreshed" : ""}`);
-    }
-    if (lockUpdates.length > 0) parts.push(`locked ${lockUpdates.length} crate(s) at a newer version in Cargo.lock`);
-    const message2 = parts.join("; ");
-    return {
-      updatedCount: updates.length + lockUpdates.length,
-      auditMessage: `${message2.charAt(0).toUpperCase()}${message2.slice(1)}.`,
-      auditSeverity: "clean",
-      integrityViolations: []
-    };
-  }
-  /** A lock-only update needs a lock file that still holds the version the scan saw. */
-  checkLockUpdates(lockUpdates, lockFile, locked) {
-    if (lockUpdates.length === 0) return;
-    if (!existsSync8(lockFile)) {
-      throw new InstallError(`${lockFile} does not exist any more; rescan the module.`);
-    }
-    for (const update of lockUpdates) {
-      const name = update.coordinate.identifier;
-      if (!(locked.get(name) ?? []).includes(update.currentClean)) {
-        throw new InstallError(`Cargo.lock no longer locks ${name} at ${update.currentClean}; rescan the module.`);
-      }
-    }
-  }
-  async resync() {
-  }
-  async refreshLock(dir, lockFile, before, updates, onProgress) {
-    const specs = [];
-    for (const update of updates) {
-      const name = update.coordinate.identifier;
-      const versions = before.get(name) ?? [];
-      const old = versions.find((v) => satisfiesRequirement(update.currentRange, v)) ?? versions[0];
-      if (old) specs.push(`${name}@${old}`);
-    }
-    if (specs.length === 0) return;
-    onProgress("Updating Cargo.lock\u2026");
-    await this.cargoUpdate(dir, specs.flatMap((s) => ["-p", s]));
-    const after = readLockedVersions(lockFile);
-    for (const update of updates) {
-      const name = update.coordinate.identifier;
-      const locked = (after.get(name) ?? []).find((v) => satisfiesRequirement(update.newRange, v));
-      if (locked && semver9.valid(update.latest) && locked !== update.latest) {
-        onProgress(`Pinning ${name} to ${update.latest}\u2026`);
-        await this.cargoUpdate(dir, ["-p", `${name}@${locked}`, "--precise", update.latest]);
-      }
-    }
-  }
-  async cargoUpdate(dir, args) {
-    const result = await runCommand("cargo", ["update", ...args], { cwd: dir, timeoutMs: UPDATE_TIMEOUT_MS });
-    if (result.exitCode !== 0) {
-      const reason = result.timedOut ? "cargo update timed out" : "cargo update failed";
-      throw new InstallError(reason, tail(result.stderr || result.stdout));
-    }
-  }
-};
-
-// src/adapters/cargo/cargo-verifier.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join13, relative as relative5, resolve as resolve7 } from "path";
-var VERIFY_TIMEOUT_MS2 = 30 * 6e4;
-var same = (a, b) => relative5(resolve7(a), resolve7(b)) === "";
-function planCheck(metadata, module, changedFiles, locked) {
-  const args = ["check", "--all-targets", ...locked ? ["--locked"] : []];
-  const rootManifest = join13(metadata.workspace_root, "Cargo.toml");
-  const lockFile = join13(metadata.workspace_root, "Cargo.lock");
-  const memberManifests = new Set(metadata.packages.map((p) => resolve7(p.manifest_path)));
-  if (changedFiles.some((f) => same(f, rootManifest))) {
-    const isVirtualRoot = !memberManifests.has(resolve7(rootManifest));
-    if (isVirtualRoot || metadata.packages.length > 1) return [...args, "--workspace"];
-  }
-  if (changedFiles.length > 0 && changedFiles.every((f) => same(f, lockFile))) return [...args, "--workspace"];
-  const changed = new Set(
-    metadata.packages.filter((p) => changedFiles.some((f) => same(f, p.manifest_path))).map((p) => p.name)
-  );
-  if (changed.size === 0) changed.add(module.id);
-  for (let grew = true; grew; ) {
-    grew = false;
-    for (const p of metadata.packages) {
-      if (changed.has(p.name)) continue;
-      if (p.dependencies.some((d) => d.source === null && d.path && changed.has(d.name))) {
-        changed.add(p.name);
-        grew = true;
-      }
-    }
-  }
-  const ordered = metadata.packages.filter((p) => changed.has(p.name)).map((p) => p.name);
-  return [...args, ...ordered.flatMap((name) => ["-p", name])];
-}
-var CargoVerificationAdapter = class {
-  constructor(deps = { loadMetadata, hasLock: (dir) => existsSync9(join13(dir, "Cargo.lock")) }) {
-    this.deps = deps;
-  }
-  deps;
-  async verify(module, rootDir, options = {}) {
-    const dir = module.aggregatorDir ?? module.path ?? rootDir;
-    if (options.customScript) {
-      const label2 = options.customLabel || options.customScript;
-      const result2 = await runShellScript(options.customScript, { cwd: dir, timeoutMs: VERIFY_TIMEOUT_MS2 });
-      return result2.exitCode === 0 ? { status: "clean", details: "Verification script succeeded.", label: label2 } : { status: "warn", details: tail(result2.stderr || result2.stdout), label: label2 };
-    }
-    const metadata = await this.deps.loadMetadata(dir);
-    const args = planCheck(metadata, module, options.changedFiles ?? [], this.deps.hasLock(dir));
-    const label = `Cargo build (cargo ${args.join(" ")})`;
-    const result = await runCargo(args, { cwd: dir, timeoutMs: VERIFY_TIMEOUT_MS2 });
-    if (result.exitCode === 0) return { status: "clean", details: "All affected crates type-check, including tests.", label };
-    return {
-      status: "warn",
-      details: result.timedOut ? "cargo check timed out." : cargoErrors(`${result.stderr}
-${result.stdout}`),
-      label
-    };
-  }
-};
-
-// src/adapters/cargo/cargo-strategy.ts
-var cargoVersionPolicy = {
-  normalize: (v) => semver10.valid(v),
-  rewrite: rewriteRequirement,
-  diff: (current, target) => semver10.valid(current) && semver10.valid(target) ? semver10.eq(current, target) ? "patch" : cargoDiff(current, target) : "minor",
-  // Updates are written where the scan found the declaration.
-  allowsManualTargets: false
-};
-var CargoEcosystemStrategy = class {
-  ecosystem = "cargo";
-  displayName = "Rust / Cargo";
-  icon = "\u{1F980}";
-  manifestFile = "Cargo.toml";
-  versioning = cargoVersionPolicy;
-  config = new CargoConfigReader();
-  index = new CargoIndexClient();
-  endpoint = (registry, cwd) => this.config.resolve(registry, cwd);
-  discovery = new CargoModuleDiscoveryAdapter();
-  registry = new CargoRegistryAdapter({ index: this.index, endpoint: this.endpoint });
-  reader = new CargoDependencyAdapter({ loadMetadata, index: this.index, endpoint: this.endpoint });
-  updater = new CargoUpdaterAdapter();
-  verifier = new CargoVerificationAdapter();
-  getTabLabels(counts, t) {
-    return {
-      all: t.tabs.all(counts.total),
-      prod: t.tabs.dependencies(counts.prodCount),
-      dev: t.tabs.devDependencies(counts.devCount)
-    };
-  }
-};
-
-// src/adapters/maven/maven-discovery.ts
-import { existsSync as existsSync12 } from "fs";
-import { dirname as dirname7, join as join16, relative as relative6, resolve as resolve10 } from "path";
-
-// src/adapters/maven/maven-project.ts
-import { existsSync as existsSync11, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join15, resolve as resolve9 } from "path";
-
-// src/adapters/maven/maven-pom.ts
-import { existsSync as existsSync10, readFileSync as readFileSync13, statSync } from "fs";
-import { dirname as dirname6, join as join14, resolve as resolve8 } from "path";
-function readPom(file) {
-  const source = readFileSync13(file, "utf8");
-  return parsePom(source, file);
-}
-function parsePom(source, file) {
-  const project = parseXml(source, file);
-  const parentElement = child(project, "parent");
-  const parent = parentElement ? {
-    groupId: childText(parentElement, "groupId") ?? "",
-    artifactId: childText(parentElement, "artifactId") ?? "",
-    version: childText(parentElement, "version") ?? "",
-    relativePath: child(parentElement, "relativePath")?.text.trim(),
-    versionElement: child(parentElement, "version")
-  } : void 0;
-  const properties = /* @__PURE__ */ new Map();
-  for (const element of child(project, "properties")?.children ?? []) {
-    properties.set(element.name, { value: element.text.trim(), element });
-  }
-  return {
-    file,
-    dir: dirname6(file),
-    groupId: childText(project, "groupId"),
-    artifactId: childText(project, "artifactId") ?? "unknown",
-    version: childText(project, "version"),
-    versionElement: child(project, "version"),
-    name: childText(project, "name"),
-    packaging: childText(project, "packaging") ?? "jar",
-    parent,
-    properties,
-    dependencies: readDependencies(child(project, "dependencies")),
-    managedDependencies: readDependencies(childAt(project, "dependencyManagement", "dependencies")),
-    modules: children(child(project, "modules"), "module").map((m) => m.text.trim()).filter(Boolean)
-  };
-}
-function readDependencies(container) {
-  return children(container, "dependency").map((element) => ({
-    groupId: childText(element, "groupId") ?? "",
-    artifactId: childText(element, "artifactId") ?? "",
-    version: childText(element, "version"),
-    type: childText(element, "type"),
-    classifier: childText(element, "classifier"),
-    scope: childText(element, "scope"),
-    versionElement: child(element, "version")
-  }));
-}
-function parentPomFile(pom) {
-  if (!pom.parent) return void 0;
-  const relativePath = pom.parent.relativePath ?? "../pom.xml";
-  if (relativePath === "") return void 0;
-  let candidate = resolve8(pom.dir, relativePath);
-  if (existsSync10(candidate) && statSync(candidate).isDirectory()) candidate = join14(candidate, "pom.xml");
-  return existsSync10(candidate) ? candidate : void 0;
-}
-function builtinProperty(name, module) {
-  switch (name) {
-    case "project.groupId":
-    case "pom.groupId":
-      return module.groupId ?? module.parent?.groupId;
-    case "project.artifactId":
-    case "pom.artifactId":
-      return module.artifactId;
-    case "project.version":
-    case "pom.version":
-      return module.version ?? module.parent?.version;
-    case "project.parent.groupId":
-      return module.parent?.groupId;
-    case "project.parent.version":
-      return module.parent?.version;
-    default:
-      return void 0;
-  }
-}
-function findProperty(name, chain) {
-  for (const pom of chain) {
-    const property = pom.properties.get(name);
-    if (property) return { pom, property };
-  }
-  return void 0;
-}
-function interpolate(text, chain, depth = 0) {
-  if (depth > 10 || !text.includes("${")) return text;
-  const module = chain[0];
-  const replaced = text.replace(/\$\{([^}]+)\}/g, (expression, name) => {
-    const builtin = module ? builtinProperty(name, module) : void 0;
-    if (builtin !== void 0) return builtin;
-    return findProperty(name, chain)?.property.value ?? expression;
-  });
-  return replaced === text ? text : interpolate(replaced, chain, depth + 1);
-}
-function propertyReference(text) {
-  return text.match(/^\$\{([^}]+)\}$/)?.[1];
-}
-
-// src/adapters/maven/maven-project.ts
-var MAX_DEPTH = 6;
-var SKIPPED_DIRS = /* @__PURE__ */ new Set(["node_modules", "target", "build", "dist", "out"]);
-var MavenProject = class _MavenProject {
-  constructor(rootDir, poms) {
-    this.rootDir = rootDir;
-    this.poms = poms;
-    for (const pom of poms) this.byFile.set(pom.file, pom);
-    this.assignAggregators();
-  }
-  rootDir;
-  poms;
-  byFile = /* @__PURE__ */ new Map();
-  aggregators = /* @__PURE__ */ new Map();
-  /**
-   * Loads every readable pom.xml below `rootDir`, plus every module listed in
-   * a `<modules>` section, even in directories the file walk skips (such as
-   * `build/` or `dist/`). Malformed files are skipped.
-   */
-  static load(rootDir) {
-    const poms = [];
-    const queue = findPomFiles(rootDir);
-    const seen = new Set(queue);
-    while (queue.length > 0) {
-      const file = queue.shift();
-      let pom;
-      try {
-        pom = readPom(file);
-      } catch {
-        continue;
-      }
-      poms.push(pom);
-      for (const entry of pom.modules) {
-        const target = resolve9(pom.dir, entry);
-        const moduleFile = target.endsWith(".xml") ? target : join15(target, "pom.xml");
-        if (!seen.has(moduleFile) && existsSync11(moduleFile)) {
-          seen.add(moduleFile);
-          queue.push(moduleFile);
-        }
-      }
-    }
-    return new _MavenProject(rootDir, poms);
-  }
-  pomAt(file) {
-    return this.byFile.get(resolve9(file));
-  }
-  /** The project followed by its local parents, stopping at the first external parent. */
-  chainOf(pom) {
-    const poms = [pom];
-    let current = pom;
-    while (current.parent) {
-      const parent = this.localParentOf(current);
-      if (!parent || poms.includes(parent)) {
-        return { poms, externalParent: parent ? void 0 : current.parent };
-      }
-      poms.push(parent);
-      current = parent;
-    }
-    return { poms };
-  }
-  /** Coordinates of a project with inherited groupId/version and interpolated values. */
-  coordinatesOf(pom) {
-    const chain = this.chainOf(pom).poms;
-    const groupId = pom.groupId ?? pom.parent?.groupId ?? "";
-    const rawVersion = pom.version ?? pom.parent?.version;
-    const version = rawVersion ? interpolate(rawVersion, chain) : void 0;
-    return {
-      groupId: interpolate(groupId, chain),
-      artifactId: pom.artifactId,
-      version: version && !version.includes("${") ? version : void 0
-    };
-  }
-  /** Directory of the outermost aggregator whose reactor includes this project. */
-  aggregatorDirOf(pom) {
-    return this.aggregators.get(pom.file);
-  }
-  localParentOf(pom) {
-    const parent = pom.parent;
-    if (!parent) return void 0;
-    const matches = (candidate) => {
-      if (!candidate) return false;
-      const groupId = interpolate(candidate.groupId ?? candidate.parent?.groupId ?? "", [candidate]);
-      const version = interpolate(candidate.version ?? candidate.parent?.version ?? "", [candidate]);
-      const expected = interpolate(parent.version, [pom]);
-      return groupId === parent.groupId && candidate.artifactId === parent.artifactId && (version.includes("${") || expected.includes("${") || version === expected);
-    };
-    const file = parentPomFile(pom);
-    const byPath = file ? this.byFile.get(resolve9(file)) : void 0;
-    return matches(byPath) ? byPath : void 0;
-  }
-  /**
-   * Walks `<modules>` from every aggregator, outermost first, and records for
-   * each reached project the aggregator that builds it.
-   */
-  assignAggregators() {
-    const aggregatorPoms = this.poms.filter((pom) => pom.modules.length > 0).sort((a, b) => a.dir.length - b.dir.length);
-    for (const aggregator of aggregatorPoms) {
-      if (this.aggregators.has(aggregator.file)) continue;
-      const queue = [aggregator];
-      while (queue.length > 0) {
-        const pom = queue.shift();
-        if (this.aggregators.has(pom.file)) continue;
-        this.aggregators.set(pom.file, aggregator.dir);
-        for (const entry of pom.modules) {
-          const target = resolve9(pom.dir, entry);
-          const file = target.endsWith(".xml") ? target : join15(target, "pom.xml");
-          const modulePom = this.byFile.get(file);
-          if (modulePom) queue.push(modulePom);
-        }
-      }
-    }
-  }
-};
-function findPomFiles(rootDir) {
-  const results = [];
-  const rootPom = join15(rootDir, "pom.xml");
-  if (existsSync11(rootPom)) results.push(resolve9(rootPom));
-  const walk = (dir, depth) => {
-    if (depth > MAX_DEPTH) return;
-    let entries2;
-    try {
-      entries2 = readdirSync2(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    const isProject = existsSync11(join15(dir, "pom.xml"));
-    for (const entry of entries2) {
-      if (!entry.isDirectory() || entry.name.startsWith(".") || SKIPPED_DIRS.has(entry.name)) continue;
-      if (isProject && entry.name === "src") continue;
-      const subDir = join15(dir, entry.name);
-      const pom = join15(subDir, "pom.xml");
-      if (existsSync11(pom) && statSync2(pom).isFile()) results.push(resolve9(pom));
-      walk(subDir, depth + 1);
-    }
-  };
-  walk(rootDir, 1);
-  return results;
-}
-
-// src/adapters/maven/maven-discovery.ts
-var MavenModuleDiscoveryAdapter = class {
-  /**
-   * Proposes a root only when `startDir` holds a pom.xml, and then climbs to
-   * the POM above until there is none: the top of the connected POM chain.
-   */
-  findRoot(startDir, boundaryDir) {
-    let dir = resolve10(startDir);
-    if (!existsSync12(join16(dir, "pom.xml"))) return void 0;
-    const boundary = boundaryDir ? resolve10(boundaryDir) : void 0;
-    for (; ; ) {
-      const above = pomAbove(dir, boundary);
-      if (!above) return dir;
-      dir = above;
-    }
-  }
-  async discover(rootDir) {
-    const project = MavenProject.load(rootDir);
-    const modules = project.poms.map((pom) => {
-      const coordinates = project.coordinatesOf(pom);
-      const relPath = relative6(rootDir, pom.dir).replace(/\\/g, "/");
-      return {
-        id: coordinates.groupId ? `${coordinates.groupId}:${coordinates.artifactId}` : coordinates.artifactId,
-        name: pom.name ? interpolate(pom.name, project.chainOf(pom).poms) : pom.artifactId,
-        path: pom.dir,
-        relPath: relPath || "Root",
-        ecosystem: "maven",
-        isRoot: relPath === "",
-        version: coordinates.version,
-        aggregatorDir: project.aggregatorDirOf(pom)
-      };
-    });
-    modules.sort((a, b) => a.isRoot ? -1 : b.isRoot ? 1 : a.relPath.localeCompare(b.relPath));
-    return modules;
-  }
-};
-function tryReadPom(file) {
-  try {
-    return readPom(file);
-  } catch {
-    return void 0;
-  }
-}
-function ancestorsWithin(dir, boundary) {
-  const result = [];
-  let current = dir;
-  while (current !== boundary) {
-    const parent = dirname7(current);
-    if (parent === current) break;
-    result.push(parent);
-    current = parent;
-  }
-  return result;
-}
-function pomAbove(dir, boundary) {
-  const pom = tryReadPom(join16(dir, "pom.xml"));
-  if (!pom) return void 0;
-  const ancestors = ancestorsWithin(dir, boundary);
-  const found = [];
-  const parentFile = parentPomFile(pom);
-  if (parentFile && pom.parent && ancestors.includes(dirname7(parentFile))) {
-    const parent = tryReadPom(parentFile);
-    const groupId = parent?.groupId ?? parent?.parent?.groupId;
-    if (parent && parent.artifactId === pom.parent.artifactId && groupId === pom.parent.groupId) {
-      found.push(dirname7(parentFile));
-    }
-  }
-  const ownFile = join16(dir, "pom.xml");
-  const aggregator = ancestors.find(
-    (ancestor) => tryReadPom(join16(ancestor, "pom.xml"))?.modules.some((entry) => {
-      const target = resolve10(ancestor, entry);
-      return target === dir || target === ownFile;
-    })
-  );
-  if (aggregator) found.push(aggregator);
-  return found.sort((a, b) => a.length - b.length)[0];
-}
-
-// src/adapters/maven/maven-registry.ts
-import { existsSync as existsSync15 } from "fs";
-import { join as join19 } from "path";
-
-// src/adapters/maven/maven-command.ts
-import { existsSync as existsSync13 } from "fs";
-import { dirname as dirname8, isAbsolute as isAbsolute2, join as join17, relative as relative7, resolve as resolve11, sep } from "path";
-var MavenUnavailableError = class extends Error {
-  constructor() {
-    super("Maven is not available: no Maven Wrapper (mvnw) in the project and no `mvn` on the PATH.");
-    this.name = "MavenUnavailableError";
-  }
-};
-var MavenCommandError = class extends Error {
-  constructor(message2, output) {
-    super(message2);
-    this.output = output;
-    this.name = "MavenCommandError";
-  }
-  output;
-};
-var IS_WINDOWS2 = process.platform === "win32";
-var WRAPPER = IS_WINDOWS2 ? "mvnw.cmd" : "mvnw";
-var BATCH_ARGS = ["-B", "--no-transfer-progress"];
-var mvnOnPath;
-function findMavenWrapper(fromDir, rootDir) {
-  let dir = resolve11(fromDir);
-  const root = resolve11(rootDir);
-  for (; ; ) {
-    const candidate = join17(dir, WRAPPER);
-    if (existsSync13(candidate)) return candidate;
-    if (dir === root || relative7(root, dir).startsWith("..")) return void 0;
-    const parent = dirname8(dir);
-    if (parent === dir) return void 0;
-    dir = parent;
-  }
-}
-function relativeToCwd(cwd, file) {
-  const path = relative7(cwd, file);
-  return isAbsolute2(path) ? file : path || ".";
-}
-async function runMaven(args, options) {
-  const wrapper = findMavenWrapper(options.cwd, options.rootDir);
-  const run = { cwd: options.cwd, timeoutMs: options.timeoutMs };
-  if (wrapper) {
-    const relativeWrapper = relativeToCwd(options.cwd, wrapper);
-    const path = isAbsolute2(relativeWrapper) || relativeWrapper.includes(sep) ? relativeWrapper : `.${sep}${relativeWrapper}`;
-    return IS_WINDOWS2 ? runCommand(path, [...BATCH_ARGS, ...args], run) : runCommand("sh", [path, ...BATCH_ARGS, ...args], run);
-  }
-  mvnOnPath ??= runCommand("mvn", ["-v"], { cwd: options.cwd, timeoutMs: 3e4 }).then(
-    (result) => result.exitCode === 0,
-    () => false
-  );
-  if (!await mvnOnPath) throw new MavenUnavailableError();
-  return runCommand("mvn", [...BATCH_ARGS, ...args], run);
-}
-function mavenErrors(output) {
-  const errors = output.split(/\r?\n/).filter((line) => line.startsWith("[ERROR]")).map((line) => line.replace(/^\[ERROR\]\s?/, "")).filter((line) => line.trim() && !line.startsWith("->") && !line.includes("Re-run Maven"));
-  return (errors.length > 0 ? errors : output.trim().split(/\r?\n/).slice(-10)).slice(0, 12).join("\n");
-}
-
-// src/adapters/maven/maven-resolution.ts
-import { randomUUID } from "crypto";
-import { existsSync as existsSync14, mkdirSync, readFileSync as readFileSync14, readdirSync as readdirSync3, rmSync, writeFileSync as writeFileSync3 } from "fs";
-import { join as join18 } from "path";
-var DEFAULT_MAVEN_PLUGINS = { help: "3.5.2", versions: "2.22.0" };
-var HELP_PLUGIN_ID = "org.apache.maven.plugins:maven-help-plugin";
-var VERSIONS_PLUGIN_ID = "org.codehaus.mojo:versions-maven-plugin";
-var DOWNLOAD_FAILURES = [
-  "could not be resolved",
-  "could not find artifact",
-  "failed to read artifact descriptor",
-  "could not transfer artifact"
-];
-var MavenPluginUnavailableError = class extends MavenCommandError {
-  constructor(plugin, output) {
-    super(
-      `Maven could not download ${plugin.id}:${plugin.version}, which Elevate uses to ${plugin.purpose}. Make this plugin available in the repository or mirror your Maven is configured with, or choose a version that is available there with "mavenPlugins": { "${plugin.key}": "<version>" } in elevate.config.json.
-${mavenErrors(output)}`,
-      output
-    );
-    this.name = "MavenPluginUnavailableError";
-  }
-};
-function isPluginUnavailable(output, pluginId) {
-  return output.split(/\r?\n/).some((line) => {
-    const lower = line.toLowerCase();
-    return line.includes(pluginId) && DOWNLOAD_FAILURES.some((phrase) => lower.includes(phrase));
-  });
-}
-var MAVEN_TIMEOUT_MS = 5 * 6e4;
-var ScratchDirectory = class {
-  path;
-  target;
-  createdTarget;
-  constructor(moduleDir) {
-    this.target = join18(moduleDir, "target");
-    this.createdTarget = !existsSync14(this.target);
-    this.path = join18(this.target, `.elevate-${randomUUID().slice(0, 8)}`);
-    mkdirSync(this.path, { recursive: true });
-  }
-  dispose() {
-    rmSync(this.path, { recursive: true, force: true });
-    try {
-      if (this.createdTarget && readdirSync3(this.target).length === 0) rmSync(this.target, { recursive: true });
-    } catch {
-    }
-  }
-};
-async function readEffectivePoms(pomFile, moduleDir, rootDir, scratch, plugins, recursive = false) {
-  const output = join18(scratch.path, "effective-pom.xml");
-  const args = [
-    "-f",
-    relativeToCwd(moduleDir, pomFile),
-    `${HELP_PLUGIN_ID}:${plugins.help}:effective-pom`,
-    `-Doutput=${relativeToCwd(moduleDir, output)}`
-  ];
-  const result = await runMaven(recursive ? args : ["-N", ...args], {
-    cwd: moduleDir,
-    rootDir,
-    timeoutMs: MAVEN_TIMEOUT_MS
-  });
-  if (result.exitCode !== 0 || !existsSync14(output)) {
-    const text = `${result.stdout}
-${result.stderr}`;
-    if (isPluginUnavailable(text, HELP_PLUGIN_ID)) {
-      throw new MavenPluginUnavailableError(
-        { id: HELP_PLUGIN_ID, version: plugins.help, key: "help", purpose: "read the effective POM" },
-        text
-      );
-    }
-    throw new MavenCommandError(`Maven could not build the effective POM:
-${mavenErrors(text)}`, text);
-  }
-  return parseEffectivePoms(readFileSync14(output, "utf8"));
-}
-function parseEffectivePoms(source) {
-  const root = parseXml(source);
-  const projects = root.name === "projects" ? children(root, "project") : [root];
-  const models = /* @__PURE__ */ new Map();
-  for (const project of projects) {
-    models.set(`${childText(project, "groupId")}:${childText(project, "artifactId")}`, toEffectiveModel(project));
-  }
-  return models;
-}
-function mergeRepositories(models) {
-  const merge2 = (name, pick) => {
-    const byId = /* @__PURE__ */ new Map();
-    for (const element of models.map(pick)) {
-      for (const repository of element?.children ?? []) {
-        const id = childText(repository, "id") ?? childText(repository, "url") ?? "";
-        if (!byId.has(id)) byId.set(id, repository);
-      }
-    }
-    return byId.size > 0 ? { name, attributes: {}, children: [...byId.values()], text: "" } : void 0;
-  };
-  return {
-    dependencies: [],
-    managedDependencies: [],
-    repositories: merge2("repositories", (m) => m.repositories),
-    pluginRepositories: merge2("pluginRepositories", (m) => m.pluginRepositories)
-  };
-}
-function toEffectiveModel(project) {
-  return {
-    dependencies: readEffectiveDependencies(child(project, "dependencies")),
-    managedDependencies: readEffectiveDependencies(childAt(project, "dependencyManagement", "dependencies")),
-    repositories: child(project, "repositories"),
-    pluginRepositories: child(project, "pluginRepositories")
-  };
-}
-function readEffectiveDependencies(container) {
-  return children(container, "dependency").map((element) => ({
-    groupId: childText(element, "groupId") ?? "",
-    artifactId: childText(element, "artifactId") ?? "",
-    version: childText(element, "version") ?? "",
-    scope: childText(element, "scope") ?? "compile",
-    type: childText(element, "type") ?? "jar",
-    classifier: childText(element, "classifier")
-  }));
-}
-function buildProbePom(artifacts, model) {
-  const seen = /* @__PURE__ */ new Set();
-  const entries2 = [];
-  for (const artifact of artifacts) {
-    const key = `${artifact.groupId}:${artifact.artifactId}:${artifact.type ?? "jar"}:${artifact.classifier ?? ""}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    const fields = [
-      `<groupId>${escapeXml(artifact.groupId)}</groupId>`,
-      `<artifactId>${escapeXml(artifact.artifactId)}</artifactId>`,
-      `<version>${escapeXml(artifact.version)}</version>`,
-      artifact.type && artifact.type !== "jar" ? `<type>${escapeXml(artifact.type)}</type>` : "",
-      artifact.classifier ? `<classifier>${escapeXml(artifact.classifier)}</classifier>` : ""
-    ].filter(Boolean);
-    entries2.push(`      <dependency>${fields.join("")}</dependency>`);
-  }
-  const repositories = [model.repositories, model.pluginRepositories].filter((element) => element !== void 0).map((element) => serializeXml(element, "  ")).join("\n");
-  return [
-    '<?xml version="1.0" encoding="UTF-8"?>',
-    '<project xmlns="http://maven.apache.org/POM/4.0.0">',
-    "  <modelVersion>4.0.0</modelVersion>",
-    "  <groupId>elevate.probe</groupId>",
-    "  <artifactId>elevate-probe</artifactId>",
-    "  <version>0</version>",
-    "  <packaging>pom</packaging>",
-    repositories,
-    "  <dependencyManagement>",
-    "    <dependencies>",
-    ...entries2,
-    "    </dependencies>",
-    "  </dependencyManagement>",
-    "</project>",
-    ""
-  ].filter((line) => line !== "").join("\n");
-}
-async function queryNewerVersions(artifacts, model, moduleDir, rootDir, scratch, plugins) {
-  if (artifacts.length === 0) return { newerVersions: /* @__PURE__ */ new Map(), failedLookups: /* @__PURE__ */ new Set() };
-  const probeDir = join18(scratch.path, "probe");
-  mkdirSync(probeDir, { recursive: true });
-  const probePom = join18(probeDir, "pom.xml");
-  writeFileSync3(probePom, buildProbePom(artifacts, model), "utf8");
-  const result = await runMaven(
-    [
-      "-N",
-      "-f",
-      relativeToCwd(moduleDir, probePom),
-      `${VERSIONS_PLUGIN_ID}:${plugins.versions}:dependency-updates-report`,
-      "-DdependencyUpdatesReportFormats=xml",
-      "-DprocessDependencyManagementTransitive=false"
-    ],
-    { cwd: moduleDir, rootDir, timeoutMs: MAVEN_TIMEOUT_MS }
-  );
-  const log = `${result.stdout}
-${result.stderr}`;
-  const reportFile = join18(probeDir, "target", "dependency-updates-report.xml");
-  if (result.exitCode !== 0 || !existsSync14(reportFile)) {
-    if (isPluginUnavailable(log, VERSIONS_PLUGIN_ID)) {
-      throw new MavenPluginUnavailableError(
-        { id: VERSIONS_PLUGIN_ID, version: plugins.versions, key: "versions", purpose: "look up newer versions" },
-        log
-      );
-    }
-    throw new MavenCommandError(`Maven could not look up newer versions:
-${mavenErrors(log)}`, log);
-  }
-  return {
-    newerVersions: parseUpdatesReport(readFileSync14(reportFile, "utf8")),
-    failedLookups: parseFailedLookups(log)
-  };
-}
-function parseUpdatesReport(source) {
-  const report = parseXml(source);
-  const sections = [
-    ...children(child(report, "dependencyManagements"), "dependencyManagement"),
-    ...children(child(report, "dependencies"), "dependency")
-  ];
-  const result = /* @__PURE__ */ new Map();
-  for (const entry of sections) {
-    const key = `${childText(entry, "groupId")}:${childText(entry, "artifactId")}`;
-    const versions = [
-      ...collect(entry, "subIncrementals", "subIncremental"),
-      ...collect(entry, "incrementals", "incremental"),
-      ...collect(entry, "minors", "minor"),
-      ...collect(entry, "majors", "major")
-    ];
-    const known = result.get(key) ?? [];
-    for (const version of versions) if (!known.includes(version)) known.push(version);
-    result.set(key, known);
-  }
-  return result;
-}
-function collect(entry, container, item) {
-  return children(child(entry, container), item).map((element) => element.text.trim()).filter(Boolean);
-}
-function parseFailedLookups(log) {
-  const failed = /* @__PURE__ */ new Set();
-  const pattern = /Could not (?:transfer|read) metadata ([^:\s/]+):([^:\s/]+)(?::[^\s/]+)?\/maven-metadata\.xml/g;
-  for (const match of log.matchAll(pattern)) failed.add(`${match[1]}:${match[2]}`);
-  return failed;
-}
-
-// src/adapters/maven/maven-registry.ts
-var PROBE_VERSION = "0";
-var NO_REPOSITORIES = { dependencies: [], managedDependencies: [] };
-var MavenRegistryAdapter = class {
-  constructor(plugins = DEFAULT_MAVEN_PLUGINS) {
-    this.plugins = plugins;
-  }
-  plugins;
-  /**
-   * The repositories come from Maven's own configuration, which Elevate does
-   * not interpret. They are reported as non-public: the lookup goes exactly
-   * where the project's build would go.
-   */
-  async resolveEndpoint() {
-    return { url: "repositories configured for Maven (settings.xml, POM)", isPublic: false };
-  }
-  async getLatestVersion(coordinate, channel = "stable", cwd = process.cwd()) {
-    const versions = await this.getAllVersions(coordinate, cwd);
-    return versions.find((v) => channel === "all" || !isPreReleaseVersion(v)) ?? null;
-  }
-  /**
-   * All versions available in the configured repositories, newest first.
-   * Throws `MavenCommandError` when Maven fails or a repository could not be
-   * read, so an error is never mistaken for "no versions".
-   */
-  async getAllVersions(coordinate, cwd = process.cwd()) {
-    if (!coordinate.group || !coordinate.artifact) return [];
-    const key = `${coordinate.group}:${coordinate.artifact}`;
-    const scratch = new ScratchDirectory(cwd);
-    try {
-      const repositories = await projectRepositories(cwd, scratch, this.plugins);
-      const report = await queryNewerVersions(
-        [{ groupId: coordinate.group, artifactId: coordinate.artifact, version: PROBE_VERSION }],
-        repositories,
-        cwd,
-        cwd,
-        scratch,
-        this.plugins
-      );
-      const versions = report.newerVersions.get(key) ?? [];
-      if (versions.length === 0 && report.failedLookups.has(key)) {
-        throw new MavenCommandError(`A Maven repository failed to deliver the versions of ${key}.`, "");
-      }
-      return [...versions].reverse();
-    } finally {
-      scratch.dispose();
-    }
-  }
-};
-async function projectRepositories(cwd, scratch, plugins) {
-  const rootPom = join19(cwd, "pom.xml");
-  if (!existsSync15(rootPom)) return NO_REPOSITORIES;
-  const models = await readEffectivePoms(rootPom, cwd, cwd, scratch, plugins);
-  return [...models.values()][0] ?? NO_REPOSITORIES;
-}
-
-// src/adapters/maven/maven-scanner.ts
-import { join as join20 } from "path";
-import semver11 from "semver";
-
-// src/adapters/maven/maven-locator.ts
-import { relative as relative8 } from "path";
-function locateDependencyVersion(chain, target, rootDir) {
-  for (const pom of chain) {
-    const dependency = findDependency(pom.dependencies, target, chain);
-    if (!dependency) continue;
-    if (!dependency.versionElement) break;
-    return resolveLiteral(pom, "dependency", dependency.versionElement, chain, target, rootDir);
-  }
-  return locateManagedVersion(chain, target, rootDir);
-}
-function locateManagedVersion(chain, target, rootDir) {
-  for (const pom of chain) {
-    const managed = findDependency(pom.managedDependencies, target, chain);
-    if (managed?.versionElement) {
-      return resolveLiteral(pom, "dependency-management", managed.versionElement, chain, target, rootDir);
-    }
-  }
-  return {
-    found: false,
-    reason: "managed-externally",
-    detail: "version is managed outside this repository (external parent POM or imported BOM)"
-  };
-}
-function locateParentVersion(module, target, rootDir) {
-  const element = module.parent?.versionElement;
-  if (!element) {
-    return { found: false, reason: "declaration-mismatch", detail: "parent has no <version> element" };
-  }
-  return resolveLiteral(module, "parent", element, [module], target, rootDir);
-}
-function findDependency(dependencies, target, chain) {
-  return dependencies.find(
-    (dep) => dep.scope !== "import" && interpolate(dep.groupId, chain) === target.groupId && interpolate(dep.artifactId, chain) === target.artifactId
-  );
-}
-function resolveLiteral(pom, kind, versionElement, chain, target, rootDir) {
-  let file = pom.file;
-  let element = versionElement;
-  let value = versionElement.text.trim();
-  let propertyName;
-  for (let depth = 0; depth < 10; depth++) {
-    const reference = propertyReference(value);
-    if (!reference) break;
-    if (reference.startsWith("project.") || reference.startsWith("pom.")) {
-      return {
-        found: false,
-        reason: "declaration-mismatch",
-        detail: `version is the expression \${${reference}}, not an editable value`
-      };
-    }
-    const definition = findProperty(reference, chain);
-    if (!definition) {
-      return {
-        found: false,
-        reason: "managed-externally",
-        detail: `property \${${reference}} is defined outside this repository`
-      };
-    }
-    file = definition.pom.file;
-    element = definition.property.element;
-    value = definition.property.value;
-    propertyName = reference;
-  }
-  if (value.includes("${")) {
-    return {
-      found: false,
-      reason: "declaration-mismatch",
-      detail: `version '${value}' combines several expressions`
-    };
-  }
-  if (value !== target.effectiveVersion) {
-    return {
-      found: false,
-      reason: "declaration-mismatch",
-      detail: `declared '${value}' but Maven resolves '${target.effectiveVersion}' (profile or command-line override?)`
-    };
-  }
-  const declaration = {
-    file,
-    kind: propertyName ? "property" : kind,
-    propertyName,
-    displayPath: relative8(rootDir, file).replace(/\\/g, "/")
-  };
-  return { found: true, declaration, element, value };
-}
-
-// src/adapters/maven/maven-scanner.ts
-var DIFF_ORDER3 = { major: 0, minor: 1, patch: 2 };
-var MavenDependencyAdapter = class {
-  constructor(plugins = DEFAULT_MAVEN_PLUGINS) {
-    this.plugins = plugins;
-  }
-  plugins;
-  async scan(module, context) {
-    const results = await this.scanMany([module], context);
-    return results.get(module) ?? { candidates: [], skipped: [] };
-  }
-  async scanMany(modules, context) {
-    const project = MavenProject.load(context.rootDir);
-    const results = /* @__PURE__ */ new Map();
-    for (const group of groupModules(project, modules)) {
-      const scratch = new ScratchDirectory(group.dir);
-      try {
-        for (const [module, result] of await this.scanGroup(project, group, context, scratch)) {
-          results.set(module, result);
-        }
-      } finally {
-        scratch.dispose();
-      }
-    }
-    return results;
-  }
-  async scanGroup(project, group, context, scratch) {
-    const rootDir = context.rootDir;
-    const effectiveModels = group.aggregatorPom ? await readEffectivePoms(group.aggregatorPom, group.dir, rootDir, scratch, this.plugins, true) : await readEffectivePoms(group.members[0].pom.file, group.dir, rootDir, scratch, this.plugins);
-    const plans = [];
-    for (const { module, pom } of group.members) {
-      const coordinates = project.coordinatesOf(pom);
-      const effective = effectiveModels.get(`${coordinates.groupId}:${coordinates.artifactId}`) ?? (group.aggregatorPom ? [...(await readEffectivePoms(pom.file, module.path, rootDir, scratch, this.plugins)).values()][0] : [...effectiveModels.values()][0]);
-      if (!effective) continue;
-      plans.push(planModule(project, pom, module, effective, context));
-    }
-    const probe = plans.flatMap((plan) => plan.lookups.map(({ subject }) => subject));
-    const report = await queryNewerVersions(
-      probe,
-      mergeRepositories(plans.map((plan) => plan.effective)),
-      group.dir,
-      rootDir,
-      scratch,
-      this.plugins
-    );
-    return new Map(plans.map((plan) => [plan.module, finishModule(plan, report, context.channel)]));
-  }
-};
-function groupModules(project, modules) {
-  const groups = /* @__PURE__ */ new Map();
-  const reactorSizes = /* @__PURE__ */ new Map();
-  for (const module of modules) {
-    if (module.aggregatorDir) reactorSizes.set(module.aggregatorDir, (reactorSizes.get(module.aggregatorDir) ?? 0) + 1);
-  }
-  for (const module of modules) {
-    const pom = project.pomAt(join20(module.path, "pom.xml"));
-    if (!pom) continue;
-    const reactor = module.aggregatorDir;
-    const batched = reactor !== void 0 && (reactorSizes.get(reactor) ?? 0) > 1;
-    const key = batched ? `reactor:${reactor}` : `module:${module.path}`;
-    const group = groups.get(key) ?? {
-      dir: batched ? reactor : module.path,
-      aggregatorPom: batched ? join20(reactor, "pom.xml") : void 0,
-      members: []
-    };
-    group.members.push({ module, pom });
-    groups.set(key, group);
-  }
-  return [...groups.values()];
-}
-function planModule(project, pom, module, effective, context) {
-  const { poms: chain, externalParent } = project.chainOf(pom);
-  const rootDir = context.rootDir;
-  const subjects = /* @__PURE__ */ new Map();
-  for (const dep of effective.dependencies) {
-    const key = `${dep.groupId}:${dep.artifactId}`;
-    if (subjects.has(key)) continue;
-    const target = { groupId: dep.groupId, artifactId: dep.artifactId };
-    subjects.set(key, {
-      ...dep,
-      scope: dep.scope === "test" ? "test" : "prod",
-      locate: (effectiveVersion) => locateDependencyVersion(chain, { ...target, effectiveVersion }, rootDir)
-    });
-  }
-  for (const managed of pom.managedDependencies) {
-    const groupId = interpolate(managed.groupId, chain);
-    const artifactId = interpolate(managed.artifactId, chain);
-    const key = `${groupId}:${artifactId}`;
-    if (subjects.has(key) || !managed.version) continue;
-    const isImport = managed.scope === "import";
-    const version = isImport ? interpolate(managed.version, chain) : effective.managedDependencies.find((m) => m.groupId === groupId && m.artifactId === artifactId)?.version;
-    if (!version || version.includes("${")) continue;
-    const target = { groupId, artifactId };
-    subjects.set(key, {
-      groupId,
-      artifactId,
-      version,
-      type: isImport ? "pom" : managed.type,
-      classifier: managed.classifier,
-      scope: "prod",
-      locate: (effectiveVersion) => locateManagedVersion(chain, { ...target, effectiveVersion }, rootDir)
-    });
-  }
-  if (pom.parent && externalParent === pom.parent) {
-    const { groupId, artifactId } = pom.parent;
-    const version = interpolate(pom.parent.version, chain);
-    subjects.set(`${groupId}:${artifactId}`, {
-      groupId,
-      artifactId,
-      version,
-      type: "pom",
-      scope: "prod",
-      locate: (effectiveVersion) => locateParentVersion(pom, { groupId, artifactId, effectiveVersion }, rootDir)
-    });
-  }
-  const plan = { module, effective, candidates: [], skipped: [], lookups: [] };
-  for (const [key, subject] of subjects) {
-    const origin = classifyOrigin(key, "maven", context);
-    if (origin.kind !== "workspace") {
-      plan.lookups.push({ subject, origin });
-      continue;
-    }
-    const target = context.workspace.get(key);
-    if (target && inSameReactor(module, target)) {
-      if (target.version && target.version !== subject.version) {
-        collect2(alignmentCandidate2(subject, target.version, origin), plan.candidates, plan.skipped);
-      }
-    } else {
-      plan.lookups.push({ subject, origin: classifyOrigin(key, "maven", { ...context, workspace: /* @__PURE__ */ new Map() }) });
-    }
-  }
-  return plan;
-}
-function inSameReactor(a, b) {
-  return a.aggregatorDir !== void 0 && a.aggregatorDir === b.aggregatorDir;
-}
-function finishModule(plan, report, channel) {
-  const { candidates, skipped } = plan;
-  for (const { subject, origin } of plan.lookups) {
-    const key = `${subject.groupId}:${subject.artifactId}`;
-    const newer = newerThan(subject.version, report.newerVersions.get(key) ?? []);
-    const latest = pickLatest(subject.version, newer, channel);
-    if (!latest) {
-      if (report.failedLookups.has(key)) {
-        skipped.push({ identifier: key, origin: origin.kind, reason: "lookup-failed", detail: "repository error" });
-      }
-      continue;
-    }
-    collect2(updateCandidate(subject, latest, newer, origin), candidates, skipped);
-  }
-  markSharedDeclarations(candidates);
-  candidates.sort((a, b) => (DIFF_ORDER3[a.diff] ?? 3) - (DIFF_ORDER3[b.diff] ?? 3));
-  return { candidates, skipped };
-}
-function newerThan(current, ascending) {
-  const index = ascending.indexOf(current);
-  return index >= 0 ? ascending.slice(index + 1) : [...ascending];
-}
-function collect2(built, candidates, skipped) {
-  if ("candidate" in built) candidates.push(built.candidate);
-  else skipped.push(built.skipped);
-}
-function updateCandidate(subject, latest, newer, origin) {
-  const base = buildCandidate(subject, latest, origin, "update");
-  if ("candidate" in base) {
-    base.candidate.availableVersions = [...newer].reverse().concat(subject.version);
-  }
-  return base;
-}
-function alignmentCandidate2(subject, localVersion, origin) {
-  const built = buildCandidate(subject, localVersion, origin, "align");
-  if ("candidate" in built) built.candidate.availableVersions = [localVersion];
-  return built;
-}
-function buildCandidate(subject, target, origin, action) {
-  const identifier = `${subject.groupId}:${subject.artifactId}`;
-  const location = subject.locate(subject.version);
-  if (!location.found) {
-    return { skipped: { identifier, origin: origin.kind, reason: location.reason, detail: location.detail } };
-  }
-  const currentClean = cleanJavaVersion(subject.version) ?? "0.0.0";
-  const targetClean = cleanJavaVersion(target) ?? currentClean;
-  const diff = semver11.eq(currentClean, targetClean) ? "patch" : diffVersions(currentClean, targetClean);
-  const isPreRelease = isPreReleaseVersion(target);
-  return {
-    candidate: {
-      coordinate: { identifier, group: subject.groupId, artifact: subject.artifactId, ecosystem: "maven" },
-      currentRange: subject.version,
-      currentClean,
-      latest: target,
-      newRange: target,
-      diff,
-      scope: subject.scope,
-      selected: diff !== "major",
-      origin,
-      action,
-      declaration: location.declaration,
-      isPreRelease,
-      preReleaseTag: isPreRelease ? extractPreReleaseTag(target) : void 0
-    }
-  };
-}
-function pickLatest(current, newer, channel) {
-  const allowed = newer.filter((v) => channel === "all" || !isPreReleaseVersion(v));
-  const flavour = flavourOf(current);
-  const sameFlavour = flavour ? allowed.filter((v) => flavourOf(v) === flavour) : [];
-  const pool = sameFlavour.length > 0 ? sameFlavour : allowed;
-  return pool[pool.length - 1];
-}
-function flavourOf(version) {
-  const suffix = version.match(/-([A-Za-z]+)$/)?.[1];
-  return suffix && !isPreReleaseVersion(version) ? suffix.toLowerCase() : void 0;
-}
-function markSharedDeclarations(candidates) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const candidate of candidates) {
-    const declaration = candidate.declaration;
-    if (declaration?.kind !== "property") continue;
-    const key = `${declaration.file}#${declaration.propertyName}`;
-    groups.set(key, [...groups.get(key) ?? [], candidate]);
-  }
-  for (const group of groups.values()) {
-    if (group.length < 2) continue;
-    for (const candidate of group) {
-      candidate.sharedWith = group.filter((other) => other !== candidate).map((other) => other.coordinate.identifier);
-    }
-  }
-}
-
-// src/adapters/maven/maven-updater.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync4 } from "fs";
-import { join as join21, resolve as resolve12 } from "path";
-var MavenUpdaterAdapter = class {
-  affectedFiles(module, _rootDir, updates) {
-    const files = new Set(updates.map((u) => resolve12(u.declaration?.file ?? join21(module.path, "pom.xml"))));
-    return [...files];
-  }
-  async applyUpdates(module, rootDir, updates, onProgress) {
-    const project = MavenProject.load(rootDir);
-    const byFile = /* @__PURE__ */ new Map();
-    for (const update of updates) {
-      if (!update.declaration) {
-        throw new InstallError(`No version declaration known for ${update.coordinate.identifier}; rescan the module.`);
-      }
-      const file = resolve12(update.declaration.file);
-      byFile.set(file, [...byFile.get(file) ?? [], update]);
-    }
-    const writes = [];
-    for (const [file, fileUpdates] of byFile) {
-      onProgress(`Preparing ${fileUpdates.length} change(s) in ${fileUpdates[0].declaration.displayPath}\u2026`);
-      const source = readFileSync15(file, "utf8");
-      const pom = parsePom(source, file);
-      const chain = project.pomAt(file) ? project.chainOf(project.pomAt(file)).poms : [pom];
-      const edits = collectEdits(pom, [pom, ...chain.slice(1)], fileUpdates);
-      try {
-        writes.push({ file, content: applyTextEdits(source, edits) });
-      } catch (err) {
-        if (err instanceof StaleEditError) throw new InstallError(`${file}: ${err.message}`);
-        throw err;
-      }
-    }
-    onProgress("Writing POM files\u2026");
-    for (const write of writes) writeFileSync4(write.file, write.content, "utf8");
-    return {
-      updatedCount: updates.length,
-      auditMessage: `Updated ${updates.length} version declaration(s) in ${writes.length} POM file(s).`,
-      auditSeverity: "clean",
-      integrityViolations: []
-    };
-  }
-  async resync() {
-  }
-};
-function collectEdits(pom, chain, updates) {
-  const edits = /* @__PURE__ */ new Map();
-  for (const update of updates) {
-    const element = findDeclarationElement(pom, chain, update);
-    if (!element) {
-      throw new InstallError(
-        `${update.declaration.displayPath}: cannot find the version of ${update.coordinate.identifier} any more; rescan the module.`
-      );
-    }
-    const existing = edits.get(element);
-    if (existing) {
-      if (existing.replacement !== update.newRange) {
-        throw new InstallError(
-          `${update.coordinate.identifier} and ${existing.identifier} share ${describe(update.declaration)} but target different versions (${update.newRange} vs ${existing.replacement}).`
-        );
-      }
-      continue;
-    }
-    edits.set(element, {
-      element,
-      expected: update.currentRange,
-      replacement: update.newRange,
-      identifier: update.coordinate.identifier
-    });
-  }
-  return [...edits.values()];
-}
-function findDeclarationElement(pom, chain, update) {
-  const declaration = update.declaration;
-  const { group, artifact } = update.coordinate;
-  const matches = (dep) => interpolate(dep.groupId, chain) === group && interpolate(dep.artifactId, chain) === artifact;
-  switch (declaration.kind) {
-    case "property":
-      return declaration.propertyName ? pom.properties.get(declaration.propertyName)?.element : void 0;
-    case "parent":
-      return pom.parent?.versionElement;
-    case "dependency":
-      return pom.dependencies.find(matches)?.versionElement;
-    case "dependency-management":
-      return pom.managedDependencies.find(matches)?.versionElement;
-  }
-}
-function describe(declaration) {
-  return declaration.kind === "property" ? `the property \${${declaration.propertyName}} in ${declaration.displayPath}` : `a version in ${declaration.displayPath}`;
-}
-
-// src/adapters/maven/maven-verifier.ts
-import { dirname as dirname9, join as join22, relative as relative9, resolve as resolve13 } from "path";
-var VERIFY_TIMEOUT_MS3 = 30 * 6e4;
-var MavenVerificationAdapter = class {
-  async verify(module, rootDir, options = {}) {
-    if (options.customScript) {
-      const label2 = options.customLabel || options.customScript;
-      const result = await runShellScript(options.customScript, { cwd: module.path, timeoutMs: VERIFY_TIMEOUT_MS3 });
-      return result.exitCode === 0 ? { status: "clean", details: "Verification script succeeded.", label: label2 } : { status: "warn", details: failureDetails2(result), label: label2 };
-    }
-    const plan = planBuild(module, rootDir, options.changedFiles ?? []);
-    const label = `Maven build (${["test-compile", ...plan.args].join(" ")})`;
-    try {
-      const result = await runMaven(["-q", "test-compile", ...plan.args], {
-        cwd: plan.cwd,
-        rootDir,
-        timeoutMs: VERIFY_TIMEOUT_MS3
-      });
-      if (result.exitCode === 0) {
-        return { status: "clean", details: "All affected modules compile, including tests.", label };
-      }
-      const details = result.timedOut ? "Maven build timed out." : failureDetails2(result);
-      return { status: "warn", details, label };
-    } catch (err) {
-      if (err instanceof MavenUnavailableError) return { status: "warn", details: err.message, label };
-      throw err;
-    }
-  }
-};
-function failureDetails2(result) {
-  const output = `${result.stdout}
-${result.stderr}`.trim();
-  return output ? mavenErrors(output) : `Exited with code ${result.exitCode}.`;
-}
-function planBuild(module, rootDir, changedFiles) {
-  const aggregatorDir = module.aggregatorDir;
-  if (!aggregatorDir) return { cwd: module.path, args: [] };
-  const project = MavenProject.load(rootDir);
-  const files = changedFiles.length > 0 ? changedFiles : [join22(module.path, "pom.xml")];
-  const selected = /* @__PURE__ */ new Set();
-  for (const file of files) {
-    const pom = project.pomAt(file);
-    const dir = resolve13(dirname9(file));
-    if (!pom || project.aggregatorDirOf(pom) !== aggregatorDir || dir === resolve13(aggregatorDir)) {
-      return { cwd: aggregatorDir, args: [] };
-    }
-    selected.add(relative9(aggregatorDir, dir).replace(/\\/g, "/"));
-  }
-  return { cwd: aggregatorDir, args: ["-pl", [...selected].join(","), "-amd"] };
-}
-
-// src/adapters/maven/maven-strategy.ts
-var MavenEcosystemStrategy = class {
-  ecosystem = "maven";
-  displayName = "Java / Maven";
-  icon = "\u2615";
-  manifestFile = "pom.xml";
-  versioning = mavenVersionPolicy;
-  discovery = new MavenModuleDiscoveryAdapter();
-  registry;
-  reader;
-  updater = new MavenUpdaterAdapter();
-  verifier = new MavenVerificationAdapter();
-  /** @param plugins versions of the Maven plugins Elevate runs (default: the pinned ones) */
-  constructor(plugins = DEFAULT_MAVEN_PLUGINS) {
-    this.registry = new MavenRegistryAdapter(plugins);
-    this.reader = new MavenDependencyAdapter(plugins);
-  }
-  getTabLabels(counts, _t) {
-    return {
-      all: `[1] Alle (${counts.total})`,
-      prod: `[2] Compile (${counts.prodCount})`,
-      dev: `[3] Test (${counts.devCount})`
-    };
-  }
-};
-
-// src/domain/ecosystem-factory.ts
-var EcosystemFactory = class {
-  static instances = /* @__PURE__ */ new Map();
-  static settings = {};
-  /**
-   * Stores the settings and drops the cached strategies, so strategies created
-   * afterwards use them. Without a call the defaults apply.
-   */
-  static configure(settings) {
-    this.settings = settings;
-    this.instances.clear();
-  }
-  /** Returns the strategy for an ecosystem (lazily created singleton). */
-  static getStrategy(ecosystem) {
-    let strategy = this.instances.get(ecosystem);
-    if (!strategy) {
-      if (ecosystem === "maven") {
-        strategy = new MavenEcosystemStrategy(this.settings.mavenPlugins);
-      } else if (ecosystem === "cargo") {
-        strategy = new CargoEcosystemStrategy();
-      } else {
-        strategy = new NpmEcosystemStrategy();
-      }
-      this.instances.set(ecosystem, strategy);
-    }
-    return strategy;
-  }
-  /** All supported ecosystems. */
-  static getAvailableEcosystems() {
-    return ["npm", "maven", "cargo"];
-  }
-  /** The ecosystem after `current`, for the dashboard's ecosystem switch. */
-  static next(current) {
-    const all = this.getAvailableEcosystems();
-    return all[(all.indexOf(current) + 1) % all.length];
-  }
-};
-
-// src/config.ts
-function findRepositoryRoot(startDir) {
-  const start = resolve14(startDir);
-  const boundary = findCheckoutBoundary(start);
-  let dir = start;
-  for (; ; ) {
-    if (existsSync16(join23(dir, "elevate.config.json"))) return dir;
-    const parent = dirname10(dir);
-    if (dir === boundary || parent === dir) break;
-    dir = parent;
-  }
-  const proposals = EcosystemFactory.getAvailableEcosystems().map((ecosystem) => EcosystemFactory.getStrategy(ecosystem).discovery.findRoot?.(start, boundary)).filter((root) => root !== void 0);
-  return proposals.sort((a, b) => a.length - b.length)[0] ?? start;
-}
-var ConfigError = class extends Error {
-  constructor(message2) {
-    super(message2);
-    this.name = "ConfigError";
-  }
-};
-var NO_CONTINUE = "Elevate does not continue without your internalScopes.";
-function stringList(file, key, source) {
-  if (!Object.hasOwn(file, key)) return void 0;
-  const value = file[key];
-  if (Array.isArray(value) && value.every((entry) => typeof entry === "string")) return value;
-  throw new ConfigError(
-    `Invalid elevate.config.json (${source}): \`${key}\` must be a list of strings, for example ["@my-org", "com.mycompany"]. ${NO_CONTINUE}`
-  );
-}
-var PLUGIN_VERSION = /^[0-9][A-Za-z0-9.-]{0,63}$/;
-function resolveMavenPlugins(value, warnings) {
-  const plugins = { ...DEFAULT_MAVEN_PLUGINS };
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return plugins;
-  const given = value;
-  for (const key of Object.keys(DEFAULT_MAVEN_PLUGINS)) {
-    if (!Object.hasOwn(given, key)) continue;
-    const version = given[key];
-    if (typeof version === "string" && PLUGIN_VERSION.test(version)) {
-      plugins[key] = version;
-    } else {
-      warnings.push(
-        `\`mavenPlugins.${key}\` is not a valid version (${JSON.stringify(version)}); using the default ${DEFAULT_MAVEN_PLUGINS[key]}.`
-      );
-    }
-  }
-  return plugins;
-}
-function resolveConfig(rootDir, file, source = "elevate.config.json") {
-  const deprecations = [];
-  const warnings = [];
-  const internal = stringList(file, "internalScopes", source);
-  const legacy = stringList(file, "excludeScopes", source);
-  if (legacy) {
-    deprecations.push(
-      internal ? "`excludeScopes` is deprecated and ignored because `internalScopes` is set; remove it from elevate.config.json." : "`excludeScopes` is deprecated; rename it to `internalScopes` in elevate.config.json."
-    );
-  }
-  return {
-    rootDir,
-    author: typeof file.author === "string" ? file.author : void 0,
-    internalScopes: internal ?? legacy ?? [],
-    postUpdateScript: typeof file.postUpdateScript === "string" ? file.postUpdateScript : void 0,
-    postUpdateLabel: typeof file.postUpdateLabel === "string" ? file.postUpdateLabel : typeof file.postUpdateScript === "string" ? file.postUpdateScript : void 0,
-    locale: file.locale === "de" || file.locale === "en" ? file.locale : void 0,
-    channel: file.channel === "all" ? "all" : "stable",
-    deprecations,
-    mavenPlugins: resolveMavenPlugins(file.mavenPlugins, warnings),
-    warnings
-  };
-}
-function loadConfig2(startDir = process.cwd()) {
-  const rootDir = findRepositoryRoot(startDir);
-  const configPath = join23(rootDir, "elevate.config.json");
-  let file = {};
-  if (existsSync16(configPath)) {
-    const unreadable = (detail) => new ConfigError(
-      `Cannot read elevate.config.json: ${detail} (${configPath}). Fix the file or remove it; ${NO_CONTINUE}`
-    );
-    let parsed;
-    try {
-      parsed = JSON.parse(readFileSync16(configPath, "utf8").replace(/^/, ""));
-    } catch (err) {
-      throw unreadable(err instanceof Error ? err.message : String(err));
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      throw unreadable("the file must contain a JSON object");
-    }
-    file = parsed;
-  }
-  return resolveConfig(rootDir, file, configPath);
-}
-
 // src/app.tsx
 import { useState as useState8, useMemo as useMemo4, useCallback as useCallback5 } from "react";
 import { Box as Box14, useInput as useInput2, useApp } from "ink";
@@ -3523,7 +38,9 @@ var de = {
   tabs: {
     all: (count) => `[1] Alle (${count})`,
     dependencies: (count) => `[2] Dependencies (${count})`,
-    devDependencies: (count) => `[3] DevDependencies (${count})`
+    devDependencies: (count) => `[3] DevDependencies (${count})`,
+    main: (count) => `[2] Haupt (${count})`,
+    testAndPlugins: (count) => `[3] Test & Plugins (${count})`
   },
   list: {
     scanning: "\u23F3 Pr\xFCfe Registry auf verf\xFCgbare Updates\u2026",
@@ -3539,7 +56,8 @@ var de = {
       "declaration-mismatch": "Ort der Versionsangabe ist nicht eindeutig",
       "invalid-name": "ung\xFCltiger Paketname",
       "not-linked": "Workspace-Paket, das pnpm ohne das workspace:-Protokoll nicht verlinkt",
-      "catalog-unresolved": "Catalog-Eintrag konnte nicht aufgel\xF6st werden"
+      "catalog-unresolved": "Catalog-Eintrag konnte nicht aufgel\xF6st werden",
+      "version-constraint": "Version ist ein Selektor oder eine Einschr\xE4nkung, keine feste Version"
     })[reason]
   },
   badges: {
@@ -3635,7 +153,9 @@ var en = {
   tabs: {
     all: (count) => `[1] All (${count})`,
     dependencies: (count) => `[2] Dependencies (${count})`,
-    devDependencies: (count) => `[3] DevDependencies (${count})`
+    devDependencies: (count) => `[3] DevDependencies (${count})`,
+    main: (count) => `[2] Main (${count})`,
+    testAndPlugins: (count) => `[3] Test & plugins (${count})`
   },
   list: {
     scanning: "\u23F3 Checking registry for available updates\u2026",
@@ -3651,7 +171,8 @@ var en = {
       "declaration-mismatch": "version location is ambiguous",
       "invalid-name": "invalid package name",
       "not-linked": "workspace package that pnpm does not link without the workspace: protocol",
-      "catalog-unresolved": "catalog entry could not be resolved"
+      "catalog-unresolved": "catalog entry could not be resolved",
+      "version-constraint": "version is a selector or constraint, not a plain version"
     })[reason]
   },
   badges: {
@@ -3800,6 +321,15 @@ async function scanModules(strategy, modules, context) {
   for (const module of modules) results.set(module, await scanModule(strategy, module, context));
   return results;
 }
+function declarationToJson(declaration) {
+  return {
+    file: declaration.displayPath,
+    kind: declaration.kind,
+    property: declaration.propertyName,
+    catalog: declaration.catalogName,
+    entry: declaration.entry
+  };
+}
 function candidateToJson(u) {
   return {
     identifier: u.coordinate.identifier,
@@ -3813,12 +343,8 @@ function candidateToJson(u) {
     scope: u.scope,
     isPreRelease: u.isPreRelease ?? false,
     preReleaseTag: u.preReleaseTag,
-    declaredIn: u.declaration ? {
-      file: u.declaration.displayPath,
-      kind: u.declaration.kind,
-      property: u.declaration.propertyName,
-      catalog: u.declaration.catalogName
-    } : void 0,
+    declaredIn: u.declaration ? declarationToJson(u.declaration) : void 0,
+    alsoDeclaredIn: u.declarations && u.declarations.length > 1 ? u.declarations.slice(1).map(declarationToJson) : void 0,
     sharedWith: u.sharedWith
   };
 }
@@ -3982,24 +508,24 @@ function usePackages(strategy, module, modules, config, channel = "stable") {
 import { useState as useState4, useCallback as useCallback4 } from "react";
 
 // src/application/update-workflow.ts
-import { existsSync as existsSync18 } from "fs";
-import { relative as relative10 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { relative } from "path";
 
 // src/adapters/shared/file-snapshot.ts
-import { existsSync as existsSync17, readFileSync as readFileSync17, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "fs";
 var FileSnapshot = class _FileSnapshot {
-  constructor(entries2) {
-    this.entries = entries2;
+  constructor(entries) {
+    this.entries = entries;
   }
   entries;
   /** Records the current content (or absence) of each file. */
   static capture(files) {
-    const entries2 = /* @__PURE__ */ new Map();
+    const entries = /* @__PURE__ */ new Map();
     for (const file of files) {
-      if (entries2.has(file)) continue;
-      entries2.set(file, existsSync17(file) ? readFileSync17(file) : null);
+      if (entries.has(file)) continue;
+      entries.set(file, existsSync(file) ? readFileSync(file) : null);
     }
-    return new _FileSnapshot(entries2);
+    return new _FileSnapshot(entries);
   }
   /** The files covered by this snapshot. */
   get files() {
@@ -4009,18 +535,18 @@ var FileSnapshot = class _FileSnapshot {
   changedFiles() {
     return this.files.filter((file) => {
       const before = this.entries.get(file) ?? null;
-      const exists = existsSync17(file);
+      const exists = existsSync(file);
       if (before === null) return exists;
-      return !exists || !readFileSync17(file).equals(before);
+      return !exists || !readFileSync(file).equals(before);
     });
   }
   /** Writes every file back to its captured state; removes files that did not exist. */
   restore() {
     for (const [file, content] of this.entries) {
       if (content === null) {
-        rmSync2(file, { force: true });
+        rmSync(file, { force: true });
       } else {
-        writeFileSync5(file, content);
+        writeFileSync(file, content);
       }
     }
   }
@@ -4059,7 +585,7 @@ Restoring the installed state failed as well: ${message(err)}`;
   let baseline;
   if (!options.skipVerification) {
     progress("Running verification on the current state\u2026");
-    baseline = await verify(snapshot.files.filter((file) => existsSync18(file)));
+    baseline = await verify(snapshot.files.filter((file) => existsSync2(file)));
   }
   let applied;
   try {
@@ -4105,7 +631,7 @@ function message(err) {
   return err instanceof Error ? err.message : String(err);
 }
 function displayPaths(files, rootDir) {
-  return files.map((file) => relative10(rootDir, file).replace(/\\/g, "/"));
+  return files.map((file) => relative(rootDir, file).replace(/\\/g, "/"));
 }
 
 // src/hooks/use-updater.ts
@@ -4586,7 +1112,7 @@ var ChickenMascot = ({ state = "idle", t, ecosystem = "npm" }) => {
     chickFace = cur.face;
     wingLeft = cur.l;
     wingRight = cur.r;
-    const chirpsPool = ecosystem === "maven" ? [...t.mascot.idleChirps, ...t.mascot.mavenChirps] : ecosystem === "cargo" ? [...t.mascot.idleChirps, ...t.mascot.cargoChirps] : t.mascot.idleChirps;
+    const chirpsPool = ecosystem === "maven" || ecosystem === "gradle" ? [...t.mascot.idleChirps, ...t.mascot.mavenChirps] : ecosystem === "cargo" ? [...t.mascot.idleChirps, ...t.mascot.cargoChirps] : t.mascot.idleChirps;
     currentChirp = chirpsPool[chirpIndex % chirpsPool.length];
   }
   return /* @__PURE__ */ jsxs7(Box7, { alignItems: "center", children: [
@@ -4746,7 +1272,7 @@ var PublicLookupRefusedError = class extends Error {
   }
 };
 function coordinateFromIdentifier(identifier, ecosystem) {
-  if (ecosystem === "maven") {
+  if (ecosystem === "maven" || ecosystem === "gradle") {
     const [group, artifact] = identifier.split(":");
     return { identifier, group, artifact: artifact || group, ecosystem };
   }
@@ -5318,7 +1844,7 @@ SUBCOMMANDS:
   mcp                                   Start stdio-based MCP server
 
 FLAGS:
-  -e, --ecosystem <npm|maven|cargo>          Target ecosystem (default: npm)
+  -e, --ecosystem <name>               Target ecosystem: npm, maven, cargo or gradle (default: npm)
   -m, --module <name|path>             Target module ID or relative path (default: root)
   -c, --channel <stable|all>           Release channel (default: stable)
   -p, --packages <pkg1,pkg2@1.2.3>     Comma-separated list of packages to update
@@ -5334,6 +1860,7 @@ FLAGS:
 EXAMPLES:
   elevate scan --json
   elevate scan --ecosystem=maven --channel=stable --all-modules --json
+  elevate scan --ecosystem=gradle --json
   elevate versions chalk --ecosystem=npm --json
   elevate update --module=apps/e2e-cockpit --packages=chalk@5.6.2 --json
   elevate update --ecosystem=npm --all --allow-major --dry-run
@@ -5385,6 +1912,8 @@ function describeSkip(skipped) {
       return `catalog entry could not be resolved${detail}`;
     case "incompatible-rust-version":
       return `newer versions need a newer Rust than the project's rust-version${detail}`;
+    case "version-constraint":
+      return `version is a selector or constraint, not a plain version${detail}`;
     case "locked-version-yanked":
       return `Cargo.lock pins a yanked release and no allowed release can replace it${detail}`;
   }
@@ -5471,13 +2000,14 @@ async function handleScanCommand(options, config) {
 `);
       continue;
     }
-    const modulePom = module.isRoot ? "pom.xml" : `${module.relPath}/pom.xml`;
+    const prefix = module.isRoot ? "" : `${module.relPath}/`;
+    const ownFiles = module.ecosystem === "gradle" ? [`${prefix}build.gradle`, `${prefix}build.gradle.kts`] : [`${prefix}pom.xml`];
     if (result.candidates.length === 0) console.log("   \u2728 All dependencies are up to date.");
     for (const u of result.candidates) {
       const diffTag = `[${u.diff.toUpperCase()}]`.padEnd(9);
       const actionTag = u.action === "align" ? "[ALIGN] " : u.action === "lock" ? "[LOCK] " : u.origin.kind === "private" ? "[INTERNAL] " : "";
       const preBadge = u.isPreRelease ? `[${u.preReleaseTag || "PRE"}] ` : "";
-      const where = u.declaration && u.declaration.displayPath !== modulePom ? `  (in ${u.declaration.displayPath}${u.declaration.propertyName ? ` \${${u.declaration.propertyName}}` : ""})` : "";
+      const where = u.declaration && !ownFiles.includes(u.declaration.displayPath) ? `  (in ${u.declaration.displayPath}${u.declaration.propertyName ? ` \${${u.declaration.propertyName}}` : ""}${u.declaration.entry ? ` ${u.declaration.entry}` : ""})` : "";
       console.log(
         `   \u2022 ${diffTag} ${actionTag}${preBadge}${u.coordinate.identifier.padEnd(36)} ${u.currentRange.padEnd(12)} \u2794 ${u.latest}${where}`
       );
@@ -5546,7 +2076,7 @@ async function handleVersionsCommand(options, config) {
 }
 
 // src/application/update-selection.ts
-import semver12 from "semver";
+import semver from "semver";
 var UpdateSelectionError = class extends Error {
   constructor(message2) {
     super(message2);
@@ -5623,7 +2153,7 @@ function retarget(found, target, options) {
   };
 }
 function manualNpmCandidate(identifier, target, options) {
-  if (!semver12.valid(target)) {
+  if (!semver.valid(target)) {
     throw new UpdateSelectionError(`'${target}' is not a valid version for '${identifier}'.`);
   }
   return {
@@ -5795,9 +2325,9 @@ function parsePackageArgument(item) {
 }
 
 // src/cli/command-init.ts
-import { existsSync as existsSync19, readFileSync as readFileSync18, writeFileSync as writeFileSync6, mkdirSync as mkdirSync2 } from "fs";
-import { homedir as homedir2, platform } from "os";
-import { join as join24, resolve as resolve15 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync } from "fs";
+import { homedir, platform } from "os";
+import { join, resolve } from "path";
 function mcpServerEntry() {
   return {
     command: "npx",
@@ -5810,7 +2340,7 @@ var ELEVATE_SKILL_CONTENT = `# Elevate \u2014 Dependency Management Agent Skill
 Use the Elevate MCP tools whenever the task involves:
 - Scanning or auditing dependencies for available updates
 - Updating one or more packages to specific or latest versions
-- Listing available versions of a package from npm or Maven registries
+- Listing available versions of a package from npm registries or Maven and Gradle repositories
 - Discovering monorepo modules and their dependency structure
 - Any dependency-related operation in a monorepo
 
@@ -5840,10 +2370,10 @@ automatic rollback.
    requested). A failed install or verification is rolled back automatically.
 4. \`elevate_verify\` \u2014 Verify build integrity when needed
 `;
-var home = homedir2();
+var home = homedir();
 var isWin = platform() === "win32";
 function appData() {
-  return process.env.APPDATA || join24(home, "AppData", "Roaming");
+  return process.env.APPDATA || join(home, "AppData", "Roaming");
 }
 function detectCursor(cwd) {
   const env = {
@@ -5855,25 +2385,25 @@ function detectCursor(cwd) {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const workspaceCursorDir = join24(cwd, ".cursor");
-  const globalCursorDir = join24(home, ".cursor");
-  if (existsSync19(workspaceCursorDir) || existsSync19(globalCursorDir)) {
+  const workspaceCursorDir = join(cwd, ".cursor");
+  const globalCursorDir = join(home, ".cursor");
+  if (existsSync3(workspaceCursorDir) || existsSync3(globalCursorDir)) {
     env.detected = true;
-    env.reason = existsSync19(workspaceCursorDir) ? `Found .cursor/ in workspace` : `Found ~/.cursor/ global config`;
+    env.reason = existsSync3(workspaceCursorDir) ? `Found .cursor/ in workspace` : `Found ~/.cursor/ global config`;
   }
-  const mcpPath = join24(cwd, ".cursor", "mcp.json");
-  if (existsSync19(mcpPath)) {
+  const mcpPath = join(cwd, ".cursor", "mcp.json");
+  if (existsSync3(mcpPath)) {
     try {
-      const content = JSON.parse(readFileSync18(mcpPath, "utf8"));
+      const content = JSON.parse(readFileSync2(mcpPath, "utf8"));
       if (content?.mcpServers?.elevate) {
         env.mcpConfigured = true;
       }
     } catch {
     }
   }
-  const rulesPath = join24(cwd, ".cursorrules");
-  if (existsSync19(rulesPath)) {
-    const content = readFileSync18(rulesPath, "utf8");
+  const rulesPath = join(cwd, ".cursorrules");
+  if (existsSync3(rulesPath)) {
+    const content = readFileSync2(rulesPath, "utf8");
     if (content.includes("elevate") || content.includes("Elevate")) {
       env.skillConfigured = true;
     }
@@ -5890,12 +2420,12 @@ function detectClaudeDesktop() {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const configPath = isWin ? join24(appData(), "Claude", "claude_desktop_config.json") : join24(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
-  if (existsSync19(configPath)) {
+  const configPath = isWin ? join(appData(), "Claude", "claude_desktop_config.json") : join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  if (existsSync3(configPath)) {
     env.detected = true;
     env.reason = `Found ${configPath}`;
     try {
-      const content = JSON.parse(readFileSync18(configPath, "utf8"));
+      const content = JSON.parse(readFileSync2(configPath, "utf8"));
       if (content?.mcpServers?.elevate) {
         env.mcpConfigured = true;
       }
@@ -5914,23 +2444,23 @@ function detectClaudeCode(cwd) {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const mcpJsonPath = join24(cwd, ".mcp.json");
-  const claudeMdPath = join24(cwd, "CLAUDE.md");
-  if (existsSync19(mcpJsonPath) || existsSync19(claudeMdPath)) {
+  const mcpJsonPath = join(cwd, ".mcp.json");
+  const claudeMdPath = join(cwd, "CLAUDE.md");
+  if (existsSync3(mcpJsonPath) || existsSync3(claudeMdPath)) {
     env.detected = true;
-    env.reason = existsSync19(mcpJsonPath) ? `Found .mcp.json in workspace` : `Found CLAUDE.md in workspace`;
+    env.reason = existsSync3(mcpJsonPath) ? `Found .mcp.json in workspace` : `Found CLAUDE.md in workspace`;
   }
-  if (existsSync19(mcpJsonPath)) {
+  if (existsSync3(mcpJsonPath)) {
     try {
-      const content = JSON.parse(readFileSync18(mcpJsonPath, "utf8"));
+      const content = JSON.parse(readFileSync2(mcpJsonPath, "utf8"));
       if (content?.mcpServers?.elevate) {
         env.mcpConfigured = true;
       }
     } catch {
     }
   }
-  if (existsSync19(claudeMdPath)) {
-    const content = readFileSync18(claudeMdPath, "utf8");
+  if (existsSync3(claudeMdPath)) {
+    const content = readFileSync2(claudeMdPath, "utf8");
     if (content.includes("elevate") || content.includes("Elevate")) {
       env.skillConfigured = true;
     }
@@ -5947,20 +2477,20 @@ function detectAntigravity(cwd) {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const globalGeminiDir = join24(home, ".gemini");
-  const workspaceAgentsDir = join24(cwd, ".agents");
-  if (existsSync19(globalGeminiDir) || existsSync19(workspaceAgentsDir)) {
+  const globalGeminiDir = join(home, ".gemini");
+  const workspaceAgentsDir = join(cwd, ".agents");
+  if (existsSync3(globalGeminiDir) || existsSync3(workspaceAgentsDir)) {
     env.detected = true;
-    env.reason = existsSync19(workspaceAgentsDir) ? `Found .agents/ in workspace` : `Found ~/.gemini/ global config`;
+    env.reason = existsSync3(workspaceAgentsDir) ? `Found .agents/ in workspace` : `Found ~/.gemini/ global config`;
   }
   const mcpPaths = [
-    join24(cwd, ".agents", "mcp_config.json"),
-    join24(home, ".gemini", "config", "mcp_config.json")
+    join(cwd, ".agents", "mcp_config.json"),
+    join(home, ".gemini", "config", "mcp_config.json")
   ];
   for (const p of mcpPaths) {
-    if (existsSync19(p)) {
+    if (existsSync3(p)) {
       try {
-        const content = JSON.parse(readFileSync18(p, "utf8"));
+        const content = JSON.parse(readFileSync2(p, "utf8"));
         if (content?.mcpServers?.elevate) {
           env.mcpConfigured = true;
           break;
@@ -5981,24 +2511,24 @@ function detectVSCode(cwd) {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const vscodeDir = join24(cwd, ".vscode");
-  if (existsSync19(vscodeDir)) {
+  const vscodeDir = join(cwd, ".vscode");
+  if (existsSync3(vscodeDir)) {
     env.detected = true;
     env.reason = `Found .vscode/ in workspace`;
   }
-  const mcpPath = join24(cwd, ".vscode", "mcp.json");
-  if (existsSync19(mcpPath)) {
+  const mcpPath = join(cwd, ".vscode", "mcp.json");
+  if (existsSync3(mcpPath)) {
     try {
-      const content = JSON.parse(readFileSync18(mcpPath, "utf8"));
+      const content = JSON.parse(readFileSync2(mcpPath, "utf8"));
       if (content?.servers?.elevate) {
         env.mcpConfigured = true;
       }
     } catch {
     }
   }
-  const copilotInstructions = join24(cwd, ".github", "copilot-instructions.md");
-  if (existsSync19(copilotInstructions)) {
-    const content = readFileSync18(copilotInstructions, "utf8");
+  const copilotInstructions = join(cwd, ".github", "copilot-instructions.md");
+  if (existsSync3(copilotInstructions)) {
+    const content = readFileSync2(copilotInstructions, "utf8");
     if (content.includes("elevate") || content.includes("Elevate")) {
       env.skillConfigured = true;
     }
@@ -6015,14 +2545,14 @@ function detectWindsurf() {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const configPath = isWin ? join24(appData(), "Codeium", "Windsurf", "mcp_config.json") : join24(home, ".codeium", "windsurf", "mcp_config.json");
-  const altPath = join24(home, ".codeium", "windsurf", "mcp_config.json");
-  if (existsSync19(configPath) || existsSync19(altPath)) {
+  const configPath = isWin ? join(appData(), "Codeium", "Windsurf", "mcp_config.json") : join(home, ".codeium", "windsurf", "mcp_config.json");
+  const altPath = join(home, ".codeium", "windsurf", "mcp_config.json");
+  if (existsSync3(configPath) || existsSync3(altPath)) {
     env.detected = true;
     env.reason = `Found Windsurf config`;
-    const path = existsSync19(configPath) ? configPath : altPath;
+    const path = existsSync3(configPath) ? configPath : altPath;
     try {
-      const content = JSON.parse(readFileSync18(path, "utf8"));
+      const content = JSON.parse(readFileSync2(path, "utf8"));
       if (content?.mcpServers?.elevate) {
         env.mcpConfigured = true;
       }
@@ -6033,9 +2563,9 @@ function detectWindsurf() {
 }
 function mergeJsonMcpServer(filePath, serverKey, topLevelKey) {
   let existing = {};
-  if (existsSync19(filePath)) {
+  if (existsSync3(filePath)) {
     try {
-      existing = JSON.parse(readFileSync18(filePath, "utf8"));
+      existing = JSON.parse(readFileSync2(filePath, "utf8"));
     } catch {
       existing = {};
     }
@@ -6047,69 +2577,69 @@ function mergeJsonMcpServer(filePath, serverKey, topLevelKey) {
   servers[serverKey] = mcpServerEntry();
   existing[topLevelKey] = servers;
   const dir = filePath.substring(0, filePath.lastIndexOf(isWin ? "\\" : "/"));
-  if (dir && !existsSync19(dir)) {
-    mkdirSync2(dir, { recursive: true });
+  if (dir && !existsSync3(dir)) {
+    mkdirSync(dir, { recursive: true });
   }
-  writeFileSync6(filePath, JSON.stringify(existing, null, 2) + "\n", "utf8");
+  writeFileSync2(filePath, JSON.stringify(existing, null, 2) + "\n", "utf8");
   return { written: true, message: `${filePath}: elevate MCP server registered` };
 }
 function appendSkillToFile(filePath, content, marker) {
-  if (existsSync19(filePath)) {
-    const existing = readFileSync18(filePath, "utf8");
+  if (existsSync3(filePath)) {
+    const existing = readFileSync2(filePath, "utf8");
     if (existing.includes(marker)) {
       return { written: false, message: `${filePath}: skill already present` };
     }
-    writeFileSync6(filePath, existing + "\n\n" + content, "utf8");
+    writeFileSync2(filePath, existing + "\n\n" + content, "utf8");
     return { written: true, message: `${filePath}: skill appended` };
   }
   const dir = filePath.substring(0, filePath.lastIndexOf(isWin ? "\\" : "/"));
-  if (dir && !existsSync19(dir)) {
-    mkdirSync2(dir, { recursive: true });
+  if (dir && !existsSync3(dir)) {
+    mkdirSync(dir, { recursive: true });
   }
-  writeFileSync6(filePath, content, "utf8");
+  writeFileSync2(filePath, content, "utf8");
   return { written: true, message: `${filePath}: skill created` };
 }
 function configureCursor(cwd, result) {
-  const mcpPath = join24(cwd, ".cursor", "mcp.json");
+  const mcpPath = join(cwd, ".cursor", "mcp.json");
   const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Cursor MCP: ${mcp.message}`);
-  const rulesPath = join24(cwd, ".cursorrules");
+  const rulesPath = join(cwd, ".cursorrules");
   const skill = appendSkillToFile(rulesPath, ELEVATE_SKILL_CONTENT, "elevate_scan");
   result.actions.push(`${skill.written ? "\u2705" : "\u23ED\uFE0F"}  Cursor Rules: ${skill.message}`);
 }
 function configureClaudeDesktop(result) {
-  const configPath = isWin ? join24(appData(), "Claude", "claude_desktop_config.json") : join24(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  const configPath = isWin ? join(appData(), "Claude", "claude_desktop_config.json") : join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
   const mcp = mergeJsonMcpServer(configPath, "elevate", "mcpServers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Claude Desktop MCP: ${mcp.message}`);
 }
 function configureClaudeCode(cwd, result) {
-  const mcpPath = join24(cwd, ".mcp.json");
+  const mcpPath = join(cwd, ".mcp.json");
   const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Claude Code MCP: ${mcp.message}`);
-  const claudeMdPath = join24(cwd, "CLAUDE.md");
+  const claudeMdPath = join(cwd, "CLAUDE.md");
   const skill = appendSkillToFile(claudeMdPath, ELEVATE_SKILL_CONTENT, "elevate_scan");
   result.actions.push(`${skill.written ? "\u2705" : "\u23ED\uFE0F"}  Claude Code Skill: ${skill.message}`);
 }
 function configureAntigravity(cwd, result) {
-  const mcpPath = join24(cwd, ".agents", "mcp_config.json");
+  const mcpPath = join(cwd, ".agents", "mcp_config.json");
   const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Antigravity MCP: ${mcp.message}`);
 }
 function configureVSCode(cwd, result) {
-  const mcpPath = join24(cwd, ".vscode", "mcp.json");
+  const mcpPath = join(cwd, ".vscode", "mcp.json");
   const mcp = mergeJsonMcpServer(mcpPath, "elevate", "servers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  VS Code MCP: ${mcp.message}`);
-  const instructionsPath = join24(cwd, ".github", "copilot-instructions.md");
+  const instructionsPath = join(cwd, ".github", "copilot-instructions.md");
   const skill = appendSkillToFile(instructionsPath, ELEVATE_SKILL_CONTENT, "elevate_scan");
   result.actions.push(`${skill.written ? "\u2705" : "\u23ED\uFE0F"}  Copilot Instructions: ${skill.message}`);
 }
 function configureWindsurf(result) {
-  const configPath = isWin ? join24(appData(), "Codeium", "Windsurf", "mcp_config.json") : join24(home, ".codeium", "windsurf", "mcp_config.json");
+  const configPath = isWin ? join(appData(), "Codeium", "Windsurf", "mcp_config.json") : join(home, ".codeium", "windsurf", "mcp_config.json");
   const mcp = mergeJsonMcpServer(configPath, "elevate", "mcpServers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Windsurf MCP: ${mcp.message}`);
 }
 async function handleInitCommand(options) {
-  const cwd = resolve15(process.cwd());
+  const cwd = resolve(process.cwd());
   const result = {
     cwd,
     environments: [],
@@ -6137,7 +2667,7 @@ async function handleInitCommand(options) {
       console.log(`  Creating portable .mcp.json for broad compatibility.
 `);
     }
-    const mcpPath = join24(cwd, ".mcp.json");
+    const mcpPath = join(cwd, ".mcp.json");
     const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
     result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Generic MCP: ${mcp.message}`);
   } else {
@@ -6224,7 +2754,7 @@ async function startMcpServer(config) {
       tools: [
         {
           name: "elevate_discover_modules",
-          description: "Discovers all repository modules and workspaces for Node/npm (package.json), Java/Maven (pom.xml) or Rust/Cargo (Cargo.toml).",
+          description: "Discovers all repository modules and workspaces for Node/npm (package.json), Java/Maven (pom.xml), Rust/Cargo (Cargo.toml) or Java/Gradle (build.gradle). Gradle modules also report the kind of their build (root, included, buildSrc).",
           inputSchema: {
             type: "object",
             properties: {
@@ -6264,7 +2794,7 @@ async function startMcpServer(config) {
               ecosystem: ECOSYSTEM_PROPERTY,
               identifier: {
                 type: "string",
-                description: "Package identifier (npm: chalk, maven: org.slf4j:slf4j-api, cargo: serde)"
+                description: "Package identifier (npm: chalk, maven/gradle: org.slf4j:slf4j-api, gradle plugin: org.springframework.boot, cargo: serde)"
               }
             },
             required: ["identifier"]
@@ -6357,7 +2887,8 @@ async function startMcpServer(config) {
             name: m.name,
             relPath: m.relPath,
             isRoot: m.isRoot,
-            version: m.version
+            version: m.version,
+            ...m.buildKind ? { buildKind: m.buildKind } : {}
           }))
         });
       }
@@ -6472,7 +3003,7 @@ import { jsx as jsx15 } from "react/jsx-runtime";
 async function main() {
   let config;
   try {
-    config = loadConfig2();
+    config = loadConfig();
   } catch (err) {
     if (!(err instanceof ConfigError)) throw err;
     process.stderr.write(`\u274C ${err.message}
@@ -6521,7 +3052,8 @@ async function main() {
   render(/* @__PURE__ */ jsx15(App, { config }));
 }
 main().catch((err) => {
-  console.error("\u274C Elevate fatal error:", err);
+  const detail = err instanceof Error ? process.env.ELEVATE_DEBUG ? err.stack ?? err.message : `${err.name}: ${err.message}` : String(err);
+  console.error(`\u274C Elevate fatal error: ${detail}`);
   process.exit(1);
 });
 //# sourceMappingURL=cli.js.map