@dennisrepa/elevate 1.3.0 → 1.5.0

package/dist/cli.js

@@ -4,74 +4,82 @@
 import { render } from "ink";
 
 // src/config.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
-import { dirname as dirname8, join as join16, resolve as resolve10 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync16 } from "fs";
+import { dirname as dirname10, join as join23, resolve as resolve14 } from "path";
 
-// src/adapters/npm/npm-discovery.ts
-import { readFileSync } from "fs";
-import { dirname, join, relative, resolve } from "path";
-import mapWorkspaces from "@npmcli/map-workspaces";
-function readJson(filePath) {
-  try {
-    return JSON.parse(readFileSync(filePath, "utf8"));
-  } catch {
-    return null;
-  }
+// 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);
 }
-var NpmModuleDiscoveryAdapter = class {
-  /**
-   * The nearest directory, from `startDir` upwards to the boundary, whose
-   * package.json is valid JSON and declares `workspaces`.
-   */
-  findRoot(startDir, boundaryDir) {
-    let dir = resolve(startDir);
-    const boundary = boundaryDir ? resolve(boundaryDir) : void 0;
-    for (; ; ) {
-      if (readJson(join(dir, "package.json"))?.workspaces) return dir;
-      const parent = dirname(dir);
-      if (dir === boundary || parent === dir) return void 0;
-      dir = parent;
-    }
-  }
-  async discover(rootDir) {
-    const rootPkg = readJson(join(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
-      }
-    ];
-    if (!rootPkg?.workspaces) return modules;
-    let workspaces;
-    try {
-      workspaces = await mapWorkspaces({ cwd: rootDir, pkg: rootPkg });
-    } catch {
-      return modules;
-    }
-    for (const [name, path] of workspaces) {
-      const pkg = readJson(join(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;
+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-registry.ts
-import semver from "semver";
+// 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";
@@ -86,7 +94,7 @@ var UnsafeArgumentError = class extends Error {
 var IS_WINDOWS = process.platform === "win32";
 var WINDOWS_UNSAFE = /["%!^&|<>\r\n]/;
 function runCommand(command, args, options) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve16, reject) => {
     const spawnOptions = { cwd: options.cwd, windowsHide: true, env: process.env };
     let child2;
     if (IS_WINDOWS) {
@@ -116,19 +124,19 @@ function runCommand(command, args, options) {
     });
     child2.on("close", (code) => {
       if (timer) clearTimeout(timer);
-      resolve12({ exitCode: code ?? 1, stdout, stderr, timedOut });
+      resolve16({ exitCode: code ?? 1, stdout, stderr, timedOut });
     });
   });
 }
 function runShellScript(script, options) {
-  return new Promise((resolve12) => {
+  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;
-        resolve12({ exitCode, stdout, stderr, timedOut });
+        resolve16({ exitCode, stdout, stderr, timedOut });
       }
     );
   });
@@ -148,6 +156,213 @@ 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();
@@ -194,9 +409,24 @@ function npmScopeOf(name) {
   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"]);
+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). */
@@ -233,7 +463,8 @@ function parseNpmConfig(json) {
 }
 async function loadConfig(cwd) {
   try {
-    const result = await runCommand("npm", ["config", "list", "--json"], { cwd, timeoutMs: 15e3 });
+    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 {
@@ -260,13 +491,13 @@ var NpmRegistryAdapter = class {
     if (!isValidPackageName(coordinate.identifier)) return null;
     if (channel === "stable") {
       const latest = await this.view(coordinate.identifier, "dist-tags.latest", cwd);
-      if (typeof latest === "string" && semver.valid(latest) && semver.prerelease(latest) === null) {
+      if (typeof latest === "string" && semver3.valid(latest) && semver3.prerelease(latest) === null) {
         return latest;
       }
       const releases = (await this.getAllVersions(coordinate, cwd)).filter(
-        (v) => semver.valid(v) && semver.prerelease(v) === null
+        (v) => semver3.valid(v) && semver3.prerelease(v) === null
       );
-      return releases.length > 0 ? semver.rsort(releases)[0] : 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;
@@ -277,10 +508,11 @@ var NpmRegistryAdapter = class {
     const list = Array.isArray(versions) ? versions : versions ? [versions] : [];
     return list.map(String).reverse();
   }
-  /** Runs `npm view <name> <field> --json`; resolves null on any failure. */
+  /** Runs `npm view <name> <field> --json` (`pnpm view` in a pnpm repository); resolves null on any failure. */
   async view(name, field, cwd) {
     try {
-      const result = await runCommand("npm", ["view", name, field, "--json"], {
+      const { command, args } = commands.view(driverFor(cwd), name, field);
+      const result = await runCommand(command, args, {
         cwd,
         timeoutMs: LOOKUP_TIMEOUT_MS
       });
@@ -293,44 +525,9 @@ var NpmRegistryAdapter = class {
 };
 
 // src/adapters/npm/npm-scanner.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { join as join4 } from "path";
-import semver3 from "semver";
-
-// src/domain/versions.ts
-import semver2 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 semver2.coerce(match[1])?.version ?? null;
-}
-function diffVersions(from, to) {
-  const kind = semver2.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 "";
-}
+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) {
@@ -347,72 +544,12 @@ async function mapPooled(items, concurrency, fn) {
   return results;
 }
 
-// src/adapters/npm/npm-package-manager.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname3, join as join3, resolve as resolve3 } from "path";
-
-// src/adapters/shared/checkout.ts
-import { existsSync } from "fs";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
-function findCheckoutBoundary(startDir) {
-  let dir = resolve2(startDir);
-  for (; ; ) {
-    if (existsSync(join2(dir, ".git"))) return dir;
-    const parent = dirname2(dir);
-    if (parent === dir) return void 0;
-    dir = parent;
-  }
-}
-
-// 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 for Node.js projects; using it here would create an npm lockfile next to ${detected.name}'s. Nothing was changed.`
-    );
-    this.name = "UnsupportedPackageManagerError";
-  }
-};
-function detectPackageManager(dir) {
-  const boundary = findCheckoutBoundary(dir);
-  let current = resolve3(dir);
-  for (; ; ) {
-    const found = detectIn(current);
-    if (found) return found;
-    const parent = dirname3(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(join3(dir, file)));
-    if (found) return { name: manager, evidence: found };
-  }
-  return void 0;
-}
-function assertNpmManaged(rootDir) {
-  const detected = detectPackageManager(rootDir);
-  if (detected.name !== "npm") throw new UnsupportedPackageManagerError(detected);
-}
-function readPackageManagerField(rootDir) {
-  try {
-    const field = JSON.parse(readFileSync2(join3(rootDir, "package.json"), "utf8"))?.packageManager;
-    return typeof field === "string" ? field : void 0;
-  } catch {
-    return void 0;
-  }
-}
+// 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;
@@ -425,10 +562,11 @@ var NpmDependencyAdapter = class {
   registry;
   config;
   async scan(module, context) {
-    assertNpmManaged(context.rootDir);
+    const manager = await prepareSupportedPackageManager(context.rootDir);
+    const pnpm = manager === "pnpm";
     let pkg;
     try {
-      pkg = JSON.parse(readFileSync3(join4(module.path, "package.json"), "utf8"));
+      pkg = JSON.parse(readFileSync4(join5(module.path, "package.json"), "utf8"));
     } catch {
       return { candidates: [], skipped: [] };
     }
@@ -442,13 +580,20 @@ var NpmDependencyAdapter = class {
         [...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);
-        const candidate = target ? alignmentCandidate(dep, target, origin) : null;
+        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 = [];
@@ -461,8 +606,34 @@ var NpmDependencyAdapter = class {
     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) {
+  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" } };
@@ -487,9 +658,9 @@ var NpmDependencyAdapter = class {
     if (!latest) {
       return { skipped: { identifier: dep.name, origin: origin.kind, reason: "lookup-failed" } };
     }
-    const currentClean = semver3.minVersion(dep.range)?.version;
-    if (!currentClean || !semver3.valid(latest) || !semver3.gt(latest, currentClean)) return null;
-    const tag = semver3.prerelease(latest) ? extractPreReleaseTag(latest) ?? "PRE" : void 0;
+    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: {
@@ -504,7 +675,8 @@ var NpmDependencyAdapter = class {
         origin: resolvedOrigin,
         action: "update",
         isPreRelease: tag !== void 0,
-        preReleaseTag: tag
+        preReleaseTag: tag,
+        ...extra
       }
     };
   }
@@ -523,21 +695,24 @@ function declaredDependencies(pkg) {
 function isUpgradableRange(range) {
   const trimmed = range.trim();
   if (trimmed === "" || trimmed === "*" || trimmed.toLowerCase() === "x") return false;
-  return semver3.validRange(trimmed) !== null;
+  return semver4.validRange(trimmed) !== null;
 }
-function alignmentCandidate(dep, target, origin) {
+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 || !semver3.valid(local) || !isUpgradableRange(dep.range)) return null;
-  if (semver3.satisfies(local, dep.range, { includePrerelease: true })) return null;
-  const currentClean = semver3.minVersion(dep.range)?.version ?? "0.0.0";
+  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 = semver3.prerelease(local) ? extractPreReleaseTag(local) ?? "PRE" : void 0;
+  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: `${rangePrefix(dep.range)}${local}`,
+    newRange: `${protocol}${rangePrefix(range)}${local}`,
     diff,
     scope: dep.scope,
     selected: diff !== "major",
@@ -548,10 +723,27 @@ function alignmentCandidate(dep, target, origin) {
     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 readFileSync5, writeFileSync } from "fs";
-import { join as join6, relative as relative2 } from "path";
+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 {
@@ -564,13 +756,13 @@ var InstallError = class extends Error {
 };
 
 // src/adapters/npm/npm-lockfile.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
+import { join as join6 } from "path";
 function readLockfile(rootDir) {
-  const file = join5(rootDir, "package-lock.json");
+  const file = join6(rootDir, "package-lock.json");
   if (!existsSync3(file)) return void 0;
   try {
-    return JSON.parse(readFileSync4(file, "utf8"));
+    return JSON.parse(readFileSync5(file, "utf8"));
   } catch {
     return void 0;
   }
@@ -591,51 +783,168 @@ function findUnlinkedWorkspaceDependencies(lockfile, moduleRelPath, names) {
   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 [
-      join6(module.path, "package.json"),
-      join6(rootDir, "package.json"),
-      join6(rootDir, "package-lock.json"),
-      join6(rootDir, "npm-shrinkwrap.json")
+      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 {
-      assertNpmManaged(rootDir);
+      manager = await prepareSupportedPackageManager(rootDir);
     } catch (err) {
-      if (err instanceof UnsupportedPackageManagerError) throw new InstallError(err.message);
+      if (err instanceof UnsupportedPackageManagerError || err instanceof PackageManagerNotFoundError) {
+        throw new InstallError(err.message);
+      }
       throw err;
     }
-    const pkgPath = join6(module.path, "package.json");
-    let source;
-    let pkg;
-    try {
-      source = readFileSync5(pkgPath, "utf8");
-      pkg = JSON.parse(source);
-    } catch {
-      throw new InstallError(`Cannot read package.json in ${module.path}.`);
+    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}.`);
+      }
     }
-    onProgress("Writing new versions to package.json\u2026");
-    for (const item of updates) {
-      const name = item.coordinate.artifact;
-      for (const section of DEPENDENCY_SECTIONS) {
-        if (typeof pkg[section]?.[name] === "string") pkg[section][name] = item.newRange;
+    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");
     }
-    writeFileSync(pkgPath, serializeLike(source, pkg), "utf8");
-    onProgress("Running npm install\u2026");
-    const install = await runCommand("npm", ["install"], { cwd: rootDir, timeoutMs: INSTALL_TIMEOUT_MS });
-    if (install.exitCode !== 0) {
-      const reason = install.timedOut ? "npm install timed out" : "npm install failed";
-      throw new InstallError(reason, tail(install.stderr || install.stdout));
-    }
-    onProgress("Checking workspace links in package-lock.json\u2026");
-    const integrityViolations = verifyAlignedLinks(module, rootDir, updates);
-    const combined = `${install.stdout}
-${install.stderr}`;
+    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 {
@@ -647,14 +956,42 @@ ${install.stderr}`;
     };
   }
   async resync(_module, rootDir, onProgress) {
-    if (detectPackageManager(rootDir).name !== "npm") return;
-    onProgress("Restoring node_modules (npm install)\u2026");
-    const result = await runCommand("npm", ["install"], { cwd: rootDir, timeoutMs: INSTALL_TIMEOUT_MS });
+    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("npm install failed while restoring the previous state", tail(result.stderr));
+      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/)) {
@@ -663,12 +1000,13 @@ function parseAuditSummary(output) {
   }
   return { message: "No known vulnerabilities found.", severity: "clean" };
 }
-function verifyAlignedLinks(module, rootDir, updates) {
+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"];
-  const moduleRelPath = relative2(rootDir, module.path).replace(/\\/g, "/");
   return findUnlinkedWorkspaceDependencies(lockfile, moduleRelPath, aligned);
 }
 function serializeLike(original, value) {
@@ -682,58 +1020,801 @@ function serializeLike(original, value) {
 var VERIFY_TIMEOUT_MS = 10 * 6e4;
 var NpmVerificationAdapter = class {
   async verify(_module, rootDir, options = {}) {
-    const label = options.customLabel || options.customScript || "Dependency tree integrity (npm ls)";
+    let manager = "npm";
     if (!options.customScript) {
       try {
-        assertNpmManaged(rootDir);
+        manager = await prepareSupportedPackageManager(rootDir);
       } catch (err) {
-        if (err instanceof UnsupportedPackageManagerError) return { status: "warn", details: err.message, label };
+        if (err instanceof UnsupportedPackageManagerError || err instanceof PackageManagerNotFoundError) {
+          return { status: "warn", details: err.message, label: options.customLabel || "Dependency verification" };
+        }
         throw err;
       }
     }
-    const result = options.customScript ? await runShellScript(options.customScript, { cwd: rootDir, timeoutMs: VERIFY_TIMEOUT_MS }) : await runCommand("npm", ["ls"], { cwd: rootDir, timeoutMs: VERIFY_TIMEOUT_MS });
-    if (result.exitCode === 0) {
-      return { status: "clean", details: "All dependencies are installed and consistent.", label };
+    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.5.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 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 readFileSync10 } 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-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 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, 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, 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` } };
     }
-    return {
-      status: "warn",
-      details: result.timedOut ? "Verification timed out." : tail(result.stderr || result.stdout),
-      label
+    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 null;
+    }
+    const newRange = rewriteRequirement(literal, latest);
+    if (newRange === literal) return null;
+    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 };
   }
 };
-
-// src/adapters/npm/npm-strategy.ts
-var NpmEcosystemStrategy = class {
-  ecosystem = "npm";
-  displayName = "Node / npm";
-  icon = "\u{1F4E6}";
-  manifestFile = "package.json";
-  discovery = new NpmModuleDiscoveryAdapter();
-  registry = new NpmRegistryAdapter();
-  reader = new NpmDependencyAdapter(this.registry, this.registry.config);
-  updater = new NpmUpdaterAdapter();
-  verifier = new NpmVerificationAdapter();
-  getTabLabels(counts, t) {
+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(readFileSync10(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 {
-      all: t.tabs.all(counts.total),
-      prod: t.tabs.dependencies(counts.prodCount),
-      dev: t.tabs.devDependencies(counts.devCount)
+      version: shared.version,
+      inherited: true,
+      declaration: { file: rootManifest, kind: "dependency-management", displayPath: display(repoRoot, rootManifest) }
     };
   }
-};
-
-// src/adapters/maven/maven-discovery.ts
-import { existsSync as existsSync6 } from "fs";
-import { dirname as dirname5, join as join9, relative as relative3, resolve as resolve6 } from "path";
-
-// src/adapters/maven/maven-project.ts
-import { existsSync as existsSync5, readdirSync, statSync as statSync2 } from "fs";
-import { join as join8, resolve as resolve5 } from "path";
+  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/maven/maven-pom.ts
-import { existsSync as existsSync4, readFileSync as readFileSync6, statSync } from "fs";
-import { dirname as dirname4, join as join7, resolve as resolve4 } from "path";
+// 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";
@@ -866,9 +1947,226 @@ function localName(qualified) {
   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-lockfile.ts
+import { existsSync as existsSync7, readFileSync as readFileSync11 } 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(readFileSync11(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-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 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);
+    }
+    return {
+      updatedCount: updates.length,
+      auditMessage: `Updated ${updates.length} requirement(s) in ${writes.length} Cargo.toml file(s)${existsSync8(lockFile) ? "; Cargo.lock refreshed" : ""}.`,
+      auditSeverity: "clean",
+      integrityViolations: []
+    };
+  }
+  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 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"];
+  }
+  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 = readFileSync6(file, "utf8");
+  const source = readFileSync13(file, "utf8");
   return parsePom(source, file);
 }
 function parsePom(source, file) {
@@ -887,7 +2185,7 @@ function parsePom(source, file) {
   }
   return {
     file,
-    dir: dirname4(file),
+    dir: dirname6(file),
     groupId: childText(project, "groupId"),
     artifactId: childText(project, "artifactId") ?? "unknown",
     version: childText(project, "version"),
@@ -916,9 +2214,9 @@ function parentPomFile(pom) {
   if (!pom.parent) return void 0;
   const relativePath = pom.parent.relativePath ?? "../pom.xml";
   if (relativePath === "") return void 0;
-  let candidate = resolve4(pom.dir, relativePath);
-  if (existsSync4(candidate) && statSync(candidate).isDirectory()) candidate = join7(candidate, "pom.xml");
-  return existsSync4(candidate) ? candidate : 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) {
@@ -993,9 +2291,9 @@ var MavenProject = class _MavenProject {
       }
       poms.push(pom);
       for (const entry of pom.modules) {
-        const target = resolve5(pom.dir, entry);
-        const moduleFile = target.endsWith(".xml") ? target : join8(target, "pom.xml");
-        if (!seen.has(moduleFile) && existsSync5(moduleFile)) {
+        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);
         }
@@ -1004,7 +2302,7 @@ var MavenProject = class _MavenProject {
     return new _MavenProject(rootDir, poms);
   }
   pomAt(file) {
-    return this.byFile.get(resolve5(file));
+    return this.byFile.get(resolve9(file));
   }
   /** The project followed by its local parents, stopping at the first external parent. */
   chainOf(pom) {
@@ -1047,7 +2345,7 @@ var MavenProject = class _MavenProject {
       return groupId === parent.groupId && candidate.artifactId === parent.artifactId && (version.includes("${") || expected.includes("${") || version === expected);
     };
     const file = parentPomFile(pom);
-    const byPath = file ? this.byFile.get(resolve5(file)) : void 0;
+    const byPath = file ? this.byFile.get(resolve9(file)) : void 0;
     return matches(byPath) ? byPath : void 0;
   }
   /**
@@ -1064,8 +2362,8 @@ var MavenProject = class _MavenProject {
         if (this.aggregators.has(pom.file)) continue;
         this.aggregators.set(pom.file, aggregator.dir);
         for (const entry of pom.modules) {
-          const target = resolve5(pom.dir, entry);
-          const file = target.endsWith(".xml") ? target : join8(target, "pom.xml");
+          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);
         }
@@ -1075,23 +2373,23 @@ var MavenProject = class _MavenProject {
 };
 function findPomFiles(rootDir) {
   const results = [];
-  const rootPom = join8(rootDir, "pom.xml");
-  if (existsSync5(rootPom)) results.push(resolve5(rootPom));
+  const rootPom = join15(rootDir, "pom.xml");
+  if (existsSync11(rootPom)) results.push(resolve9(rootPom));
   const walk = (dir, depth) => {
     if (depth > MAX_DEPTH) return;
-    let entries;
+    let entries2;
     try {
-      entries = readdirSync(dir, { withFileTypes: true });
+      entries2 = readdirSync2(dir, { withFileTypes: true });
     } catch {
       return;
     }
-    const isProject = existsSync5(join8(dir, "pom.xml"));
-    for (const entry of entries) {
+    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 = join8(dir, entry.name);
-      const pom = join8(subDir, "pom.xml");
-      if (existsSync5(pom) && statSync2(pom).isFile()) results.push(resolve5(pom));
+      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);
     }
   };
@@ -1106,9 +2404,9 @@ var MavenModuleDiscoveryAdapter = class {
    * the POM above until there is none: the top of the connected POM chain.
    */
   findRoot(startDir, boundaryDir) {
-    let dir = resolve6(startDir);
-    if (!existsSync6(join9(dir, "pom.xml"))) return void 0;
-    const boundary = boundaryDir ? resolve6(boundaryDir) : void 0;
+    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;
@@ -1119,7 +2417,7 @@ var MavenModuleDiscoveryAdapter = class {
     const project = MavenProject.load(rootDir);
     const modules = project.poms.map((pom) => {
       const coordinates = project.coordinatesOf(pom);
-      const relPath = relative3(rootDir, pom.dir).replace(/\\/g, "/");
+      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,
@@ -1146,7 +2444,7 @@ function ancestorsWithin(dir, boundary) {
   const result = [];
   let current = dir;
   while (current !== boundary) {
-    const parent = dirname5(current);
+    const parent = dirname7(current);
     if (parent === current) break;
     result.push(parent);
     current = parent;
@@ -1154,22 +2452,22 @@ function ancestorsWithin(dir, boundary) {
   return result;
 }
 function pomAbove(dir, boundary) {
-  const pom = tryReadPom(join9(dir, "pom.xml"));
+  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(dirname5(parentFile))) {
+  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(dirname5(parentFile));
+      found.push(dirname7(parentFile));
     }
   }
-  const ownFile = join9(dir, "pom.xml");
+  const ownFile = join16(dir, "pom.xml");
   const aggregator = ancestors.find(
-    (ancestor) => tryReadPom(join9(ancestor, "pom.xml"))?.modules.some((entry) => {
-      const target = resolve6(ancestor, entry);
+    (ancestor) => tryReadPom(join16(ancestor, "pom.xml"))?.modules.some((entry) => {
+      const target = resolve10(ancestor, entry);
       return target === dir || target === ownFile;
     })
   );
@@ -1178,12 +2476,12 @@ function pomAbove(dir, boundary) {
 }
 
 // src/adapters/maven/maven-registry.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { join as join19 } from "path";
 
 // src/adapters/maven/maven-command.ts
-import { existsSync as existsSync7 } from "fs";
-import { dirname as dirname6, isAbsolute, join as join10, relative as relative4, resolve as resolve7, sep } from "path";
+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.");
@@ -1203,27 +2501,27 @@ var WRAPPER = IS_WINDOWS2 ? "mvnw.cmd" : "mvnw";
 var BATCH_ARGS = ["-B", "--no-transfer-progress"];
 var mvnOnPath;
 function findMavenWrapper(fromDir, rootDir) {
-  let dir = resolve7(fromDir);
-  const root = resolve7(rootDir);
+  let dir = resolve11(fromDir);
+  const root = resolve11(rootDir);
   for (; ; ) {
-    const candidate = join10(dir, WRAPPER);
-    if (existsSync7(candidate)) return candidate;
-    if (dir === root || relative4(root, dir).startsWith("..")) return void 0;
-    const parent = dirname6(dir);
+    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 = relative4(cwd, file);
-  return isAbsolute(path) ? file : path || ".";
+  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 = isAbsolute(relativeWrapper) || relativeWrapper.includes(sep) ? relativeWrapper : `.${sep}${relativeWrapper}`;
+    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(
@@ -1240,8 +2538,8 @@ function mavenErrors(output) {
 
 // src/adapters/maven/maven-resolution.ts
 import { randomUUID } from "crypto";
-import { existsSync as existsSync8, mkdirSync, readFileSync as readFileSync7, readdirSync as readdirSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join11 } from "path";
+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";
@@ -1273,21 +2571,21 @@ var ScratchDirectory = class {
   target;
   createdTarget;
   constructor(moduleDir) {
-    this.target = join11(moduleDir, "target");
-    this.createdTarget = !existsSync8(this.target);
-    this.path = join11(this.target, `.elevate-${randomUUID().slice(0, 8)}`);
+    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 && readdirSync2(this.target).length === 0) rmSync(this.target, { recursive: true });
+      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 = join11(scratch.path, "effective-pom.xml");
+  const output = join18(scratch.path, "effective-pom.xml");
   const args = [
     "-f",
     relativeToCwd(moduleDir, pomFile),
@@ -1299,7 +2597,7 @@ async function readEffectivePoms(pomFile, moduleDir, rootDir, scratch, plugins,
     rootDir,
     timeoutMs: MAVEN_TIMEOUT_MS
   });
-  if (result.exitCode !== 0 || !existsSync8(output)) {
+  if (result.exitCode !== 0 || !existsSync14(output)) {
     const text = `${result.stdout}
 ${result.stderr}`;
     if (isPluginUnavailable(text, HELP_PLUGIN_ID)) {
@@ -1311,7 +2609,7 @@ ${result.stderr}`;
     throw new MavenCommandError(`Maven could not build the effective POM:
 ${mavenErrors(text)}`, text);
   }
-  return parseEffectivePoms(readFileSync7(output, "utf8"));
+  return parseEffectivePoms(readFileSync14(output, "utf8"));
 }
 function parseEffectivePoms(source) {
   const root = parseXml(source);
@@ -1323,7 +2621,7 @@ function parseEffectivePoms(source) {
   return models;
 }
 function mergeRepositories(models) {
-  const merge = (name, pick) => {
+  const merge2 = (name, pick) => {
     const byId = /* @__PURE__ */ new Map();
     for (const element of models.map(pick)) {
       for (const repository of element?.children ?? []) {
@@ -1336,8 +2634,8 @@ function mergeRepositories(models) {
   return {
     dependencies: [],
     managedDependencies: [],
-    repositories: merge("repositories", (m) => m.repositories),
-    pluginRepositories: merge("pluginRepositories", (m) => m.pluginRepositories)
+    repositories: merge2("repositories", (m) => m.repositories),
+    pluginRepositories: merge2("pluginRepositories", (m) => m.pluginRepositories)
   };
 }
 function toEffectiveModel(project) {
@@ -1360,7 +2658,7 @@ function readEffectiveDependencies(container) {
 }
 function buildProbePom(artifacts, model) {
   const seen = /* @__PURE__ */ new Set();
-  const entries = [];
+  const entries2 = [];
   for (const artifact of artifacts) {
     const key = `${artifact.groupId}:${artifact.artifactId}:${artifact.type ?? "jar"}:${artifact.classifier ?? ""}`;
     if (seen.has(key)) continue;
@@ -1372,7 +2670,7 @@ function buildProbePom(artifacts, model) {
       artifact.type && artifact.type !== "jar" ? `<type>${escapeXml(artifact.type)}</type>` : "",
       artifact.classifier ? `<classifier>${escapeXml(artifact.classifier)}</classifier>` : ""
     ].filter(Boolean);
-    entries.push(`      <dependency>${fields.join("")}</dependency>`);
+    entries2.push(`      <dependency>${fields.join("")}</dependency>`);
   }
   const repositories = [model.repositories, model.pluginRepositories].filter((element) => element !== void 0).map((element) => serializeXml(element, "  ")).join("\n");
   return [
@@ -1386,7 +2684,7 @@ function buildProbePom(artifacts, model) {
     repositories,
     "  <dependencyManagement>",
     "    <dependencies>",
-    ...entries,
+    ...entries2,
     "    </dependencies>",
     "  </dependencyManagement>",
     "</project>",
@@ -1395,10 +2693,10 @@ function buildProbePom(artifacts, model) {
 }
 async function queryNewerVersions(artifacts, model, moduleDir, rootDir, scratch, plugins) {
   if (artifacts.length === 0) return { newerVersions: /* @__PURE__ */ new Map(), failedLookups: /* @__PURE__ */ new Set() };
-  const probeDir = join11(scratch.path, "probe");
+  const probeDir = join18(scratch.path, "probe");
   mkdirSync(probeDir, { recursive: true });
-  const probePom = join11(probeDir, "pom.xml");
-  writeFileSync2(probePom, buildProbePom(artifacts, model), "utf8");
+  const probePom = join18(probeDir, "pom.xml");
+  writeFileSync3(probePom, buildProbePom(artifacts, model), "utf8");
   const result = await runMaven(
     [
       "-N",
@@ -1412,8 +2710,8 @@ async function queryNewerVersions(artifacts, model, moduleDir, rootDir, scratch,
   );
   const log = `${result.stdout}
 ${result.stderr}`;
-  const reportFile = join11(probeDir, "target", "dependency-updates-report.xml");
-  if (result.exitCode !== 0 || !existsSync8(reportFile)) {
+  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" },
@@ -1424,7 +2722,7 @@ ${result.stderr}`;
 ${mavenErrors(log)}`, log);
   }
   return {
-    newerVersions: parseUpdatesReport(readFileSync7(reportFile, "utf8")),
+    newerVersions: parseUpdatesReport(readFileSync14(reportFile, "utf8")),
     failedLookups: parseFailedLookups(log)
   };
 }
@@ -1509,18 +2807,18 @@ var MavenRegistryAdapter = class {
   }
 };
 async function projectRepositories(cwd, scratch, plugins) {
-  const rootPom = join12(cwd, "pom.xml");
-  if (!existsSync9(rootPom)) return NO_REPOSITORIES;
+  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 join13 } from "path";
-import semver4 from "semver";
+import { join as join20 } from "path";
+import semver11 from "semver";
 
 // src/adapters/maven/maven-locator.ts
-import { relative as relative5 } from "path";
+import { relative as relative8 } from "path";
 function locateDependencyVersion(chain, target, rootDir) {
   for (const pom of chain) {
     const dependency = findDependency(pom.dependencies, target, chain);
@@ -1601,13 +2899,13 @@ function resolveLiteral(pom, kind, versionElement, chain, target, rootDir) {
     file,
     kind: propertyName ? "property" : kind,
     propertyName,
-    displayPath: relative5(rootDir, file).replace(/\\/g, "/")
+    displayPath: relative8(rootDir, file).replace(/\\/g, "/")
   };
   return { found: true, declaration, element, value };
 }
 
 // src/adapters/maven/maven-scanner.ts
-var DIFF_ORDER2 = { major: 0, minor: 1, patch: 2 };
+var DIFF_ORDER3 = { major: 0, minor: 1, patch: 2 };
 var MavenDependencyAdapter = class {
   constructor(plugins = DEFAULT_MAVEN_PLUGINS) {
     this.plugins = plugins;
@@ -1661,14 +2959,14 @@ function groupModules(project, modules) {
     if (module.aggregatorDir) reactorSizes.set(module.aggregatorDir, (reactorSizes.get(module.aggregatorDir) ?? 0) + 1);
   }
   for (const module of modules) {
-    const pom = project.pomAt(join13(module.path, "pom.xml"));
+    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 ? join13(reactor, "pom.xml") : void 0,
+      aggregatorPom: batched ? join20(reactor, "pom.xml") : void 0,
       members: []
     };
     group.members.push({ module, pom });
@@ -1757,7 +3055,7 @@ function finishModule(plan, report, channel) {
     collect2(updateCandidate(subject, latest, newer, origin), candidates, skipped);
   }
   markSharedDeclarations(candidates);
-  candidates.sort((a, b) => (DIFF_ORDER2[a.diff] ?? 3) - (DIFF_ORDER2[b.diff] ?? 3));
+  candidates.sort((a, b) => (DIFF_ORDER3[a.diff] ?? 3) - (DIFF_ORDER3[b.diff] ?? 3));
   return { candidates, skipped };
 }
 function newerThan(current, ascending) {
@@ -1788,7 +3086,7 @@ function buildCandidate(subject, target, origin, action) {
   }
   const currentClean = cleanJavaVersion(subject.version) ?? "0.0.0";
   const targetClean = cleanJavaVersion(target) ?? currentClean;
-  const diff = semver4.eq(currentClean, targetClean) ? "patch" : diffVersions(currentClean, targetClean);
+  const diff = semver11.eq(currentClean, targetClean) ? "patch" : diffVersions(currentClean, targetClean);
   const isPreRelease = isPreReleaseVersion(target);
   return {
     candidate: {
@@ -1836,11 +3134,11 @@ function markSharedDeclarations(candidates) {
 }
 
 // src/adapters/maven/maven-updater.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
-import { join as join14, resolve as resolve8 } from "path";
+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) => resolve8(u.declaration?.file ?? join14(module.path, "pom.xml"))));
+    const files = new Set(updates.map((u) => resolve12(u.declaration?.file ?? join21(module.path, "pom.xml"))));
     return [...files];
   }
   async applyUpdates(module, rootDir, updates, onProgress) {
@@ -1850,13 +3148,13 @@ var MavenUpdaterAdapter = class {
       if (!update.declaration) {
         throw new InstallError(`No version declaration known for ${update.coordinate.identifier}; rescan the module.`);
       }
-      const file = resolve8(update.declaration.file);
+      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 = readFileSync8(file, "utf8");
+      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);
@@ -1868,7 +3166,7 @@ var MavenUpdaterAdapter = class {
       }
     }
     onProgress("Writing POM files\u2026");
-    for (const write of writes) writeFileSync3(write.file, write.content, "utf8");
+    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).`,
@@ -1926,14 +3224,14 @@ function describe(declaration) {
 }
 
 // src/adapters/maven/maven-verifier.ts
-import { dirname as dirname7, join as join15, relative as relative6, resolve as resolve9 } from "path";
-var VERIFY_TIMEOUT_MS2 = 30 * 6e4;
+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_MS2 });
-      return result.exitCode === 0 ? { status: "clean", details: "Verification script succeeded.", label: label2 } : { status: "warn", details: failureDetails(result), label: label2 };
+      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(" ")})`;
@@ -1941,12 +3239,12 @@ var MavenVerificationAdapter = class {
       const result = await runMaven(["-q", "test-compile", ...plan.args], {
         cwd: plan.cwd,
         rootDir,
-        timeoutMs: VERIFY_TIMEOUT_MS2
+        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." : failureDetails(result);
+      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 };
@@ -1954,7 +3252,7 @@ var MavenVerificationAdapter = class {
     }
   }
 };
-function failureDetails(result) {
+function failureDetails2(result) {
   const output = `${result.stdout}
 ${result.stderr}`.trim();
   return output ? mavenErrors(output) : `Exited with code ${result.exitCode}.`;
@@ -1963,15 +3261,15 @@ 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 : [join15(module.path, "pom.xml")];
+  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 = resolve9(dirname7(file));
-    if (!pom || project.aggregatorDirOf(pom) !== aggregatorDir || dir === resolve9(aggregatorDir)) {
+    const dir = resolve13(dirname9(file));
+    if (!pom || project.aggregatorDirOf(pom) !== aggregatorDir || dir === resolve13(aggregatorDir)) {
       return { cwd: aggregatorDir, args: [] };
     }
-    selected.add(relative6(aggregatorDir, dir).replace(/\\/g, "/"));
+    selected.add(relative9(aggregatorDir, dir).replace(/\\/g, "/"));
   }
   return { cwd: aggregatorDir, args: ["-pl", [...selected].join(","), "-amd"] };
 }
@@ -1982,6 +3280,7 @@ var MavenEcosystemStrategy = class {
   displayName = "Java / Maven";
   icon = "\u2615";
   manifestFile = "pom.xml";
+  versioning = mavenVersionPolicy;
   discovery = new MavenModuleDiscoveryAdapter();
   registry;
   reader;
@@ -2019,6 +3318,8 @@ var EcosystemFactory = class {
     if (!strategy) {
       if (ecosystem === "maven") {
         strategy = new MavenEcosystemStrategy(this.settings.mavenPlugins);
+      } else if (ecosystem === "cargo") {
+        strategy = new CargoEcosystemStrategy();
       } else {
         strategy = new NpmEcosystemStrategy();
       }
@@ -2028,18 +3329,23 @@ var EcosystemFactory = class {
   }
   /** All supported ecosystems. */
   static getAvailableEcosystems() {
-    return ["npm", "maven"];
+    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 = resolve10(startDir);
+  const start = resolve14(startDir);
   const boundary = findCheckoutBoundary(start);
   let dir = start;
   for (; ; ) {
-    if (existsSync10(join16(dir, "elevate.config.json"))) return dir;
-    const parent = dirname8(dir);
+    if (existsSync16(join23(dir, "elevate.config.json"))) return dir;
+    const parent = dirname10(dir);
     if (dir === boundary || parent === dir) break;
     dir = parent;
   }
@@ -2104,15 +3410,15 @@ function resolveConfig(rootDir, file, source = "elevate.config.json") {
 }
 function loadConfig2(startDir = process.cwd()) {
   const rootDir = findRepositoryRoot(startDir);
-  const configPath = join16(rootDir, "elevate.config.json");
+  const configPath = join23(rootDir, "elevate.config.json");
   let file = {};
-  if (existsSync10(configPath)) {
+  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(readFileSync9(configPath, "utf8").replace(/^/, ""));
+      parsed = JSON.parse(readFileSync16(configPath, "utf8").replace(/^/, ""));
     } catch (err) {
       throw unreadable(err instanceof Error ? err.message : String(err));
     }
@@ -2161,7 +3467,9 @@ var de = {
       "lookup-failed": "Abfrage der Registry fehlgeschlagen",
       "managed-externally": "Version wird au\xDFerhalb dieses Repos verwaltet",
       "declaration-mismatch": "Ort der Versionsangabe ist nicht eindeutig",
-      "invalid-name": "ung\xFCltiger Paketname"
+      "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"
     })[reason]
   },
   badges: {
@@ -2171,7 +3479,8 @@ var de = {
     dev: "(dev/test)",
     prod: "(prod/compile)",
     align: "[Angleichen]",
-    internal: "[Intern]"
+    internal: "[Intern]",
+    shared: (count) => `[+${count} Crates]`
   },
   status: {
     selectedOf: (selected, total) => `${selected} von ${total}`,
@@ -2200,6 +3509,7 @@ var de = {
     hint: "[\u2191/\u2193/j/k] Navigieren  \u2502  [Enter] Ausw\xE4hlen  \u2502  [Esc] Abbrechen  \u2502  [Backspace] Filter l\xF6schen",
     latestBadge: "LATEST",
     currentBadge: "AKTUELL",
+    alsoChanges: (names) => `\xC4ndert auch: ${names.join(", ")}`,
     customBadge: "MANUELL"
   },
   updating: {
@@ -2228,6 +3538,7 @@ var de = {
     scanningChirps: ["*such*", "pr\xFCfe...", "oh, Updates?", "einen Moment!"],
     updatingChirps: ["*schuft*", "baue Code...", "gleich fertig!", "arbeite emsig..."],
     successChirps: ["hurra! \u{1F389}", "alles aktuell!", "top gepflegt! \u{1FAB6}", "super gemacht!"],
+    cargoChirps: ["*krabbel* \u{1F980}", "cargo check l\xE4uft durch!", "Borrow Checker nickt!", "furchtlose Updates!"],
     mavenChirps: ["*kaffee schl\xFCrf* \u2615", "Spring Boot l\xE4uft!", "Java 25 rockt!", "sauber gebaut!"]
   },
   splash: {
@@ -2267,7 +3578,9 @@ var en = {
       "lookup-failed": "registry lookup failed",
       "managed-externally": "version is managed outside this repository",
       "declaration-mismatch": "version location is ambiguous",
-      "invalid-name": "invalid package name"
+      "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"
     })[reason]
   },
   badges: {
@@ -2277,7 +3590,8 @@ var en = {
     dev: "(dev/test)",
     prod: "(prod/compile)",
     align: "[Align]",
-    internal: "[Internal]"
+    internal: "[Internal]",
+    shared: (count) => `[+${count} crates]`
   },
   status: {
     selectedOf: (selected, total) => `${selected} of ${total}`,
@@ -2306,6 +3620,7 @@ var en = {
     hint: "[\u2191/\u2193/j/k] Navigate  \u2502  [Enter] Select  \u2502  [Esc] Cancel  \u2502  [Backspace] Clear filter",
     latestBadge: "LATEST",
     currentBadge: "CURRENT",
+    alsoChanges: (names) => `Also changes: ${names.join(", ")}`,
     customBadge: "MANUAL"
   },
   updating: {
@@ -2334,6 +3649,7 @@ var en = {
     scanningChirps: ["*peeking*", "checking...", "ooh, updates?", "just a sec!"],
     updatingChirps: ["*working hard*", "building...", "almost there!", "packing modules..."],
     successChirps: ["hooray! \u{1F389}", "all updated!", "looking sharp! \u{1FAB6}", "great job!"],
+    cargoChirps: ["*crab walk* \u{1F980}", "cargo check passes!", "borrow checker approves!", "fearless updates!"],
     mavenChirps: ["*sipping coffee* \u2615", "Spring Boot rocks!", "Java 25 is fly!", "clean build!"]
   },
   splash: {
@@ -2370,48 +3686,12 @@ function useI18n(initialLocale = "de") {
 
 // src/hooks/use-workspaces.ts
 import { useState as useState2, useEffect, useCallback as useCallback2 } from "react";
-function useWorkspaces(strategy, rootDir) {
-  const [modules, setModules] = useState2([]);
-  const [loading, setLoading] = useState2(true);
-  const [activeIndex, setActiveIndex] = useState2(0);
-  const reload = useCallback2(async () => {
-    setLoading(true);
-    setModules([]);
-    setActiveIndex(0);
-    try {
-      setModules(await strategy.discovery.discover(rootDir));
-    } catch {
-      setModules([]);
-    } finally {
-      setLoading(false);
-    }
-  }, [strategy, rootDir]);
-  useEffect(() => {
-    reload();
-  }, [reload]);
-  const active = modules[activeIndex] || {
-    id: "empty",
-    name: "No module found",
-    path: rootDir,
-    relPath: "Root",
-    ecosystem: strategy.ecosystem,
-    isRoot: true
-  };
-  return {
-    modules,
-    active,
-    activeIndex,
-    setActiveIndex,
-    loading,
-    reload
-  };
-}
-
-// src/hooks/use-packages.ts
-import { useState as useState3, useEffect as useEffect2, useMemo as useMemo2, useCallback as useCallback3, useRef } from "react";
-import semver5 from "semver";
 
 // src/application/scan.ts
+async function discoverModules(strategy, rootDir) {
+  const modules = await strategy.discovery.discover(rootDir);
+  return { modules, diagnostics: strategy.discovery.diagnostics?.() ?? [] };
+}
 function createScanContext(modules, config, channel) {
   return {
     rootDir: config.rootDir,
@@ -2461,12 +3741,62 @@ 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 } : void 0,
+    declaredIn: u.declaration ? {
+      file: u.declaration.displayPath,
+      kind: u.declaration.kind,
+      property: u.declaration.propertyName,
+      catalog: u.declaration.catalogName
+    } : void 0,
     sharedWith: u.sharedWith
   };
 }
 
+// src/hooks/use-workspaces.ts
+function useWorkspaces(strategy, rootDir) {
+  const [modules, setModules] = useState2([]);
+  const [loading, setLoading] = useState2(true);
+  const [activeIndex, setActiveIndex] = useState2(0);
+  const [diagnostics, setDiagnostics] = useState2([]);
+  const reload = useCallback2(async () => {
+    setLoading(true);
+    setModules([]);
+    setActiveIndex(0);
+    setDiagnostics([]);
+    try {
+      const found = await discoverModules(strategy, rootDir);
+      setModules(found.modules);
+      setDiagnostics(found.diagnostics);
+    } catch (err) {
+      setModules([]);
+      setDiagnostics([err instanceof Error ? err.message : String(err)]);
+    } finally {
+      setLoading(false);
+    }
+  }, [strategy, rootDir]);
+  useEffect(() => {
+    reload();
+  }, [reload]);
+  const active = modules[activeIndex] || {
+    id: "empty",
+    name: "No module found",
+    path: rootDir,
+    relPath: "Root",
+    ecosystem: strategy.ecosystem,
+    isRoot: true
+  };
+  return {
+    modules,
+    active,
+    activeIndex,
+    setActiveIndex,
+    loading,
+    diagnostics,
+    reload
+  };
+}
+
 // src/hooks/use-packages.ts
+import { useState as useState3, useEffect as useEffect2, useMemo as useMemo2, useCallback as useCallback3, useRef } from "react";
 function usePackages(strategy, module, modules, config, channel = "stable") {
   const [candidates, setCandidates] = useState3([]);
   const [skipped, setSkipped] = useState3([]);
@@ -2533,15 +3863,12 @@ function usePackages(strategy, module, modules, config, channel = "stable") {
     setCandidates(
       (prev) => prev.map((c) => {
         if (c.coordinate.identifier !== identifier) return c;
-        const target = c.coordinate.ecosystem === "maven" ? cleanJavaVersion(chosenVersion) : semver5.valid(chosenVersion);
-        let diff = "minor";
-        if (c.currentClean && target && semver5.valid(c.currentClean)) {
-          diff = semver5.eq(c.currentClean, target) ? "patch" : diffVersions(c.currentClean, target);
-        }
+        const policy = strategy.versioning;
+        const diff = c.currentClean ? policy.diff(c.currentClean, chosenVersion) : "minor";
         const isPre = isPreReleaseVersion(chosenVersion);
         return {
           ...c,
-          newRange: c.coordinate.ecosystem === "npm" ? `${rangePrefix(c.currentRange)}${chosenVersion}` : chosenVersion,
+          newRange: policy.rewrite(c.currentRange, chosenVersion),
           latest: chosenVersion,
           diff,
           selected: true,
@@ -2551,7 +3878,7 @@ function usePackages(strategy, module, modules, config, channel = "stable") {
         };
       })
     );
-  }, []);
+  }, [strategy]);
   const switchTab = useCallback3((tab) => {
     setActiveTab(tab);
     setCursor(0);
@@ -2583,24 +3910,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 existsSync12 } from "fs";
-import { relative as relative7 } from "path";
+import { existsSync as existsSync18 } from "fs";
+import { relative as relative10 } from "path";
 
 // src/adapters/shared/file-snapshot.ts
-import { existsSync as existsSync11, readFileSync as readFileSync10, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync17, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
 var FileSnapshot = class _FileSnapshot {
-  constructor(entries) {
-    this.entries = entries;
+  constructor(entries2) {
+    this.entries = entries2;
   }
   entries;
   /** Records the current content (or absence) of each file. */
   static capture(files) {
-    const entries = /* @__PURE__ */ new Map();
+    const entries2 = /* @__PURE__ */ new Map();
     for (const file of files) {
-      if (entries.has(file)) continue;
-      entries.set(file, existsSync11(file) ? readFileSync10(file) : null);
+      if (entries2.has(file)) continue;
+      entries2.set(file, existsSync17(file) ? readFileSync17(file) : null);
     }
-    return new _FileSnapshot(entries);
+    return new _FileSnapshot(entries2);
   }
   /** The files covered by this snapshot. */
   get files() {
@@ -2610,9 +3937,9 @@ var FileSnapshot = class _FileSnapshot {
   changedFiles() {
     return this.files.filter((file) => {
       const before = this.entries.get(file) ?? null;
-      const exists = existsSync11(file);
+      const exists = existsSync17(file);
       if (before === null) return exists;
-      return !exists || !readFileSync10(file).equals(before);
+      return !exists || !readFileSync17(file).equals(before);
     });
   }
   /** Writes every file back to its captured state; removes files that did not exist. */
@@ -2621,7 +3948,7 @@ var FileSnapshot = class _FileSnapshot {
       if (content === null) {
         rmSync2(file, { force: true });
       } else {
-        writeFileSync4(file, content);
+        writeFileSync5(file, content);
       }
     }
   }
@@ -2660,7 +3987,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) => existsSync12(file)));
+    baseline = await verify(snapshot.files.filter((file) => existsSync18(file)));
   }
   let applied;
   try {
@@ -2706,7 +4033,7 @@ function message(err) {
   return err instanceof Error ? err.message : String(err);
 }
 function displayPaths(files, rootDir) {
-  return files.map((file) => relative7(rootDir, file).replace(/\\/g, "/"));
+  return files.map((file) => relative10(rootDir, file).replace(/\\/g, "/"));
 }
 
 // src/hooks/use-updater.ts
@@ -2864,7 +4191,8 @@ var Header = ({
   currentLocale,
   strategy,
   nextStrategyName,
-  channel
+  channel,
+  rootDir
 }) => /* @__PURE__ */ jsxs2(
   Box2,
   {
@@ -2885,7 +4213,7 @@ var Header = ({
           /* @__PURE__ */ jsxs2(Text2, { color: theme.colors.brandLight, bold: true, children: [
             strategy.icon,
             " ",
-            strategy.displayName
+            rootDir && strategy.displayNameFor?.(rootDir) || strategy.displayName
           ] }),
           /* @__PURE__ */ jsxs2(Text2, { color: theme.colors.muted, children: [
             " [",
@@ -2919,33 +4247,39 @@ var Header = ({
 // src/components/workspace-bar.tsx
 import { Box as Box3, Text as Text3 } from "ink";
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
-var WorkspaceBar = ({ module, internalScopes, strategy, t }) => {
+var WorkspaceBar = ({ module, internalScopes, strategy, t, diagnostics = [] }) => {
   const scopeHint = internalScopes.length > 0 ? t.status.internalScopes(internalScopes) : t.status.noInternalScopes;
-  return /* @__PURE__ */ jsxs3(Box3, { marginY: 1, justifyContent: "space-between", alignItems: "center", children: [
-    /* @__PURE__ */ jsxs3(Box3, { alignItems: "center", flexShrink: 1, children: [
-      /* @__PURE__ */ jsxs3(Text3, { bold: true, children: [
-        "\u{1F4CD} ",
-        strategy.icon,
-        " ",
-        t.workspace.label,
-        ": "
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs3(Box3, { marginY: 1, justifyContent: "space-between", alignItems: "center", children: [
+      /* @__PURE__ */ jsxs3(Box3, { alignItems: "center", flexShrink: 1, children: [
+        /* @__PURE__ */ jsxs3(Text3, { bold: true, children: [
+          "\u{1F4CD} ",
+          strategy.icon,
+          " ",
+          t.workspace.label,
+          ": "
+        ] }),
+        /* @__PURE__ */ jsx3(Text3, { bold: true, color: theme.colors.brandLight, children: module.name }),
+        /* @__PURE__ */ jsxs3(Text3, { color: theme.colors.muted, children: [
+          " (",
+          module.relPath,
+          ")"
+        ] })
       ] }),
-      /* @__PURE__ */ jsx3(Text3, { bold: true, color: theme.colors.brandLight, children: module.name }),
-      /* @__PURE__ */ jsxs3(Text3, { color: theme.colors.muted, children: [
-        " (",
-        module.relPath,
-        ")"
+      /* @__PURE__ */ jsxs3(Box3, { alignItems: "center", marginLeft: 2, children: [
+        /* @__PURE__ */ jsx3(Text3, { color: theme.colors.muted, children: scopeHint }),
+        /* @__PURE__ */ jsx3(Text3, { color: theme.colors.muted, children: "  \u2502  " }),
+        /* @__PURE__ */ jsx3(Text3, { color: theme.colors.brandLight, bold: true, children: "[W]" }),
+        /* @__PURE__ */ jsxs3(Text3, { color: theme.colors.muted, children: [
+          " ",
+          t.workspace.switchHint.replace("[W]", "").trim()
+        ] })
       ] })
     ] }),
-    /* @__PURE__ */ jsxs3(Box3, { alignItems: "center", marginLeft: 2, children: [
-      /* @__PURE__ */ jsx3(Text3, { color: theme.colors.muted, children: scopeHint }),
-      /* @__PURE__ */ jsx3(Text3, { color: theme.colors.muted, children: "  \u2502  " }),
-      /* @__PURE__ */ jsx3(Text3, { color: theme.colors.brandLight, bold: true, children: "[W]" }),
-      /* @__PURE__ */ jsxs3(Text3, { color: theme.colors.muted, children: [
-        " ",
-        t.workspace.switchHint.replace("[W]", "").trim()
-      ] })
-    ] })
+    diagnostics.slice(0, 2).map((d) => /* @__PURE__ */ jsxs3(Text3, { color: theme.colors.danger, wrap: "truncate-end", children: [
+      "\u26A0 ",
+      d.split("\n")[0]
+    ] }, d))
   ] });
 };
 
@@ -2995,7 +4329,9 @@ import { Box as Box5, Text as Text5 } from "ink";
 import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 var PackageRow = ({ item, isFocused, t }) => {
   const badge = item.diff === "major" ? /* @__PURE__ */ jsx5(Text5, { bold: true, color: theme.colors.danger, children: t.badges.major }) : item.diff === "minor" ? /* @__PURE__ */ jsx5(Text5, { color: theme.colors.warning, children: t.badges.minor }) : /* @__PURE__ */ jsx5(Text5, { color: theme.colors.success, children: t.badges.patch });
-  const displayName = item.coordinate.identifier;
+  const shared = item.sharedWith && item.sharedWith.length > 0 ? ` ${t.badges.shared(item.sharedWith.length)}` : "";
+  const label = item.qualifier ? `${item.coordinate.identifier} (${item.qualifier})` : item.coordinate.identifier;
+  const displayName = label.slice(0, 42 - shared.length) + shared;
   const isDevOrTest = item.scope === "dev" || item.scope === "test";
   const property = item.declaration?.kind === "property" ? `\${${item.declaration.propertyName}}` : void 0;
   return /* @__PURE__ */ jsxs5(Box5, { justifyContent: "space-between", children: [
@@ -3174,7 +4510,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] : t.mascot.idleChirps;
+    const chirpsPool = ecosystem === "maven" ? [...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: [
@@ -3452,6 +4788,7 @@ var VersionModal = ({
           ] }),
           /* @__PURE__ */ jsx11(Text11, { color: theme.colors.muted, children: t.versionModal.current(candidate.currentRange) })
         ] }),
+        candidate.sharedWith && candidate.sharedWith.length > 0 && /* @__PURE__ */ jsx11(Box11, { marginBottom: 1, children: /* @__PURE__ */ jsx11(Text11, { color: theme.colors.warning, children: t.versionModal.alsoChanges(candidate.sharedWith) }) }),
         /* @__PURE__ */ jsxs11(
           Box11,
           {
@@ -3626,10 +4963,10 @@ var App = ({ config }) => {
   const [versionPickerCandidate, setVersionPickerCandidate] = useState8(null);
   const [ecosystem, setEcosystem] = useState8("npm");
   const strategy = useMemo4(() => EcosystemFactory.getStrategy(ecosystem), [ecosystem]);
-  const nextEcosystem = ecosystem === "npm" ? "maven" : "npm";
+  const nextEcosystem = EcosystemFactory.next(ecosystem);
   const nextStrategy = useMemo4(() => EcosystemFactory.getStrategy(nextEcosystem), [nextEcosystem]);
   const toggleEcosystem = useCallback5(() => {
-    setEcosystem((prev) => prev === "npm" ? "maven" : "npm");
+    setEcosystem((prev) => EcosystemFactory.next(prev));
   }, []);
   const { locale, toggleLocale, t } = useI18n(resolveInitialLocale(config.locale));
   const ws = useWorkspaces(strategy, config.rootDir);
@@ -3733,7 +5070,8 @@ var App = ({ config }) => {
           currentLocale: locale,
           strategy,
           nextStrategyName: `${nextStrategy.icon} ${nextStrategy.displayName}`,
-          channel: config.channel
+          channel: config.channel,
+          rootDir: config.rootDir
         }
       ),
       view === "workspace_modal" && /* @__PURE__ */ jsx14(
@@ -3780,7 +5118,8 @@ var App = ({ config }) => {
             module: ws.active,
             internalScopes: config.internalScopes,
             strategy,
-            t
+            t,
+            diagnostics: ws.diagnostics
           }
         ),
         /* @__PURE__ */ jsx14(
@@ -3820,6 +5159,7 @@ var App = ({ config }) => {
 };
 
 // src/cli/parser.ts
+var isEcosystem = (v) => EcosystemFactory.getAvailableEcosystems().includes(v);
 function parseCliArgs(args) {
   const [first, ...rest] = args;
   if (!first || first === "--help" || first === "-h" || first === "help") {
@@ -3857,10 +5197,10 @@ function parseCliArgs(args) {
       result.help = true;
     } else if (arg.startsWith("--ecosystem=")) {
       const val = arg.split("=")[1];
-      if (val === "npm" || val === "maven") result.ecosystem = val;
+      if (isEcosystem(val)) result.ecosystem = val;
     } else if (arg === "-e" || arg === "--ecosystem") {
       const val = remaining[++i];
-      if (val === "npm" || val === "maven") result.ecosystem = val;
+      if (isEcosystem(val)) result.ecosystem = val;
     } else if (arg.startsWith("--module=")) {
       result.module = arg.split("=")[1];
     } else if (arg === "-m" || arg === "--module") {
@@ -3902,7 +5242,7 @@ SUBCOMMANDS:
   mcp                                   Start stdio-based MCP server
 
 FLAGS:
-  -e, --ecosystem <npm|maven>          Target ecosystem (default: npm)
+  -e, --ecosystem <npm|maven|cargo>          Target ecosystem (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
@@ -3930,19 +5270,22 @@ EXAMPLES:
 async function handleModulesCommand(options, config) {
   const ecosystem = options.ecosystem ?? "npm";
   const strategy = EcosystemFactory.getStrategy(ecosystem);
-  const modules = await strategy.discovery.discover(config.rootDir);
+  const { modules, diagnostics } = await discoverModules(strategy, config.rootDir);
+  const displayName = strategy.displayNameFor?.(config.rootDir) ?? strategy.displayName;
+  const packageManager = strategy.packageManagerFor?.(config.rootDir);
   if (options.json) {
-    console.log(JSON.stringify({ ecosystem, count: modules.length, modules }, null, 2));
+    console.log(JSON.stringify({ ecosystem, ...packageManager ? { packageManager } : {}, count: modules.length, modules, diagnostics }, null, 2));
     return 0;
   }
   console.log(`
-\u{1FAB6} Discovered ${strategy.icon} ${strategy.displayName} Modules (${modules.length}):
+\u{1FAB6} Discovered ${strategy.icon} ${displayName} Modules (${modules.length}):
 `);
   for (const m of modules) {
     const isRootBadge = m.isRoot ? " [ROOT]" : "";
     console.log(`  \u2022 ${m.name.padEnd(45)} (${m.relPath})${isRootBadge}`);
   }
   console.log("");
+  for (const problem of diagnostics) console.error(`\u26A0\uFE0F  ${problem}`);
   return 0;
 }
 
@@ -3960,6 +5303,12 @@ function describeSkip(skipped) {
       return `version location is ambiguous${detail}`;
     case "invalid-name":
       return "not a valid package name";
+    case "not-linked":
+      return `workspace package that pnpm does not link unless it is declared with the workspace: protocol${detail}`;
+    case "catalog-unresolved":
+      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}`;
   }
 }
 
@@ -3968,7 +5317,8 @@ async function handleScanCommand(options, config) {
   const ecosystem = options.ecosystem ?? "npm";
   const channel = options.channel ?? config.channel ?? "stable";
   const strategy = EcosystemFactory.getStrategy(ecosystem);
-  const modules = await strategy.discovery.discover(config.rootDir);
+  const { modules, diagnostics } = await discoverModules(strategy, config.rootDir);
+  for (const problem of diagnostics) console.error(`\u26A0\uFE0F  ${problem}`);
   if (modules.length === 0) {
     if (options.json) {
       console.log(JSON.stringify({ error: `No ${strategy.displayName} modules found.`, ecosystem }, null, 2));
@@ -4118,7 +5468,7 @@ async function handleVersionsCommand(options, config) {
 }
 
 // src/application/update-selection.ts
-import semver6 from "semver";
+import semver12 from "semver";
 var UpdateSelectionError = class extends Error {
   constructor(message2) {
     super(message2);
@@ -4143,9 +5493,9 @@ function selectRequested(scan, requests, options) {
         `'${request.identifier}' has no pending update. Specify a target version (e.g. ${request.identifier}@1.2.3).`
       );
     }
-    if (options.ecosystem === "maven") {
+    if (!policyOf(options).allowsManualTargets) {
       throw new UpdateSelectionError(
-        `'${request.identifier}' has no pending update. Maven updates are written where the scan located the version; a dependency without an offered update cannot be retargeted.`
+        `'${request.identifier}' has no pending update. Updates are written where the scan located the version; a dependency without an offered update cannot be retargeted.`
       );
     }
     if (options.originOf(request.identifier) !== "public") {
@@ -4170,12 +5520,12 @@ function retarget(found, target, options) {
       `'${found.coordinate.identifier}' is a workspace module; it can only be aligned to its local version ${found.latest}.`
     );
   }
-  if (options.ecosystem === "maven" && found.availableVersions && !found.availableVersions.includes(target)) {
+  if (!policyOf(options).allowsManualTargets && found.availableVersions && !found.availableVersions.includes(target)) {
     throw new UpdateSelectionError(
       `'${found.coordinate.identifier}' has no version ${target} in the configured repositories. Available: ${found.availableVersions.slice(0, 5).join(", ")}${found.availableVersions.length > 5 ? ", \u2026" : ""}.`
     );
   }
-  const diff = computeDiff(found.currentClean, target, options.ecosystem);
+  const diff = policyOf(options).diff(found.currentClean, target);
   if (diff === "major" && !options.allowMajor) {
     throw new UpdateSelectionError(
       `'${found.coordinate.identifier}' requires a major upgrade to ${target}. Pass --allow-major / allowMajor.`
@@ -4184,7 +5534,7 @@ function retarget(found, target, options) {
   const isPreRelease = isPreReleaseVersion(target);
   return {
     ...found,
-    newRange: options.ecosystem === "npm" ? `${rangePrefix(found.currentRange)}${target}` : target,
+    newRange: policyOf(options).rewrite(found.currentRange, target),
     diff,
     selected: true,
     isCustomVersion: true,
@@ -4193,7 +5543,7 @@ function retarget(found, target, options) {
   };
 }
 function manualNpmCandidate(identifier, target, options) {
-  if (!semver6.valid(target)) {
+  if (!semver12.valid(target)) {
     throw new UpdateSelectionError(`'${target}' is not a valid version for '${identifier}'.`);
   }
   return {
@@ -4210,10 +5560,8 @@ function manualNpmCandidate(identifier, target, options) {
     isCustomVersion: true
   };
 }
-function computeDiff(current, target, ecosystem) {
-  const to = ecosystem === "maven" ? cleanJavaVersion(target) : semver6.valid(target);
-  if (!to || !semver6.valid(current)) return "minor";
-  return semver6.eq(current, to) ? "patch" : diffVersions(current, to);
+function policyOf(options) {
+  return EcosystemFactory.getStrategy(options.ecosystem).versioning;
 }
 
 // src/cli/command-update.ts
@@ -4225,7 +5573,8 @@ async function handleUpdateCommand(options, config) {
     else console.error(`\u274C ${message2}`);
     return code;
   };
-  const modules = await strategy.discovery.discover(config.rootDir);
+  const { modules, diagnostics } = await discoverModules(strategy, config.rootDir);
+  for (const problem of diagnostics) console.error(`\u26A0\uFE0F  ${problem}`);
   if (modules.length === 0) return fail(`No ${strategy.displayName} modules found.`);
   const targetModule = options.module ? findModule(modules, options.module) : modules[0];
   if (!targetModule) return fail(`Module '${options.module}' not found.`);
@@ -4366,9 +5715,9 @@ function parsePackageArgument(item) {
 }
 
 // src/cli/command-init.ts
-import { existsSync as existsSync13, readFileSync as readFileSync11, writeFileSync as writeFileSync5, mkdirSync as mkdirSync2 } from "fs";
-import { homedir, platform } from "os";
-import { join as join17, resolve as resolve11 } from "path";
+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";
 function mcpServerEntry() {
   return {
     command: "npx",
@@ -4411,10 +5760,10 @@ automatic rollback.
    requested). A failed install or verification is rolled back automatically.
 4. \`elevate_verify\` \u2014 Verify build integrity when needed
 `;
-var home = homedir();
+var home = homedir2();
 var isWin = platform() === "win32";
 function appData() {
-  return process.env.APPDATA || join17(home, "AppData", "Roaming");
+  return process.env.APPDATA || join24(home, "AppData", "Roaming");
 }
 function detectCursor(cwd) {
   const env = {
@@ -4426,25 +5775,25 @@ function detectCursor(cwd) {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const workspaceCursorDir = join17(cwd, ".cursor");
-  const globalCursorDir = join17(home, ".cursor");
-  if (existsSync13(workspaceCursorDir) || existsSync13(globalCursorDir)) {
+  const workspaceCursorDir = join24(cwd, ".cursor");
+  const globalCursorDir = join24(home, ".cursor");
+  if (existsSync19(workspaceCursorDir) || existsSync19(globalCursorDir)) {
     env.detected = true;
-    env.reason = existsSync13(workspaceCursorDir) ? `Found .cursor/ in workspace` : `Found ~/.cursor/ global config`;
+    env.reason = existsSync19(workspaceCursorDir) ? `Found .cursor/ in workspace` : `Found ~/.cursor/ global config`;
   }
-  const mcpPath = join17(cwd, ".cursor", "mcp.json");
-  if (existsSync13(mcpPath)) {
+  const mcpPath = join24(cwd, ".cursor", "mcp.json");
+  if (existsSync19(mcpPath)) {
     try {
-      const content = JSON.parse(readFileSync11(mcpPath, "utf8"));
+      const content = JSON.parse(readFileSync18(mcpPath, "utf8"));
       if (content?.mcpServers?.elevate) {
         env.mcpConfigured = true;
       }
     } catch {
     }
   }
-  const rulesPath = join17(cwd, ".cursorrules");
-  if (existsSync13(rulesPath)) {
-    const content = readFileSync11(rulesPath, "utf8");
+  const rulesPath = join24(cwd, ".cursorrules");
+  if (existsSync19(rulesPath)) {
+    const content = readFileSync18(rulesPath, "utf8");
     if (content.includes("elevate") || content.includes("Elevate")) {
       env.skillConfigured = true;
     }
@@ -4461,12 +5810,12 @@ function detectClaudeDesktop() {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const configPath = isWin ? join17(appData(), "Claude", "claude_desktop_config.json") : join17(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
-  if (existsSync13(configPath)) {
+  const configPath = isWin ? join24(appData(), "Claude", "claude_desktop_config.json") : join24(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  if (existsSync19(configPath)) {
     env.detected = true;
     env.reason = `Found ${configPath}`;
     try {
-      const content = JSON.parse(readFileSync11(configPath, "utf8"));
+      const content = JSON.parse(readFileSync18(configPath, "utf8"));
       if (content?.mcpServers?.elevate) {
         env.mcpConfigured = true;
       }
@@ -4485,23 +5834,23 @@ function detectClaudeCode(cwd) {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const mcpJsonPath = join17(cwd, ".mcp.json");
-  const claudeMdPath = join17(cwd, "CLAUDE.md");
-  if (existsSync13(mcpJsonPath) || existsSync13(claudeMdPath)) {
+  const mcpJsonPath = join24(cwd, ".mcp.json");
+  const claudeMdPath = join24(cwd, "CLAUDE.md");
+  if (existsSync19(mcpJsonPath) || existsSync19(claudeMdPath)) {
     env.detected = true;
-    env.reason = existsSync13(mcpJsonPath) ? `Found .mcp.json in workspace` : `Found CLAUDE.md in workspace`;
+    env.reason = existsSync19(mcpJsonPath) ? `Found .mcp.json in workspace` : `Found CLAUDE.md in workspace`;
   }
-  if (existsSync13(mcpJsonPath)) {
+  if (existsSync19(mcpJsonPath)) {
     try {
-      const content = JSON.parse(readFileSync11(mcpJsonPath, "utf8"));
+      const content = JSON.parse(readFileSync18(mcpJsonPath, "utf8"));
       if (content?.mcpServers?.elevate) {
         env.mcpConfigured = true;
       }
     } catch {
     }
   }
-  if (existsSync13(claudeMdPath)) {
-    const content = readFileSync11(claudeMdPath, "utf8");
+  if (existsSync19(claudeMdPath)) {
+    const content = readFileSync18(claudeMdPath, "utf8");
     if (content.includes("elevate") || content.includes("Elevate")) {
       env.skillConfigured = true;
     }
@@ -4518,20 +5867,20 @@ function detectAntigravity(cwd) {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const globalGeminiDir = join17(home, ".gemini");
-  const workspaceAgentsDir = join17(cwd, ".agents");
-  if (existsSync13(globalGeminiDir) || existsSync13(workspaceAgentsDir)) {
+  const globalGeminiDir = join24(home, ".gemini");
+  const workspaceAgentsDir = join24(cwd, ".agents");
+  if (existsSync19(globalGeminiDir) || existsSync19(workspaceAgentsDir)) {
     env.detected = true;
-    env.reason = existsSync13(workspaceAgentsDir) ? `Found .agents/ in workspace` : `Found ~/.gemini/ global config`;
+    env.reason = existsSync19(workspaceAgentsDir) ? `Found .agents/ in workspace` : `Found ~/.gemini/ global config`;
   }
   const mcpPaths = [
-    join17(cwd, ".agents", "mcp_config.json"),
-    join17(home, ".gemini", "config", "mcp_config.json")
+    join24(cwd, ".agents", "mcp_config.json"),
+    join24(home, ".gemini", "config", "mcp_config.json")
   ];
   for (const p of mcpPaths) {
-    if (existsSync13(p)) {
+    if (existsSync19(p)) {
       try {
-        const content = JSON.parse(readFileSync11(p, "utf8"));
+        const content = JSON.parse(readFileSync18(p, "utf8"));
         if (content?.mcpServers?.elevate) {
           env.mcpConfigured = true;
           break;
@@ -4552,24 +5901,24 @@ function detectVSCode(cwd) {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const vscodeDir = join17(cwd, ".vscode");
-  if (existsSync13(vscodeDir)) {
+  const vscodeDir = join24(cwd, ".vscode");
+  if (existsSync19(vscodeDir)) {
     env.detected = true;
     env.reason = `Found .vscode/ in workspace`;
   }
-  const mcpPath = join17(cwd, ".vscode", "mcp.json");
-  if (existsSync13(mcpPath)) {
+  const mcpPath = join24(cwd, ".vscode", "mcp.json");
+  if (existsSync19(mcpPath)) {
     try {
-      const content = JSON.parse(readFileSync11(mcpPath, "utf8"));
+      const content = JSON.parse(readFileSync18(mcpPath, "utf8"));
       if (content?.servers?.elevate) {
         env.mcpConfigured = true;
       }
     } catch {
     }
   }
-  const copilotInstructions = join17(cwd, ".github", "copilot-instructions.md");
-  if (existsSync13(copilotInstructions)) {
-    const content = readFileSync11(copilotInstructions, "utf8");
+  const copilotInstructions = join24(cwd, ".github", "copilot-instructions.md");
+  if (existsSync19(copilotInstructions)) {
+    const content = readFileSync18(copilotInstructions, "utf8");
     if (content.includes("elevate") || content.includes("Elevate")) {
       env.skillConfigured = true;
     }
@@ -4586,14 +5935,14 @@ function detectWindsurf() {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const configPath = isWin ? join17(appData(), "Codeium", "Windsurf", "mcp_config.json") : join17(home, ".codeium", "windsurf", "mcp_config.json");
-  const altPath = join17(home, ".codeium", "windsurf", "mcp_config.json");
-  if (existsSync13(configPath) || existsSync13(altPath)) {
+  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)) {
     env.detected = true;
     env.reason = `Found Windsurf config`;
-    const path = existsSync13(configPath) ? configPath : altPath;
+    const path = existsSync19(configPath) ? configPath : altPath;
     try {
-      const content = JSON.parse(readFileSync11(path, "utf8"));
+      const content = JSON.parse(readFileSync18(path, "utf8"));
       if (content?.mcpServers?.elevate) {
         env.mcpConfigured = true;
       }
@@ -4604,9 +5953,9 @@ function detectWindsurf() {
 }
 function mergeJsonMcpServer(filePath, serverKey, topLevelKey) {
   let existing = {};
-  if (existsSync13(filePath)) {
+  if (existsSync19(filePath)) {
     try {
-      existing = JSON.parse(readFileSync11(filePath, "utf8"));
+      existing = JSON.parse(readFileSync18(filePath, "utf8"));
     } catch {
       existing = {};
     }
@@ -4618,69 +5967,69 @@ function mergeJsonMcpServer(filePath, serverKey, topLevelKey) {
   servers[serverKey] = mcpServerEntry();
   existing[topLevelKey] = servers;
   const dir = filePath.substring(0, filePath.lastIndexOf(isWin ? "\\" : "/"));
-  if (dir && !existsSync13(dir)) {
+  if (dir && !existsSync19(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
-  writeFileSync5(filePath, JSON.stringify(existing, null, 2) + "\n", "utf8");
+  writeFileSync6(filePath, JSON.stringify(existing, null, 2) + "\n", "utf8");
   return { written: true, message: `${filePath}: elevate MCP server registered` };
 }
 function appendSkillToFile(filePath, content, marker) {
-  if (existsSync13(filePath)) {
-    const existing = readFileSync11(filePath, "utf8");
+  if (existsSync19(filePath)) {
+    const existing = readFileSync18(filePath, "utf8");
     if (existing.includes(marker)) {
       return { written: false, message: `${filePath}: skill already present` };
     }
-    writeFileSync5(filePath, existing + "\n\n" + content, "utf8");
+    writeFileSync6(filePath, existing + "\n\n" + content, "utf8");
     return { written: true, message: `${filePath}: skill appended` };
   }
   const dir = filePath.substring(0, filePath.lastIndexOf(isWin ? "\\" : "/"));
-  if (dir && !existsSync13(dir)) {
+  if (dir && !existsSync19(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
-  writeFileSync5(filePath, content, "utf8");
+  writeFileSync6(filePath, content, "utf8");
   return { written: true, message: `${filePath}: skill created` };
 }
 function configureCursor(cwd, result) {
-  const mcpPath = join17(cwd, ".cursor", "mcp.json");
+  const mcpPath = join24(cwd, ".cursor", "mcp.json");
   const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Cursor MCP: ${mcp.message}`);
-  const rulesPath = join17(cwd, ".cursorrules");
+  const rulesPath = join24(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 ? join17(appData(), "Claude", "claude_desktop_config.json") : join17(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  const configPath = isWin ? join24(appData(), "Claude", "claude_desktop_config.json") : join24(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 = join17(cwd, ".mcp.json");
+  const mcpPath = join24(cwd, ".mcp.json");
   const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Claude Code MCP: ${mcp.message}`);
-  const claudeMdPath = join17(cwd, "CLAUDE.md");
+  const claudeMdPath = join24(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 = join17(cwd, ".agents", "mcp_config.json");
+  const mcpPath = join24(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 = join17(cwd, ".vscode", "mcp.json");
+  const mcpPath = join24(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 = join17(cwd, ".github", "copilot-instructions.md");
+  const instructionsPath = join24(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 ? join17(appData(), "Codeium", "Windsurf", "mcp_config.json") : join17(home, ".codeium", "windsurf", "mcp_config.json");
+  const configPath = isWin ? join24(appData(), "Codeium", "Windsurf", "mcp_config.json") : join24(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 = resolve11(process.cwd());
+  const cwd = resolve15(process.cwd());
   const result = {
     cwd,
     environments: [],
@@ -4708,7 +6057,7 @@ async function handleInitCommand(options) {
       console.log(`  Creating portable .mcp.json for broad compatibility.
 `);
     }
-    const mcpPath = join17(cwd, ".mcp.json");
+    const mcpPath = join24(cwd, ".mcp.json");
     const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
     result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Generic MCP: ${mcp.message}`);
   } else {
@@ -4775,14 +6124,14 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 var ECOSYSTEM_PROPERTY = {
   type: "string",
-  enum: ["npm", "maven"],
+  enum: EcosystemFactory.getAvailableEcosystems(),
   description: "Target ecosystem (default: npm)"
 };
 async function startMcpServer(config) {
   const server = new Server(
     {
       name: "elevate-mcp",
-      version: "1.2.0"
+      version: VERSION
     },
     {
       capabilities: {
@@ -4795,7 +6144,7 @@ async function startMcpServer(config) {
       tools: [
         {
           name: "elevate_discover_modules",
-          description: "Discovers all repository modules and workspaces for Node/npm (package.json) or Java/Maven (pom.xml).",
+          description: "Discovers all repository modules and workspaces for Node/npm (package.json), Java/Maven (pom.xml) or Rust/Cargo (Cargo.toml).",
           inputSchema: {
             type: "object",
             properties: {
@@ -4835,7 +6184,7 @@ async function startMcpServer(config) {
               ecosystem: ECOSYSTEM_PROPERTY,
               identifier: {
                 type: "string",
-                description: "Package identifier (npm: chalk, maven: org.slf4j:slf4j-api)"
+                description: "Package identifier (npm: chalk, maven: org.slf4j:slf4j-api, cargo: serde)"
               }
             },
             required: ["identifier"]
@@ -4916,10 +6265,13 @@ async function startMcpServer(config) {
     };
     try {
       if (name === "elevate_discover_modules") {
-        const modules = await strategy.discovery.discover(config.rootDir);
+        const { modules, diagnostics } = await discoverModules(strategy, config.rootDir);
+        const packageManager = strategy.packageManagerFor?.(config.rootDir);
         return reply({
           ecosystem,
+          ...packageManager ? { packageManager } : {},
           count: modules.length,
+          diagnostics,
           modules: modules.map((m) => ({
             id: m.id,
             name: m.name,