depfresh 0.9.2

package/dist/shared/depfresh.ClIHCCxD.mjs

@@ -0,0 +1,1938 @@
+import c from 'ansis';
+import { C as CacheError, a as ConfigError, c as createLogger, R as RegistryError, b as ResolveError, W as WriteError } from './depfresh.B1o7OHO_.mjs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { findUpSync } from 'find-up-simple';
+import { parse } from 'ini';
+import { join, dirname, resolve } from 'pathe';
+import { execSync } from 'node:child_process';
+import detectIndent from 'detect-indent';
+import * as semver from 'semver';
+import { parsePnpmWorkspaceYaml } from 'pnpm-workspace-yaml';
+import YAML from 'yaml';
+import pLimit from 'p-limit';
+import Database from 'better-sqlite3';
+import { glob } from 'tinyglobby';
+
+function detectPackageManager(cwd, packages) {
+  for (const pkg of packages) {
+    if (pkg.packageManager?.name) {
+      return pkg.packageManager.name;
+    }
+  }
+  if (existsSync(join(cwd, "bun.lock")) || existsSync(join(cwd, "bun.lockb"))) return "bun";
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+async function runInstall(cwd, packages, logger) {
+  const pm = detectPackageManager(cwd, packages);
+  try {
+    logger.info(`Running ${pm} install...`);
+    execSync(`${pm} install`, { cwd, stdio: "inherit" });
+  } catch {
+    logger.error(`${pm} install failed`);
+  }
+}
+async function runUpdate(cwd, packages, logger) {
+  const pm = detectPackageManager(cwd, packages);
+  try {
+    logger.info(`Running ${pm} update...`);
+    execSync(`${pm} update`, { cwd, stdio: "inherit" });
+  } catch {
+    logger.error(`${pm} update failed`);
+  }
+}
+
+const CACHE_DIR = join(homedir(), ".depzy");
+const CACHE_DB = join(CACHE_DIR, "cache.db");
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS registry_cache (
+    package TEXT NOT NULL,
+    data TEXT NOT NULL,
+    fetched_at INTEGER NOT NULL,
+    expires_at INTEGER NOT NULL,
+    PRIMARY KEY (package)
+  )
+`;
+const INDEX = `CREATE INDEX IF NOT EXISTS idx_expires ON registry_cache(expires_at)`;
+function createSqliteCache() {
+  mkdirSync(CACHE_DIR, { recursive: true });
+  let db;
+  try {
+    db = new Database(CACHE_DB);
+  } catch {
+    return createMemoryFallback();
+  }
+  try {
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA synchronous = NORMAL");
+    db.exec(SCHEMA);
+    db.exec(INDEX);
+  } catch {
+    db.close();
+    return createMemoryFallback();
+  }
+  const getStmt = db.prepare("SELECT data FROM registry_cache WHERE package = ? AND expires_at > ?");
+  const setStmt = db.prepare(
+    "INSERT OR REPLACE INTO registry_cache (package, data, fetched_at, expires_at) VALUES (?, ?, ?, ?)"
+  );
+  const hasStmt = db.prepare("SELECT 1 FROM registry_cache WHERE package = ? AND expires_at > ?");
+  const clearStmt = db.prepare("DELETE FROM registry_cache");
+  const countStmt = db.prepare("SELECT COUNT(*) as count FROM registry_cache WHERE expires_at > ?");
+  const pruneStmt = db.prepare("DELETE FROM registry_cache WHERE expires_at <= ?");
+  const deleteStmt = db.prepare("DELETE FROM registry_cache WHERE package = ?");
+  let hits = 0;
+  let misses = 0;
+  pruneStmt.run(Date.now());
+  return {
+    get(key) {
+      let row;
+      try {
+        row = getStmt.get(key, Date.now());
+      } catch (error) {
+        throw new CacheError(`Failed to read cache entry for ${key}`, { cause: error });
+      }
+      if (row) {
+        try {
+          const parsed = JSON.parse(row.data);
+          hits++;
+          return parsed;
+        } catch {
+          deleteStmt.run(key);
+          misses++;
+          return void 0;
+        }
+      }
+      misses++;
+      return void 0;
+    },
+    set(key, data, ttl) {
+      const now = Date.now();
+      try {
+        setStmt.run(key, JSON.stringify(data), now, now + ttl);
+      } catch (error) {
+        throw new CacheError(`Failed to write cache entry for ${key}`, { cause: error });
+      }
+    },
+    has(key) {
+      try {
+        return !!hasStmt.get(key, Date.now());
+      } catch (error) {
+        throw new CacheError(`Failed to check cache entry for ${key}`, { cause: error });
+      }
+    },
+    clear() {
+      try {
+        clearStmt.run();
+      } catch (error) {
+        throw new CacheError("Failed to clear cache", { cause: error });
+      }
+    },
+    close() {
+      try {
+        db.close();
+      } catch (error) {
+        throw new CacheError("Failed to close cache database", { cause: error });
+      }
+    },
+    stats() {
+      let row;
+      try {
+        row = countStmt.get(Date.now());
+      } catch (error) {
+        throw new CacheError("Failed to read cache stats", { cause: error });
+      }
+      return { hits, misses, size: row.count };
+    }
+  };
+}
+function createMemoryFallback() {
+  const store = /* @__PURE__ */ new Map();
+  let hits = 0;
+  let misses = 0;
+  return {
+    get(key) {
+      const entry = store.get(key);
+      if (entry && entry.expiresAt > Date.now()) {
+        hits++;
+        return entry.data;
+      }
+      if (entry) store.delete(key);
+      misses++;
+      return void 0;
+    },
+    set(key, data, ttl) {
+      store.set(key, { data, expiresAt: Date.now() + ttl });
+    },
+    has(key) {
+      const entry = store.get(key);
+      return !!entry && entry.expiresAt > Date.now();
+    },
+    clear() {
+      store.clear();
+    },
+    close() {
+      store.clear();
+    },
+    stats() {
+      return { hits, misses, size: store.size };
+    }
+  };
+}
+
+async function loadCatalogs(cwd, options) {
+  const catalogs = [];
+  const loaders = await Promise.all([
+    Promise.resolve().then(function () { return pnpm; }).then((m) => m.pnpmCatalogLoader),
+    Promise.resolve().then(function () { return bun; }).then((m) => m.bunCatalogLoader),
+    Promise.resolve().then(function () { return yarn; }).then((m) => m.yarnCatalogLoader)
+  ]);
+  const detected = await Promise.all(
+    loaders.map(async (loader) => {
+      if (await loader.detect(cwd)) {
+        return loader.load(cwd, options);
+      }
+      return [];
+    })
+  );
+  for (const result of detected) {
+    catalogs.push(...result);
+  }
+  return catalogs;
+}
+
+const PREFIX_RE = /^(\^|~|>=?|<=?|=)?/;
+function getVersionPrefix(version) {
+  const match = version.match(PREFIX_RE);
+  return match?.[1] ?? "";
+}
+function isRange(version) {
+  return /[~^>=<|*x ]/.test(version);
+}
+function isLocked(version) {
+  return !isRange(version) && !!semver.valid(version);
+}
+function getMaxSatisfying(versions, range) {
+  const valid = versions.filter((v) => semver.satisfies(v, range));
+  if (valid.length === 0) return null;
+  return valid.reduce((max, v) => semver.gt(v, max) ? v : max, valid[0]);
+}
+function getMaxVersion(versions) {
+  if (versions.length === 0) return null;
+  return versions.reduce((max, v) => semver.gt(v, max) ? v : max, versions[0]);
+}
+function getDiff(current, target) {
+  const c = semver.coerce(current);
+  const t = semver.coerce(target);
+  if (!(c && t)) return "error";
+  if (semver.eq(c, t)) return "none";
+  const diff = semver.diff(c, t);
+  if (!diff) return "none";
+  if (diff.startsWith("major") || diff === "premajor") return "major";
+  if (diff.startsWith("minor") || diff === "preminor") return "minor";
+  if (diff.startsWith("patch") || diff === "prepatch" || diff === "prerelease") return "patch";
+  return "patch";
+}
+function applyVersionPrefix(version, prefix) {
+  if (!prefix) return version;
+  return `${prefix}${version}`;
+}
+function resolveTargetVersion(currentVersion, versions, distTags, mode) {
+  switch (mode) {
+    case "latest":
+      return distTags.latest ?? null;
+    case "newest": {
+      return getMaxVersion(versions);
+    }
+    case "next":
+      return distTags.next ?? distTags.latest ?? null;
+    case "major":
+      return getMaxVersion(versions);
+    case "minor": {
+      const current = semver.coerce(currentVersion);
+      if (!current) return null;
+      const minor = versions.filter((v) => {
+        const parsed = semver.parse(v);
+        return parsed && parsed.major === current.major;
+      });
+      return getMaxVersion(minor);
+    }
+    case "patch": {
+      const current = semver.coerce(currentVersion);
+      if (!current) return null;
+      const patch = versions.filter((v) => {
+        const parsed = semver.parse(v);
+        return parsed && parsed.major === current.major && parsed.minor === current.minor;
+      });
+      return getMaxVersion(patch);
+    }
+    default:
+      return getMaxSatisfying(versions, currentVersion) ?? distTags.latest ?? null;
+  }
+}
+
+function parseProtocol(version) {
+  const npmMatch = version.match(/^npm:(.+)@(.+)$/);
+  if (npmMatch) {
+    return { protocol: "npm", currentVersion: npmMatch[2] };
+  }
+  const jsrMatch = version.match(/^jsr:(.+)@(.+)$/);
+  if (jsrMatch) {
+    return { protocol: "jsr", currentVersion: jsrMatch[2] };
+  }
+  return { currentVersion: version };
+}
+
+function parseOverrideKey(key) {
+  if (key.startsWith("@")) {
+    const secondAt = key.indexOf("@", 1);
+    if (secondAt !== -1) {
+      return key.slice(0, secondAt);
+    }
+    return key;
+  }
+  const atIndex = key.indexOf("@");
+  if (atIndex !== -1) {
+    return key.slice(0, atIndex);
+  }
+  return key;
+}
+function getNestedField(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (!current || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function flattenOverrides(obj, source, deps, options, parents, includePatterns, excludePatterns, skipFn) {
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === "string") {
+      const name = parseOverrideKey(key);
+      if (skipFn(name, value, options, includePatterns, excludePatterns)) continue;
+      const protocol = parseProtocol(value);
+      deps.push({
+        name,
+        currentVersion: protocol.currentVersion,
+        source,
+        update: !isLocked(protocol.currentVersion) || options.includeLocked,
+        parents: [...parents, key],
+        protocol: protocol.protocol
+      });
+    } else if (typeof value === "object" && value !== null) {
+      flattenOverrides(
+        value,
+        source,
+        deps,
+        options,
+        [...parents, key],
+        includePatterns,
+        excludePatterns,
+        skipFn
+      );
+    }
+  }
+}
+
+function isGlob(pattern) {
+  return pattern.includes("*") && !/[\^$[\]()\\|+?]/.test(pattern);
+}
+function patternToRegex(pattern) {
+  const slashMatch = pattern.match(/^\/(.+)\/([gimsuy]*)$/);
+  if (slashMatch) {
+    return new RegExp(slashMatch[1], slashMatch[2]);
+  }
+  if (isGlob(pattern)) {
+    const escaped = pattern.replace(/[.@/]/g, "\\$&").replace(/\*/g, "[^/]*");
+    return new RegExp(`^${escaped}$`);
+  }
+  return new RegExp(pattern);
+}
+function compilePatternsStrict(patterns) {
+  const compiled = [];
+  for (const p of patterns) {
+    try {
+      compiled.push(patternToRegex(p));
+    } catch (error) {
+      throw new ConfigError(`Invalid dependency filter pattern: ${p}`, { cause: error });
+    }
+  }
+  return compiled;
+}
+
+const DEP_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+const OVERRIDE_FIELDS = ["overrides", "resolutions", "pnpm.overrides"];
+function isDepFieldEnabled(field, options) {
+  if (options.depFields?.[field] === false) return false;
+  if (field === "peerDependencies" && !options.peer) return false;
+  return true;
+}
+function shouldSkipDependency(name, version, options, includePatterns = [], excludePatterns = []) {
+  if (version.startsWith("workspace:") && !options.includeWorkspace) return true;
+  if (version.startsWith("catalog:")) return true;
+  if (/^(link|file|git|github|https?):/.test(version)) return true;
+  if (includePatterns.length && !includePatterns.some((re) => re.test(name))) {
+    return true;
+  }
+  if (excludePatterns.length && excludePatterns.some((re) => re.test(name))) {
+    return true;
+  }
+  return false;
+}
+function parseDependencies(raw, options) {
+  const deps = [];
+  const includePatterns = options.include?.length ? compilePatternsStrict(options.include) : [];
+  const excludePatterns = options.exclude?.length ? compilePatternsStrict(options.exclude) : [];
+  for (const field of DEP_FIELDS) {
+    if (!isDepFieldEnabled(field, options)) continue;
+    const section = raw[field];
+    if (!section || typeof section !== "object") continue;
+    for (const [name, version] of Object.entries(section)) {
+      if (shouldSkipDependency(name, version, options, includePatterns, excludePatterns)) continue;
+      const protocol = parseProtocol(version);
+      deps.push({
+        name,
+        currentVersion: protocol.currentVersion,
+        source: field,
+        update: !isLocked(protocol.currentVersion) || options.includeLocked,
+        parents: [],
+        protocol: protocol.protocol
+      });
+    }
+  }
+  for (const field of OVERRIDE_FIELDS) {
+    if (!isDepFieldEnabled(field, options)) continue;
+    const section = getNestedField(raw, field);
+    if (!section || typeof section !== "object") continue;
+    flattenOverrides(
+      section,
+      field,
+      deps,
+      options,
+      [],
+      includePatterns,
+      excludePatterns,
+      shouldSkipDependency
+    );
+  }
+  return deps;
+}
+
+function parsePackageManagerField(raw) {
+  const match = raw.match(/^(npm|pnpm|yarn|bun)@([^+]+)(?:\+(.+))?$/);
+  if (!match) return void 0;
+  return {
+    name: match[1],
+    version: match[2],
+    hash: match[3],
+    raw
+  };
+}
+
+function belongsToNestedWorkspace(filepath, rootDir) {
+  const pkgDir = dirname(filepath);
+  const normalizedRoot = resolve(rootDir);
+  if (resolve(pkgDir) === normalizedRoot) return false;
+  const pnpmWs = findUpSync("pnpm-workspace.yaml", { cwd: pkgDir, stopAt: normalizedRoot });
+  if (pnpmWs && resolve(dirname(pnpmWs)) !== normalizedRoot) return true;
+  const yarnRc = findUpSync(".yarnrc.yml", { cwd: pkgDir, stopAt: normalizedRoot });
+  if (yarnRc && resolve(dirname(yarnRc)) !== normalizedRoot) return true;
+  try {
+    const content = JSON.parse(readFileSync(filepath, "utf-8"));
+    if (content.workspaces) return true;
+  } catch {
+  }
+  const parentDir = dirname(pkgDir);
+  if (resolve(parentDir) !== normalizedRoot) {
+    const nestedPkg = findUpSync("package.json", { cwd: parentDir, stopAt: normalizedRoot });
+    if (nestedPkg && resolve(dirname(nestedPkg)) !== normalizedRoot) {
+      try {
+        const content = JSON.parse(readFileSync(nestedPkg, "utf-8"));
+        if (content.workspaces) return true;
+      } catch {
+      }
+    }
+  }
+  const gitDir = findUpSync(".git", {
+    cwd: pkgDir,
+    stopAt: normalizedRoot,
+    type: "directory"
+  });
+  if (gitDir && resolve(dirname(gitDir)) !== normalizedRoot) return true;
+  return false;
+}
+
+async function loadPackages(options) {
+  const logger = createLogger(options.loglevel);
+  if (options.global) {
+    const { loadGlobalPackages } = await import('../chunks/index3.mjs').then(function (n) { return n.g; });
+    const packages2 = loadGlobalPackages();
+    logger.info(
+      `Found ${packages2.length} packages with ${packages2.reduce((sum, p) => sum + p.deps.length, 0)} dependencies`
+    );
+    return packages2;
+  }
+  const packages = [];
+  let jsonFiles = await glob(["**/package.json"], {
+    cwd: options.cwd,
+    ignore: options.ignorePaths,
+    absolute: true
+  });
+  if (options.ignoreOtherWorkspaces) {
+    const rootDir = resolve(options.cwd);
+    const before = jsonFiles.length;
+    jsonFiles = jsonFiles.filter((f) => !belongsToNestedWorkspace(f, rootDir));
+    const skipped = before - jsonFiles.length;
+    if (skipped > 0) {
+      logger.debug(`Skipped ${skipped} package(s) from nested workspaces`);
+    }
+  }
+  for (const filepath of jsonFiles) {
+    try {
+      const content = readFileSync(filepath, "utf-8");
+      const raw = JSON.parse(content);
+      const indent = detectIndent(content).indent || "  ";
+      const deps = parseDependencies(raw, options);
+      const meta = {
+        name: raw.name ?? dirname(filepath),
+        type: "package.json",
+        filepath,
+        deps,
+        resolved: [],
+        raw,
+        indent
+      };
+      if (raw.packageManager && typeof raw.packageManager === "string") {
+        meta.packageManager = parsePackageManagerField(raw.packageManager);
+      }
+      packages.push(meta);
+      logger.debug(`Loaded ${filepath} (${deps.length} deps)`);
+    } catch (error) {
+      logger.warn(`Failed to load ${filepath}:`, error);
+    }
+  }
+  try {
+    const catalogs = await loadCatalogs(options.cwd, options);
+    for (const catalog of catalogs) {
+      const catalogTypeName = catalog.type === "pnpm" ? "pnpm-workspace" : catalog.type === "bun" ? "bun-workspace" : "yarn-workspace";
+      const displayName = catalog.name === "default" ? `${catalog.type} catalog` : `${catalog.type} catalog:${catalog.name}`;
+      packages.push({
+        name: displayName,
+        type: catalogTypeName,
+        filepath: catalog.filepath,
+        deps: catalog.deps,
+        resolved: [],
+        raw: catalog.raw,
+        indent: catalog.indent,
+        catalogs: [catalog]
+      });
+      logger.debug(`Loaded catalog ${displayName} (${catalog.deps.length} deps)`);
+    }
+  } catch (error) {
+    logger.warn("Failed to load workspace catalogs:", error);
+  }
+  logger.info(
+    `Found ${packages.length} packages with ${packages.reduce((sum, p) => sum + p.deps.length, 0)} dependencies`
+  );
+  return packages;
+}
+
+const DEFAULT_REGISTRY = "https://registry.npmjs.org/";
+function loadNpmrc(cwd) {
+  const config = {
+    registries: /* @__PURE__ */ new Map(),
+    defaultRegistry: DEFAULT_REGISTRY,
+    strictSsl: true
+  };
+  const globalPath = process.env.npm_config_userconfig || join(homedir(), ".npmrc");
+  const projectFile = findUpSync(".npmrc", { cwd });
+  loadNpmrcFile(globalPath, config);
+  if (projectFile) {
+    loadNpmrcFile(projectFile, config);
+  }
+  applyEnvOverrides(config);
+  return config;
+}
+function loadNpmrcFile(filepath, config) {
+  let content;
+  try {
+    content = readFileSync(filepath, "utf-8");
+  } catch {
+    return;
+  }
+  const parsed = parse(content);
+  for (const [key, value] of Object.entries(parsed)) {
+    if (key === "registry" && typeof value === "string") {
+      config.defaultRegistry = ensureTrailingSlash(value);
+      continue;
+    }
+    if (key === "proxy" && typeof value === "string") {
+      config.proxy = value;
+      continue;
+    }
+    if (key === "https-proxy" && typeof value === "string") {
+      config.httpsProxy = value;
+      continue;
+    }
+    if (key === "strict-ssl" && typeof value === "string") {
+      config.strictSsl = value !== "false";
+      continue;
+    }
+    if (key === "cafile" && typeof value === "string") {
+      config.cafile = resolve(filepath, "..", value);
+      continue;
+    }
+    const scopedMatch = key.match(/^(@[^:]+):registry$/);
+    if (scopedMatch && typeof value === "string") {
+      const scope = scopedMatch[1];
+      const url = ensureTrailingSlash(value);
+      const existing = config.registries.get(scope) ?? { url };
+      existing.url = url;
+      config.registries.set(scope, existing);
+      continue;
+    }
+    const tokenMatch = key.match(/^\/\/(.+)\/:_authToken$/);
+    if (tokenMatch && typeof value === "string") {
+      const host = tokenMatch[1];
+      for (const [_scope, reg] of config.registries) {
+        if (reg.url.includes(host)) {
+          reg.token = value;
+          reg.authType = "bearer";
+        }
+      }
+      if (config.defaultRegistry.includes(host)) {
+        const defaultReg = config.registries.get("default") ?? {
+          url: config.defaultRegistry
+        };
+        defaultReg.token = value;
+        defaultReg.authType = "bearer";
+        config.registries.set("default", defaultReg);
+      }
+    }
+  }
+}
+function applyEnvOverrides(config) {
+  const envRegistry = process.env.npm_config_registry || process.env.NPM_CONFIG_REGISTRY;
+  if (envRegistry) {
+    config.defaultRegistry = ensureTrailingSlash(envRegistry);
+  }
+  const envProxy = process.env.npm_config_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
+  if (envProxy) {
+    config.proxy = envProxy;
+  }
+  const envHttpsProxy = process.env.npm_config_https_proxy || process.env.HTTPS_PROXY || process.env.https_proxy;
+  if (envHttpsProxy) {
+    config.httpsProxy = envHttpsProxy;
+  }
+}
+function getRegistryForPackage(name, config) {
+  const scopeMatch = name.match(/^(@[^/]+)\//);
+  if (scopeMatch) {
+    const scoped = config.registries.get(scopeMatch[1]);
+    if (scoped) return scoped;
+  }
+  const defaultReg = config.registries.get("default");
+  if (defaultReg) return defaultReg;
+  return { url: config.defaultRegistry };
+}
+function ensureTrailingSlash(url) {
+  return url.endsWith("/") ? url : `${url}/`;
+}
+
+function buildJsonPackage(name, updates) {
+  return {
+    name,
+    updates: updates.map((u) => ({
+      name: u.name,
+      current: u.currentVersion,
+      target: u.targetVersion,
+      diff: u.diff,
+      source: u.source,
+      ...u.deprecated ? { deprecated: u.deprecated } : {},
+      ...u.publishedAt ? { publishedAt: u.publishedAt } : {},
+      ...u.currentVersionTime ? { currentVersionTime: u.currentVersionTime } : {}
+    }))
+  };
+}
+function outputJsonEnvelope(packages, options) {
+  const allUpdates = packages.flatMap((p) => p.updates);
+  const count = (diff) => allUpdates.filter((u) => u.diff === diff).length;
+  const output = {
+    packages,
+    summary: {
+      total: allUpdates.length,
+      major: count("major"),
+      minor: count("minor"),
+      patch: count("patch"),
+      packages: packages.length
+    },
+    meta: {
+      cwd: options.cwd,
+      mode: options.mode,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  console.log(JSON.stringify(output, null, 2));
+}
+
+async function runExecute(command, cwd, logger) {
+  try {
+    logger.info(`Running: ${command}`);
+    execSync(command, { cwd, stdio: "inherit" });
+  } catch {
+    logger.error(`Command failed: ${command}`);
+  }
+}
+function renderUpToDate(packageName) {
+  const log = console.log;
+  log();
+  log(c.cyan.bold(packageName));
+  log(`  ${c.green("All dependencies are up to date")}`);
+  log();
+}
+async function selectInteractiveUpdates(updates, explain) {
+  const { runInteractive } = await import('../chunks/interactive.mjs');
+  return runInteractive(updates, { explain });
+}
+
+function getPackageMode(packageName, packageMode, defaultMode) {
+  if (!packageMode) return defaultMode;
+  if (packageMode[packageName]) {
+    return packageMode[packageName];
+  }
+  for (const [pattern, mode] of Object.entries(packageMode)) {
+    if (pattern === packageName) continue;
+    try {
+      const regex = patternToRegex(pattern);
+      if (regex.test(packageName)) {
+        return mode;
+      }
+    } catch {
+    }
+  }
+  return defaultMode;
+}
+
+async function fetchPackageData(name, options) {
+  const registry = getRegistryForPackage(name, options.npmrc);
+  if (name.startsWith("jsr:")) {
+    return fetchJsrPackage(name.slice(4), options);
+  }
+  return fetchNpmPackage(name, registry, options);
+}
+async function fetchNpmPackage(name, registry, options) {
+  const encodedName = name.startsWith("@") ? `@${encodeURIComponent(name.slice(1))}` : encodeURIComponent(name);
+  const url = `${registry.url}${encodedName}`;
+  const headers = {
+    accept: "application/vnd.npm.install-v1+json"
+  };
+  if (registry.token) {
+    headers.authorization = registry.authType === "basic" ? `Basic ${registry.token}` : `Bearer ${registry.token}`;
+  }
+  const json = await fetchWithRetry(url, headers, options);
+  const versionsObj = json.versions ?? {};
+  const versions = Object.keys(versionsObj).filter((v) => semver.valid(v));
+  const distTags = json["dist-tags"] ?? {};
+  const time = json.time ?? {};
+  const deprecated = {};
+  const provenance = {};
+  const engines = {};
+  for (const [ver, data] of Object.entries(versionsObj)) {
+    if (data.deprecated) {
+      deprecated[ver] = String(data.deprecated);
+    }
+    provenance[ver] = data.hasSignatures ? "attested" : "none";
+    const enginesObj = data.engines;
+    if (enginesObj?.node) {
+      engines[ver] = enginesObj.node;
+    }
+  }
+  return {
+    name,
+    versions,
+    distTags,
+    time,
+    deprecated: Object.keys(deprecated).length > 0 ? deprecated : void 0,
+    provenance: Object.keys(provenance).length > 0 ? provenance : void 0,
+    engines: Object.keys(engines).length > 0 ? engines : void 0,
+    description: json.description,
+    homepage: json.homepage,
+    repository: typeof json.repository === "string" ? json.repository : json.repository?.url
+  };
+}
+async function fetchJsrPackage(name, options) {
+  const url = `https://jsr.io/${name}/meta.json`;
+  const json = await fetchWithRetry(url, {}, options);
+  const versionsObj = json.versions ?? {};
+  const versions = Object.keys(versionsObj);
+  const latest = json.latest ?? versions[versions.length - 1] ?? "";
+  return {
+    name: `jsr:${name}`,
+    versions,
+    distTags: { latest }
+  };
+}
+async function fetchWithRetry(url, headers, options, attempt = 0) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeout);
+  try {
+    const response = await fetch(url, {
+      headers,
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new RegistryError(
+        `HTTP ${response.status}: ${response.statusText} for ${url}`,
+        response.status,
+        url
+      );
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof RegistryError && error.status >= 400 && error.status < 500) {
+      throw error;
+    }
+    if (attempt < options.retries) {
+      const delay = Math.min(1e3 * 2 ** attempt, 5e3);
+      options.logger.debug(`Retry ${attempt + 1}/${options.retries} for ${url} in ${delay}ms`);
+      await sleep(delay);
+      return fetchWithRetry(url, headers, options, attempt + 1);
+    }
+    if (error instanceof RegistryError) {
+      throw error;
+    }
+    if (error instanceof ResolveError) {
+      throw error;
+    }
+    if (isAbortError(error)) {
+      throw new ResolveError(`Request timeout after ${options.timeout}ms for ${url}`, {
+        cause: error
+      });
+    }
+    const causeMessage = error instanceof Error ? `: ${error.message}` : "";
+    throw new ResolveError(`Network failure while fetching ${url}${causeMessage}`, { cause: error });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function isAbortError(error) {
+  if (!error || typeof error !== "object") return false;
+  const named = error;
+  return named.name === "AbortError";
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function filterVersions(pkgData, dep, options) {
+  const currentPrerelease = semver.prerelease(dep.currentVersion);
+  const currentChannel = currentPrerelease?.[0];
+  let filtered = pkgData.versions.filter((v) => {
+    if (pkgData.deprecated?.[v] && !pkgData.deprecated?.[dep.currentVersion]) {
+      return false;
+    }
+    const vPrerelease = semver.prerelease(v);
+    if (vPrerelease?.length && !currentPrerelease?.length) {
+      return false;
+    }
+    if (vPrerelease?.length && currentPrerelease?.length) {
+      const vChannel = vPrerelease[0];
+      if (typeof currentChannel === "string" && typeof vChannel === "string") {
+        if (vChannel !== currentChannel) {
+          return false;
+        }
+      }
+    }
+    return true;
+  });
+  if (options?.cooldown && options.cooldown > 0) {
+    filtered = filterVersionsByMaturityPeriod(filtered, pkgData.time, options.cooldown);
+  }
+  return filtered;
+}
+function filterVersionsByMaturityPeriod(versions, time, days) {
+  if (!time || days <= 0) return versions;
+  const cutoff = Date.now() - days * 864e5;
+  const filtered = versions.filter((v) => {
+    const published = time[v];
+    if (!published) return true;
+    return new Date(published).getTime() <= cutoff;
+  });
+  return filtered.length > 0 ? filtered : versions;
+}
+
+async function resolveDependency(dep, options, cache, npmrc, logger, privatePackages) {
+  const packageName = dep.aliasName ?? dep.name;
+  if (privatePackages?.has(packageName)) {
+    logger.debug(`Skipping private workspace package: ${packageName}`);
+    return null;
+  }
+  const mode = getPackageMode(packageName, options.packageMode, options.mode);
+  if (mode === "ignore") {
+    logger.debug(`Ignoring ${packageName} (mode: ignore)`);
+    return null;
+  }
+  let pkgData = cache.get(packageName);
+  if (!pkgData) {
+    try {
+      pkgData = await fetchPackageData(packageName, {
+        npmrc,
+        timeout: options.timeout,
+        retries: options.retries,
+        logger
+      });
+      cache.set(packageName, pkgData, options.cacheTTL);
+    } catch (error) {
+      logger.debug(`Failed to fetch ${packageName}: ${error}`);
+      return {
+        ...dep,
+        targetVersion: dep.currentVersion,
+        diff: "error",
+        pkgData: { name: packageName, versions: [], distTags: {} }
+      };
+    }
+  }
+  const versions = filterVersions(pkgData, dep, options);
+  const targetVersion = resolveTargetVersion(dep.currentVersion, versions, pkgData.distTags, mode);
+  if (!targetVersion) {
+    return null;
+  }
+  const prefix = getVersionPrefix(dep.currentVersion);
+  const prefixedTarget = applyVersionPrefix(targetVersion, prefix);
+  const diff = getDiff(dep.currentVersion, targetVersion);
+  if (diff === "none" && !options.force) {
+    return null;
+  }
+  const cleanCurrent = semver.coerce(dep.currentVersion)?.version ?? void 0;
+  const currentProvenance = cleanCurrent ? pkgData.provenance?.[cleanCurrent] : void 0;
+  const targetProvenance = pkgData.provenance?.[targetVersion];
+  const nodeCompat = pkgData.engines?.[targetVersion];
+  const nodeCompatible = nodeCompat ? semver.satisfies(process.version, nodeCompat) : void 0;
+  return {
+    ...dep,
+    targetVersion: prefixedTarget,
+    diff,
+    pkgData,
+    deprecated: pkgData.deprecated?.[targetVersion],
+    latestVersion: pkgData.distTags.latest,
+    publishedAt: pkgData.time?.[targetVersion],
+    currentVersionTime: cleanCurrent ? pkgData.time?.[cleanCurrent] : void 0,
+    provenance: targetProvenance,
+    currentProvenance,
+    nodeCompat,
+    nodeCompatible
+  };
+}
+
+async function resolvePackage(pkg, options, externalCache, externalNpmrc, privatePackages, onDependencyProcessed) {
+  const logger = createLogger(options.loglevel);
+  const npmrc = externalNpmrc ?? loadNpmrc(options.cwd);
+  const cache = externalCache ?? createSqliteCache();
+  const ownCache = !externalCache;
+  const limit = pLimit(options.concurrency);
+  try {
+    const results = await Promise.allSettled(
+      pkg.deps.filter((dep) => dep.update).map(
+        (dep) => limit(async () => {
+          try {
+            return await resolveDependency(dep, options, cache, npmrc, logger, privatePackages);
+          } finally {
+            await onDependencyProcessed?.(pkg, dep);
+          }
+        })
+      )
+    );
+    const resolved = [];
+    for (const result of results) {
+      if (result.status === "fulfilled" && result.value) {
+        resolved.push(result.value);
+        options.onDependencyResolved?.(pkg, result.value);
+      } else if (result.status === "rejected") {
+        logger.debug(`Resolution failed: ${result.reason}`);
+      }
+    }
+    return resolved;
+  } finally {
+    if (ownCache) {
+      const stats = cache.stats();
+      cache.close();
+      logger.debug(`Cache stats: ${stats.hits} hits, ${stats.misses} misses, ${stats.size} entries`);
+    }
+  }
+}
+
+function parseCatalogDeps(catalog, parentPath, options) {
+  const deps = [];
+  for (const [name, version] of Object.entries(catalog)) {
+    deps.push({
+      name,
+      currentVersion: version,
+      source: "catalog",
+      update: !isLocked(version) || options.includeLocked,
+      parents: [parentPath]
+    });
+  }
+  return deps;
+}
+const bunCatalogLoader = {
+  async detect(cwd) {
+    const pkgPath = join(cwd, "package.json");
+    if (!existsSync(pkgPath)) return false;
+    try {
+      const raw = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      return !!raw.workspaces?.catalog || !!raw.workspaces?.catalogs;
+    } catch {
+      return false;
+    }
+  },
+  async load(cwd, options) {
+    const filepath = join(cwd, "package.json");
+    const content = readFileSync(filepath, "utf-8");
+    const raw = JSON.parse(content);
+    const indent = detectIndent(content).indent || "  ";
+    const sources = [];
+    if (raw.workspaces?.catalog) {
+      const catalog = raw.workspaces.catalog;
+      sources.push({
+        type: "bun",
+        name: "default",
+        filepath,
+        deps: parseCatalogDeps(catalog, "workspaces.catalog", options),
+        raw,
+        indent
+      });
+    }
+    if (raw.workspaces?.catalogs) {
+      const catalogs = raw.workspaces.catalogs;
+      for (const [catalogName, catalog] of Object.entries(catalogs)) {
+        sources.push({
+          type: "bun",
+          name: catalogName,
+          filepath,
+          deps: parseCatalogDeps(catalog, `workspaces.catalogs.${catalogName}`, options),
+          raw,
+          indent
+        });
+      }
+    }
+    return sources;
+  },
+  write(catalog, changes) {
+    const content = readFileSync(catalog.filepath, "utf-8");
+    const raw = JSON.parse(content);
+    const indent = detectIndent(content).indent || catalog.indent;
+    let section;
+    if (catalog.name === "default") {
+      section = raw.workspaces?.catalog;
+    } else {
+      section = raw.workspaces?.catalogs?.[catalog.name];
+    }
+    if (!section) return;
+    for (const [name, version] of changes) {
+      if (name in section) {
+        section[name] = version;
+      }
+    }
+    const lineEnding = detectLineEnding(content);
+    const newContent = JSON.stringify(raw, null, indent);
+    const withTrailing = content.endsWith("\n") ? `${newContent}
+` : newContent;
+    const final = lineEnding === "\r\n" ? withTrailing.replace(/\n/g, "\r\n") : withTrailing;
+    writeFileSync(catalog.filepath, final, "utf-8");
+  }
+};
+
+const bun = {
+  __proto__: null,
+  bunCatalogLoader: bunCatalogLoader
+};
+
+const pnpmCatalogLoader = {
+  async detect(cwd) {
+    return !!findUpSync("pnpm-workspace.yaml", { cwd });
+  },
+  async load(cwd, options) {
+    const filepath = findUpSync("pnpm-workspace.yaml", { cwd });
+    if (!filepath) return [];
+    const content = readFileSync(filepath, "utf-8");
+    const workspace = parsePnpmWorkspaceYaml(content);
+    const schema = workspace.toJSON();
+    const catalogs = [];
+    if (schema.catalog && typeof schema.catalog === "object") {
+      catalogs.push(parseCatalogSection(schema.catalog, "default", filepath, options, content));
+    }
+    if (schema.catalogs && typeof schema.catalogs === "object") {
+      for (const [name, deps] of Object.entries(schema.catalogs)) {
+        catalogs.push(parseCatalogSection(deps, name, filepath, options, content));
+      }
+    }
+    return catalogs;
+  },
+  write(catalog, changes) {
+    const content = readFileSync(catalog.filepath, "utf-8");
+    const workspace = parsePnpmWorkspaceYaml(content);
+    for (const [name, version] of changes) {
+      workspace.setPackage(catalog.name === "default" ? "default" : catalog.name, name, version);
+    }
+    writeFileSync(catalog.filepath, workspace.toString(), "utf-8");
+  }
+};
+function parseCatalogSection(deps, name, filepath, options, rawContent) {
+  const parsed = [];
+  for (const [depName, version] of Object.entries(deps)) {
+    parsed.push({
+      name: depName,
+      currentVersion: version,
+      source: "catalog",
+      update: !isLocked(version) || options.includeLocked,
+      parents: [name === "default" ? "catalog" : `catalogs.${name}`]
+    });
+  }
+  return {
+    type: "pnpm",
+    name,
+    filepath,
+    deps: parsed,
+    raw: rawContent,
+    indent: "  "
+  };
+}
+
+const pnpm = {
+  __proto__: null,
+  pnpmCatalogLoader: pnpmCatalogLoader
+};
+
+const yarnCatalogLoader = {
+  async detect(cwd) {
+    const rcFile = findUpSync(".yarnrc.yml", { cwd });
+    return !!rcFile;
+  },
+  async load(cwd, options) {
+    const filepath = findUpSync(".yarnrc.yml", { cwd });
+    if (!filepath) return [];
+    const content = readFileSync(filepath, "utf-8");
+    const doc = YAML.parseDocument(content);
+    const raw = doc.toJSON();
+    if (!raw?.catalog) return [];
+    const deps = [];
+    const catalog = raw.catalog;
+    for (const [name, version] of Object.entries(catalog)) {
+      deps.push({
+        name,
+        currentVersion: version,
+        source: "catalog",
+        update: !isLocked(version) || options.includeLocked,
+        parents: ["catalog"]
+      });
+    }
+    return [
+      {
+        type: "yarn",
+        name: "default",
+        filepath,
+        deps,
+        raw: doc,
+        indent: "  "
+      }
+    ];
+  },
+  write(catalog, changes) {
+    const doc = catalog.raw;
+    const catalogNode = doc.get("catalog");
+    if (!catalogNode) return;
+    for (const [name, version] of changes) {
+      if (catalogNode.has(name)) {
+        catalogNode.set(name, version);
+      }
+    }
+    writeFileSync(catalog.filepath, doc.toString(), "utf-8");
+  }
+};
+
+const yarn = {
+  __proto__: null,
+  yarnCatalogLoader: yarnCatalogLoader
+};
+
+const catalogWriters = {
+  pnpm: pnpmCatalogLoader,
+  bun: bunCatalogLoader,
+  yarn: yarnCatalogLoader
+};
+function writeCatalogPackage(pkg, changes, logger) {
+  if (!pkg.catalogs?.length) return;
+  for (const catalog of pkg.catalogs) {
+    const changeMap = /* @__PURE__ */ new Map();
+    for (const change of changes) {
+      if (catalog.deps.some((d) => d.name === change.name)) {
+        changeMap.set(change.name, change.targetVersion);
+      }
+    }
+    if (changeMap.size === 0) continue;
+    const writer = catalogWriters[catalog.type];
+    if (writer) {
+      try {
+        writer.write(catalog, changeMap);
+      } catch (error) {
+        throw new WriteError(
+          `Failed to write ${catalog.type} catalog "${catalog.name}" (${catalog.filepath})`,
+          { cause: error }
+        );
+      }
+      logger.success(
+        `Updated ${catalog.type} catalog "${catalog.name}" (${changeMap.size} changes)`
+      );
+    }
+  }
+}
+
+function detectLineEnding(content) {
+  return content.includes("\r\n") ? "\r\n" : "\n";
+}
+
+function writePackageJson(pkg, changes, logger) {
+  let content;
+  try {
+    content = readFileSync(pkg.filepath, "utf-8");
+  } catch (error) {
+    throw new WriteError(`Failed to read ${pkg.filepath}`, { cause: error });
+  }
+  const indent = detectIndent(content).indent || pkg.indent;
+  let raw;
+  try {
+    raw = JSON.parse(content);
+  } catch (error) {
+    throw new WriteError(`Failed to parse JSON in ${pkg.filepath}`, { cause: error });
+  }
+  const bySource = /* @__PURE__ */ new Map();
+  for (const change of changes) {
+    const group = bySource.get(change.source) ?? [];
+    group.push(change);
+    bySource.set(change.source, group);
+  }
+  for (const [source, sourceChanges] of bySource) {
+    const section = getSection(raw, source);
+    if (!section) continue;
+    for (const change of sourceChanges) {
+      if (change.name in section) {
+        const oldVersion = section[change.name];
+        section[change.name] = rebuildVersion(oldVersion, change.targetVersion);
+        logger.debug(`  ${change.name}: ${oldVersion} -> ${section[change.name]}`);
+      }
+    }
+  }
+  const pmChange = changes.find((c) => c.source === "packageManager");
+  if (pmChange && pkg.packageManager) {
+    const newPm = pkg.packageManager.hash ? `${pkg.packageManager.name}@${pmChange.targetVersion}+${pkg.packageManager.hash}` : `${pkg.packageManager.name}@${pmChange.targetVersion}`;
+    raw.packageManager = newPm;
+  }
+  const lineEnding = detectLineEnding(content);
+  const newContent = JSON.stringify(raw, null, indent);
+  const withTrailing = content.endsWith("\n") ? `${newContent}
+` : newContent;
+  const finalContent = lineEnding === "\r\n" ? withTrailing.replace(/\n/g, "\r\n") : withTrailing;
+  try {
+    writeFileSync(pkg.filepath, finalContent, "utf-8");
+  } catch (error) {
+    throw new WriteError(`Failed to write ${pkg.filepath}`, { cause: error });
+  }
+  logger.success(`Updated ${pkg.filepath} (${changes.length} changes)`);
+}
+function getSection(raw, source) {
+  if (source.includes(".")) {
+    const parts = source.split(".");
+    let current = raw;
+    for (const part of parts) {
+      if (!current || typeof current !== "object") return null;
+      current = current[part];
+    }
+    return current;
+  }
+  return raw[source] ?? null;
+}
+function rebuildVersion(original, newVersion) {
+  const npmMatch = original.match(/^(npm:.+@)/);
+  if (npmMatch) return `${npmMatch[1]}${newVersion}`;
+  const jsrMatch = original.match(/^(jsr:.+@)/);
+  if (jsrMatch) return `${jsrMatch[1]}${newVersion}`;
+  return newVersion;
+}
+
+function backupPackageFiles(pkg) {
+  const backups = [];
+  let mainContent;
+  try {
+    mainContent = readFileSync(pkg.filepath, "utf-8");
+  } catch (error) {
+    throw new WriteError(`Failed to backup file ${pkg.filepath}`, { cause: error });
+  }
+  backups.push({
+    filepath: pkg.filepath,
+    content: mainContent
+  });
+  if (pkg.catalogs?.length) {
+    for (const catalog of pkg.catalogs) {
+      let catalogContent;
+      try {
+        catalogContent = readFileSync(catalog.filepath, "utf-8");
+      } catch (error) {
+        throw new WriteError(`Failed to backup file ${catalog.filepath}`, { cause: error });
+      }
+      backups.push({
+        filepath: catalog.filepath,
+        content: catalogContent
+      });
+    }
+  }
+  return backups;
+}
+function restorePackageFiles(backups) {
+  for (const backup of backups) {
+    try {
+      writeFileSync(backup.filepath, backup.content, "utf-8");
+    } catch (error) {
+      throw new WriteError(`Failed to restore file ${backup.filepath}`, { cause: error });
+    }
+  }
+}
+
+function writePackage(pkg, changes, loglevel = "info") {
+  const logger = createLogger(loglevel);
+  if (changes.length === 0) return;
+  if (pkg.type === "package.json") {
+    writePackageJson(pkg, changes, logger);
+  } else if (pkg.catalogs?.length) {
+    writeCatalogPackage(pkg, changes, logger);
+  }
+}
+
+async function verifyAndWrite(pkg, changes, verifyCommand, logger) {
+  let applied = 0;
+  let reverted = 0;
+  for (const change of changes) {
+    const backups = backupPackageFiles(pkg);
+    writePackage(pkg, [change], "silent");
+    try {
+      execSync(verifyCommand, { cwd: pkg.filepath.replace(/\/[^/]+$/, ""), stdio: "pipe" });
+      applied++;
+      logger.success(`  ${change.name} ${change.currentVersion} \u2192 ${change.targetVersion} \u2713`);
+    } catch {
+      restorePackageFiles(backups);
+      reverted++;
+      logger.warn(
+        `  ${change.name} ${change.currentVersion} \u2192 ${change.targetVersion} \u2717 (reverted)`
+      );
+    }
+  }
+  return { applied, reverted };
+}
+async function applyPackageWrite(pkg, changes, options, logger) {
+  if (changes.length === 0) return false;
+  if (options.verifyCommand) {
+    const result = await verifyAndWrite(pkg, changes, options.verifyCommand, logger);
+    logger.info(`  Verify: ${result.applied} applied, ${result.reverted} reverted`);
+    return result.applied > 0;
+  }
+  if (pkg.type === "global") {
+    const { writeGlobalPackage } = await import('../chunks/index3.mjs').then(function (n) { return n.g; });
+    const pmName = pkg.filepath.replace("global:", "");
+    for (const change of changes) {
+      writeGlobalPackage(pmName, change.name, change.targetVersion);
+    }
+    return true;
+  }
+  writePackage(pkg, changes, options.loglevel);
+  return true;
+}
+
+async function processPackage(pkg, options, hooks) {
+  await options.beforePackageStart?.(pkg);
+  try {
+    pkg.resolved = await resolvePackage(
+      pkg,
+      options,
+      hooks.cache,
+      hooks.npmrc,
+      hooks.workspacePackageNames,
+      hooks.onDependencyProcessed
+    );
+    const updates = pkg.resolved.filter((d) => d.diff !== "none" && d.diff !== "error");
+    if (updates.length === 0) {
+      hooks.onAllModeNoUpdates();
+      return;
+    }
+    hooks.onHasUpdates(updates);
+    const selected = options.interactive ? await selectInteractiveUpdates(updates, options.explain) : updates;
+    if (!options.write || selected.length === 0) return;
+    const shouldWrite = await options.beforePackageWrite?.(pkg) ?? true;
+    if (!shouldWrite) return;
+    if (await applyPackageWrite(pkg, selected, options, hooks.logger)) {
+      hooks.onDidWrite();
+    }
+    await options.afterPackageWrite?.(pkg);
+  } finally {
+    await options.afterPackageEnd?.(pkg);
+  }
+}
+
+const ANSI_PATTERN = new RegExp(`${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`, "g");
+function stripAnsi(str) {
+  return str.replace(ANSI_PATTERN, "");
+}
+
+const DIFF_COLORS = {
+  major: c.red,
+  minor: c.yellow,
+  patch: c.green,
+  none: c.gray,
+  error: c.red
+};
+function colorDiff(diff) {
+  const color = DIFF_COLORS[diff];
+  return color(diff);
+}
+function colorVersion(version, diff) {
+  const color = DIFF_COLORS[diff];
+  return color(version);
+}
+function colorizeVersionDiff(from, to, diff) {
+  if (diff === "none" || diff === "error") return colorVersion(to, diff);
+  const color = DIFF_COLORS[diff];
+  const prefixMatch = to.match(/^([^\d]*)(.*)$/);
+  const prefix = prefixMatch?.[1] ?? "";
+  const toVersion = prefixMatch?.[2] ?? to;
+  const fromPrefixMatch = from.match(/^([^\d]*)(.*)$/);
+  const fromVersion = fromPrefixMatch?.[2] ?? from;
+  const fromParts = fromVersion.split(".");
+  const toParts = toVersion.split(".");
+  let diffIdx = -1;
+  for (let i = 0; i < toParts.length; i++) {
+    if (fromParts[i] !== toParts[i]) {
+      diffIdx = i;
+      break;
+    }
+  }
+  if (diffIdx === -1) return colorVersion(to, diff);
+  const unchanged = toParts.slice(0, diffIdx).join(".");
+  const changed = toParts.slice(diffIdx).join(".");
+  const separator = diffIdx > 0 ? "." : "";
+  return prefix + unchanged + separator + color(changed);
+}
+function arrow() {
+  return c.gray(" -> ");
+}
+
+function timeDifference(dateStr) {
+  if (!dateStr) return void 0;
+  const date = new Date(dateStr);
+  if (Number.isNaN(date.getTime())) return void 0;
+  const now = Date.now();
+  const diffMs = now - date.getTime();
+  if (diffMs < 0) return { text: "~0d", color: "green" };
+  const days = diffMs / (1e3 * 60 * 60 * 24);
+  if (days < 90) {
+    const d = Math.max(1, Math.round(days));
+    return { text: `~${d}d`, color: "green" };
+  }
+  if (days < 365) {
+    const months = Math.round(days / 30);
+    return { text: `~${months}mo`, color: "yellow" };
+  }
+  const years = days / 365;
+  const formatted = years >= 10 ? `~${Math.round(years)}y` : `~${years.toFixed(1)}y`;
+  return { text: formatted, color: "red" };
+}
+
+function visualLength(str) {
+  const plain = stripAnsi(str);
+  let width = 0;
+  for (const char of plain) {
+    const codePoint = char.codePointAt(0);
+    if (codePoint === void 0) continue;
+    if (isZeroWidthChar(char, codePoint)) continue;
+    width += isWideCodePoint(codePoint) ? 2 : 1;
+  }
+  return width;
+}
+function visualPadEnd(str, len) {
+  const diff = len - visualLength(str);
+  return diff > 0 ? str + " ".repeat(diff) : str;
+}
+function visualPadStart(str, len) {
+  const diff = len - visualLength(str);
+  return diff > 0 ? " ".repeat(diff) + str : str;
+}
+function visualTruncate(str, maxLen) {
+  if (maxLen <= 0) return "";
+  const plain = stripAnsi(str);
+  if (visualLength(plain) <= maxLen) return plain;
+  if (maxLen === 1) return "\u2026";
+  let out = "";
+  let used = 0;
+  const target = maxLen - 1;
+  for (const char of plain) {
+    const codePoint = char.codePointAt(0);
+    if (codePoint === void 0) continue;
+    const charWidth = isZeroWidthChar(char, codePoint) ? 0 : isWideCodePoint(codePoint) ? 2 : 1;
+    if (used + charWidth > target) break;
+    out += char;
+    used += charWidth;
+  }
+  return `${out}\u2026`;
+}
+function padEnd(str, len) {
+  return visualPadEnd(str, len);
+}
+function truncate(str, maxLen) {
+  return visualTruncate(str, maxLen);
+}
+function isZeroWidthChar(char, codePoint) {
+  if (codePoint === 0) return true;
+  if (codePoint >= 0 && codePoint <= 31 || codePoint >= 127 && codePoint <= 159) {
+    return true;
+  }
+  if (codePoint === 8204 || codePoint === 8205 || codePoint === 173) {
+    return true;
+  }
+  if (/\p{Mark}/u.test(char)) {
+    return true;
+  }
+  return codePoint >= 65024 && codePoint <= 65039;
+}
+function isWideCodePoint(codePoint) {
+  if (codePoint < 4352) return false;
+  return codePoint <= 4447 || // Hangul Jamo
+  codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || // Hangul Syllables
+  codePoint >= 63744 && codePoint <= 64255 || // CJK Compatibility Ideographs
+  codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || // Fullwidth Forms
+  codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 128591 || // Emoji
+  codePoint >= 129280 && codePoint <= 129535 || codePoint >= 131072 && codePoint <= 262141;
+}
+
+const BAR_WIDTH = 24;
+const LINES = 2;
+function createCheckProgress(options, packages) {
+  if (!shouldRenderProgress(options)) {
+    return null;
+  }
+  const state = {
+    totalPackages: packages.length,
+    totalDeps: packages.reduce((sum, p) => sum + p.deps.filter((d) => d.update).length, 0),
+    completedPackages: 0,
+    completedDeps: 0,
+    currentPackageName: "",
+    currentPackageTotalDeps: 0,
+    currentPackageResolvedDeps: 0,
+    renderedLines: 0
+  };
+  const progress = {
+    onPackageStart(pkg) {
+      state.currentPackageName = pkg.name || "(unnamed)";
+      state.currentPackageTotalDeps = pkg.deps.filter((d) => d.update).length;
+      state.currentPackageResolvedDeps = 0;
+      render(state);
+    },
+    onDependencyProcessed() {
+      state.currentPackageResolvedDeps = Math.min(
+        state.currentPackageResolvedDeps + 1,
+        state.currentPackageTotalDeps
+      );
+      state.completedDeps = Math.min(state.completedDeps + 1, state.totalDeps);
+      render(state);
+    },
+    onPackageEnd() {
+      state.completedPackages = Math.min(state.completedPackages + 1, state.totalPackages);
+      state.currentPackageResolvedDeps = state.currentPackageTotalDeps;
+      render(state);
+    },
+    done() {
+      clear(state);
+    }
+  };
+  return progress;
+}
+function shouldRenderProgress(options) {
+  return process.stdout.isTTY && options.output === "table" && options.loglevel !== "silent";
+}
+function render(state) {
+  const maxLabel = getMaxLabelWidth();
+  const pkgLabel = clampLabel("Packages", maxLabel);
+  const depLabel = clampLabel(`Deps (${state.currentPackageName || "-"})`, maxLabel);
+  const pkgBar = formatBar(state.completedPackages, state.totalPackages);
+  const depBar = formatBar(state.currentPackageResolvedDeps, state.currentPackageTotalDeps);
+  const pkgLine = `${pkgLabel} ${pkgBar}`;
+  const depLine = `${depLabel} ${depBar}  total ${state.completedDeps}/${state.totalDeps}`;
+  if (state.renderedLines > 0) {
+    moveCursorUp(state.renderedLines);
+  }
+  writeLine(pkgLine);
+  writeLine(depLine);
+  state.renderedLines = LINES;
+}
+function clear(state) {
+  if (state.renderedLines === 0) return;
+  moveCursorUp(state.renderedLines);
+  for (let i = 0; i < state.renderedLines; i++) {
+    process.stdout.write("\r\x1B[2K\n");
+  }
+  moveCursorUp(state.renderedLines);
+  state.renderedLines = 0;
+}
+function formatBar(value, total) {
+  if (total <= 0) {
+    return `[${"-".repeat(BAR_WIDTH)}] 0/0`;
+  }
+  const clamped = Math.min(value, total);
+  const ratio = clamped / total;
+  const filled = Math.round(BAR_WIDTH * ratio);
+  const empty = Math.max(0, BAR_WIDTH - filled);
+  return `[${"=".repeat(filled)}${"-".repeat(empty)}] ${clamped}/${total}`;
+}
+function getMaxLabelWidth() {
+  const columns = typeof process.stdout.columns === "number" ? process.stdout.columns : 80;
+  return Math.max(12, Math.floor(columns / 2) - 22);
+}
+function clampLabel(label, max) {
+  const clean = visualLength(label) > max ? visualTruncate(label, max) : label;
+  const pad = max - visualLength(clean);
+  return `${clean}${" ".repeat(Math.max(0, pad))}`;
+}
+function moveCursorUp(lines) {
+  if (lines > 0) {
+    process.stdout.write(`\x1B[${lines}A`);
+  }
+}
+function writeLine(text) {
+  process.stdout.write(`\r\x1B[2K${text}
+`);
+}
+
+const DIFF_ORDER = {
+  major: 0,
+  minor: 1,
+  patch: 2,
+  error: 3,
+  none: 4
+};
+function byDiff(a, b) {
+  return (DIFF_ORDER[a.diff] ?? 4) - (DIFF_ORDER[b.diff] ?? 4);
+}
+function byTime(a, b) {
+  const aTime = a.publishedAt ? new Date(a.publishedAt).getTime() : 0;
+  const bTime = b.publishedAt ? new Date(b.publishedAt).getTime() : 0;
+  return aTime - bTime;
+}
+function byName(a, b) {
+  return a.name.localeCompare(b.name);
+}
+function sortDeps(deps, sort) {
+  if (deps.length === 0) return deps;
+  const sorted = [...deps];
+  switch (sort) {
+    case "diff-asc":
+      sorted.sort(byDiff);
+      break;
+    case "diff-desc":
+      sorted.sort((a, b) => byDiff(b, a));
+      break;
+    case "time-asc":
+      sorted.sort(byTime);
+      break;
+    case "time-desc":
+      sorted.sort((a, b) => byTime(b, a));
+      break;
+    case "name-asc":
+      sorted.sort(byName);
+      break;
+    case "name-desc":
+      sorted.sort((a, b) => byName(b, a));
+      break;
+  }
+  return sorted;
+}
+
+const MIN_NAME_COL = 8;
+const MIN_VERSION_COL = 6;
+const MIN_SOURCE_COL = 6;
+function buildColumnLayout(deps, showSource, showTimediff, terminalWidth) {
+  const layout = {
+    nameWidth: Math.max(4, ...deps.map((u) => visualLength(u.name))),
+    sourceWidth: showSource ? Math.max(6, ...deps.map((u) => visualLength(u.source))) : 0,
+    currentWidth: Math.max(7, ...deps.map((u) => visualLength(u.currentVersion))),
+    targetWidth: Math.max(6, ...deps.map((u) => visualLength(u.targetVersion))),
+    diffWidth: Math.max(4, ...deps.map((u) => visualLength(u.diff))),
+    ageWidth: showTimediff ? 8 : 0,
+    showSource,
+    showTimediff
+  };
+  if (!terminalWidth || terminalWidth <= 0) {
+    return layout;
+  }
+  while (totalRowWidth(layout) > terminalWidth) {
+    if (layout.nameWidth > MIN_NAME_COL) {
+      layout.nameWidth--;
+      continue;
+    }
+    if (layout.currentWidth > MIN_VERSION_COL) {
+      layout.currentWidth--;
+      continue;
+    }
+    if (layout.targetWidth > MIN_VERSION_COL) {
+      layout.targetWidth--;
+      continue;
+    }
+    if (layout.showSource && layout.sourceWidth > MIN_SOURCE_COL) {
+      layout.sourceWidth--;
+      continue;
+    }
+    break;
+  }
+  return layout;
+}
+function totalRowWidth(layout) {
+  const base = 4 + // indentation
+  layout.nameWidth + 2 + layout.currentWidth + visualLength(arrow()) + layout.targetWidth + 2 + layout.diffWidth;
+  const source = layout.showSource ? layout.sourceWidth + 2 : 0;
+  const timediff = layout.showTimediff ? layout.ageWidth + 2 : 0;
+  return base + source + timediff;
+}
+function fitCell(value, width) {
+  return visualLength(value) > width ? visualTruncate(value, width) : value;
+}
+function getTerminalWidth() {
+  if (!process.stdout.isTTY) return void 0;
+  return typeof process.stdout.columns === "number" ? process.stdout.columns : void 0;
+}
+
+function renderRows(deps, options, log, showSource, terminalWidth) {
+  const showTimediff = options.timediff;
+  const showNodecompat = options.nodecompat;
+  const showLong = options.long;
+  const layout = buildColumnLayout(deps, showSource, showTimediff, terminalWidth);
+  const header = buildHeader(layout);
+  log(header);
+  const separatorLen = Math.max(0, totalRowWidth(layout) - 4);
+  log(c.gray(`    ${"-".repeat(separatorLen)}`));
+  for (const dep of deps) {
+    const name = visualPadEnd(fitCell(dep.name, layout.nameWidth), layout.nameWidth);
+    const currentRaw = fitCell(dep.currentVersion, layout.currentWidth);
+    const current = visualPadEnd(currentRaw, layout.currentWidth);
+    const targetRaw = fitCell(dep.targetVersion, layout.targetWidth);
+    const target = visualPadEnd(
+      colorizeVersionDiff(dep.currentVersion, targetRaw, dep.diff),
+      layout.targetWidth
+    );
+    const diff = visualPadEnd(colorDiff(dep.diff), layout.diffWidth);
+    const deprecated = dep.deprecated ? c.red(" (deprecated)") : "";
+    let line = `    ${name}  `;
+    if (showSource) {
+      const source = visualPadEnd(
+        c.gray(fitCell(dep.source, layout.sourceWidth)),
+        layout.sourceWidth
+      );
+      line += `${source}  `;
+    }
+    line += `${current}${arrow()}${target}  ${diff}`;
+    if (showTimediff) {
+      line += `  ${renderTimediff(dep.publishedAt, layout.ageWidth)}`;
+    }
+    if (hasProvenanceDowngrade(dep)) {
+      line += `  ${c.yellow("\u26A0")}`;
+    }
+    if (showNodecompat) {
+      if (dep.nodeCompatible === true) {
+        line += `  ${c.green.dim("\u2713")}`;
+      } else if (dep.nodeCompatible === false) {
+        line += `  ${c.red("\u2717node")}`;
+      }
+    }
+    line += deprecated;
+    log(line);
+    if (showLong && dep.pkgData.homepage) {
+      log(c.gray(`      \u21B3 ${dep.pkgData.homepage}`));
+    }
+  }
+}
+function buildHeader(layout) {
+  let header = `    ${visualPadEnd(c.gray("name"), layout.nameWidth)}  `;
+  if (layout.showSource) {
+    header += `${visualPadEnd(c.gray("source"), layout.sourceWidth)}  `;
+  }
+  header += `${visualPadEnd(c.gray("current"), layout.currentWidth)}`;
+  header += `${arrow()}${visualPadEnd(c.gray("target"), layout.targetWidth)}`;
+  header += `  ${visualPadEnd(c.gray("diff"), layout.diffWidth)}`;
+  if (layout.showTimediff) {
+    header += `  ${visualPadStart(c.gray("age"), layout.ageWidth)}`;
+  }
+  return header;
+}
+function renderTimediff(publishedAt, ageWidth) {
+  const td = timeDifference(publishedAt);
+  if (!td) return " ".repeat(ageWidth);
+  const colorFn = td.color === "green" ? c.green : td.color === "yellow" ? c.yellow : c.red;
+  return visualPadStart(colorFn(td.text), ageWidth);
+}
+function hasProvenanceDowngrade(dep) {
+  return (dep.currentProvenance === "trusted" || dep.currentProvenance === "attested") && dep.provenance === "none";
+}
+
+function renderSummary(updates, log) {
+  const major = updates.filter((u) => u.diff === "major").length;
+  const minor = updates.filter((u) => u.diff === "minor").length;
+  const patch = updates.filter((u) => u.diff === "patch").length;
+  const parts = [];
+  if (major) parts.push(c.red(`${major} major`));
+  if (minor) parts.push(c.yellow(`${minor} minor`));
+  if (patch) parts.push(c.green(`${patch} patch`));
+  log(`  ${parts.join(c.gray(" | "))}  ${c.gray(`(${updates.length} total)`)}`);
+  log();
+}
+
+const DEP_SOURCE_SHORT_NAMES = {
+  dependencies: "dependencies",
+  devDependencies: "devDependencies",
+  peerDependencies: "peerDependencies",
+  optionalDependencies: "optionalDependencies",
+  overrides: "overrides",
+  resolutions: "resolutions",
+  "pnpm.overrides": "pnpm.overrides",
+  catalog: "catalog",
+  packageManager: "packageManager"
+};
+function renderTable(packageName, updates, options) {
+  const log = console.log;
+  const terminalWidth = getTerminalWidth();
+  const title = terminalWidth ? fitCell(packageName, Math.max(1, terminalWidth - 2)) : packageName;
+  log();
+  log(c.cyan.bold(title));
+  log();
+  const sorted = sortDeps(updates, options.sort);
+  if (options.group) {
+    renderGrouped(sorted, options, log, terminalWidth);
+  } else {
+    renderFlat(sorted, options, log, terminalWidth);
+  }
+  renderSummary(updates, log);
+}
+function renderGrouped(sorted, options, log, terminalWidth) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const dep of sorted) {
+    const source = dep.source;
+    const existing = groups.get(source);
+    if (existing) {
+      existing.push(dep);
+    } else {
+      groups.set(source, [dep]);
+    }
+  }
+  for (const [source, deps] of groups) {
+    const label = DEP_SOURCE_SHORT_NAMES[source] ?? source;
+    const outLabel = terminalWidth ? fitCell(label, Math.max(1, terminalWidth - 4)) : label;
+    log(c.gray(`  ${outLabel}`));
+    renderRows(deps, options, log, false, terminalWidth);
+    log();
+  }
+}
+function renderFlat(sorted, options, log, terminalWidth) {
+  renderRows(sorted, options, log, true, terminalWidth);
+  log();
+}
+
+async function check(options) {
+  const logLevel = options.output === "json" ? "silent" : options.loglevel;
+  const logger = createLogger(logLevel);
+  try {
+    const packages = await loadPackages(options);
+    if (packages.length === 0) {
+      logger.warn("No packages found");
+      if (options.output === "json") {
+        outputJsonEnvelope([], options);
+      }
+      return 0;
+    }
+    await options.afterPackagesLoaded?.(packages);
+    let hasUpdates = false;
+    let didWrite = false;
+    const jsonPackages = [];
+    const progress = createCheckProgress(options, packages);
+    const cache = createSqliteCache();
+    const npmrc = loadNpmrc(options.cwd);
+    const workspacePackageNames = new Set(packages.map((p) => p.name).filter(Boolean));
+    try {
+      for (const pkg of packages) {
+        progress?.onPackageStart(pkg);
+        await processPackage(pkg, options, {
+          cache,
+          npmrc,
+          workspacePackageNames,
+          onDependencyProcessed: () => progress?.onDependencyProcessed(),
+          onHasUpdates: (updates) => {
+            hasUpdates = true;
+            if (options.output === "json") {
+              jsonPackages.push(buildJsonPackage(pkg.name, updates));
+            } else {
+              renderTable(pkg.name, updates, options);
+            }
+          },
+          onAllModeNoUpdates: () => {
+            if (!options.all) return;
+            if (options.output === "json") {
+              jsonPackages.push(buildJsonPackage(pkg.name, []));
+            } else {
+              renderUpToDate(pkg.name);
+            }
+          },
+          onDidWrite: () => {
+            didWrite = true;
+          },
+          logger
+        });
+        progress?.onPackageEnd();
+      }
+      await options.afterPackagesEnd?.(packages);
+    } finally {
+      progress?.done();
+      const stats = cache.stats();
+      cache.close();
+      logger.debug(`Cache stats: ${stats.hits} hits, ${stats.misses} misses, ${stats.size} entries`);
+    }
+    if (options.execute && options.write && didWrite) {
+      await runExecute(options.execute, options.cwd, logger);
+    }
+    if (options.write && didWrite) {
+      if (options.update) {
+        await runUpdate(options.cwd, packages, logger);
+      } else if (options.install) {
+        await runInstall(options.cwd, packages, logger);
+      }
+    }
+    if (options.output === "json") {
+      outputJsonEnvelope(jsonPackages, options);
+    }
+    if (!hasUpdates) {
+      logger.success("All dependencies are up to date");
+    }
+    if (hasUpdates && options.output === "table") {
+      if (options.mode === "default") {
+        logger.info(c.gray("Tip: Run `depzy major` to check for major updates"));
+      }
+      if (!options.write) {
+        logger.info(c.gray("Tip: Add `-w` to write changes to package files"));
+      }
+    }
+    return hasUpdates && !options.write && options.failOnOutdated ? 1 : 0;
+  } catch (error) {
+    logger.error("Check failed:", error instanceof Error ? error.message : String(error));
+    return 2;
+  }
+}
+
+export { arrow as a, colorizeVersionDiff as b, check as c, detectPackageManager as d, colorDiff as e, applyVersionPrefix as f, getVersionPrefix as g, getDiff as h, truncate as i, padEnd as j, loadPackages as l, parseDependencies as p, resolvePackage as r, stripAnsi as s, timeDifference as t, writePackage as w };