deps-conflict-resolver 1.0.0

package/dist/webpack.js

@@ -0,0 +1,2370 @@
+import { promises, existsSync, readFileSync } from 'fs';
+import { join, dirname, relative } from 'path';
+import { createRequire } from 'module';
+import { pathToFileURL } from 'url';
+import { parse } from 'yaml';
+import semver from 'semver';
+import { spawn } from 'child_process';
+
+// src/constants.ts
+var DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org";
+var LOCK_FILE_MAP = {
+  "pnpm-lock.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm",
+  "npm-shrinkwrap.json": "npm"
+};
+var DEFAULT_NPM_REGISTRY_TIMEOUT_MS = 1e4;
+
+// src/utils/logger.ts
+var DEFAULT_GLOBAL_LEVEL = 2 /* INFO */ | 4 /* WARN */ | 8 /* ERROR */;
+var __GLOBAL_LEVEL__ = DEFAULT_GLOBAL_LEVEL;
+var Logger = class {
+  prefix;
+  levelOverride;
+  constructor(config = {}) {
+    this.prefix = config.prefix ?? "[deps-conflict-resolver]";
+    this.levelOverride = config.level;
+  }
+  /**
+   * 设置日志级别
+   */
+  setLevel(level) {
+    __GLOBAL_LEVEL__ = level;
+    this.levelOverride = void 0;
+  }
+  getEffectiveLevel() {
+    return this.levelOverride ?? __GLOBAL_LEVEL__;
+  }
+  /**
+   * 调试日志
+   */
+  debug(...args) {
+    if (this.getEffectiveLevel() & 1 /* DEBUG */) {
+      console.debug(this.formatPrefix("DEBUG"), ...args);
+    }
+  }
+  /**
+   * 信息日志
+   */
+  info(...args) {
+    if (this.getEffectiveLevel() & 2 /* INFO */) {
+      console.info(this.formatPrefix("INFO"), ...args);
+    }
+  }
+  /**
+   * 警告日志
+   */
+  warn(...args) {
+    if (this.getEffectiveLevel() & 4 /* WARN */) {
+      console.warn(this.formatPrefix("WARN"), ...args);
+    }
+  }
+  /**
+   * 错误日志
+   */
+  error(...args) {
+    if (this.getEffectiveLevel() & 8 /* ERROR */) {
+      console.error(this.formatPrefix("ERROR"), ...args);
+    }
+  }
+  /**
+   * 格式化前缀
+   */
+  formatPrefix(level) {
+    return `${this.prefix} [${level}]`;
+  }
+};
+function createLogger(subPrefix, debug = false) {
+  return new Logger({
+    prefix: `[deps-conflict-resolver:${subPrefix}]`,
+    // debug=true 时强制当前 logger 输出所有日志；否则使用全局级别（默认 INFO/WARN/ERROR）
+    level: debug ? 15 /* ALL */ : void 0
+  });
+}
+
+// src/utils/lru-cache.ts
+var LruCache = class {
+  map = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor(options) {
+    this.maxEntries = options.maxEntries;
+  }
+  /**
+   * 当前缓存条目数
+   */
+  get size() {
+    return this.map.size;
+  }
+  /**
+   * 获取最大条目数
+   */
+  getMaxEntries() {
+    return this.maxEntries;
+  }
+  /**
+   * 动态调整最大条目数
+   * - 调小会立即触发淘汰
+   */
+  setMaxEntries(maxEntries) {
+    this.maxEntries = maxEntries;
+    if (this.maxEntries <= 0) {
+      this.map.clear();
+      return;
+    }
+    this.trim();
+  }
+  clear() {
+    this.map.clear();
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  /**
+   * 获取并刷新 LRU 顺序（命中后会变成“最近使用”）
+   */
+  get(key) {
+    if (this.maxEntries <= 0) {
+      return void 0;
+    }
+    if (!this.map.has(key)) {
+      return void 0;
+    }
+    const value = this.map.get(key);
+    this.map.delete(key);
+    this.map.set(key, value);
+    return value;
+  }
+  /**
+   * 写入并刷新 LRU 顺序
+   */
+  set(key, value) {
+    if (this.maxEntries <= 0) {
+      return;
+    }
+    if (this.map.has(key)) {
+      this.map.delete(key);
+    }
+    this.map.set(key, value);
+    this.trim();
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  trim() {
+    if (this.maxEntries <= 0) return;
+    while (this.map.size > this.maxEntries) {
+      const iter = this.map.keys().next();
+      if (iter.done) break;
+      this.map.delete(iter.value);
+    }
+  }
+};
+
+// src/utils/fs.ts
+function* iterateParentDirs(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    yield currentDir;
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+}
+var DEFAULT_PACKAGE_JSON_CACHE_MAX_ENTRIES = 5e3;
+var packageJsonCache = new LruCache({
+  maxEntries: DEFAULT_PACKAGE_JSON_CACHE_MAX_ENTRIES
+});
+var DEFAULT_REQUIRE_CACHE_MAX_ENTRIES = 200;
+var requireCache = new LruCache({
+  maxEntries: DEFAULT_REQUIRE_CACHE_MAX_ENTRIES
+});
+var DEFAULT_PACKAGE_PATH_CACHE_MAX_ENTRIES = 2e4;
+var packagePathCache = new LruCache({
+  maxEntries: DEFAULT_PACKAGE_PATH_CACHE_MAX_ENTRIES
+});
+function clearPackageJsonCache() {
+  packageJsonCache.clear();
+  packagePathCache.clear();
+  requireCache.clear();
+}
+function readJsonFileSync(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function fileExists(filePath) {
+  return existsSync(filePath);
+}
+function readPackageJsonCached(dir) {
+  const pkgPath = join(dir, "package.json");
+  const cached = packageJsonCache.get(pkgPath);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const result = readJsonFileSync(pkgPath);
+  packageJsonCache.set(pkgPath, result);
+  return result;
+}
+function findProjectRoot(startDir) {
+  for (const dir of iterateParentDirs(startDir)) {
+    if (fileExists(join(dir, "package.json"))) {
+      return dir;
+    }
+  }
+  return null;
+}
+function findPackagePath(packageName, baseDir) {
+  const cacheKey = `${baseDir}\0${packageName}`;
+  const cached = packagePathCache.get(cacheKey);
+  if (cached !== void 0) {
+    return cached;
+  }
+  try {
+    let require2 = requireCache.get(baseDir);
+    if (!require2) {
+      const baseUrl = pathToFileURL(join(baseDir, "package.json")).href;
+      require2 = createRequire(baseUrl);
+      requireCache.set(baseDir, require2);
+    }
+    const pkgJsonPath = require2.resolve(`${packageName}/package.json`);
+    const resolved = dirname(pkgJsonPath);
+    packagePathCache.set(cacheKey, resolved);
+    return resolved;
+  } catch {
+    const resolved = findPackagePathFallback(packageName, baseDir);
+    packagePathCache.set(cacheKey, resolved);
+    return resolved;
+  }
+}
+function findPackagePathFallback(packageName, baseDir) {
+  const packagePath = join(baseDir, "node_modules", packageName);
+  if (fileExists(packagePath)) {
+    return packagePath;
+  }
+  for (const dir of iterateParentDirs(baseDir)) {
+    const candidatePath = join(dir, "node_modules", packageName);
+    if (fileExists(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return null;
+}
+var logger = createLogger("environment-detector");
+var EnvironmentDetector = class {
+  projectRoot;
+  detectionResult = null;
+  registryCache = null;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  /**
+   * 获取检测到的包管理器类型
+   */
+  async getPackageManager() {
+    const result = await this.detect();
+    return result.packageManager;
+  }
+  /**
+   * 获取检测到的 registry
+   */
+  async getRegistry() {
+    if (this.registryCache) {
+      return this.registryCache;
+    }
+    const result = await this.detect();
+    this.registryCache = await this.detectRegistry(result.packageManager);
+    return this.registryCache;
+  }
+  /**
+   * 获取指定包管理器的 registry（兼容旧 API）
+   */
+  async getRegistryForPackageManager(packageManager) {
+    return this.detectRegistry(packageManager);
+  }
+  /**
+   * 获取完整的检测结果
+   */
+  async getDetectionResult() {
+    return this.detect();
+  }
+  /**
+   * 重置缓存，强制重新检测
+   */
+  reset() {
+    this.detectionResult = null;
+    this.registryCache = null;
+  }
+  /**
+   * 更新项目根目录
+   */
+  setProjectRoot(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.reset();
+  }
+  /**
+   * 检测项目使用的包管理器
+   *
+   * 检测优先级：
+   * 1. package.json 中的 packageManager 字段（如 "pnpm@8.0.0"）- 向上遍历查找
+   * 2. lock 文件存在 - 向上遍历查找（支持 monorepo）
+   * 3. 默认为 npm
+   */
+  detect() {
+    if (this.detectionResult) {
+      return Promise.resolve(this.detectionResult);
+    }
+    for (const currentDir of iterateParentDirs(this.projectRoot)) {
+      const pkgJsonPath = join(currentDir, "package.json");
+      if (fileExists(pkgJsonPath)) {
+        const pkgJson = readPackageJsonCached(currentDir);
+        const pmField = pkgJson?.packageManager;
+        if (pmField) {
+          const pm = this.parsePackageManagerField(pmField);
+          if (pm) {
+            logger.debug(`Detected package manager from package.json: ${pm} (at ${currentDir})`);
+            this.detectionResult = {
+              packageManager: pm,
+              detectedFrom: "packageJson",
+              rootDir: currentDir
+            };
+            return Promise.resolve(this.detectionResult);
+          }
+        }
+      }
+      for (const [lockFile, pm] of Object.entries(LOCK_FILE_MAP)) {
+        if (fileExists(join(currentDir, lockFile))) {
+          logger.debug(
+            `Detected package manager from lock file: ${pm} (${lockFile} at ${currentDir})`
+          );
+          this.detectionResult = {
+            packageManager: pm,
+            detectedFrom: "lockfile",
+            rootDir: currentDir
+          };
+          return Promise.resolve(this.detectionResult);
+        }
+      }
+    }
+    logger.debug("No lock file found, defaulting to npm");
+    this.detectionResult = {
+      packageManager: "npm",
+      detectedFrom: "default"
+    };
+    return Promise.resolve(this.detectionResult);
+  }
+  /**
+   * 解析 package.json 中的 packageManager 字段
+   * 格式如：pnpm@8.0.0, yarn@3.2.0, npm@9.0.0
+   */
+  parsePackageManagerField(value) {
+    const match = value.match(/^(npm|yarn|pnpm)(@|$)/);
+    if (match) {
+      return match[1];
+    }
+    return null;
+  }
+  /**
+   * 检测项目使用的 registry
+   *
+   * 检测优先级：
+   * 1. 项目级 .npmrc（向上遍历，覆盖 monorepo 子包场景）
+   * 2. 用户级 .npmrc
+   * 3. 包管理器特定配置
+   * 4. 默认 registry
+   */
+  async detectRegistry(packageManager) {
+    const defaultRegistry = DEFAULT_NPM_REGISTRY;
+    for (const dir of iterateParentDirs(this.projectRoot)) {
+      const npmrcPath = join(dir, ".npmrc");
+      if (fileExists(npmrcPath)) {
+        const registry = await this.parseRegistryFromNpmrc(npmrcPath);
+        if (registry) {
+          logger.debug(`Detected registry from .npmrc: ${registry} (at ${dir})`);
+          return registry;
+        }
+      }
+    }
+    const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    if (homeDir) {
+      const userNpmrc = join(homeDir, ".npmrc");
+      if (fileExists(userNpmrc)) {
+        const registry = await this.parseRegistryFromNpmrc(userNpmrc);
+        if (registry) {
+          logger.debug(`Detected registry from user .npmrc: ${registry}`);
+          return registry;
+        }
+      }
+      if (packageManager === "pnpm") {
+        const pnpmConfig = join(homeDir, ".pnpmrc");
+        if (fileExists(pnpmConfig)) {
+          const registry = await this.parseRegistryFromNpmrc(pnpmConfig);
+          if (registry) {
+            logger.debug(`Detected registry from .pnpmrc: ${registry}`);
+            return registry;
+          }
+        }
+      }
+      if (packageManager === "yarn") {
+        const yarnrc = join(this.projectRoot, ".yarnrc.yml");
+        if (fileExists(yarnrc)) {
+          const registry = await this.parseRegistryFromYarnrc(yarnrc);
+          if (registry) {
+            logger.debug(`Detected registry from .yarnrc.yml: ${registry}`);
+            return registry;
+          }
+        }
+      }
+    }
+    logger.debug(`Using default registry: ${defaultRegistry}`);
+    return defaultRegistry;
+  }
+  /**
+   * 从 .npmrc 文件解析 registry
+   */
+  async parseRegistryFromNpmrc(filePath) {
+    try {
+      const content = await promises.readFile(filePath, "utf-8");
+      const lines = content.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith(";")) {
+          continue;
+        }
+        const match = trimmed.match(/^registry\s*=\s*(.+)$/i);
+        if (match?.[1]) {
+          return match[1].trim().replace(/["']/g, "");
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  /**
+   * 从 .yarnrc.yml 文件解析 registry
+   */
+  async parseRegistryFromYarnrc(filePath) {
+    try {
+      const content = await promises.readFile(filePath, "utf-8");
+      const lines = content.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        const match = trimmed.match(/^npmRegistryServer:\s*["']?(.+?)["']?\s*$/);
+        if (match?.[1]) {
+          return match[1];
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+};
+function createEnvironmentDetector(projectRoot) {
+  return new EnvironmentDetector(projectRoot);
+}
+
+// src/utils/version-spec.ts
+var NPM_ALIAS_PATTERN = /^npm:(@?[^@]+)@(.+)$/;
+function parseNpmAlias(versionSpec) {
+  const match = versionSpec.match(NPM_ALIAS_PATTERN);
+  if (match?.[1] && match?.[2]) {
+    return [match[1], match[2]];
+  }
+  return null;
+}
+
+// src/core/workspace-detector.ts
+var logger2 = createLogger("workspace-detector");
+var PROTOCOL_PREFIXES = {
+  "catalog:": "catalog",
+  "workspace:": "workspace",
+  "npm:": "npm",
+  "file:": "file",
+  "link:": "link",
+  "portal:": "portal"
+};
+function extractAliasesFromDeps(deps, targetPackage, definedIn, existingAliases) {
+  if (!deps) return [];
+  const aliases = [];
+  for (const [aliasName, versionSpec] of Object.entries(deps)) {
+    if (typeof versionSpec !== "string") continue;
+    if (existingAliases.has(aliasName)) continue;
+    const parsed = parseNpmAlias(versionSpec);
+    if (parsed && parsed[0] === targetPackage) {
+      aliases.push({
+        aliasName,
+        targetPackage,
+        versionSpec: parsed[1],
+        definedIn,
+        isWorkspaceRoot: true
+      });
+      existingAliases.add(aliasName);
+      logger2.debug(`Found alias: ${aliasName} -> ${targetPackage}@${parsed[1]} (in ${definedIn})`);
+    }
+  }
+  return aliases;
+}
+var WorkspaceDetector = class {
+  projectRoot;
+  detectionResult = null;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  /**
+   * 获取 workspace 检测结果
+   */
+  detect() {
+    if (this.detectionResult) {
+      return Promise.resolve(this.detectionResult);
+    }
+    this.detectionResult = this.detectWorkspace();
+    return Promise.resolve(this.detectionResult);
+  }
+  /**
+   * 重置缓存
+   */
+  reset() {
+    this.detectionResult = null;
+  }
+  /**
+   * 解析 catalog: 协议的版本
+   * @param packageName 包名
+   * @param versionSpec 版本规格（如 "catalog:" 或 "catalog:react17"）
+   */
+  async resolveCatalogVersion(packageName, versionSpec) {
+    const result = {
+      original: versionSpec,
+      resolved: null,
+      catalogName: "default",
+      success: false
+    };
+    if (versionSpec === "catalog:" || versionSpec === "catalog:default") {
+      result.catalogName = "default";
+    } else if (versionSpec.startsWith("catalog:")) {
+      result.catalogName = versionSpec.slice("catalog:".length);
+    } else {
+      return result;
+    }
+    const workspace = await this.detect();
+    if (!workspace.isMonorepo || !workspace.workspaceRoot) {
+      logger2.warn(`Cannot resolve catalog: protocol - not in a monorepo`);
+      return result;
+    }
+    if (result.catalogName === "default") {
+      const version = workspace.catalog?.[packageName];
+      if (version) {
+        result.resolved = version;
+        result.success = true;
+        logger2.debug(`Resolved ${packageName} from default catalog: ${version}`);
+      }
+    } else {
+      const namedCatalog = workspace.catalogs?.[result.catalogName];
+      if (namedCatalog) {
+        const version = namedCatalog[packageName];
+        if (version) {
+          result.resolved = version;
+          result.success = true;
+          logger2.debug(`Resolved ${packageName} from catalog:${result.catalogName}: ${version}`);
+        }
+      }
+    }
+    if (!result.success) {
+      logger2.warn(`Package "${packageName}" not found in catalog:${result.catalogName}`);
+    }
+    return result;
+  }
+  /**
+   * 解析版本规格（支持各种特殊协议）
+   * @param packageName 包名
+   * @param versionSpec 版本规格
+   * @returns 解析后的普通版本范围，或 null（如无法解析）
+   */
+  async resolveVersionSpec(packageName, versionSpec) {
+    const protocol = this.getVersionProtocol(versionSpec);
+    switch (protocol) {
+      case "catalog": {
+        const resolution = await this.resolveCatalogVersion(packageName, versionSpec);
+        return resolution.resolved;
+      }
+      case "workspace":
+      case "file":
+      case "link":
+      case "portal":
+        return "*";
+      case "npm": {
+        const parsed = parseNpmAlias(versionSpec);
+        return parsed?.[1] ?? null;
+      }
+      default:
+        return versionSpec;
+    }
+  }
+  /**
+   * 判断版本规格的协议类型
+   */
+  getVersionProtocol(versionSpec) {
+    for (const [prefix, protocol] of Object.entries(PROTOCOL_PREFIXES)) {
+      if (versionSpec.startsWith(prefix)) {
+        return protocol;
+      }
+    }
+    return "normal";
+  }
+  /**
+   * 从 workspace 根目录和 catalog 中查找已存在的别名
+   */
+  async findWorkspaceAliases(targetPackage) {
+    const workspace = await this.detect();
+    if (!workspace.isMonorepo || !workspace.workspaceRoot) {
+      return [];
+    }
+    const existingAliases = /* @__PURE__ */ new Set();
+    const aliases = [];
+    const catalogPath = join(workspace.workspaceRoot, "pnpm-workspace.yaml");
+    if (workspace.workspaceType === "pnpm") {
+      aliases.push(
+        ...extractAliasesFromDeps(workspace.catalog, targetPackage, catalogPath, existingAliases)
+      );
+      if (workspace.catalogs) {
+        for (const catalog of Object.values(workspace.catalogs)) {
+          aliases.push(
+            ...extractAliasesFromDeps(catalog, targetPackage, catalogPath, existingAliases)
+          );
+        }
+      }
+    }
+    const rootPkgPath = join(workspace.workspaceRoot, "package.json");
+    const rootPkgJson = readPackageJsonCached(workspace.workspaceRoot);
+    if (rootPkgJson) {
+      aliases.push(
+        ...extractAliasesFromDeps(
+          rootPkgJson.dependencies,
+          targetPackage,
+          rootPkgPath,
+          existingAliases
+        ),
+        ...extractAliasesFromDeps(
+          rootPkgJson.devDependencies,
+          targetPackage,
+          rootPkgPath,
+          existingAliases
+        )
+      );
+    }
+    return aliases;
+  }
+  /**
+   * 获取 workspace 根目录
+   */
+  async getWorkspaceRoot() {
+    const result = await this.detect();
+    return result.workspaceRoot;
+  }
+  /**
+   * 检测 workspace
+   */
+  detectWorkspace() {
+    for (const dir of iterateParentDirs(this.projectRoot)) {
+      const result = this.tryDetectWorkspaceAt(dir);
+      if (result) {
+        return result;
+      }
+    }
+    return {
+      isMonorepo: false,
+      workspaceRoot: null,
+      workspaceType: "none"
+    };
+  }
+  /**
+   * 尝试在指定目录检测 workspace
+   */
+  tryDetectWorkspaceAt(dir) {
+    const pnpmWorkspacePath = join(dir, "pnpm-workspace.yaml");
+    if (fileExists(pnpmWorkspacePath)) {
+      const config = this.parsePnpmWorkspaceYaml(pnpmWorkspacePath);
+      logger2.debug(`Detected pnpm workspace at: ${dir}`);
+      return {
+        isMonorepo: true,
+        workspaceRoot: dir,
+        currentProjectPath: relative(dir, this.projectRoot) || ".",
+        workspaceType: "pnpm",
+        catalog: config.catalog,
+        catalogs: config.catalogs
+      };
+    }
+    const pkgJson = readPackageJsonCached(dir);
+    if (pkgJson?.workspaces) {
+      const isYarn = fileExists(join(dir, "yarn.lock"));
+      const workspaceType = isYarn ? "yarn" : "npm";
+      logger2.debug(`Detected ${workspaceType} workspace at: ${dir}`);
+      return {
+        isMonorepo: true,
+        workspaceRoot: dir,
+        currentProjectPath: relative(dir, this.projectRoot) || ".",
+        workspaceType
+      };
+    }
+    if (fileExists(join(dir, "lerna.json"))) {
+      logger2.debug(`Detected lerna workspace at: ${dir}`);
+      return {
+        isMonorepo: true,
+        workspaceRoot: dir,
+        currentProjectPath: relative(dir, this.projectRoot) || ".",
+        workspaceType: "lerna"
+      };
+    }
+    return null;
+  }
+  /**
+   * 解析 pnpm-workspace.yaml
+   */
+  parsePnpmWorkspaceYaml(filePath) {
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const parsed = parse(content);
+      return parsed ?? {};
+    } catch (error) {
+      logger2.warn(`Failed to parse pnpm-workspace.yaml: ${String(error)}`);
+      return {};
+    }
+  }
+};
+function createWorkspaceDetector(projectRoot) {
+  return new WorkspaceDetector(projectRoot);
+}
+function satisfies(version, range) {
+  try {
+    return semver.satisfies(version, range, { includePrerelease: false });
+  } catch {
+    return false;
+  }
+}
+function compare(v1, v2) {
+  try {
+    return semver.compare(v1, v2);
+  } catch {
+    return 0;
+  }
+}
+function findIntersection(versions, ranges) {
+  if (ranges.length === 0) return versions;
+  return versions.filter((version) => {
+    return ranges.every((range) => satisfies(version, range));
+  });
+}
+function findBestVersion(versions, ranges) {
+  const satisfyingVersions = findIntersection(versions, ranges);
+  if (satisfyingVersions.length === 0) {
+    return null;
+  }
+  const sorted = [...satisfyingVersions].sort((a, b) => compare(b, a));
+  return sorted[0] ?? null;
+}
+function rangesIntersect(range1, range2) {
+  try {
+    const intersection = semver.intersects(range1, range2);
+    return intersection;
+  } catch {
+    return false;
+  }
+}
+function createAliasInstallSpec(alias, packageName, version) {
+  return `${alias}@npm:${packageName}@${version}`;
+}
+function generateAliasName(packageName, version) {
+  let major;
+  try {
+    major = semver.major(version);
+  } catch {
+    const m = version.match(/^(\d+)/);
+    major = m ? Number(m[1]) : 0;
+  }
+  const cleanName = packageName.replace(/^@/, "").replace(/\//g, "-");
+  return `${cleanName}${major}`;
+}
+
+// src/core/npm-registry.ts
+var logger3 = createLogger("npm-registry");
+var packageCache = /* @__PURE__ */ new Map();
+function clearNpmRegistryCache() {
+  packageCache.clear();
+}
+async function fetchWithTimeout(url, options = {}, timeout = DEFAULT_NPM_REGISTRY_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal
+    });
+    return response;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function fetchPackageInfo(packageName, registry = DEFAULT_NPM_REGISTRY) {
+  const cacheKey = `${registry}:${packageName}`;
+  const cached = packageCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const encodedName = packageName.startsWith("@") ? `@${encodeURIComponent(packageName.slice(1))}` : packageName;
+    const url = `${registry}/${encodedName}`;
+    logger3.debug(`Fetching package info from: ${url}`);
+    const response = await fetchWithTimeout(url, {
+      headers: {
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        logger3.warn(`Package not found: ${packageName}`);
+        return null;
+      }
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    const packageInfo = {
+      name: data.name,
+      versions: Object.keys(data.versions),
+      versionDetails: data.versions,
+      distTags: data["dist-tags"]
+    };
+    const cacheEntry = {
+      name: packageInfo.name,
+      versions: packageInfo.versions,
+      versionDetails: {},
+      distTags: packageInfo.distTags
+    };
+    packageCache.set(cacheKey, cacheEntry);
+    return packageInfo;
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      logger3.error(
+        `Timeout fetching package info for ${packageName} (>${DEFAULT_NPM_REGISTRY_TIMEOUT_MS}ms)`
+      );
+    } else {
+      logger3.error(`Failed to fetch package info for ${packageName}:`, error);
+    }
+    return null;
+  }
+}
+async function fetchAllVersions(packageName, registry = DEFAULT_NPM_REGISTRY) {
+  const info = await fetchPackageInfo(packageName, registry);
+  return info?.versions ?? [];
+}
+
+// src/core/dependency-analyzer.ts
+var logger4 = createLogger("dependency-analyzer");
+var DependencyAnalyzer = class {
+  options;
+  /** 主项目声明的依赖（解析后的版本，catalog: 等协议已转换） */
+  declaredDeps;
+  /** 主项目声明的原始依赖（未解析，保留 catalog: 等协议） */
+  rawDeclaredDeps;
+  /** 分析结果：存储有 peer 依赖的包信息 */
+  analyzedDependencies = /* @__PURE__ */ new Map();
+  /** 已访问的包名（使用包名，同一个包只分析一次） */
+  visitedPackages = /* @__PURE__ */ new Set();
+  /** 已安装包的信息缓存（按需填充，避免扫描整个 node_modules） */
+  installedPackageCache = /* @__PURE__ */ new Map();
+  /**
+   * 已存在的别名映射：真实包名 -> 别名信息列表
+   * 从 package.json 的 npm:package@version 格式解析得到
+   * 这是最准确的别名识别方式
+   */
+  existingAliasesMap = /* @__PURE__ */ new Map();
+  /** Workspace 检测器（用于 catalog 协议解析和 workspace 别名查找） */
+  workspaceDetector;
+  /** Workspace 级别的别名缓存 */
+  workspaceAliasesCache = /* @__PURE__ */ new Map();
+  /** workspace 根目录 package.json 声明的依赖（dependencies/devDependencies），用于“声明判断”合并 */
+  workspaceRootDeclaredDeps = {};
+  /** 是否已加载 workspaceRootDeclaredDeps */
+  workspaceRootDeclaredLoaded = false;
+  constructor(options, mainPackageJson, installedDeps) {
+    this.options = options;
+    this.rawDeclaredDeps = {
+      ...mainPackageJson.dependencies,
+      ...mainPackageJson.devDependencies
+    };
+    this.declaredDeps = { ...this.rawDeclaredDeps };
+    this.workspaceDetector = createWorkspaceDetector(options.projectRoot);
+    this.parseExistingAliases();
+    if (installedDeps) {
+      for (const [name, info] of installedDeps) {
+        this.installedPackageCache.set(name, info);
+      }
+    }
+  }
+  /**
+   * 统一封装：在指定 baseDir 下解析包安装路径并读取 package.json
+   * - 用于收敛 findPackagePath + readPackageJsonCached 的重复逻辑
+   * - 返回 { packagePath: null } 表示无法 resolve 到该包
+   * - 返回 { packagePath, pkgJson: null } 表示找到了目录但 package.json 无法读取/解析
+   */
+  resolvePackageJson(packageName, baseDir) {
+    const packagePath = findPackagePath(packageName, baseDir);
+    if (!packagePath) {
+      return { packagePath: null, pkgJson: null };
+    }
+    const pkgJson = readPackageJsonCached(packagePath);
+    return { packagePath, pkgJson };
+  }
+  /**
+   * 加载 workspace 根目录 package.json 声明的依赖（dependencies/devDependencies）
+   *
+   * 目的：在 monorepo/workspace 场景下，“主工程声明”需要合并当前包与 workspace 根的声明，
+   * 与 WorkspaceDetector 的 workspaceRoot 判断逻辑保持一致。
+   */
+  async ensureWorkspaceRootDeclaredDepsLoaded() {
+    if (this.workspaceRootDeclaredLoaded) {
+      return;
+    }
+    this.workspaceRootDeclaredLoaded = true;
+    const workspaceRoot = await this.workspaceDetector.getWorkspaceRoot();
+    if (!workspaceRoot || workspaceRoot === this.options.projectRoot) {
+      return;
+    }
+    const rootPkgJson = readPackageJsonCached(workspaceRoot);
+    if (!rootPkgJson) {
+      return;
+    }
+    this.workspaceRootDeclaredDeps = {
+      ...rootPkgJson.dependencies,
+      ...rootPkgJson.devDependencies
+    };
+  }
+  /**
+   * 判断某个包是否在“主工程”声明（dependencies/devDependencies）
+   *
+   * 默认行为（与 workspace 判断逻辑一致）：
+   * - 非 workspace：只看当前 projectRoot 的 package.json
+   * - workspace/monorepo：合并 projectRoot + workspaceRoot 两处 package.json 的声明
+   */
+  isDeclaredInMainProject(packageName) {
+    return Object.prototype.hasOwnProperty.call(this.declaredDeps, packageName) || Object.prototype.hasOwnProperty.call(this.workspaceRootDeclaredDeps, packageName);
+  }
+  /**
+   * 解析 package.json 中的 npm: 协议别名
+   * 格式：aliasName: "npm:realPackage@version"
+   * 这是识别别名最准确的方式
+   */
+  parseExistingAliases() {
+    for (const [aliasName, versionSpec] of Object.entries(this.declaredDeps)) {
+      if (typeof versionSpec !== "string") continue;
+      const parsed = parseNpmAlias(versionSpec);
+      if (parsed) {
+        const [targetPackage, version] = parsed;
+        const aliasInfo = {
+          aliasName,
+          targetPackage,
+          versionSpec: version,
+          installedVersion: null
+          // 稍后在需要时填充
+        };
+        const existing = this.existingAliasesMap.get(targetPackage) ?? [];
+        existing.push(aliasInfo);
+        this.existingAliasesMap.set(targetPackage, existing);
+        logger4.debug(`Found npm alias: ${aliasName} -> ${targetPackage}@${version}`);
+      }
+    }
+    if (this.existingAliasesMap.size > 0) {
+      logger4.debug(`Found ${this.existingAliasesMap.size} npm: protocol aliases`);
+    }
+  }
+  /**
+   * 获取别名的已安装版本（懒加载）
+   */
+  getAliasInstalledVersion(aliasName) {
+    const cached = this.installedPackageCache.get(aliasName);
+    if (cached) {
+      return cached.version;
+    }
+    const { packagePath, pkgJson } = this.resolvePackageJson(aliasName, this.options.projectRoot);
+    if (packagePath && pkgJson?.version) {
+      this.installedPackageCache.set(aliasName, {
+        name: aliasName,
+        version: pkgJson.version,
+        path: packagePath,
+        isAlias: true,
+        realName: pkgJson.name
+      });
+      return pkgJson.version;
+    }
+    return null;
+  }
+  /**
+   * 解析所有 catalog: 协议的依赖版本
+   * 将 catalog:xxx 转换为实际的版本范围
+   */
+  async resolveCatalogDependencies() {
+    for (const [pkgName, versionSpec] of Object.entries(this.rawDeclaredDeps)) {
+      if (typeof versionSpec !== "string") continue;
+      if (versionSpec.startsWith("catalog:")) {
+        const resolved = await this.workspaceDetector.resolveVersionSpec(pkgName, versionSpec);
+        if (resolved) {
+          this.declaredDeps[pkgName] = resolved;
+          logger4.debug(`Resolved catalog dependency: ${pkgName} "${versionSpec}" -> "${resolved}"`);
+        } else {
+          logger4.warn(`Failed to resolve catalog dependency: ${pkgName}@${versionSpec}`);
+        }
+      } else if (versionSpec.startsWith("workspace:")) {
+        const resolved = await this.workspaceDetector.resolveVersionSpec(pkgName, versionSpec);
+        if (resolved) {
+          this.declaredDeps[pkgName] = resolved;
+          logger4.debug(
+            `Resolved workspace dependency: ${pkgName} "${versionSpec}" -> "${resolved}"`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * 分析依赖并找出冲突
+   */
+  async analyze() {
+    logger4.info("Starting dependency analysis...");
+    try {
+      await this.resolveCatalogDependencies();
+      await this.ensureWorkspaceRootDeclaredDepsLoaded();
+      for (const depName of this.options.dependencies) {
+        this.analyzeDependencyRecursive(depName, []);
+      }
+      const peerDepsMap = this.collectFirstLevelPeerDependencies();
+      const peerConflicts = await this.analyzePeerConflicts(peerDepsMap);
+      const aliasMappings = await this.generateAliasMappings(peerConflicts);
+      const missingFirstLevelPeers = this.findMissingFirstLevelPeers(peerDepsMap);
+      const conflictsNeedingAlias = peerConflicts.filter((c) => c.needsAlias).length;
+      logger4.info(
+        `Analysis complete. Found ${conflictsNeedingAlias} first-level peer conflicts needing alias, ${missingFirstLevelPeers.length} missing peers (not auto-installing). Analyzed ${this.analyzedDependencies.size} packages, visited ${this.visitedPackages.size} packages total.`
+      );
+      return {
+        analyzedDependencies: this.analyzedDependencies,
+        peerConflicts,
+        aliasMappings,
+        missingFirstLevelPeers
+      };
+    } finally {
+      clearPackageJsonCache();
+      clearNpmRegistryCache();
+    }
+  }
+  /**
+   * 递归分析单个依赖及其所有子依赖
+   */
+  analyzeDependencyRecursive(packageName, dependencyPath) {
+    if (this.visitedPackages.has(packageName)) {
+      logger4.debug(`Skipping already visited package: ${packageName}`);
+      return this.analyzedDependencies.get(packageName) ?? null;
+    }
+    let rootInfo = null;
+    const stack = [
+      { name: packageName, path: dependencyPath }
+    ];
+    while (stack.length > 0) {
+      const item = stack.pop();
+      if (!item) break;
+      const name = item.name;
+      const path = item.path;
+      if (this.visitedPackages.has(name)) {
+        continue;
+      }
+      this.visitedPackages.add(name);
+      const { packagePath, pkgJson } = this.resolvePackageJson(name, this.options.projectRoot);
+      if (!packagePath) {
+        logger4.debug(`Package not found: ${name}`);
+        continue;
+      }
+      if (!pkgJson) {
+        logger4.debug(`Could not read package.json for: ${name}`);
+        continue;
+      }
+      this.cacheInstalledPackageInfo(name, packagePath, pkgJson);
+      logger4.debug(`Analyzing ${name}@${pkgJson.version}`);
+      const depInfo = {
+        name,
+        version: pkgJson.version ?? "unknown",
+        dependencyPath: [...path],
+        dependencies: pkgJson.dependencies ?? {},
+        peerDependencies: pkgJson.peerDependencies ?? {},
+        peerDependenciesMeta: pkgJson.peerDependenciesMeta
+      };
+      this.analyzedDependencies.set(name, depInfo);
+      if (name === packageName) {
+        rootInfo = depInfo;
+      }
+      const currentPath = [...path, name];
+      const depsToCheck = [
+        ...Object.keys(pkgJson.dependencies ?? {}),
+        ...Object.keys(pkgJson.peerDependencies ?? {})
+      ];
+      for (const depName of depsToCheck) {
+        if (this.visitedPackages.has(depName)) {
+          continue;
+        }
+        stack.push({ name: depName, path: currentPath });
+      }
+    }
+    return rootInfo;
+  }
+  /**
+   * 缓存已安装包的信息（用于后续查找别名等）
+   */
+  cacheInstalledPackageInfo(packageName, packagePath, pkgJson) {
+    if (this.installedPackageCache.has(packageName)) {
+      return;
+    }
+    const info = {
+      name: packageName,
+      version: pkgJson.version ?? "unknown",
+      path: packagePath
+    };
+    if (pkgJson.name && pkgJson.name !== packageName) {
+      info.isAlias = true;
+      info.realName = pkgJson.name;
+    }
+    const declaredSpec = this.declaredDeps[packageName];
+    if (typeof declaredSpec === "string" && declaredSpec.startsWith("npm:")) {
+      info.isAlias = true;
+      const parsed = parseNpmAlias(declaredSpec);
+      if (parsed) {
+        info.realName = parsed[0];
+      }
+    }
+    this.installedPackageCache.set(packageName, info);
+  }
+  /**
+   * 收集第一层依赖的 peer 依赖
+   * 只分析用户指定的 dependencies 的直接 peerDependencies，不分析子依赖的 peerDependencies
+   *
+   * 注意：虽然只收集第一层的 peer 依赖用于冲突检测和别名安装，
+   * 但依赖树仍然会被完整构建，用于后续的重定向判断
+   */
+  collectFirstLevelPeerDependencies() {
+    const peerDepsMap = /* @__PURE__ */ new Map();
+    for (const depName of this.options.dependencies) {
+      const depInfo = this.analyzedDependencies.get(depName);
+      if (!depInfo) continue;
+      const peerDeps = depInfo.peerDependencies;
+      const peerMeta = depInfo.peerDependenciesMeta ?? {};
+      for (const [peerName, peerRange] of Object.entries(peerDeps)) {
+        const isOptional = peerMeta[peerName]?.optional === true;
+        const existing = peerDepsMap.get(peerName) ?? [];
+        existing.push({
+          path: [depName],
+          requiredRange: peerRange
+        });
+        peerDepsMap.set(peerName, existing);
+        logger4.debug(
+          `Found first-level peer dependency: ${peerName}@${peerRange} required by ${depName}${isOptional ? " (optional)" : ""}`
+        );
+      }
+    }
+    return peerDepsMap;
+  }
+  /**
+   * 分析 peer 依赖冲突
+   * 只有当主工程已安装某个依赖，且 peerDeps 要求的版本不兼容时，才需要别名
+   */
+  async analyzePeerConflicts(peerDepsMap) {
+    const conflicts = [];
+    for (const [packageName, requestedBy] of peerDepsMap) {
+      const isDeclared = this.isDeclaredInMainProject(packageName);
+      const mainVersion = isDeclared ? this.getMainProjectVersion(packageName) : null;
+      const isInstalled = mainVersion !== null;
+      let hasConflict = false;
+      const conflictingRanges = [];
+      for (const request of requestedBy) {
+        const resolvedRange = await this.workspaceDetector.resolveVersionSpec(packageName, request.requiredRange) ?? request.requiredRange;
+        if (mainVersion && satisfies(mainVersion, resolvedRange)) ; else {
+          conflictingRanges.push({
+            ...request,
+            requiredRange: resolvedRange
+            // 使用解析后的版本范围
+          });
+          if (isDeclared && isInstalled) {
+            hasConflict = true;
+          }
+        }
+      }
+      const needsAlias = isDeclared && isInstalled && hasConflict && conflictingRanges.length > 0;
+      if (needsAlias) {
+        logger4.info(
+          `Peer conflict: ${packageName}@${mainVersion} - ${conflictingRanges.length} incompatible ranges`
+        );
+      }
+      conflicts.push({
+        packageName,
+        mainProjectVersion: mainVersion,
+        requiredRange: this.mergeRequiredRanges(requestedBy),
+        requestedBy,
+        conflictingRanges,
+        // 只记录冲突的范围
+        hasConflict,
+        needsAlias
+      });
+    }
+    return conflicts;
+  }
+  /**
+   * 获取已安装的包版本（从 node_modules 读取实际版本）
+   * 返回 null 表示包未安装
+   */
+  getMainProjectVersion(packageName) {
+    const cached = this.installedPackageCache.get(packageName);
+    if (cached) {
+      return cached.version;
+    }
+    const { packagePath, pkgJson } = this.resolvePackageJson(packageName, this.options.projectRoot);
+    if (packagePath && pkgJson?.version) {
+      this.installedPackageCache.set(packageName, {
+        name: packageName,
+        version: pkgJson.version,
+        path: packagePath
+      });
+      return pkgJson.version;
+    }
+    return null;
+  }
+  /**
+   * 合并多个版本范围为描述字符串
+   */
+  mergeRequiredRanges(requests) {
+    const ranges = [...new Set(requests.map((r) => r.requiredRange))];
+    return ranges.join(" || ");
+  }
+  /**
+   * 生成别名映射
+   */
+  async generateAliasMappings(conflicts) {
+    const aliasMappings = [];
+    const aliasNeeded = conflicts.filter((c) => c.needsAlias);
+    const allConflictPackageNames = aliasNeeded.map((c) => c.packageName);
+    for (const conflict of aliasNeeded) {
+      const mappings = await this.createAliasMappingsForConflict(conflict, allConflictPackageNames);
+      aliasMappings.push(...mappings);
+    }
+    return aliasMappings;
+  }
+  /**
+   * 为单个冲突创建别名映射
+   */
+  async createAliasMappingsForConflict(conflict, allConflictPackageNames) {
+    const { packageName, conflictingRanges } = conflict;
+    const rangeGroups = this.groupRangesByCompatibility(conflictingRanges);
+    logger4.info(`Creating alias for "${packageName}": ${rangeGroups.length} version groups`);
+    const workspaceRoot = await this.workspaceDetector.getWorkspaceRoot();
+    if (workspaceRoot) {
+      logger4.info(`  Workspace root detected: ${workspaceRoot}`);
+      const wsAliases = await this.findWorkspaceAliasesForPackage(packageName);
+      if (wsAliases.length > 0) {
+        logger4.info(`  Found ${wsAliases.length} workspace alias(es) for ${packageName}:`);
+        for (const a of wsAliases) {
+          logger4.info(
+            `    - ${a.aliasName}: npm:${packageName}@${a.versionSpec} (defined in: ${a.definedIn})`
+          );
+        }
+      } else {
+        logger4.info(
+          `  No workspace aliases found for ${packageName} (expected npm:${packageName}@version format in root package.json)`
+        );
+      }
+    } else {
+      logger4.info(`  Not in a monorepo workspace`);
+    }
+    const localAliases = this.existingAliasesMap.get(packageName);
+    if (localAliases && localAliases.length > 0) {
+      logger4.info(`  Found ${localAliases.length} local alias(es) for ${packageName}:`);
+      for (const a of localAliases) {
+        logger4.info(
+          `    - ${a.aliasName}: npm:${packageName}@${a.versionSpec} (installed: ${a.installedVersion ?? "not installed"})`
+        );
+      }
+    }
+    const versions = await fetchAllVersions(packageName, this.options.registry);
+    if (versions.length === 0) {
+      logger4.warn(`No versions found for ${packageName}`);
+      return [];
+    }
+    const existingAliasNames = await this.getExistingAliasNames(packageName);
+    const usedAliasNames = /* @__PURE__ */ new Set();
+    const mappings = [];
+    for (let i = 0; i < rangeGroups.length; i++) {
+      const group = rangeGroups[i];
+      if (!group || group.length === 0) continue;
+      const groupRanges = [...new Set(group.map((r) => r.requiredRange))];
+      logger4.debug(`  Group ${i + 1}: ${groupRanges.join(", ")}`);
+      const mapping = await this.createAliasMappingForGroup(
+        packageName,
+        group,
+        groupRanges,
+        versions,
+        existingAliasNames,
+        usedAliasNames,
+        allConflictPackageNames
+      );
+      if (mapping) {
+        mappings.push(mapping);
+        usedAliasNames.add(mapping.aliasName);
+      }
+    }
+    return mappings;
+  }
+  /**
+   * 按范围兼容性分组
+   * 有交集的范围放在一组，互斥的分开
+   */
+  groupRangesByCompatibility(requests) {
+    const groups = [];
+    for (const request of requests) {
+      let added = false;
+      for (const group of groups) {
+        const canJoin = group.every(
+          (existing) => rangesIntersect(existing.requiredRange, request.requiredRange)
+        );
+        if (canJoin) {
+          group.push(request);
+          added = true;
+          break;
+        }
+      }
+      if (!added) {
+        groups.push([request]);
+      }
+    }
+    return groups;
+  }
+  /**
+   * 为一个兼容组创建别名映射
+   */
+  async createAliasMappingForGroup(packageName, group, groupRanges, versions, existingAliasNames, usedAliasNames, allConflictPackageNames) {
+    const existingAlias = await this.findExistingAliasForRanges(
+      packageName,
+      groupRanges,
+      usedAliasNames
+    );
+    if (existingAlias) {
+      logger4.debug(
+        `    Reusing: ${existingAlias.name}@${existingAlias.version}${existingAlias.isWorkspaceAlias ? " (workspace)" : ""}`
+      );
+      return this.buildAliasMapping(
+        packageName,
+        existingAlias.name,
+        existingAlias.version,
+        "",
+        // 不需要安装
+        group,
+        allConflictPackageNames
+      );
+    }
+    const bestVersion = findBestVersion(versions, groupRanges);
+    if (!bestVersion) {
+      logger4.warn(
+        `    No version satisfies all ranges [${groupRanges.join(", ")}] for ${packageName}`
+      );
+      return null;
+    }
+    const combinedExisting = /* @__PURE__ */ new Set([...existingAliasNames, ...usedAliasNames]);
+    const aliasName = this.generateUniqueAliasName(packageName, bestVersion, combinedExisting);
+    const installSpec = createAliasInstallSpec(aliasName, packageName, bestVersion);
+    logger4.info(`    New alias: ${aliasName}@${bestVersion}`);
+    return this.buildAliasMapping(
+      packageName,
+      aliasName,
+      bestVersion,
+      installSpec,
+      group,
+      allConflictPackageNames
+    );
+  }
+  /**
+   * 构建 AliasMapping 对象
+   */
+  buildAliasMapping(packageName, aliasName, version, installSpec, group, allConflictPackageNames) {
+    const usedBy = group.map((r) => r.path.join(">"));
+    const usedByRoots = [
+      ...new Set(group.map((r) => r.path[0]).filter((p) => p !== void 0))
+    ];
+    const allDependents = this.collectAllRelatedPackages(usedByRoots, allConflictPackageNames);
+    return {
+      originalName: packageName,
+      aliasName,
+      installSpec,
+      resolvedVersion: version,
+      usedBy,
+      allDependents
+    };
+  }
+  /**
+   * 查找满足指定范围的现有别名（排除已使用的）
+   * 优先查找当前项目的别名，然后查找 workspace 级别的别名
+   */
+  async findExistingAliasForRanges(packageName, ranges, excludeAliases) {
+    logger4.debug(
+      `  Searching for existing alias for ${packageName} satisfying ranges: [${ranges.join(", ")}]`
+    );
+    const npmAliases = this.existingAliasesMap.get(packageName);
+    if (npmAliases && npmAliases.length > 0) {
+      logger4.debug(`  Checking ${npmAliases.length} local alias(es)...`);
+      for (const alias of npmAliases) {
+        if (excludeAliases.has(alias.aliasName)) {
+          logger4.debug(`    Skip ${alias.aliasName}: already used`);
+          continue;
+        }
+        if (alias.installedVersion === null) {
+          alias.installedVersion = this.getAliasInstalledVersion(alias.aliasName);
+        }
+        if (!alias.installedVersion) {
+          logger4.debug(`    Skip ${alias.aliasName}: not installed`);
+          continue;
+        }
+        const allSatisfied = ranges.every((range) => satisfies(alias.installedVersion, range));
+        if (allSatisfied) {
+          logger4.info(`    Reusing local alias: ${alias.aliasName}@${alias.installedVersion}`);
+          return { name: alias.aliasName, version: alias.installedVersion };
+        } else {
+          logger4.debug(
+            `    Skip ${alias.aliasName}@${alias.installedVersion}: version doesn't satisfy all ranges`
+          );
+        }
+      }
+    }
+    const workspaceAliases = await this.findWorkspaceAliasesForPackage(packageName);
+    const workspaceRoot = await this.workspaceDetector.getWorkspaceRoot();
+    if (workspaceAliases.length > 0) {
+      logger4.debug(`  Checking ${workspaceAliases.length} workspace alias(es)...`);
+    }
+    for (const wsAlias of workspaceAliases) {
+      if (excludeAliases.has(wsAlias.aliasName)) {
+        logger4.debug(`    Skip ${wsAlias.aliasName}: already used`);
+        continue;
+      }
+      let installedVersion = null;
+      if (workspaceRoot) {
+        const { packagePath, pkgJson } = this.resolvePackageJson(wsAlias.aliasName, workspaceRoot);
+        if (packagePath) {
+          installedVersion = pkgJson?.version ?? null;
+          logger4.debug(
+            `    Found ${wsAlias.aliasName} installed at workspace root: ${installedVersion}`
+          );
+        }
+      }
+      if (!installedVersion) {
+        installedVersion = this.getAliasInstalledVersion(wsAlias.aliasName);
+        if (installedVersion) {
+          logger4.debug(`    Found ${wsAlias.aliasName} installed at project: ${installedVersion}`);
+        }
+      }
+      if (installedVersion) {
+        const allSatisfied = ranges.every((range) => satisfies(installedVersion, range));
+        if (allSatisfied) {
+          logger4.info(`    Reusing workspace alias: ${wsAlias.aliasName}@${installedVersion}`);
+          return {
+            name: wsAlias.aliasName,
+            version: installedVersion,
+            isWorkspaceAlias: true
+          };
+        } else {
+          logger4.debug(
+            `    Skip ${wsAlias.aliasName}@${installedVersion}: version doesn't satisfy all ranges`
+          );
+        }
+        continue;
+      }
+      const declaredSpec = wsAlias.versionSpec;
+      if (declaredSpec) {
+        logger4.debug(
+          `    Checking ${wsAlias.aliasName} (declared: ${declaredSpec}) - not installed yet`
+        );
+        const hasIntersection = ranges.every((range) => rangesIntersect(declaredSpec, range));
+        if (hasIntersection) {
+          logger4.info(
+            `    Can reuse workspace alias: ${wsAlias.aliasName} (declared: ${declaredSpec})`
+          );
+          return {
+            name: wsAlias.aliasName,
+            version: declaredSpec,
+            isWorkspaceAlias: true
+          };
+        } else {
+          logger4.debug(
+            `    Skip ${wsAlias.aliasName}: declared range ${declaredSpec} doesn't intersect with [${ranges.join(", ")}]`
+          );
+        }
+      }
+    }
+    logger4.debug(`  No existing alias found for ${packageName}`);
+    return null;
+  }
+  /**
+   * 查找 workspace 级别的别名（带缓存）
+   */
+  async findWorkspaceAliasesForPackage(packageName) {
+    if (this.workspaceAliasesCache.has(packageName)) {
+      return this.workspaceAliasesCache.get(packageName);
+    }
+    const aliases = await this.workspaceDetector.findWorkspaceAliases(packageName);
+    this.workspaceAliasesCache.set(packageName, aliases);
+    return aliases;
+  }
+  /**
+   * 生成唯一的别名名称，避免与已存在的别名冲突
+   */
+  generateUniqueAliasName(packageName, version, existingNames) {
+    const baseName = `${this.options.aliasPrefix}${generateAliasName(packageName, version)}`;
+    if (!existingNames.has(baseName)) {
+      return baseName;
+    }
+    const versionSuffix = version.replace(/\./g, "-");
+    const nameWithVersion = `${this.options.aliasPrefix}${packageName.replace(/^@/, "").replace(/\//g, "-")}-${versionSuffix}`;
+    if (!existingNames.has(nameWithVersion)) {
+      return nameWithVersion;
+    }
+    let counter = 2;
+    while (existingNames.has(`${baseName}-${counter}`)) {
+      counter++;
+    }
+    return `${baseName}-${counter}`;
+  }
+  /**
+   * 获取包的所有已存在的别名名称（不管版本是否符合）
+   * 用于生成新别名时避免命名冲突
+   *
+   * 包含当前项目和 workspace 级别的别名
+   */
+  async getExistingAliasNames(packageName) {
+    const names = /* @__PURE__ */ new Set();
+    const npmAliases = this.existingAliasesMap.get(packageName);
+    if (npmAliases) {
+      for (const alias of npmAliases) {
+        names.add(alias.aliasName);
+      }
+    }
+    const workspaceAliases = await this.findWorkspaceAliasesForPackage(packageName);
+    for (const wsAlias of workspaceAliases) {
+      names.add(wsAlias.aliasName);
+    }
+    return names;
+  }
+  /**
+   * 递归收集指定包的所有子依赖（dependencies + peerDependencies）
+   *
+   * 用于构建 allDependents 列表，这些包引用冲突依赖时都需要做重定向解析
+   *
+   * 逻辑说明：
+   * - 冲突检测：只检测第一层依赖的 peerDependencies 与主工程的冲突
+   * - 重定向范围：声明冲突 peerDep 的包及其所有子依赖都需要重定向
+   *   因为这些子依赖内部引用冲突包时，也需要解析到别名版本
+   *
+   * 性能优化：优先从 analyzedDependencies 内存数据中读取，避免重复磁盘 I/O
+   */
+  collectAllSubDependenciesRecursive(packageName, visited, collected, baseDir) {
+    const stack = [{ name: packageName, baseDir }];
+    while (stack.length > 0) {
+      const item = stack.pop();
+      if (!item) break;
+      const name = item.name;
+      const currentBaseDir = item.baseDir;
+      collected.add(name);
+      const analyzed = this.analyzedDependencies.get(name);
+      if (analyzed) {
+        if (visited.has(name)) {
+          continue;
+        }
+        visited.add(name);
+        for (const depName of Object.keys(analyzed.dependencies)) {
+          stack.push({ name: depName, baseDir: currentBaseDir });
+        }
+        for (const peerName of Object.keys(analyzed.peerDependencies)) {
+          stack.push({ name: peerName, baseDir: currentBaseDir });
+        }
+        continue;
+      }
+      const { packagePath, pkgJson } = this.resolvePackageJson(name, currentBaseDir);
+      if (!packagePath) {
+        logger4.debug(
+          `Package not found for dependency collection: ${name} (from ${currentBaseDir})`
+        );
+        continue;
+      }
+      if (visited.has(packagePath)) {
+        continue;
+      }
+      visited.add(packagePath);
+      if (!pkgJson) {
+        continue;
+      }
+      const deps = pkgJson.dependencies ?? {};
+      const peerDeps = pkgJson.peerDependencies ?? {};
+      for (const depName of Object.keys(deps)) {
+        stack.push({ name: depName, baseDir: packagePath });
+      }
+      for (const peerName of Object.keys(peerDeps)) {
+        stack.push({ name: peerName, baseDir: packagePath });
+      }
+    }
+  }
+  /**
+   * 收集多个包的所有子依赖（用于 allDependents）
+   * 包括 dependencies 和 peerDependencies 递归下去的所有包
+   */
+  collectAllRelatedPackages(packageNames, excludePackages = []) {
+    const collected = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    const excludeSet = new Set(excludePackages);
+    for (const pkgName of packageNames) {
+      this.collectAllSubDependenciesRecursive(
+        pkgName,
+        visited,
+        collected,
+        this.options.projectRoot
+      );
+    }
+    for (const excludePkg of excludeSet) {
+      collected.delete(excludePkg);
+    }
+    return Array.from(collected);
+  }
+  /**
+   * 找出第一层依赖中缺失的 peer 依赖（无冲突）
+   * 复用 collectFirstLevelPeerDependencies 已收集的 peerDepsMap，避免重复遍历
+   */
+  findMissingFirstLevelPeers(peerDepsMap) {
+    const missing = [];
+    for (const [peerName, requests] of peerDepsMap) {
+      if (this.isDeclaredInMainProject(peerName)) {
+        continue;
+      }
+      for (const request of requests) {
+        const requestedBy = request.path[0];
+        if (!requestedBy) continue;
+        const depInfo = this.analyzedDependencies.get(requestedBy);
+        const isOptional = depInfo?.peerDependenciesMeta?.[peerName]?.optional === true;
+        if (isOptional) {
+          continue;
+        }
+        missing.push({
+          packageName: peerName,
+          requiredRange: request.requiredRange,
+          requestedBy
+        });
+      }
+    }
+    return missing;
+  }
+};
+function createDependencyAnalyzer(options) {
+  const mainPackageJson = readPackageJsonCached(options.projectRoot);
+  if (!mainPackageJson) {
+    throw new Error(`Could not read package.json at ${options.projectRoot}`);
+  }
+  return new DependencyAnalyzer(options, mainPackageJson);
+}
+var logger5 = createLogger("alias-manager");
+var AliasManager = class {
+  options;
+  aliasMappings = [];
+  /**
+   * 规则索引：originalName -> 相关规则列表
+   * 用于在 resolveModule 时避免全量遍历所有规则，提升 dev server/HMR 场景下性能。
+   */
+  rulesMap = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * 从分析结果初始化别名映射
+   */
+  initFromAnalysisResult(result) {
+    this.aliasMappings = result.aliasMappings;
+    this.buildRules();
+    logger5.info(`Initialized ${this.aliasMappings.length} alias mappings`);
+  }
+  /**
+   * 基于 allDependents 构建规则（用 Set 做成员判断，避免超大正则导致的性能与长度问题）
+   */
+  buildRules() {
+    this.rulesMap = /* @__PURE__ */ new Map();
+    for (const mapping of this.aliasMappings) {
+      let dependents = mapping.allDependents ?? [];
+      const excludeList = this.options.excludeRedirects[mapping.originalName] ?? [];
+      if (excludeList.length > 0) {
+        dependents = dependents.filter((dep) => !excludeList.includes(dep));
+        logger5.debug(`Excluded redirects for ${mapping.originalName}: ${excludeList.join(", ")}`);
+      }
+      const rule = {
+        originalName: mapping.originalName,
+        aliasName: mapping.aliasName,
+        dependents: new Set(dependents)
+      };
+      const list = this.rulesMap.get(rule.originalName);
+      if (list) {
+        list.push(rule);
+      } else {
+        this.rulesMap.set(rule.originalName, [rule]);
+      }
+    }
+  }
+  /**
+   * 从模块请求中提取“包名部分”，用于索引命中：
+   * - vue/compiler-sfc            -> vue
+   * - @scope/pkg/subpath          -> @scope/pkg
+   * - @scope/pkg/subpath?raw      -> @scope/pkg
+   * - virtual:xxx                 -> virtual:xxx
+   * - C:\path\to\file (Windows)   -> ''（视为非包请求）
+   */
+  getRequestPackageName(request) {
+    if (!request) return "";
+    const base = request.split(/[?#]/, 1)[0] ?? "";
+    if (!base) return "";
+    if (/^[a-zA-Z]:[\\/]/.test(base)) {
+      return "";
+    }
+    if (base.startsWith("@")) {
+      const firstSlash = base.indexOf("/");
+      if (firstSlash === -1) return base;
+      const secondSlash = base.indexOf("/", firstSlash + 1);
+      return secondSlash === -1 ? base : base.slice(0, secondSlash);
+    }
+    const slash = base.indexOf("/");
+    return slash === -1 ? base : base.slice(0, slash);
+  }
+  /**
+   * 从 importer 路径中提取所有 node_modules 里出现过的包名（包含嵌套 node_modules）。
+   *
+   * 示例：
+   * - /p/node_modules/a/index.js                -> ["a"]
+   * - /p/node_modules/a/node_modules/b/x.js     -> ["a","b"]
+   * - /p/node_modules/@s/a/dist/index.js        -> ["@s/a"]
+   * - /p/node_modules/.pnpm/a@1/node_modules/a/ -> ["a"]（会跳过 ".pnpm"）
+   */
+  extractImporterPackages(importer) {
+    const normalized = importer.replace(/\\/g, "/");
+    const parts = normalized.split("/");
+    const packages = [];
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (parts[i] !== "node_modules") continue;
+      const next = parts[i + 1];
+      if (!next || next.startsWith(".")) {
+        continue;
+      }
+      if (next.startsWith("@")) {
+        const name = parts[i + 2];
+        if (name) {
+          packages.push(`${next}/${name}`);
+        }
+        continue;
+      }
+      packages.push(next);
+    }
+    return packages;
+  }
+  /**
+   * 解析模块请求
+   * @returns 解析后的模块名，如果不需要重定向则返回 null
+   */
+  resolveModule(context) {
+    const { request, importer } = context;
+    if (!importer) {
+      return null;
+    }
+    const importerPackages = this.extractImporterPackages(importer);
+    if (importerPackages.length === 0) {
+      return null;
+    }
+    const requestPackageName = this.getRequestPackageName(request);
+    if (!requestPackageName) {
+      return null;
+    }
+    const candidateRules = this.rulesMap.get(requestPackageName);
+    if (!candidateRules || candidateRules.length === 0) {
+      return null;
+    }
+    for (const rule of candidateRules) {
+      let shouldRedirect = false;
+      for (const pkg of importerPackages) {
+        if (rule.dependents.has(pkg)) {
+          shouldRedirect = true;
+          break;
+        }
+      }
+      if (!shouldRedirect) {
+        continue;
+      }
+      if (request === rule.originalName) {
+        logger5.debug(`Resolving ${request} -> ${rule.aliasName} (from ${importer})`);
+        return rule.aliasName;
+      }
+      const prefix = `${rule.originalName}/`;
+      if (request.startsWith(prefix)) {
+        const resolved = `${rule.aliasName}${request.slice(rule.originalName.length)}`;
+        logger5.debug(`Resolving ${request} -> ${resolved} (from ${importer})`);
+        return resolved;
+      }
+    }
+    return null;
+  }
+  /**
+   * 获取别名路径映射
+   * 返回别名名称到实际路径的映射，供构建工具插件转换为各自的格式
+   */
+  getAliasPathMappings() {
+    const mappings = [];
+    for (const mapping of this.aliasMappings) {
+      const aliasPath = findPackagePath(mapping.aliasName, this.options.projectRoot);
+      const resolvedPath = aliasPath ?? join(this.options.projectRoot, "node_modules", mapping.aliasName);
+      mappings.push({
+        aliasName: mapping.aliasName,
+        originalName: mapping.originalName,
+        path: resolvedPath
+      });
+    }
+    return mappings;
+  }
+};
+function createAliasManager(options) {
+  return new AliasManager(options);
+}
+var logger6 = createLogger("package-installer");
+var INSTALL_TIMEOUT = 12e4;
+var PackageInstaller = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * 安装别名依赖
+   */
+  async installAliases(mappings) {
+    const result = {
+      success: true,
+      installed: [],
+      failed: [],
+      errors: []
+    };
+    if (mappings.length === 0) {
+      logger6.info("No aliases to install");
+      return result;
+    }
+    const toInstall = mappings.filter((m) => {
+      if (!m.installSpec) {
+        logger6.debug(`Skipping ${m.aliasName}: reusing existing installation`);
+        return false;
+      }
+      const aliasPath = join(this.options.projectRoot, "node_modules", m.aliasName);
+      if (!fileExists(aliasPath)) {
+        return true;
+      }
+      const versionMatch = this.verifyInstalledVersion(
+        aliasPath,
+        m.originalName,
+        m.resolvedVersion
+      );
+      if (!versionMatch) {
+        logger6.info(`${m.aliasName} exists but version mismatch, will reinstall`);
+        return true;
+      }
+      logger6.debug(`${m.aliasName} already installed with correct version`);
+      return false;
+    });
+    if (toInstall.length === 0) {
+      logger6.info("All aliases already installed with correct versions");
+      return result;
+    }
+    logger6.info(`Installing ${toInstall.length} alias packages...`);
+    const installSpecs = toInstall.map((m) => m.installSpec);
+    const installResult = await this.runInstall(installSpecs);
+    if (installResult.success) {
+      result.installed = toInstall.map((m) => m.aliasName);
+      logger6.info(`Successfully installed: ${result.installed.join(", ")}`);
+    } else {
+      result.success = false;
+      result.failed = toInstall.map((m) => m.aliasName);
+      result.errors = installResult.errors;
+      logger6.error(`Failed to install aliases: ${installResult.errors.join(", ")}`);
+    }
+    return result;
+  }
+  /**
+   * 验证已安装的别名版本是否正确
+   * @returns true 如果版本匹配
+   */
+  verifyInstalledVersion(aliasPath, expectedPackageName, expectedVersion) {
+    try {
+      const pkgJsonPath = join(aliasPath, "package.json");
+      if (!fileExists(pkgJsonPath)) {
+        return false;
+      }
+      const pkgJson = readPackageJsonCached(aliasPath);
+      if (!pkgJson) {
+        logger6.debug(`Failed to verify version: unable to read/parse ${pkgJsonPath}`);
+        return false;
+      }
+      if (pkgJson.name !== expectedPackageName) {
+        logger6.debug(
+          `Package name mismatch: expected ${expectedPackageName}, got ${pkgJson.name ?? "unknown"}`
+        );
+        return false;
+      }
+      const installedClean = semver.clean(pkgJson.version ?? "");
+      const expectedClean = semver.clean(expectedVersion);
+      if (!installedClean || !expectedClean || installedClean !== expectedClean) {
+        logger6.debug(
+          `Version mismatch: expected ${expectedVersion}, got ${pkgJson.version ?? "unknown"}`
+        );
+        return false;
+      }
+      return true;
+    } catch (error) {
+      logger6.debug(`Failed to verify version: ${String(error)}`);
+      return false;
+    }
+  }
+  /**
+   * 执行安装命令
+   */
+  async runInstall(packages) {
+    if (packages.length === 0) {
+      return { success: true, errors: [] };
+    }
+    const { packageManager, projectRoot } = this.options;
+    let command;
+    let args;
+    switch (packageManager) {
+      case "yarn":
+        command = "yarn";
+        args = ["add", ...packages];
+        break;
+      case "pnpm":
+        command = "pnpm";
+        args = ["add", ...packages];
+        break;
+      case "npm":
+      default:
+        command = "npm";
+        args = ["install", "--legacy-peer-deps", ...packages];
+        break;
+    }
+    const fullCommand = `${command} ${args.join(" ")}`;
+    logger6.info(`Running: ${fullCommand}`);
+    const startTime = Date.now();
+    return new Promise((resolve) => {
+      let resolved = false;
+      const child = spawn(command, args, {
+        cwd: projectRoot,
+        shell: true,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      const timeoutId = setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          logger6.error(`Install timeout after ${INSTALL_TIMEOUT / 1e3}s`);
+          child.kill("SIGTERM");
+          setTimeout(() => {
+            if (!child.killed) {
+              child.kill("SIGKILL");
+            }
+          }, 5e3);
+          resolve({
+            success: false,
+            errors: [`Install timeout after ${INSTALL_TIMEOUT / 1e3}s`]
+          });
+        }
+      }, INSTALL_TIMEOUT);
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.on("error", (error) => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeoutId);
+          logger6.error(`Install error: ${error.message}`);
+          resolve({
+            success: false,
+            errors: [error.message]
+          });
+        }
+      });
+      child.on("close", (code) => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeoutId);
+          const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+          if (code === 0) {
+            if (stdout) {
+              logger6.debug(`stdout: ${stdout}`);
+            }
+            logger6.info(`Install completed in ${elapsed}s`);
+            resolve({ success: true, errors: [] });
+          } else {
+            logger6.error(`Install failed with exit code ${code}`);
+            if (stdout) {
+              logger6.debug(`stdout: ${stdout}`);
+            }
+            if (stderr) {
+              logger6.debug(`stderr: ${stderr}`);
+            }
+            resolve({
+              success: false,
+              errors: stderr ? [stderr] : [`Process exited with code ${code}`]
+            });
+          }
+        }
+      });
+    });
+  }
+};
+function createPackageInstaller(options) {
+  return new PackageInstaller(options);
+}
+
+// src/core/resolver.ts
+var logger7 = createLogger("resolver");
+var DEFAULT_OPTIONS = {
+  autoInstall: true,
+  debug: false,
+  aliasPrefix: "aliased-"
+};
+var DepsConflictResolver = class {
+  options;
+  userOptions;
+  hooks;
+  environmentDetector = null;
+  analyzer = null;
+  aliasManager;
+  installer;
+  analysisResult = null;
+  initialized = false;
+  constructor(userOptions, hooks = {}) {
+    this.userOptions = userOptions;
+    this.hooks = hooks;
+    if (userOptions.debug) {
+      logger7.setLevel(1 /* DEBUG */);
+    }
+  }
+  /**
+   * 解析配置，填充默认值（异步，支持自动检测）
+   */
+  async resolveOptions(userOptions, projectRoot) {
+    this.environmentDetector = createEnvironmentDetector(projectRoot);
+    let packageManager;
+    if (!userOptions.packageManager || userOptions.packageManager === "auto") {
+      const detected = await this.environmentDetector.getDetectionResult();
+      packageManager = detected.packageManager;
+      logger7.info(
+        `Auto-detected package manager: ${packageManager} (from ${detected.detectedFrom})`
+      );
+    } else {
+      packageManager = userOptions.packageManager;
+    }
+    let registry;
+    if (!userOptions.registry) {
+      registry = await this.environmentDetector.getRegistryForPackageManager(packageManager);
+      if (registry !== DEFAULT_NPM_REGISTRY) {
+        logger7.info(`Auto-detected registry: ${registry}`);
+      }
+    } else {
+      registry = userOptions.registry;
+    }
+    return {
+      ...DEFAULT_OPTIONS,
+      dependencies: userOptions.dependencies,
+      projectRoot,
+      packageManager,
+      registry,
+      autoInstall: userOptions.autoInstall ?? DEFAULT_OPTIONS.autoInstall,
+      debug: userOptions.debug ?? DEFAULT_OPTIONS.debug,
+      aliasPrefix: userOptions.aliasPrefix ?? DEFAULT_OPTIONS.aliasPrefix,
+      excludeRedirects: userOptions.excludeRedirects ?? {}
+    };
+  }
+  /**
+   * 初始化解析器
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    logger7.info("Initializing dependencies resolver...");
+    const projectRoot = this.userOptions.projectRoot ?? process.cwd();
+    const validRoot = findProjectRoot(projectRoot);
+    if (!validRoot) {
+      throw new Error(`Could not find package.json in ${projectRoot} or parent directories`);
+    }
+    if (validRoot !== projectRoot) {
+      logger7.debug(`Adjusted project root to: ${validRoot}`);
+    }
+    this.options = await this.resolveOptions(this.userOptions, validRoot);
+    if (this.options.debug) {
+      logger7.setLevel(1 /* DEBUG */);
+    }
+    this.aliasManager = createAliasManager(this.options);
+    this.installer = createPackageInstaller(this.options);
+    this.analyzer = createDependencyAnalyzer(this.options);
+    this.analysisResult = await this.analyzer.analyze();
+    this.logMissingFirstLevelPeers(this.analysisResult);
+    this.aliasManager.initFromAnalysisResult(this.analysisResult);
+    if (this.hooks.onAnalysisComplete) {
+      await this.hooks.onAnalysisComplete(this.analysisResult);
+    }
+    if (this.options.autoInstall) {
+      await this.installDependencies();
+    }
+    this.initialized = true;
+    logger7.info("Dependencies resolver initialized");
+  }
+  /**
+   * 输出第一层依赖中缺失的 peer 依赖警告（不自动安装，仅提示）
+   *
+   * 放在 initialize 阶段统一输出，避免各插件重复打印，且在 autoInstall=false 时也能看到提示。
+   */
+  logMissingFirstLevelPeers(result) {
+    const missing = result.missingFirstLevelPeers;
+    if (!missing || missing.length === 0) {
+      return;
+    }
+    logger7.warn(`Found ${missing.length} unsatisfied peer dependencies (not auto-installing):`);
+    for (const peer of missing) {
+      logger7.warn(
+        `  - ${peer.packageName}@${peer.requiredRange} (required by ${peer.requestedBy})`
+      );
+    }
+  }
+  /**
+   * 安装所需依赖
+   *
+   * 安装策略（按用户需求）：
+   * 1. 只自动安装「主工程已声明的依赖 & peerDeps 要求版本与主工程版本冲突」的别名版本
+   * 2. 缺失的 peer 依赖（主工程未声明）：不自动安装，只警告
+   * 3. 内部依赖冲突（子依赖之间的版本冲突）：不自动安装，只做编译时重定向
+   *
+   * 这样可以避免"什么依赖都自动安装"的问题，用户可以根据警告自行决定是否安装缺失的依赖
+   */
+  async installDependencies() {
+    if (!this.analysisResult) {
+      throw new Error("Resolver not initialized. Call initialize() first.");
+    }
+    const { aliasMappings } = this.analysisResult;
+    const aliasResult = await this.installer.installAliases(aliasMappings);
+    if (!aliasResult.success) {
+      logger7.warn(`Some alias installations failed: ${aliasResult.errors.join(", ")}`);
+    }
+    if (this.hooks.onInstallComplete) {
+      await this.hooks.onInstallComplete(aliasMappings);
+    }
+  }
+  /**
+   * 解析模块请求
+   * @returns 解析后的模块名，如果不需要重定向则返回 null
+   */
+  resolveModule(request, importer) {
+    if (this.hooks.beforeResolve) {
+      const hookResult = this.hooks.beforeResolve(request, importer);
+      if (hookResult !== void 0) {
+        return hookResult;
+      }
+    }
+    return this.aliasManager.resolveModule({ request, importer });
+  }
+  /**
+   * 获取别名路径映射
+   * 返回别名名称到实际路径的映射，供构建工具插件转换为各自的格式
+   */
+  getAliasPathMappings() {
+    return this.aliasManager.getAliasPathMappings();
+  }
+  /**
+   * 获取分析结果
+   */
+  getAnalysisResult() {
+    return this.analysisResult;
+  }
+  /**
+   * 获取配置
+   */
+  getOptions() {
+    return { ...this.options };
+  }
+};
+
+// src/utils/module-request.ts
+function isPathLikeRequest(request) {
+  if (!request) return false;
+  if (request.startsWith(".")) {
+    return true;
+  }
+  if (request.startsWith("/")) {
+    return true;
+  }
+  if (/^[a-zA-Z]:[\\/]/.test(request)) {
+    return true;
+  }
+  if (request.startsWith("\\\\")) {
+    return true;
+  }
+  return false;
+}
+function isWebpackInternalRequest(request) {
+  return request.startsWith("webpack/") || request.startsWith("!");
+}
+
+// src/plugins/webpack/index.ts
+var logger8 = createLogger("webpack-plugin");
+var PLUGIN_NAME = "DepsConflictResolverWebpackPlugin";
+var DepsConflictResolverWebpackPlugin = class {
+  config;
+  resolver = null;
+  analysisResult = null;
+  initPromise = null;
+  initialized = false;
+  constructor(config) {
+    this.config = config;
+    if (config.debug) {
+      logger8.setLevel(1 /* DEBUG */);
+    }
+  }
+  /**
+   * 初始化解析器
+   */
+  async initialize() {
+    if (this.initialized) return;
+    logger8.info("Initializing dependencies resolver...");
+    const { hooks, ...resolverOptions } = this.config;
+    this.resolver = new DepsConflictResolver(resolverOptions, hooks);
+    await this.resolver.initialize();
+    this.analysisResult = this.resolver.getAnalysisResult();
+    if (this.analysisResult && this.analysisResult.aliasMappings.length > 0) {
+      logger8.info(`Detected ${this.analysisResult.aliasMappings.length} peer dependency conflicts`);
+      if (this.config.debug) {
+        logger8.debug(
+          "Alias mappings:",
+          this.analysisResult.aliasMappings.map((m) => ({
+            original: m.originalName,
+            alias: m.aliasName,
+            usedBy: m.usedBy,
+            allDependents: m.allDependents
+          }))
+        );
+      }
+    } else {
+      logger8.info("No peer dependency conflicts detected");
+    }
+    this.initialized = true;
+  }
+  /**
+   * 处理模块解析请求
+   * 直接修改 resolveData.request 来实现重定向
+   *
+   * 注意：这里直接使用别名包名作为新的请求，而不是转换为文件系统路径
+   * 因为 webpack 5 的 ESM 模式需要模块请求而不是目录路径
+   */
+  handleResolve(resolveData) {
+    const { request, contextInfo } = resolveData;
+    if (!request || isPathLikeRequest(request)) {
+      return;
+    }
+    if (isWebpackInternalRequest(request)) {
+      return;
+    }
+    if (!this.resolver) {
+      return;
+    }
+    const importer = contextInfo.issuer || resolveData.context;
+    if (!importer) {
+      return;
+    }
+    const resolvedModule = this.resolver.resolveModule(request, importer);
+    if (!resolvedModule) {
+      return;
+    }
+    if (this.config.debug) {
+      logger8.debug(`Redirecting ${request} -> ${resolvedModule} (importer: ${importer})`);
+    }
+    resolveData.request = resolvedModule;
+  }
+  apply(compiler) {
+    logger8.info("Applying DepsConflictResolverWebpackPlugin...");
+    this.initPromise = this.initialize();
+    compiler.hooks.beforeRun.tapPromise(PLUGIN_NAME, async () => {
+      await this.initPromise;
+    });
+    compiler.hooks.watchRun.tapPromise(PLUGIN_NAME, async () => {
+      await this.initPromise;
+    });
+    compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, (nmf) => {
+      nmf.hooks.beforeResolve.tapAsync(PLUGIN_NAME, (resolveData, callback) => {
+        this.initPromise.then(() => {
+          this.handleResolve(resolveData);
+          callback();
+        }).catch((err) => {
+          logger8.error("Error during module resolution:", err);
+          callback();
+        });
+      });
+    });
+    compiler.hooks.done.tap(PLUGIN_NAME, (stats) => {
+      if (stats.hasErrors()) {
+        return;
+      }
+      if (this.analysisResult && this.analysisResult.aliasMappings.length > 0) {
+        logger8.info(
+          `Resolved ${this.analysisResult.aliasMappings.length} peer dependency conflicts`
+        );
+      }
+    });
+  }
+  /**
+   * 获取解析器实例
+   */
+  getResolver() {
+    return this.resolver;
+  }
+  /**
+   * 获取分析结果
+   */
+  getAnalysisResult() {
+    return this.analysisResult;
+  }
+  /**
+   * 获取别名配置
+   * 返回 webpack 格式的别名映射
+   */
+  getAliasConfig() {
+    if (!this.resolver) {
+      return {};
+    }
+    const mappings = this.resolver.getAliasPathMappings();
+    const aliases = {};
+    for (const mapping of mappings) {
+      aliases[mapping.aliasName] = mapping.path;
+    }
+    return aliases;
+  }
+  /**
+   * 检查是否已初始化
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+};
+function createWebpackPlugin(config) {
+  return new DepsConflictResolverWebpackPlugin(config);
+}
+var webpack_default = DepsConflictResolverWebpackPlugin;
+
+export { DepsConflictResolverWebpackPlugin, createWebpackPlugin, webpack_default as default };
+//# sourceMappingURL=webpack.js.map
+//# sourceMappingURL=webpack.js.map