@olegkuibar/plunk 0.2.0-canary.04ff96f

package/dist/chunk-CSMZ6DZA.mjs

@@ -0,0 +1,367 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+
+// node_modules/.pnpm/citty@0.2.1/node_modules/citty/dist/_chunks/libs/scule.mjs
+var NUMBER_CHAR_RE = /\d/;
+var STR_SPLITTERS = [
+  "-",
+  "_",
+  "/",
+  "."
+];
+function isUppercase(char = "") {
+  if (NUMBER_CHAR_RE.test(char)) return;
+  return char !== char.toLowerCase();
+}
+function splitByCase(str, separators) {
+  const splitters = separators ?? STR_SPLITTERS;
+  const parts = [];
+  if (!str || typeof str !== "string") return parts;
+  let buff = "";
+  let previousUpper;
+  let previousSplitter;
+  for (const char of str) {
+    const isSplitter = splitters.includes(char);
+    if (isSplitter === true) {
+      parts.push(buff);
+      buff = "";
+      previousUpper = void 0;
+      continue;
+    }
+    const isUpper = isUppercase(char);
+    if (previousSplitter === false) {
+      if (previousUpper === false && isUpper === true) {
+        parts.push(buff);
+        buff = char;
+        previousUpper = isUpper;
+        continue;
+      }
+      if (previousUpper === true && isUpper === false && buff.length > 1) {
+        const lastChar = buff.at(-1);
+        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+        buff = lastChar + char;
+        previousUpper = isUpper;
+        continue;
+      }
+    }
+    buff += char;
+    previousUpper = isUpper;
+    previousSplitter = isSplitter;
+  }
+  parts.push(buff);
+  return parts;
+}
+function upperFirst(str) {
+  return str ? str[0].toUpperCase() + str.slice(1) : "";
+}
+function lowerFirst(str) {
+  return str ? str[0].toLowerCase() + str.slice(1) : "";
+}
+function pascalCase(str, opts) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => upperFirst(opts?.normalize ? p.toLowerCase() : p)).join("") : "";
+}
+function camelCase(str, opts) {
+  return lowerFirst(pascalCase(str || "", opts));
+}
+function kebabCase(str, joiner) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
+}
+
+// node_modules/.pnpm/citty@0.2.1/node_modules/citty/dist/index.mjs
+import { parseArgs as parseArgs$1 } from "util";
+function toArray(val) {
+  if (Array.isArray(val)) return val;
+  return val === void 0 ? [] : [val];
+}
+function formatLineColumns(lines, linePrefix = "") {
+  const maxLength = [];
+  for (const line of lines) for (const [i, element] of line.entries()) maxLength[i] = Math.max(maxLength[i] || 0, element.length);
+  return lines.map((l) => l.map((c, i) => linePrefix + c[i === 0 ? "padStart" : "padEnd"](maxLength[i])).join("  ")).join("\n");
+}
+function resolveValue(input) {
+  return typeof input === "function" ? input() : input;
+}
+var CLIError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "CLIError";
+    this.code = code;
+  }
+};
+function parseRawArgs(args = [], opts = {}) {
+  const booleans = new Set(opts.boolean || []);
+  const strings = new Set(opts.string || []);
+  const aliasMap = opts.alias || {};
+  const defaults = opts.default || {};
+  const aliasToMain = /* @__PURE__ */ new Map();
+  const mainToAliases = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(aliasMap)) {
+    const targets = value;
+    for (const target of targets) {
+      aliasToMain.set(key, target);
+      if (!mainToAliases.has(target)) mainToAliases.set(target, []);
+      mainToAliases.get(target).push(key);
+      aliasToMain.set(target, key);
+      if (!mainToAliases.has(key)) mainToAliases.set(key, []);
+      mainToAliases.get(key).push(target);
+    }
+  }
+  const options = {};
+  function getType(name) {
+    if (booleans.has(name)) return "boolean";
+    const aliases = mainToAliases.get(name) || [];
+    for (const alias of aliases) if (booleans.has(alias)) return "boolean";
+    return "string";
+  }
+  const allOptions = /* @__PURE__ */ new Set([
+    ...booleans,
+    ...strings,
+    ...Object.keys(aliasMap),
+    ...Object.values(aliasMap).flat(),
+    ...Object.keys(defaults)
+  ]);
+  for (const name of allOptions) if (!options[name]) options[name] = {
+    type: getType(name),
+    default: defaults[name]
+  };
+  for (const [alias, main] of aliasToMain.entries()) if (alias.length === 1 && options[main] && !options[main].short) options[main].short = alias;
+  const processedArgs = [];
+  const negatedFlags = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      processedArgs.push(...args.slice(i));
+      break;
+    }
+    if (arg.startsWith("--no-")) {
+      const flagName = arg.slice(5);
+      negatedFlags[flagName] = true;
+      continue;
+    }
+    processedArgs.push(arg);
+  }
+  let parsed;
+  try {
+    parsed = parseArgs$1({
+      args: processedArgs,
+      options: Object.keys(options).length > 0 ? options : void 0,
+      allowPositionals: true,
+      strict: false
+    });
+  } catch {
+    parsed = {
+      values: {},
+      positionals: processedArgs
+    };
+  }
+  const out = { _: [] };
+  out._ = parsed.positionals;
+  for (const [key, value] of Object.entries(parsed.values)) out[key] = value;
+  for (const [name] of Object.entries(negatedFlags)) {
+    out[name] = false;
+    const mainName = aliasToMain.get(name);
+    if (mainName) out[mainName] = false;
+    const aliases = mainToAliases.get(name);
+    if (aliases) for (const alias of aliases) out[alias] = false;
+  }
+  for (const [alias, main] of aliasToMain.entries()) {
+    if (out[alias] !== void 0 && out[main] === void 0) out[main] = out[alias];
+    if (out[main] !== void 0 && out[alias] === void 0) out[alias] = out[main];
+  }
+  return out;
+}
+var noColor = /* @__PURE__ */ (() => {
+  const env = globalThis.process?.env ?? {};
+  return env.NO_COLOR === "1" || env.TERM === "dumb" || env.TEST || env.CI;
+})();
+var _c = (c, r = 39) => (t) => noColor ? t : `\x1B[${c}m${t}\x1B[${r}m`;
+var bold = /* @__PURE__ */ _c(1, 22);
+var cyan = /* @__PURE__ */ _c(36);
+var gray = /* @__PURE__ */ _c(90);
+var underline = /* @__PURE__ */ _c(4, 24);
+function parseArgs(rawArgs, argsDef) {
+  const parseOptions = {
+    boolean: [],
+    string: [],
+    alias: {},
+    default: {}
+  };
+  const args = resolveArgs(argsDef);
+  for (const arg of args) {
+    if (arg.type === "positional") continue;
+    if (arg.type === "string" || arg.type === "enum") parseOptions.string.push(arg.name);
+    else if (arg.type === "boolean") parseOptions.boolean.push(arg.name);
+    if (arg.default !== void 0) parseOptions.default[arg.name] = arg.default;
+    if (arg.alias) parseOptions.alias[arg.name] = arg.alias;
+    const camelName = camelCase(arg.name);
+    const kebabName = kebabCase(arg.name);
+    if (camelName !== arg.name || kebabName !== arg.name) {
+      const existingAliases = toArray(parseOptions.alias[arg.name] || []);
+      if (camelName !== arg.name && !existingAliases.includes(camelName)) existingAliases.push(camelName);
+      if (kebabName !== arg.name && !existingAliases.includes(kebabName)) existingAliases.push(kebabName);
+      if (existingAliases.length > 0) parseOptions.alias[arg.name] = existingAliases;
+    }
+  }
+  const parsed = parseRawArgs(rawArgs, parseOptions);
+  const [...positionalArguments] = parsed._;
+  const parsedArgsProxy = new Proxy(parsed, { get(target, prop) {
+    return target[prop] ?? target[camelCase(prop)] ?? target[kebabCase(prop)];
+  } });
+  for (const [, arg] of args.entries()) if (arg.type === "positional") {
+    const nextPositionalArgument = positionalArguments.shift();
+    if (nextPositionalArgument !== void 0) parsedArgsProxy[arg.name] = nextPositionalArgument;
+    else if (arg.default === void 0 && arg.required !== false) throw new CLIError(`Missing required positional argument: ${arg.name.toUpperCase()}`, "EARG");
+    else parsedArgsProxy[arg.name] = arg.default;
+  } else if (arg.type === "enum") {
+    const argument = parsedArgsProxy[arg.name];
+    const options = arg.options || [];
+    if (argument !== void 0 && options.length > 0 && !options.includes(argument)) throw new CLIError(`Invalid value for argument: ${cyan(`--${arg.name}`)} (${cyan(argument)}). Expected one of: ${options.map((o) => cyan(o)).join(", ")}.`, "EARG");
+  } else if (arg.required && parsedArgsProxy[arg.name] === void 0) throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
+  return parsedArgsProxy;
+}
+function resolveArgs(argsDef) {
+  const args = [];
+  for (const [name, argDef] of Object.entries(argsDef || {})) args.push({
+    ...argDef,
+    name,
+    alias: toArray(argDef.alias)
+  });
+  return args;
+}
+function defineCommand(def) {
+  return def;
+}
+async function runCommand(cmd, opts) {
+  const cmdArgs = await resolveValue(cmd.args || {});
+  const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
+  const context = {
+    rawArgs: opts.rawArgs,
+    args: parsedArgs,
+    data: opts.data,
+    cmd
+  };
+  if (typeof cmd.setup === "function") await cmd.setup(context);
+  let result;
+  try {
+    const subCommands = await resolveValue(cmd.subCommands);
+    if (subCommands && Object.keys(subCommands).length > 0) {
+      const subCommandArgIndex = opts.rawArgs.findIndex((arg) => !arg.startsWith("-"));
+      const subCommandName = opts.rawArgs[subCommandArgIndex];
+      if (subCommandName) {
+        if (!subCommands[subCommandName]) throw new CLIError(`Unknown command ${cyan(subCommandName)}`, "E_UNKNOWN_COMMAND");
+        const subCommand = await resolveValue(subCommands[subCommandName]);
+        if (subCommand) await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
+      } else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+    }
+    if (typeof cmd.run === "function") result = await cmd.run(context);
+  } finally {
+    if (typeof cmd.cleanup === "function") await cmd.cleanup(context);
+  }
+  return { result };
+}
+async function resolveSubCommand(cmd, rawArgs, parent) {
+  const subCommands = await resolveValue(cmd.subCommands);
+  if (subCommands && Object.keys(subCommands).length > 0) {
+    const subCommandArgIndex = rawArgs.findIndex((arg) => !arg.startsWith("-"));
+    const subCommandName = rawArgs[subCommandArgIndex];
+    const subCommand = await resolveValue(subCommands[subCommandName]);
+    if (subCommand) return resolveSubCommand(subCommand, rawArgs.slice(subCommandArgIndex + 1), cmd);
+  }
+  return [cmd, parent];
+}
+async function showUsage(cmd, parent) {
+  try {
+    console.log(await renderUsage(cmd, parent) + "\n");
+  } catch (error) {
+    console.error(error);
+  }
+}
+var negativePrefixRe = /^no[-A-Z]/;
+async function renderUsage(cmd, parent) {
+  const cmdMeta = await resolveValue(cmd.meta || {});
+  const cmdArgs = resolveArgs(await resolveValue(cmd.args || {}));
+  const parentMeta = await resolveValue(parent?.meta || {});
+  const commandName = `${parentMeta.name ? `${parentMeta.name} ` : ""}` + (cmdMeta.name || process.argv[1]);
+  const argLines = [];
+  const posLines = [];
+  const commandsLines = [];
+  const usageLine = [];
+  for (const arg of cmdArgs) if (arg.type === "positional") {
+    const name = arg.name.toUpperCase();
+    const isRequired = arg.required !== false && arg.default === void 0;
+    const defaultHint = arg.default ? `="${arg.default}"` : "";
+    posLines.push([
+      cyan(name + defaultHint),
+      arg.description || "",
+      arg.valueHint ? `<${arg.valueHint}>` : ""
+    ]);
+    usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
+  } else {
+    const isRequired = arg.required === true && arg.default === void 0;
+    const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + (arg.type === "string" && (arg.valueHint || arg.default) ? `=${arg.valueHint ? `<${arg.valueHint}>` : `"${arg.default || ""}"`}` : "") + (arg.type === "enum" && arg.options ? `=<${arg.options.join("|")}>` : "");
+    argLines.push([cyan(argStr + (isRequired ? " (required)" : "")), arg.description || ""]);
+    if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
+      const negativeArgStr = [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ");
+      argLines.push([cyan(negativeArgStr + (isRequired ? " (required)" : "")), arg.negativeDescription || ""]);
+    }
+    if (isRequired) usageLine.push(argStr);
+  }
+  if (cmd.subCommands) {
+    const commandNames = [];
+    const subCommands = await resolveValue(cmd.subCommands);
+    for (const [name, sub] of Object.entries(subCommands)) {
+      const meta = await resolveValue((await resolveValue(sub))?.meta);
+      if (meta?.hidden) continue;
+      commandsLines.push([cyan(name), meta?.description || ""]);
+      commandNames.push(name);
+    }
+    usageLine.push(commandNames.join("|"));
+  }
+  const usageLines = [];
+  const version = cmdMeta.version || parentMeta.version;
+  usageLines.push(gray(`${cmdMeta.description} (${commandName + (version ? ` v${version}` : "")})`), "");
+  const hasOptions = argLines.length > 0 || posLines.length > 0;
+  usageLines.push(`${underline(bold("USAGE"))} ${cyan(`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}`)}`, "");
+  if (posLines.length > 0) {
+    usageLines.push(underline(bold("ARGUMENTS")), "");
+    usageLines.push(formatLineColumns(posLines, "  "));
+    usageLines.push("");
+  }
+  if (argLines.length > 0) {
+    usageLines.push(underline(bold("OPTIONS")), "");
+    usageLines.push(formatLineColumns(argLines, "  "));
+    usageLines.push("");
+  }
+  if (commandsLines.length > 0) {
+    usageLines.push(underline(bold("COMMANDS")), "");
+    usageLines.push(formatLineColumns(commandsLines, "  "));
+    usageLines.push("", `Use ${cyan(`${commandName} <command> --help`)} for more information about a command.`);
+  }
+  return usageLines.filter((l) => typeof l === "string").join("\n");
+}
+async function runMain(cmd, opts = {}) {
+  const rawArgs = opts.rawArgs || process.argv.slice(2);
+  const showUsage$1 = opts.showUsage || showUsage;
+  try {
+    if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+      await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+      process.exit(0);
+    } else if (rawArgs.length === 1 && rawArgs[0] === "--version") {
+      const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
+      if (!meta?.version) throw new CLIError("No version specified", "E_NO_VERSION");
+      console.log(meta.version);
+    } else await runCommand(cmd, { rawArgs });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+      console.error(error.message);
+    } else console.error(error, "\n");
+    process.exit(1);
+  }
+}
+
+export {
+  defineCommand,
+  runMain
+};

package/dist/chunk-CZM4TNAI.mjs

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  detectAllBundlers,
+  detectYarnNodeLinker
+} from "./chunk-34UXZ622.mjs";
+import {
+  getConsumerBackupPath,
+  getNodeModulesPackagePath
+} from "./chunk-EDUXIQ5W.mjs";
+import {
+  copyDir,
+  ensureDir,
+  exists,
+  incrementalCopy,
+  isNodeError,
+  removeDir
+} from "./chunk-HKNM3UWU.mjs";
+import {
+  consola,
+  verbose
+} from "./chunk-I6SN7BBN.mjs";
+
+// src/core/injector.ts
+import { readFile, readdir, realpath, stat } from "fs/promises";
+import { join as join3, resolve as resolve2 } from "path";
+
+// src/utils/bin-linker.ts
+import { mkdir, symlink, writeFile, chmod, rm } from "fs/promises";
+import { join, relative, resolve, sep } from "path";
+import { platform } from "os";
+function resolveBinEntries(pkg) {
+  if (!pkg.bin) return {};
+  if (typeof pkg.bin === "string") {
+    const binName = pkg.name.startsWith("@") ? pkg.name.split("/")[1] : pkg.name;
+    return { [binName]: pkg.bin };
+  }
+  return pkg.bin;
+}
+async function createBinLinks(consumerPath, packageName, pkg) {
+  const entries = resolveBinEntries(pkg);
+  if (Object.keys(entries).length === 0) return 0;
+  const binDir = join(consumerPath, "node_modules", ".bin");
+  await mkdir(binDir, { recursive: true });
+  const isWindows = platform() === "win32";
+  let count = 0;
+  for (const [binName, binPath] of Object.entries(entries)) {
+    const packageRoot = join(consumerPath, "node_modules", packageName);
+    const targetAbsolute = join(packageRoot, binPath);
+    const resolvedTarget = resolve(targetAbsolute);
+    if (!resolvedTarget.startsWith(resolve(packageRoot) + sep) && resolvedTarget !== resolve(packageRoot)) {
+      consola.warn(`bin "${binName}" points outside package directory, skipping`);
+      continue;
+    }
+    const targetRelative = relative(binDir, targetAbsolute).replace(
+      /\\/g,
+      "/"
+    );
+    if (isWindows) {
+      const cmdPath = join(binDir, `${binName}.cmd`);
+      const cmdContent = `@ECHO off\r
+GOTO start\r
+:find_dp0\r
+SET dp0=%~dp0\r
+EXIT /b\r
+:start\r
+CALL :find_dp0\r
+"%dp0%\\${targetRelative}" %*\r
+`;
+      await writeFile(cmdPath, cmdContent);
+      const shPath = join(binDir, binName);
+      const shContent = `#!/bin/sh
+exec node "${targetRelative}" "$@"
+`;
+      await writeFile(shPath, shContent);
+    } else {
+      const linkPath = join(binDir, binName);
+      try {
+        await rm(linkPath, { force: true });
+      } catch {
+      }
+      try {
+        await symlink(targetRelative, linkPath);
+        await chmod(targetAbsolute, 493);
+      } catch (err) {
+        if (isNodeError(err) && (err.code === "EPERM" || err.code === "EACCES")) {
+          verbose(`[bin-linker] Symlink failed (${err.code}), using shell wrapper for ${binName}`);
+          const shContent = `#!/bin/sh
+exec node "${targetRelative}" "$@"
+`;
+          await writeFile(linkPath, shContent);
+          await chmod(linkPath, 493);
+        } else {
+          throw err;
+        }
+      }
+    }
+    count++;
+  }
+  return count;
+}
+async function removeBinLinks(consumerPath, pkg) {
+  const entries = resolveBinEntries(pkg);
+  const binDir = join(consumerPath, "node_modules", ".bin");
+  const isWindows = platform() === "win32";
+  for (const binName of Object.keys(entries)) {
+    try {
+      await rm(join(binDir, binName), { force: true });
+      if (isWindows) {
+        await rm(join(binDir, `${binName}.cmd`), { force: true });
+      }
+    } catch {
+    }
+  }
+}
+
+// src/utils/bundler-cache.ts
+import { join as join2 } from "path";
+var CACHE_DIRS = {
+  vite: ["node_modules/.vite"],
+  next: [".next/cache"],
+  webpack: ["node_modules/.cache"]
+};
+async function invalidateBundlerCache(consumerPath) {
+  const bundlers = await detectAllBundlers(consumerPath);
+  for (const bundler of bundlers) {
+    if (!bundler.type) continue;
+    const dirs = CACHE_DIRS[bundler.type];
+    if (!dirs) continue;
+    for (const dir of dirs) {
+      const cacheDir = join2(consumerPath, dir);
+      if (await exists(cacheDir)) {
+        try {
+          await removeDir(cacheDir);
+          verbose(`[inject] Invalidated ${bundler.type} cache: ${dir}`);
+        } catch {
+          verbose(`[inject] Could not clear ${bundler.type} cache: ${dir} (locked?)`);
+        }
+      }
+    }
+  }
+}
+
+// src/core/injector.ts
+async function inject(storeEntry, consumerPath, pm) {
+  const targetDir = await resolveTargetDir(
+    consumerPath,
+    storeEntry.name,
+    pm,
+    storeEntry.version
+  );
+  verbose(`[inject] ${storeEntry.name}@${storeEntry.version} \u2192 ${targetDir}`);
+  await ensureDir(targetDir);
+  const { copied, removed, skipped } = await incrementalCopy(
+    storeEntry.packageDir,
+    targetDir
+  );
+  verbose(`[inject] ${copied} copied, ${removed} removed, ${skipped} skipped`);
+  if (copied > 0 || removed > 0) {
+    await invalidateBundlerCache(consumerPath);
+  }
+  const pkg = await readPackageJson(storeEntry.packageDir);
+  const binLinks = pkg ? await createBinLinks(consumerPath, storeEntry.name, pkg) : 0;
+  if (binLinks > 0) {
+    verbose(`[inject] Created ${binLinks} bin link(s)`);
+  }
+  return { copied, removed, skipped, binLinks };
+}
+async function backupExisting(consumerPath, packageName, pm) {
+  const installedDir = await resolveTargetDir(consumerPath, packageName, pm);
+  if (!await exists(installedDir)) return false;
+  const backupDir = getConsumerBackupPath(consumerPath, packageName);
+  await removeDir(backupDir);
+  await copyDir(installedDir, backupDir);
+  return true;
+}
+async function restoreBackup(consumerPath, packageName, pm) {
+  const backupDir = getConsumerBackupPath(consumerPath, packageName);
+  if (!await exists(backupDir)) return false;
+  const targetDir = await resolveTargetDir(consumerPath, packageName, pm);
+  await removeDir(targetDir);
+  await copyDir(backupDir, targetDir);
+  await removeDir(backupDir);
+  return true;
+}
+async function removeInjected(consumerPath, packageName, pm) {
+  const targetDir = await resolveTargetDir(consumerPath, packageName, pm);
+  const pkg = await readPackageJson(targetDir);
+  if (pkg) {
+    await removeBinLinks(consumerPath, pkg);
+  }
+  await removeDir(targetDir);
+}
+async function checkMissingDeps(storeEntry, consumerPath) {
+  const pkg = await readPackageJson(storeEntry.packageDir);
+  if (!pkg) return [];
+  const allDeps = {
+    ...pkg.dependencies,
+    ...Object.fromEntries(
+      Object.entries(pkg.peerDependencies ?? {}).filter(
+        ([name]) => !pkg.peerDependenciesMeta?.[name]?.optional
+      )
+    )
+  };
+  if (Object.keys(allDeps).length === 0) return [];
+  const missing = [];
+  for (const dep of Object.keys(allDeps)) {
+    const depPath = join3(consumerPath, "node_modules", dep);
+    if (!await exists(depPath)) {
+      missing.push(dep);
+    }
+  }
+  return missing;
+}
+async function resolveTargetDir(consumerPath, packageName, pm, version) {
+  const directPath = getNodeModulesPackagePath(consumerPath, packageName);
+  const needsSymlinkResolution = pm === "pnpm" || pm === "yarn" && await detectYarnNodeLinker(consumerPath) === "pnpm";
+  if (!needsSymlinkResolution) {
+    return directPath;
+  }
+  try {
+    const realPath = await resolveRealPath(directPath);
+    if (realPath !== resolve2(directPath)) {
+      verbose(`[inject] pnpm: resolved symlink \u2192 ${realPath}`);
+      return realPath;
+    }
+  } catch (err) {
+    if (isNodeError(err) && err.code !== "ENOENT") {
+      consola.debug(`pnpm symlink resolution error: ${err}`);
+    }
+  }
+  const pnpmDir = join3(consumerPath, "node_modules", ".pnpm");
+  if (await exists(pnpmDir)) {
+    verbose(`[inject] pnpm: scanning .pnpm/ for ${packageName}`);
+    const encodedName = packageName.replace("/", "+");
+    if (version) {
+      const exactEntry = `${encodedName}@${version}`;
+      const candidate = join3(pnpmDir, exactEntry, "node_modules", packageName);
+      if (await exists(candidate)) {
+        verbose(`[inject] pnpm: exact version match in .pnpm/ \u2192 ${candidate}`);
+        return candidate;
+      }
+    }
+    const entries = await readdir(pnpmDir);
+    for (const entry of entries) {
+      if (entry.startsWith(encodedName + "@")) {
+        const candidate = join3(
+          pnpmDir,
+          entry,
+          "node_modules",
+          packageName
+        );
+        if (await exists(candidate)) {
+          verbose(`[inject] pnpm: found in .pnpm/ \u2192 ${candidate}`);
+          return candidate;
+        }
+      }
+    }
+  }
+  consola.warn(`pnpm: falling back to direct node_modules path for ${packageName}`);
+  return directPath;
+}
+async function resolveRealPath(linkPath) {
+  try {
+    await stat(linkPath);
+    return await realpath(linkPath);
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") {
+      return resolve2(linkPath);
+    }
+    throw err;
+  }
+}
+async function readPackageJson(dir) {
+  try {
+    const content = await readFile(join3(dir, "package.json"), "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    if (isNodeError(err) && err.code !== "ENOENT") {
+      consola.warn(`Failed to read package.json in ${dir}: ${err}`);
+    }
+    return null;
+  }
+}
+
+export {
+  inject,
+  backupExisting,
+  restoreBackup,
+  removeInjected,
+  checkMissingDeps
+};