knarr 0.0.2 → 0.1.0

package/dist/index.mjs

@@ -1,7 +1,12 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -293,7 +298,7 @@ var init_logger = __esm({
 // src/utils/hash.ts
 import { createHash } from "crypto";
 import { readFile as readFile2, stat } from "fs/promises";
-import { relative as relative2 } from "path";
+import { join as join3, relative as relative2 } from "path";
 import { availableParallelism } from "os";
 function getXXHash() {
   if (!_xxhash) {
@@ -304,18 +309,28 @@ function getXXHash() {
   }
   return _xxhash;
 }
-async function computeContentHash(files, baseDir) {
-  const sorted = [...files].sort((a, b) => {
-    const relA = normalizePath(relative2(baseDir, a));
-    const relB = normalizePath(relative2(baseDir, b));
-    return relA.localeCompare(relB);
-  });
-  const currentFiles = new Set(sorted);
+async function computeContentHash(files, baseDir, contentOverrides = /* @__PURE__ */ new Map()) {
+  const fileByRel = new Map(
+    files.map((file) => [normalizePath(relative2(baseDir, file)), file])
+  );
+  for (const rel of contentOverrides.keys()) {
+    if (!fileByRel.has(rel)) fileByRel.set(rel, join3(baseDir, rel));
+  }
+  const sorted = [...fileByRel.entries()].sort(
+    ([relA], [relB]) => relA.localeCompare(relB)
+  );
+  const currentFiles = new Set(fileByRel.values());
   let cacheHits = 0;
   const contents = await Promise.all(
     sorted.map(
-      (file) => limit(async () => {
-        const rel = normalizePath(relative2(baseDir, file));
+      ([rel, file]) => limit(async () => {
+        const override = contentOverrides.get(rel);
+        if (override !== void 0) {
+          return {
+            rel,
+            content: Buffer.isBuffer(override) ? override : Buffer.from(override)
+          };
+        }
         const s = await stat(file);
         const cached = _contentCache.get(file);
         if (cached && cached.mtimeMs === s.mtimeMs && cached.size === s.size) {
@@ -331,7 +346,7 @@ async function computeContentHash(files, baseDir) {
   for (const key of _contentCache.keys()) {
     if (!currentFiles.has(key)) _contentCache.delete(key);
   }
-  verbose(`[hash] Computing content hash for ${files.length} files (${cacheHits} cached)`);
+  verbose(`[hash] Computing content hash for ${sorted.length} files (${cacheHits} cached)`);
   const hash = createHash("sha256");
   const lenBuf = Buffer.alloc(4);
   for (const { rel, content } of contents) {
@@ -382,13 +397,21 @@ var init_hash = __esm({
 function recordMutation(mutation) {
   mutations.push(mutation);
 }
+function getMutations() {
+  return [...mutations];
+}
+function markDryRunJsonReportPrinted() {
+  jsonReportPrinted = true;
+}
 function printDryRunReport() {
   if (mutations.length === 0) {
     consola.info("[dry-run] No mutations would be performed");
     return;
   }
   if (isJsonOutput()) {
+    if (jsonReportPrinted) return;
     console.log(JSON.stringify({ dryRun: true, mutations }, null, 2));
+    jsonReportPrinted = true;
     return;
   }
   const grouped = /* @__PURE__ */ new Map();
@@ -430,14 +453,16 @@ function printDryRunReport() {
 }
 function resetMutations() {
   mutations.length = 0;
+  jsonReportPrinted = false;
 }
-var mutations;
+var mutations, jsonReportPrinted;
 var init_dry_run = __esm({
   "src/utils/dry-run.ts"() {
     "use strict";
     init_logger();
     init_console();
     mutations = [];
+    jsonReportPrinted = false;
   }
 });
 
@@ -469,7 +494,7 @@ import {
   writeFile,
   constants
 } from "fs/promises";
-import { join as join3, dirname, relative as relative3, parse as parsePath } from "path";
+import { join as join4, dirname, relative as relative3, parse as parsePath } from "path";
 import { availableParallelism as availableParallelism2 } from "os";
 function isNodeError(err) {
   return err instanceof Error && "code" in err;
@@ -508,7 +533,39 @@ async function copyWithCoW(src, dest, options) {
 }
 async function collectFiles(dir) {
   const entries = await readdir(dir, { recursive: true, withFileTypes: true });
-  return entries.filter((e) => e.isFile()).map((e) => join3(e.parentPath, e.name));
+  return entries.filter((e) => e.isFile()).map((e) => join4(e.parentPath, e.name));
+}
+async function removeDestinationConflicts(destDir, relPath) {
+  const parts = relPath.split(/[\\/]/).filter(Boolean);
+  let current = destDir;
+  for (let i = 0; i < parts.length; i++) {
+    current = join4(current, parts[i]);
+    try {
+      const s = await stat2(current);
+      const isLeaf = i === parts.length - 1;
+      if (s.isDirectory()) {
+        if (isLeaf) {
+          if (isDryRun()) {
+            recordMutation({ type: "remove", path: current });
+          } else {
+            await rm(current, { recursive: true, force: true });
+          }
+        }
+        continue;
+      }
+      if (!isLeaf) {
+        if (isDryRun()) {
+          recordMutation({ type: "remove", path: current });
+          return;
+        } else {
+          await rm(current, { force: true });
+        }
+      }
+    } catch (err) {
+      if (isNodeError(err) && err.code === "ENOENT") return;
+      throw err;
+    }
+  }
 }
 async function incrementalCopy(srcDir, destDir, options = {}) {
   const srcFilesPromise = collectFiles(srcDir);
@@ -524,7 +581,7 @@ async function incrementalCopy(srcDir, destDir, options = {}) {
     srcFiles.map(
       (srcFile) => ioLimit(async () => {
         const rel = relative3(srcDir, srcFile);
-        const destFile = join3(destDir, rel);
+        const destFile = join4(destDir, rel);
         let needsCopy = true;
         let srcTimes = null;
         if (options.force) {
@@ -554,7 +611,7 @@ async function incrementalCopy(srcDir, destDir, options = {}) {
               }
             }
           } catch (err) {
-            if (isNodeError(err) && err.code === "ENOENT") {
+            if (isNodeError(err) && (err.code === "ENOENT" || err.code === "ENOTDIR")) {
               verbose(`[copy] ${rel} (new file)`);
             } else {
               throw err;
@@ -562,7 +619,9 @@ async function incrementalCopy(srcDir, destDir, options = {}) {
           }
         }
         if (needsCopy) {
+          await removeDestinationConflicts(destDir, rel);
           await copyWithCoW(srcFile, destFile);
+          if (isDryRun()) return "copied";
           if (!srcTimes) {
             const s = await stat2(srcFile);
             srcTimes = { atime: s.atime, mtime: s.mtime };
@@ -589,7 +648,12 @@ async function incrementalCopy(srcDir, destDir, options = {}) {
         if (isDryRun()) {
           recordMutation({ type: "remove", path: destFile });
         } else {
-          await rm(destFile);
+          await rm(destFile, { force: true }).catch((err) => {
+            if (isNodeError(err) && (err.code === "ENOENT" || err.code === "ENOTDIR" || err.code === "EISDIR" || err.code === "ERR_FS_EISDIR")) {
+              return;
+            }
+            throw err;
+          });
         }
       })
     )
@@ -691,17 +755,17 @@ var init_fs = __esm({
 
 // src/utils/pack-list.ts
 import { readFile as readFile3, readdir as readdir2, stat as stat3 } from "fs/promises";
-import { join as join4, relative as relative4, resolve as resolve2, sep } from "path";
+import { join as join5, relative as relative4, resolve as resolve2, sep } from "path";
 import picomatch from "picomatch";
 async function resolvePackFiles(packageDir, pkg) {
   const files = [];
   const absDir = resolve2(packageDir);
-  files.push(join4(absDir, "package.json"));
+  files.push(join5(absDir, "package.json"));
   const allFiles = await collectAllFiles(absDir, absDir);
   const allRelPaths = allFiles.map((f) => normalizePath(relative4(absDir, f)));
   if (pkg.files && pkg.files.length > 0) {
     for (const pattern of pkg.files) {
-      const target = join4(absDir, pattern);
+      const target = join5(absDir, pattern);
       const resolved = resolve2(target);
       if (!resolved.startsWith(absDir + sep) && resolved !== absDir) {
         consola.warn(`files pattern "${pattern}" escapes package directory, skipping`);
@@ -754,7 +818,7 @@ async function resolvePackFiles(packageDir, pkg) {
   const fileSet = new Set(files);
   const allFileSet = new Set(allFiles);
   for (const name of ["README.md", "README", "LICENSE", "LICENCE", "CHANGELOG.md"]) {
-    const p = join4(absDir, name);
+    const p = join5(absDir, name);
     if (fileSet.has(p)) continue;
     if (!allFileSet.has(p)) continue;
     files.push(p);
@@ -778,28 +842,38 @@ function shouldIgnore(relPath, matchers) {
   return false;
 }
 async function loadNpmIgnore(dir) {
-  const matchers = { literals: /* @__PURE__ */ new Set(), patterns: [], negations: [] };
+  const npmIgnore = await readIgnoreFile(dir, ".npmignore");
+  if (npmIgnore !== null) return parseIgnoreFile(npmIgnore);
+  const gitIgnore = await readIgnoreFile(dir, ".gitignore");
+  return gitIgnore === null ? createIgnoreMatchers() : parseIgnoreFile(gitIgnore);
+}
+async function readIgnoreFile(dir, filename) {
   try {
-    const content = await readFile3(join4(dir, ".npmignore"), "utf-8");
-    for (const line of content.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-      if (trimmed.startsWith("!")) {
-        const pat = trimmed.slice(1);
-        if (hasGlobChars(pat)) {
-          matchers.negations.push(picomatch(pat, { dot: true }));
-        } else {
-          matchers.negations.push(picomatch(pat, { dot: true }));
-        }
-      } else if (hasGlobChars(trimmed)) {
-        matchers.patterns.push(picomatch(trimmed, { dot: true }));
+    return await readFile3(join5(dir, filename), "utf-8");
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+function createIgnoreMatchers() {
+  return { literals: /* @__PURE__ */ new Set(), patterns: [], negations: [] };
+}
+function parseIgnoreFile(content) {
+  const matchers = { literals: /* @__PURE__ */ new Set(), patterns: [], negations: [] };
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith("!")) {
+      const pat = trimmed.slice(1);
+      if (hasGlobChars(pat)) {
+        matchers.negations.push(picomatch(pat, { dot: true }));
       } else {
-        matchers.literals.add(trimmed.replace(/\/$/, ""));
+        matchers.negations.push(picomatch(pat, { dot: true }));
       }
-    }
-  } catch (err) {
-    if (isNodeError(err) && err.code !== "ENOENT") {
-      throw err;
+    } else if (hasGlobChars(trimmed)) {
+      matchers.patterns.push(picomatch(trimmed, { dot: true }));
+    } else {
+      matchers.literals.add(trimmed.replace(/\/$/, ""));
     }
   }
   return matchers;
@@ -812,7 +886,7 @@ async function collectAllFiles(dir, rootDir) {
   try {
     const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = join4(dir, entry.name);
+      const full = join5(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === ".git") continue;
         if (dir === rootDir && entry.name === "node_modules") continue;
@@ -844,6 +918,7 @@ var init_pack_list = __esm({
       ".hg",
       ".DS_Store",
       ".npmrc",
+      ".gitignore",
       ".knarr",
       "test",
       "tests",
@@ -1028,6 +1103,208 @@ var init_lockfile = __esm({
   }
 });
 
+// src/utils/pm-detect.ts
+import { readFile as readFile5, stat as stat5 } from "fs/promises";
+import { join as join7, dirname as dirname3 } from "path";
+function parsePackageManagerSpec(value) {
+  if (typeof value !== "string") return null;
+  const match = value.trim().match(/^([^@\s]+)(?:@(.+))?$/);
+  if (!match) return null;
+  const name = match[1];
+  if (!VALID_PMS.has(name)) return null;
+  return {
+    name,
+    version: match[2]?.trim() ?? ""
+  };
+}
+async function readPackageManagerSpec(dir) {
+  try {
+    const raw = await readFile5(join7(dir, "package.json"), "utf-8");
+    const pkg = JSON.parse(raw);
+    return parsePackageManagerSpec(pkg.packageManager);
+  } catch {
+    return null;
+  }
+}
+async function findPackageManagerSpec(projectDir) {
+  let dir = projectDir;
+  for (; ; ) {
+    const spec = await readPackageManagerSpec(dir);
+    if (spec) return spec;
+    const parent = dirname3(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function yarnDefaultsToPnp(version) {
+  const normalized = version.trim().replace(/^npm:/, "");
+  if (normalized === "classic") return false;
+  const major = normalized.match(/^v?(\d+)(?:[.+-]|$)/);
+  if (major) return Number(major[1]) >= 2;
+  return normalized.length > 0;
+}
+async function detectPackageManager(projectDir) {
+  return (await detectPackageManagerInfo(projectDir)).packageManager;
+}
+async function detectPackageManagerInfo(projectDir) {
+  let dir = projectDir;
+  for (; ; ) {
+    const fromField = await readPackageManagerSpec(dir);
+    if (fromField) {
+      return {
+        packageManager: fromField.name,
+        source: "packageManager",
+        dir,
+        file: join7(dir, "package.json")
+      };
+    }
+    const results = await Promise.all(
+      LOCKFILES.map(async ([lockfile, packageManager]) => {
+        try {
+          await stat5(join7(dir, lockfile));
+          return { lockfile, packageManager };
+        } catch {
+          return null;
+        }
+      })
+    );
+    const found = results.find((result) => result !== null);
+    if (found) {
+      return {
+        packageManager: found.packageManager,
+        source: "lockfile",
+        dir,
+        file: join7(dir, found.lockfile)
+      };
+    }
+    const yarnArtifact = await findExistingFile(dir, YARN_PROJECT_ARTIFACTS);
+    if (yarnArtifact) {
+      return {
+        packageManager: "yarn",
+        source: "yarnArtifact",
+        dir,
+        file: join7(dir, yarnArtifact)
+      };
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) {
+      return {
+        packageManager: "npm",
+        source: "default",
+        dir: projectDir
+      };
+    }
+    dir = parent;
+  }
+}
+async function findExistingFile(dir, filenames) {
+  for (const filename of filenames) {
+    try {
+      await stat5(join7(dir, filename));
+      return filename;
+    } catch {
+    }
+  }
+  return null;
+}
+function readYarnrcScalar(content, key) {
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || !trimmed.includes(key)) continue;
+    const match = trimmed.match(new RegExp(`^${key}:\\s*(.+)$`));
+    if (!match) continue;
+    const value = match[1].trim().replace(/\s+#.*$/, "").trim().replace(/^["']|["']$/g, "");
+    if (value) return value;
+  }
+  return null;
+}
+async function findYarnrcScalar(projectDir, key) {
+  let dir = projectDir;
+  for (; ; ) {
+    try {
+      const content = await readFile5(join7(dir, ".yarnrc.yml"), "utf-8");
+      const value = readYarnrcScalar(content, key);
+      if (value) return value;
+    } catch {
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+async function detectYarnNodeLinker(projectDir) {
+  const value = await findYarnrcScalar(projectDir, "nodeLinker");
+  if (value === "node-modules" || value === "pnpm" || value === "pnp") {
+    return value;
+  }
+  return null;
+}
+async function detectYarnPnpmStoreFolder(projectDir) {
+  return findYarnrcScalar(projectDir, "pnpmStoreFolder");
+}
+async function hasYarnrcYml(projectDir) {
+  let dir = projectDir;
+  for (; ; ) {
+    try {
+      await stat5(join7(dir, ".yarnrc.yml"));
+      return true;
+    } catch {
+      const parent = dirname3(dir);
+      if (parent === dir) return false;
+      dir = parent;
+    }
+  }
+}
+async function hasYarnPnpManifest(projectDir) {
+  let dir = projectDir;
+  for (; ; ) {
+    const results = await Promise.all(
+      YARN_PNP_MANIFESTS.map(async (manifest) => {
+        try {
+          await stat5(join7(dir, manifest));
+          return true;
+        } catch {
+          return false;
+        }
+      })
+    );
+    if (results.some(Boolean)) return true;
+    const parent = dirname3(dir);
+    if (parent === dir) return false;
+    dir = parent;
+  }
+}
+async function hasYarnPnpMarkers(projectDir) {
+  if (await hasYarnPnpManifest(projectDir)) return true;
+  return await detectYarnNodeLinker(projectDir) === "pnp";
+}
+async function isYarnPnpProject(projectDir) {
+  const linker = await detectYarnNodeLinker(projectDir);
+  if (linker === "pnp") return true;
+  if (linker === "node-modules" || linker === "pnpm") return false;
+  if (await hasYarnPnpManifest(projectDir)) return true;
+  if (await hasYarnrcYml(projectDir)) return true;
+  const spec = await findPackageManagerSpec(projectDir);
+  return spec?.name === "yarn" && yarnDefaultsToPnp(spec.version);
+}
+var VALID_PMS, LOCKFILES, YARN_PNP_MANIFESTS, YARN_PROJECT_ARTIFACTS;
+var init_pm_detect = __esm({
+  "src/utils/pm-detect.ts"() {
+    "use strict";
+    VALID_PMS = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "bun"]);
+    LOCKFILES = [
+      ["pnpm-lock.yaml", "pnpm"],
+      ["bun.lockb", "bun"],
+      ["bun.lock", "bun"],
+      ["yarn.lock", "yarn"],
+      ["package-lock.json", "npm"],
+      ["npm-shrinkwrap.json", "npm"]
+    ];
+    YARN_PNP_MANIFESTS = [".pnp.cjs", ".pnp.js", ".pnp.loader.mjs"];
+    YARN_PROJECT_ARTIFACTS = [".yarnrc.yml", ...YARN_PNP_MANIFESTS];
+  }
+});
+
 // src/core/history.ts
 var history_exports = {};
 __export(history_exports, {
@@ -1039,13 +1316,13 @@ __export(history_exports, {
   resolveHistoryLimit: () => resolveHistoryLimit,
   restoreHistoryEntry: () => restoreHistoryEntry
 });
-import { readdir as readdir4, readFile as readFile5 } from "fs/promises";
-import { join as join6 } from "path";
+import { readdir as readdir4, readFile as readFile6 } from "fs/promises";
+import { join as join8 } from "path";
 async function captureHistory(name, version, oldEntryDir, historyLimit) {
-  const metaPath = join6(oldEntryDir, ".knarr-meta.json");
+  const metaPath = join8(oldEntryDir, ".knarr-meta.json");
   let meta;
   try {
-    meta = JSON.parse(await readFile5(metaPath, "utf-8"));
+    meta = JSON.parse(await readFile6(metaPath, "utf-8"));
   } catch {
     verbose(`[history] Could not read meta from ${metaPath}, skipping history capture`);
     return;
@@ -1065,12 +1342,12 @@ async function captureHistory(name, version, oldEntryDir, historyLimit) {
   const tmpHistoryEntry = entryDir + `.tmp-${process.pid}`;
   try {
     await ensureDir(tmpHistoryEntry);
-    const oldPkgDir = join6(oldEntryDir, "package");
+    const oldPkgDir = join8(oldEntryDir, "package");
     if (await exists(oldPkgDir)) {
-      await moveDir(oldPkgDir, join6(tmpHistoryEntry, "package"));
+      await moveDir(oldPkgDir, join8(tmpHistoryEntry, "package"));
     }
     await atomicWriteFile(
-      join6(tmpHistoryEntry, ".knarr-meta.json"),
+      join8(tmpHistoryEntry, ".knarr-meta.json"),
       JSON.stringify(meta, null, 2)
     );
     await moveDir(tmpHistoryEntry, entryDir);
@@ -1093,16 +1370,16 @@ async function listHistory(name, version) {
   }
   const result = [];
   for (const buildId of entries) {
-    const entryDir = join6(historyDir, buildId);
-    const metaPath = join6(entryDir, ".knarr-meta.json");
+    const entryDir = join8(historyDir, buildId);
+    const metaPath = join8(entryDir, ".knarr-meta.json");
     try {
-      const meta = JSON.parse(await readFile5(metaPath, "utf-8"));
+      const meta = JSON.parse(await readFile6(metaPath, "utf-8"));
       result.push({
         buildId: meta.buildId ?? buildId,
         contentHash: meta.contentHash,
         publishedAt: meta.publishedAt,
         sourcePath: meta.sourcePath,
-        packageDir: join6(entryDir, "package")
+        packageDir: join8(entryDir, "package")
       });
     } catch {
     }
@@ -1112,15 +1389,15 @@ async function listHistory(name, version) {
 }
 async function getHistoryEntry(name, version, buildId) {
   const entryDir = getHistoryEntryPath(name, version, buildId);
-  const metaPath = join6(entryDir, ".knarr-meta.json");
+  const metaPath = join8(entryDir, ".knarr-meta.json");
   try {
-    const meta = JSON.parse(await readFile5(metaPath, "utf-8"));
+    const meta = JSON.parse(await readFile6(metaPath, "utf-8"));
     return {
       buildId: meta.buildId ?? buildId,
       contentHash: meta.contentHash,
       publishedAt: meta.publishedAt,
       sourcePath: meta.sourcePath,
-      packageDir: join6(entryDir, "package")
+      packageDir: join8(entryDir, "package")
     };
   } catch {
     return null;
@@ -1131,17 +1408,17 @@ async function restoreHistoryEntry(name, version, buildId, historyLimit) {
   if (!entry) return null;
   const storeEntryDir = getStoreEntryPath(name, version);
   const historyEntryDir = getHistoryEntryPath(name, version, buildId);
-  const historyPkg = join6(historyEntryDir, "package");
-  const historyMeta = join6(historyEntryDir, ".knarr-meta.json");
-  const metaContent = await readFile5(historyMeta, "utf-8");
-  const storePkg = join6(storeEntryDir, "package");
-  const storeMeta = join6(storeEntryDir, ".knarr-meta.json");
+  const historyPkg = join8(historyEntryDir, "package");
+  const historyMeta = join8(historyEntryDir, ".knarr-meta.json");
+  const metaContent = await readFile6(historyMeta, "utf-8");
+  const storePkg = join8(storeEntryDir, "package");
+  const storeMeta = join8(storeEntryDir, ".knarr-meta.json");
   if (!await exists(historyPkg)) {
     throw new Error(`History entry ${buildId} is missing its package directory`);
   }
-  const currentMetaContent = await readFile5(storeMeta, "utf-8").catch(() => null);
+  const currentMetaContent = await readFile6(storeMeta, "utf-8").catch(() => null);
   const oldEntryDir = storeEntryDir + `.restore-old-${process.pid}-${Date.now()}`;
-  const oldPkg = join6(oldEntryDir, "package");
+  const oldPkg = join8(oldEntryDir, "package");
   let stagedOld = false;
   let historyMovedToStore = false;
   try {
@@ -1151,7 +1428,7 @@ async function restoreHistoryEntry(name, version, buildId, historyLimit) {
         await moveDir(storePkg, oldPkg);
       }
       if (currentMetaContent) {
-        await atomicWriteFile(join6(oldEntryDir, ".knarr-meta.json"), currentMetaContent);
+        await atomicWriteFile(join8(oldEntryDir, ".knarr-meta.json"), currentMetaContent);
       }
       stagedOld = true;
     }
@@ -1227,30 +1504,35 @@ var workspace_exports = {};
 __export(workspace_exports, {
   buildReverseAdjacency: () => buildReverseAdjacency,
   buildWorkspaceGraph: () => buildWorkspaceGraph,
+  filterPublishableWorkspaceGraph: () => filterPublishableWorkspaceGraph,
+  findWorkspacePackageRoot: () => findWorkspacePackageRoot,
   findWorkspacePackages: () => findWorkspacePackages,
   findWorkspaceRoot: () => findWorkspaceRoot,
   parseCatalogs: () => parseCatalogs
 });
-import { readFile as readFile6, readdir as readdir5 } from "fs/promises";
-import { join as join7, dirname as dirname3, resolve as resolve3, relative as relative5 } from "path";
+import { readFile as readFile7, readdir as readdir5 } from "fs/promises";
+import { join as join9, dirname as dirname4, resolve as resolve3, relative as relative5 } from "path";
 import picomatch2 from "picomatch";
 async function findWorkspaceRoot(startDir) {
   let dir = startDir;
   for (; ; ) {
-    if (await exists(join7(dir, "pnpm-workspace.yaml"))) {
+    if (await exists(join9(dir, "pnpm-workspace.yaml"))) {
       return dir;
     }
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
+async function findWorkspacePackageRoot(startDir) {
+  return await findWorkspaceRoot(startDir) ?? await findPackageJsonWorkspaceRoot(startDir);
+}
 async function parseCatalogs(workspaceRoot) {
   const result = { default: {}, named: {} };
-  const filePath = join7(workspaceRoot, "pnpm-workspace.yaml");
+  const filePath = join9(workspaceRoot, "pnpm-workspace.yaml");
   let content;
   try {
-    content = await readFile6(filePath, "utf-8");
+    content = await readFile7(filePath, "utf-8");
   } catch {
     return result;
   }
@@ -1319,7 +1601,7 @@ async function findWorkspacePackages(startDir) {
   const rootDir = pnpmRoot ?? await findPackageJsonWorkspaceRoot(startDir);
   if (!rootDir) return [];
   try {
-    const rootPkg = JSON.parse(await readFile6(join7(rootDir, "package.json"), "utf-8"));
+    const rootPkg = JSON.parse(await readFile7(join9(rootDir, "package.json"), "utf-8"));
     const workspaces = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces : rootPkg.workspaces?.packages ?? [];
     if (workspaces.length === 0) return [];
     const positive = workspaces.filter((p) => !p.startsWith("!"));
@@ -1330,10 +1612,10 @@ async function findWorkspacePackages(startDir) {
   }
 }
 async function parsePnpmWorkspacePackages(workspaceRoot) {
-  const filePath = join7(workspaceRoot, "pnpm-workspace.yaml");
+  const filePath = join9(workspaceRoot, "pnpm-workspace.yaml");
   let content;
   try {
-    content = await readFile6(filePath, "utf-8");
+    content = await readFile7(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -1360,11 +1642,11 @@ async function findPackageJsonWorkspaceRoot(startDir) {
   let dir = startDir;
   for (; ; ) {
     try {
-      const pkg = JSON.parse(await readFile6(join7(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(await readFile7(join9(dir, "package.json"), "utf-8"));
       if (pkg.workspaces) return dir;
     } catch {
     }
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -1382,7 +1664,7 @@ async function resolveWorkspaceGlobs(rootDir, patterns, negations = []) {
           foundGlob = true;
           globParts.push(part);
         } else {
-          staticPrefix = join7(staticPrefix, part);
+          staticPrefix = join9(staticPrefix, part);
         }
       }
       if (globParts.length === 1 && globParts[0] === "*") {
@@ -1390,8 +1672,8 @@ async function resolveWorkspaceGlobs(rootDir, patterns, negations = []) {
           const entries = await readdir5(staticPrefix, { withFileTypes: true });
           for (const entry of entries) {
             if (entry.isDirectory()) {
-              const pkgDir = join7(staticPrefix, entry.name);
-              if (await exists(join7(pkgDir, "package.json"))) {
+              const pkgDir = join9(staticPrefix, entry.name);
+              if (await exists(join9(pkgDir, "package.json"))) {
                 results.push(pkgDir);
               }
             }
@@ -1403,14 +1685,14 @@ async function resolveWorkspaceGlobs(rootDir, patterns, negations = []) {
         const candidates = await collectDirs(rootDir, 8);
         for (const candidate of candidates) {
           const rel = normalizePath(relative5(rootDir, candidate));
-          if (isMatch(rel) && await exists(join7(candidate, "package.json"))) {
+          if (isMatch(rel) && await exists(join9(candidate, "package.json"))) {
             results.push(candidate);
           }
         }
       }
     } else {
       const pkgDir = resolve3(rootDir, pattern);
-      if (await exists(join7(pkgDir, "package.json"))) {
+      if (await exists(join9(pkgDir, "package.json"))) {
         results.push(pkgDir);
       }
     }
@@ -1430,7 +1712,7 @@ async function collectDirs(dir, maxDepth) {
     const entries = await readdir5(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name === "node_modules" || entry.name === ".git") continue;
-      const full = join7(dir, entry.name);
+      const full = join9(dir, entry.name);
       results.push(full);
       results.push(...await collectDirs(full, maxDepth - 1));
     }
@@ -1444,7 +1726,7 @@ async function buildWorkspaceGraph(startDir) {
   for (const dir of dirs) {
     try {
       const pkg = JSON.parse(
-        await readFile6(join7(dir, "package.json"), "utf-8")
+        await readFile7(join9(dir, "package.json"), "utf-8")
       );
       if (pkg.name && pkg.version) {
         packages.push({ name: pkg.name, version: pkg.version, dir, pkg });
@@ -1469,6 +1751,19 @@ async function buildWorkspaceGraph(startDir) {
   }
   return { packages, adjacency };
 }
+function filterPublishableWorkspaceGraph(graph) {
+  const packages = graph.packages.filter((pkg) => !pkg.pkg.private);
+  const names = new Set(packages.map((pkg) => pkg.name));
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    const deps = graph.adjacency.get(pkg.name) ?? /* @__PURE__ */ new Set();
+    adjacency.set(
+      pkg.name,
+      new Set([...deps].filter((dep) => names.has(dep)))
+    );
+  }
+  return { packages, adjacency };
+}
 function buildReverseAdjacency(adjacency) {
   const reverse = /* @__PURE__ */ new Map();
   for (const name of adjacency.keys()) {
@@ -1491,10 +1786,25 @@ function parseKeyValue(line) {
   const colonIdx = trimmed.indexOf(":");
   if (colonIdx <= 0) return null;
   const key = trimmed.slice(0, colonIdx).trim();
-  const value = trimmed.slice(colonIdx + 1).trim();
+  const value = stripYamlInlineComment(trimmed.slice(colonIdx + 1)).trim();
   if (!key || !value) return null;
+  const unquotedKey = key.replace(/^["']|["']$/g, "");
   const unquoted = value.replace(/^["']|["']$/g, "");
-  return [key, unquoted];
+  return [unquotedKey, unquoted];
+}
+function stripYamlInlineComment(value) {
+  let quote = null;
+  for (let i = 0; i < value.length; i++) {
+    const char = value[i];
+    if ((char === '"' || char === "'") && value[i - 1] !== "\\") {
+      quote = quote === char ? null : quote ?? char;
+      continue;
+    }
+    if (!quote && char === "#" && (i === 0 || /\s/.test(value[i - 1]))) {
+      return value.slice(0, i);
+    }
+  }
+  return value;
 }
 var init_workspace = __esm({
   "src/utils/workspace.ts"() {
@@ -1505,16 +1815,16 @@ var init_workspace = __esm({
 });
 
 // src/core/publisher.ts
-import { readFile as readFile7, stat as stat5 } from "fs/promises";
-import { join as join8, relative as relative6, dirname as dirname4, resolve as resolve4 } from "path";
+import { readFile as readFile8, stat as stat6 } from "fs/promises";
+import { delimiter, join as join10, relative as relative6, dirname as dirname5, resolve as resolve4 } from "path";
 import { spawn } from "child_process";
 import { platform } from "os";
 import { availableParallelism as availableParallelism3 } from "os";
 async function publish(packageDir, options = {}) {
-  const pkgPath = join8(packageDir, "package.json");
+  const pkgPath = join10(packageDir, "package.json");
   let pkgContent;
   try {
-    pkgContent = await readFile7(pkgPath, "utf-8");
+    pkgContent = await readFile8(pkgPath, "utf-8");
   } catch {
     throw new Error(`No package.json found in ${packageDir}`);
   }
@@ -1522,11 +1832,6 @@ async function publish(packageDir, options = {}) {
   if (!pkg.name) throw new Error("package.json missing 'name' field");
   if (!pkg.version) throw new Error("package.json missing 'version' field");
   validatePackageIdentity(pkg.name, pkg.version);
-  if (pkg.private && !options.allowPrivate) {
-    throw new Error(
-      `Package "${pkg.name}" is private. Use --private flag to publish private packages.`
-    );
-  }
   await runLifecycleHook(packageDir, pkg, "preknarr");
   if (options.runScripts !== false) {
     await runLifecycleHook(packageDir, pkg, "prepack");
@@ -1535,7 +1840,7 @@ async function publish(packageDir, options = {}) {
   if (pkg.publishConfig?.directory) {
     publishDir = resolve4(packageDir, pkg.publishConfig.directory);
     try {
-      const s = await stat5(publishDir);
+      const s = await stat6(publishDir);
       if (!s.isDirectory()) {
         throw new Error(`publishConfig.directory "${pkg.publishConfig.directory}" is not a directory`);
       }
@@ -1547,22 +1852,46 @@ async function publish(packageDir, options = {}) {
     }
     verbose(`[publish] Using publishConfig.directory: ${publishDir}`);
   }
-  const filePkg = publishDir !== packageDir ? JSON.parse(await readFile7(join8(publishDir, "package.json"), "utf-8").catch(() => JSON.stringify(pkg))) : pkg;
-  const files = await resolvePackFiles(publishDir, filePkg);
+  const publishPkgPath = join10(publishDir, "package.json");
+  const publishDirHasPackageJson = publishDir === packageDir || await exists(publishPkgPath);
+  const filePkg = publishDirHasPackageJson ? JSON.parse(await readFile8(publishPkgPath, "utf-8")) : pkg;
+  if (!filePkg.name) throw new Error("publish package.json missing 'name' field");
+  if (!filePkg.version) throw new Error("publish package.json missing 'version' field");
+  validatePackageIdentity(filePkg.name, filePkg.version);
+  if (filePkg.private && !options.allowPrivate) {
+    throw new Error(
+      `Package "${filePkg.name}" is private. Use --private flag to publish private packages.`
+    );
+  }
+  const packListPkg = publishDirHasPackageJson ? filePkg : { ...filePkg, files: void 0 };
+  const files = await resolvePackFiles(publishDir, packListPkg);
   if (files.length === 0) {
     throw new Error("No publishable files found");
   }
-  verbose(`[publish] Resolved ${files.length} files for ${pkg.name}@${pkg.version}`);
-  const contentHash = await computeContentHash(files, publishDir);
-  await preloadWorkspaceVersions(pkg, packageDir);
-  await preloadCatalogs(pkg, packageDir);
+  verbose(`[publish] Resolved ${files.length} files for ${filePkg.name}@${filePkg.version}`);
+  await preloadWorkspaceVersions(filePkg, packageDir);
+  await preloadCatalogs(filePkg, packageDir);
+  let processedPkg = rewriteProtocolVersions(filePkg);
+  processedPkg = applyPublishConfig(processedPkg);
+  const contentOverrides = /* @__PURE__ */ new Map();
+  if (processedPkg !== filePkg || !publishDirHasPackageJson) {
+    contentOverrides.set("package.json", JSON.stringify(processedPkg, null, 2));
+  }
+  const hashFiles = [...files];
+  const hashFileRels = new Set(
+    files.map((file) => relative6(publishDir, file).replace(/\\/g, "/"))
+  );
+  for (const rel of contentOverrides.keys()) {
+    if (!hashFileRels.has(rel)) hashFiles.push(join10(publishDir, rel));
+  }
+  const contentHash = await computeContentHash(hashFiles, publishDir, contentOverrides);
   if (!options.force) {
-    const existingMeta = await readMeta(pkg.name, pkg.version);
+    const existingMeta = await readMeta(filePkg.name, filePkg.version);
     if (existingMeta && existingMeta.contentHash === contentHash) {
-      consola.info(`${pkg.name}@${pkg.version} already up to date (no changes since last publish)`);
+      consola.info(`${filePkg.name}@${filePkg.version} already up to date (no changes since last publish)`);
       return {
-        name: pkg.name,
-        version: pkg.version,
+        name: filePkg.name,
+        version: filePkg.version,
         fileCount: files.length,
         skipped: true,
         contentHash,
@@ -1570,17 +1899,17 @@ async function publish(packageDir, options = {}) {
       };
     }
   }
-  const storeEntryDir = getStoreEntryPath(pkg.name, pkg.version);
+  const storeEntryDir = getStoreEntryPath(filePkg.name, filePkg.version);
   const result = await withFileLock(
     storeEntryDir + ".lock",
     async () => {
       if (!options.force) {
-        const metaUnderLock = await readMeta(pkg.name, pkg.version);
+        const metaUnderLock = await readMeta(filePkg.name, filePkg.version);
         if (metaUnderLock && metaUnderLock.contentHash === contentHash) {
-          consola.info(`${pkg.name}@${pkg.version} already up to date (no changes since last publish)`);
+          consola.info(`${filePkg.name}@${filePkg.version} already up to date (no changes since last publish)`);
           return {
-            name: pkg.name,
-            version: pkg.version,
+            name: filePkg.name,
+            version: filePkg.version,
             fileCount: files.length,
             skipped: true,
             contentHash,
@@ -1589,33 +1918,36 @@ async function publish(packageDir, options = {}) {
         }
       }
       const tmpDir = storeEntryDir + `.tmp-${process.pid}-${Date.now()}`;
-      const tmpPackageDir = join8(tmpDir, "package");
+      const tmpPackageDir = join10(tmpDir, "package");
       const buildId = contentHash.slice(9, 17);
       try {
         await ensurePrivateDir(tmpPackageDir);
-        let processedPkg = rewriteProtocolVersions(pkg);
-        processedPkg = applyPublishConfig(processedPkg);
         verbose(`[publish] Copying files to temp store...`);
         const uniqueDirs = new Set(
-          files.map((file) => dirname4(join8(tmpPackageDir, relative6(publishDir, file))))
+          files.map((file) => dirname5(join10(tmpPackageDir, relative6(publishDir, file))))
         );
         await Promise.all([...uniqueDirs].map((d) => ensureDir(d)));
         await Promise.all(
           files.map(
             (file) => copyLimit(async () => {
               const rel = relative6(publishDir, file);
-              const dest = join8(tmpPackageDir, rel);
-              if (rel === "package.json" && processedPkg !== pkg) {
-                await atomicWriteFile(dest, JSON.stringify(processedPkg, null, 2));
+              const normalizedRel = rel.replace(/\\/g, "/");
+              const dest = join10(tmpPackageDir, rel);
+              const override = contentOverrides.get(normalizedRel);
+              if (override !== void 0) {
+                await atomicWriteFile(
+                  dest,
+                  Buffer.isBuffer(override) ? override.toString("utf-8") : override
+                );
               } else {
                 await copyWithCoW(file, dest, { ensureParent: false });
               }
             })
           )
         );
-        if (publishDir !== packageDir) {
+        if (contentOverrides.has("package.json")) {
           await atomicWriteFile(
-            join8(tmpPackageDir, "package.json"),
+            join10(tmpPackageDir, "package.json"),
             JSON.stringify(processedPkg, null, 2)
           );
         }
@@ -1627,7 +1959,7 @@ async function publish(packageDir, options = {}) {
           buildId
         };
         await atomicWriteFile(
-          join8(tmpDir, ".knarr-meta.json"),
+          join10(tmpDir, ".knarr-meta.json"),
           JSON.stringify(meta, null, 2)
         );
         const hadOld = await exists(storeEntryDir);
@@ -1651,7 +1983,7 @@ async function publish(packageDir, options = {}) {
         if (hadOld && !isDryRun()) {
           try {
             const { captureHistory: captureHistory2 } = await Promise.resolve().then(() => (init_history(), history_exports));
-            await captureHistory2(pkg.name, pkg.version, oldDir, options.historyLimit);
+            await captureHistory2(filePkg.name, filePkg.version, oldDir, options.historyLimit);
           } catch (err) {
             verbose(`[publish] History capture failed: ${err instanceof Error ? err.message : String(err)}`);
           }
@@ -1663,8 +1995,8 @@ async function publish(packageDir, options = {}) {
         throw err;
       }
       return {
-        name: pkg.name,
-        version: pkg.version,
+        name: filePkg.name,
+        version: filePkg.version,
         fileCount: files.length,
         skipped: false,
         contentHash,
@@ -1679,10 +2011,46 @@ async function publish(packageDir, options = {}) {
   }
   await runLifecycleHook(packageDir, pkg, "postknarr");
   consola.success(
-    `Published ${pkg.name}@${pkg.version} (${files.length} files) [${result.buildId}]`
+    `Published ${filePkg.name}@${filePkg.version} (${files.length} files) [${result.buildId}]`
   );
   return result;
 }
+function pathEnvKey(env) {
+  if (platform() !== "win32") return "PATH";
+  return Object.keys(env).find((key) => key.toLowerCase() === "path") ?? "Path";
+}
+function setEnvVar(env, key, value) {
+  if (platform() === "win32") {
+    const lowered = key.toLowerCase();
+    for (const existingKey of Object.keys(env)) {
+      if (existingKey.toLowerCase() === lowered) {
+        delete env[existingKey];
+      }
+    }
+  }
+  env[key] = value;
+}
+function buildLifecycleEnv(packageDir, pkg, hookName, script) {
+  const env = { ...process.env };
+  const key = pathEnvKey(env);
+  const existingPath = env[key] ?? "";
+  setEnvVar(
+    env,
+    key,
+    [
+      join10(packageDir, "node_modules", ".bin"),
+      existingPath
+    ].filter(Boolean).join(delimiter)
+  );
+  if (!("INIT_CWD" in env) || !env.INIT_CWD) {
+    setEnvVar(env, "INIT_CWD", packageDir);
+  }
+  setEnvVar(env, "npm_lifecycle_event", hookName);
+  setEnvVar(env, "npm_lifecycle_script", script);
+  setEnvVar(env, "npm_package_name", pkg.name);
+  setEnvVar(env, "npm_package_version", pkg.version);
+  return env;
+}
 async function runLifecycleHook(packageDir, pkg, hookName) {
   const script = pkg.scripts?.[hookName];
   if (!script) return;
@@ -1694,13 +2062,16 @@ async function runLifecycleHook(packageDir, pkg, hookName) {
     });
     return;
   }
-  verbose(`[lifecycle] Running ${hookName}: ${script}`);
+  const command = await resolveLifecycleCommand(packageDir, hookName, script);
+  verbose(`[lifecycle] Running ${hookName}: ${command}`);
   return new Promise((resolve8, reject) => {
     const isWin = platform() === "win32";
     const shell = isWin ? "cmd" : "sh";
     const shellFlag = isWin ? "/c" : "-c";
-    const child = spawn(shell, [shellFlag, script], {
+    const env = buildLifecycleEnv(packageDir, pkg, hookName, script);
+    const child = spawn(shell, [shellFlag, command], {
       cwd: packageDir,
+      env,
       stdio: "inherit"
     });
     const timer = setTimeout(() => {
@@ -1721,6 +2092,10 @@ async function runLifecycleHook(packageDir, pkg, hookName) {
     });
   });
 }
+async function resolveLifecycleCommand(packageDir, hookName, script) {
+  const shouldUseYarn = await hasYarnPnpMarkers(packageDir) || (await detectPackageManagerInfo(packageDir)).packageManager === "yarn" && await isYarnPnpProject(packageDir);
+  return shouldUseYarn ? `yarn run ${hookName}` : script;
+}
 function applyPublishConfig(pkg) {
   if (!pkg.publishConfig) return pkg;
   const result = { ...pkg };
@@ -1749,13 +2124,9 @@ function rewriteProtocolVersions(pkg) {
     const newDeps = { ...deps };
     for (const [name, version] of Object.entries(deps)) {
       if (version.startsWith("workspace:")) {
-        const versionPart = version.slice("workspace:".length);
-        if (versionPart === "*" || versionPart === "^" || versionPart === "~") {
-          const depVersion = _cachedWorkspaceVersions?.versions.get(name) ?? pkg.version;
-          newDeps[name] = versionPart === "*" ? depVersion : versionPart + depVersion;
-        } else {
-          newDeps[name] = versionPart;
-        }
+        const resolved = resolveWorkspaceSpecifier(name, version);
+        if (!resolved) continue;
+        newDeps[name] = resolved;
         fieldChanged = true;
         changed = true;
       } else if (version.startsWith("catalog:")) {
@@ -1783,6 +2154,32 @@ function rewriteProtocolVersions(pkg) {
   }
   return changed ? result : pkg;
 }
+function resolveWorkspaceSpecifier(depName, specifier) {
+  const raw = specifier.slice("workspace:".length);
+  const alias = parseWorkspaceAlias(raw);
+  const targetName = alias?.name ?? depName;
+  const versionPart = alias?.range ?? raw;
+  if (versionPart === "*" || versionPart === "^" || versionPart === "~") {
+    const depVersion = _cachedWorkspaceVersions?.versions.get(targetName);
+    if (!depVersion) {
+      consola.warn(
+        `workspace: specifier for "${targetName}" could not be resolved \u2014 published package.json will contain "${specifier}" which may cause install failures`
+      );
+      return null;
+    }
+    const resolved = versionPart === "*" ? depVersion : versionPart + depVersion;
+    return alias && targetName !== depName ? `npm:${targetName}@${resolved}` : resolved;
+  }
+  return alias && targetName !== depName ? `npm:${targetName}@${versionPart}` : versionPart;
+}
+function parseWorkspaceAlias(specifierBody) {
+  const atIndex = specifierBody.lastIndexOf("@");
+  if (atIndex <= 0) return null;
+  const name = specifierBody.slice(0, atIndex);
+  const range = specifierBody.slice(atIndex + 1);
+  if (!name || !range) return null;
+  return { name, range };
+}
 function resolveCatalogVersion(specifier, depName, catalogs) {
   const catalogRef = specifier.slice("catalog:".length);
   if (catalogRef === "" || catalogRef === "default") {
@@ -1792,8 +2189,8 @@ function resolveCatalogVersion(specifier, depName, catalogs) {
 }
 async function getWorkspaceRoot(packageDir) {
   if (_cachedWorkspaceRoot?.dir === packageDir) return _cachedWorkspaceRoot.root;
-  const { findWorkspaceRoot: findWorkspaceRoot2 } = await Promise.resolve().then(() => (init_workspace(), workspace_exports));
-  const root = await findWorkspaceRoot2(packageDir);
+  const { findWorkspacePackageRoot: findWorkspacePackageRoot2 } = await Promise.resolve().then(() => (init_workspace(), workspace_exports));
+  const root = await findWorkspacePackageRoot2(packageDir);
   _cachedWorkspaceRoot = { dir: packageDir, root };
   return root;
 }
@@ -1813,7 +2210,6 @@ async function preloadWorkspaceVersions(pkg, packageDir) {
     _cachedWorkspaceVersions = null;
     return;
   }
-  if (_cachedWorkspaceVersions?.root === root) return;
   const { findWorkspacePackages: findWorkspacePackages2 } = await Promise.resolve().then(() => (init_workspace(), workspace_exports));
   const pkgDirs = await findWorkspacePackages2(root);
   const versions = /* @__PURE__ */ new Map();
@@ -1821,7 +2217,7 @@ async function preloadWorkspaceVersions(pkg, packageDir) {
     pkgDirs.map(async (dir) => {
       try {
         const depPkg = JSON.parse(
-          await readFile7(join8(dir, "package.json"), "utf-8")
+          await readFile8(join10(dir, "package.json"), "utf-8")
         );
         if (depPkg.name && depPkg.version) {
           versions.set(depPkg.name, depPkg.version);
@@ -1848,8 +2244,8 @@ async function preloadCatalogs(pkg, packageDir) {
     _cachedCatalogs = null;
     return;
   }
-  const workspaceFile = join8(root, "pnpm-workspace.yaml");
-  const mtimeMs = (await stat5(workspaceFile).catch(() => null))?.mtimeMs ?? 0;
+  const workspaceFile = join10(root, "pnpm-workspace.yaml");
+  const mtimeMs = (await stat6(workspaceFile).catch(() => null))?.mtimeMs ?? 0;
   if (_cachedCatalogs?.root === root && _cachedCatalogs.mtimeMs === mtimeMs) return;
   const { parseCatalogs: parseCatalogs2 } = await Promise.resolve().then(() => (init_workspace(), workspace_exports));
   const catalogs = await parseCatalogs2(root);
@@ -1870,6 +2266,7 @@ var init_publisher = __esm({
     init_logger();
     init_dry_run();
     init_validators();
+    init_pm_detect();
     copyLimit = pLimit(Math.max(availableParallelism3(), 8));
     HOOK_TIMEOUT = parseInt(process.env.KNARR_HOOK_TIMEOUT ?? "30000", 10);
     PUBLISH_CONFIG_OVERRIDES = [
@@ -1888,9 +2285,54 @@ var init_publisher = __esm({
 });
 
 // src/utils/bin-linker.ts
-import { mkdir as mkdir3, symlink, writeFile as writeFile2, chmod, rm as rm3 } from "fs/promises";
-import { join as join9, relative as relative7, resolve as resolve5, sep as sep2 } from "path";
+import {
+  mkdir as mkdir3,
+  symlink,
+  writeFile as writeFile2,
+  chmod,
+  rm as rm3,
+  lstat,
+  readFile as readFile9,
+  readlink
+} from "fs/promises";
+import { join as join11, relative as relative7, resolve as resolve5, sep as sep2 } from "path";
 import { platform as platform2 } from "os";
+function safeInterpreter(value) {
+  return value && SAFE_INTERPRETER_RE.test(value) ? value : "node";
+}
+function parseShebangInterpreter(content) {
+  const firstLine = content.split(/\r?\n/, 1)[0]?.trim();
+  if (!firstLine?.startsWith("#!")) return "node";
+  const command = firstLine.slice(2).trim();
+  const parts = command.split(/\s+/).filter(Boolean);
+  if (parts.length === 0) return "node";
+  const executable = parts[0].replace(/\\/g, "/").split("/").pop();
+  if (executable === "env") {
+    const args = parts.slice(1);
+    const interpreter = args[0] === "-S" ? args[1] : args[0];
+    return safeInterpreter(interpreter);
+  }
+  return safeInterpreter(executable);
+}
+async function readBinInterpreter(targetAbsolute) {
+  try {
+    return parseShebangInterpreter(await readFile9(targetAbsolute, "utf-8"));
+  } catch {
+    return "node";
+  }
+}
+function resolveBinPath(binDir, binName, suffix = "") {
+  if (!binName || binName === "." || binName === ".." || CONTROL_CHARS_RE2.test(binName) || binName.includes("/") || binName.includes("\\") || binName.includes(":")) {
+    return null;
+  }
+  const path = join11(binDir, `${binName}${suffix}`);
+  const resolvedBinDir = resolve5(binDir);
+  const resolvedPath = resolve5(path);
+  if (resolvedPath !== resolvedBinDir && resolvedPath.startsWith(resolvedBinDir + sep2)) {
+    return path;
+  }
+  return null;
+}
 function resolveBinEntries(pkg) {
   if (!pkg.bin) return {};
   if (typeof pkg.bin === "string") {
@@ -1902,28 +2344,46 @@ function resolveBinEntries(pkg) {
 async function createBinLinks(consumerPath, packageName, pkg) {
   const entries = resolveBinEntries(pkg);
   if (Object.keys(entries).length === 0) return 0;
+  const binDir = join11(consumerPath, "node_modules", ".bin");
+  const safeEntries = Object.entries(entries).map(([binName, binPath]) => ({
+    binName,
+    binPath,
+    linkPath: resolveBinPath(binDir, binName),
+    cmdPath: resolveBinPath(binDir, binName, ".cmd"),
+    ps1Path: resolveBinPath(binDir, binName, ".ps1")
+  })).filter((entry) => {
+    if (!entry.linkPath || !entry.cmdPath || !entry.ps1Path) {
+      consola.warn(`bin name "${entry.binName}" is not safe, skipping`);
+      return false;
+    }
+    return true;
+  });
+  const packageRoot = join11(consumerPath, "node_modules", packageName);
+  const resolvedPackageRoot = resolve5(packageRoot);
+  const validEntries = safeEntries.filter(({ binName, binPath }) => {
+    const resolvedTarget = resolve5(join11(packageRoot, binPath));
+    if (resolvedTarget.startsWith(resolvedPackageRoot + sep2) || resolvedTarget === resolvedPackageRoot) {
+      return true;
+    }
+    consola.warn(`bin "${binName}" points outside package directory, skipping`);
+    return false;
+  });
+  if (validEntries.length === 0) return 0;
   if (isDryRun()) {
-    for (const binName of Object.keys(entries)) {
-      recordMutation({ type: "bin-link", path: join9(consumerPath, "node_modules", ".bin", binName), detail: packageName });
+    for (const { linkPath } of validEntries) {
+      recordMutation({ type: "bin-link", path: linkPath, detail: packageName });
     }
-    verbose(`[dry-run] would create ${Object.keys(entries).length} bin link(s) for ${packageName}`);
-    return Object.keys(entries).length;
+    verbose(`[dry-run] would create ${validEntries.length} bin link(s) for ${packageName}`);
+    return validEntries.length;
   }
-  const binDir = join9(consumerPath, "node_modules", ".bin");
   await mkdir3(binDir, { recursive: true });
   const isWindows = platform2() === "win32";
   let count = 0;
-  for (const [binName, binPath] of Object.entries(entries)) {
-    const packageRoot = join9(consumerPath, "node_modules", packageName);
-    const targetAbsolute = join9(packageRoot, binPath);
-    const resolvedTarget = resolve5(targetAbsolute);
-    if (!resolvedTarget.startsWith(resolve5(packageRoot) + sep2) && resolvedTarget !== resolve5(packageRoot)) {
-      consola.warn(`bin "${binName}" points outside package directory, skipping`);
-      continue;
-    }
+  for (const { binName, binPath, linkPath, cmdPath, ps1Path } of validEntries) {
+    const targetAbsolute = join11(packageRoot, binPath);
     const targetRelative = normalizePath(relative7(binDir, targetAbsolute));
+    const interpreter = await readBinInterpreter(targetAbsolute);
     if (isWindows) {
-      const cmdPath = join9(binDir, `${binName}.cmd`);
       const targetWindows = targetRelative.replace(/\//g, "\\");
       const cmdContent = `@ECHO off\r
 GOTO start\r
@@ -1932,23 +2392,21 @@ SET dp0=%~dp0\r
 EXIT /b\r
 :start\r
 CALL :find_dp0\r
-node "%dp0%\\${targetWindows}" %*\r
+${interpreter} "%dp0%\\${targetWindows}" %*\r
 `;
       await writeFile2(cmdPath, cmdContent);
-      const ps1Path = join9(binDir, `${binName}.ps1`);
       const ps1Content = `#!/usr/bin/env pwsh
 $basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
-& node "$basedir/${targetRelative}" $args
+& ${interpreter} "$basedir/${targetRelative}" $args
 exit $LASTEXITCODE
 `;
       await writeFile2(ps1Path, ps1Content);
-      const shPath = join9(binDir, binName);
       const shContent = `#!/bin/sh
-exec node "${targetRelative}" "$@"
+basedir=$(dirname "$0")
+exec ${interpreter} "$basedir/${targetRelative}" "$@"
 `;
-      await writeFile2(shPath, shContent);
+      await writeFile2(linkPath, shContent);
     } else {
-      const linkPath = join9(binDir, binName);
       try {
         await rm3(linkPath, { force: true });
       } catch {
@@ -1960,7 +2418,8 @@ exec node "${targetRelative}" "$@"
         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}" "$@"
+basedir=$(dirname "$0")
+exec ${interpreter} "$basedir/${targetRelative}" "$@"
 `;
           await writeFile2(linkPath, shContent);
           await chmod(linkPath, 493);
@@ -1975,26 +2434,62 @@ exec node "${targetRelative}" "$@"
 }
 async function removeBinLinks(consumerPath, pkg) {
   const entries = resolveBinEntries(pkg);
+  const binDir = join11(consumerPath, "node_modules", ".bin");
+  const safeEntries = Object.keys(entries).map((binName) => ({
+    binName,
+    linkPath: resolveBinPath(binDir, binName),
+    cmdPath: resolveBinPath(binDir, binName, ".cmd"),
+    ps1Path: resolveBinPath(binDir, binName, ".ps1")
+  })).filter(
+    (entry) => !!entry.linkPath && !!entry.cmdPath && !!entry.ps1Path
+  );
   if (isDryRun()) {
-    for (const binName of Object.keys(entries)) {
-      recordMutation({ type: "bin-unlink", path: join9(consumerPath, "node_modules", ".bin", binName) });
+    for (const { linkPath } of safeEntries) {
+      recordMutation({ type: "bin-unlink", path: linkPath });
     }
-    verbose(`[dry-run] would remove ${Object.keys(entries).length} bin link(s)`);
+    verbose(`[dry-run] would remove ${safeEntries.length} bin link(s)`);
     return;
   }
-  const binDir = join9(consumerPath, "node_modules", ".bin");
   const isWindows = platform2() === "win32";
-  for (const binName of Object.keys(entries)) {
+  const packageRoot = join11(consumerPath, "node_modules", pkg.name);
+  for (const { linkPath, cmdPath, ps1Path } of safeEntries) {
     try {
-      await rm3(join9(binDir, binName), { force: true });
+      if (await binFileBelongsToPackage(binDir, linkPath, packageRoot)) {
+        await rm3(linkPath, { force: true });
+      }
       if (isWindows) {
-        await rm3(join9(binDir, `${binName}.cmd`), { force: true });
-        await rm3(join9(binDir, `${binName}.ps1`), { force: true });
+        if (await binFileBelongsToPackage(binDir, cmdPath, packageRoot)) {
+          await rm3(cmdPath, { force: true });
+        }
+        if (await binFileBelongsToPackage(binDir, ps1Path, packageRoot)) {
+          await rm3(ps1Path, { force: true });
+        }
       }
     } catch {
     }
   }
 }
+async function binFileBelongsToPackage(binDir, linkPath, packageRoot) {
+  let fileStat;
+  try {
+    fileStat = await lstat(linkPath);
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") return false;
+    throw err;
+  }
+  const resolvedPackageRoot = resolve5(packageRoot);
+  if (fileStat.isSymbolicLink()) {
+    const target = await readlink(linkPath);
+    const resolvedTarget = resolve5(binDir, target);
+    return resolvedTarget === resolvedPackageRoot || resolvedTarget.startsWith(resolvedPackageRoot + sep2);
+  }
+  if (!fileStat.isFile()) return false;
+  const content = await readFile9(linkPath, "utf-8");
+  const relPackageRoot = normalizePath(relative7(binDir, packageRoot));
+  const relWindowsPackageRoot = relPackageRoot.replace(/\//g, "\\");
+  return content.includes(`${relPackageRoot}/`) || content.includes(`${relPackageRoot}"`) || content.includes(`${relWindowsPackageRoot}\\`) || content.includes(`${relWindowsPackageRoot}"`);
+}
+var CONTROL_CHARS_RE2, SAFE_INTERPRETER_RE;
 var init_bin_linker = __esm({
   "src/utils/bin-linker.ts"() {
     "use strict";
@@ -2003,106 +2498,31 @@ var init_bin_linker = __esm({
     init_logger();
     init_paths();
     init_dry_run();
+    CONTROL_CHARS_RE2 = /[\x00-\x1F\x7F]/;
+    SAFE_INTERPRETER_RE = /^[A-Za-z0-9._+-]+$/;
   }
 });
 
-// src/utils/pm-detect.ts
-import { readFile as readFile8, stat as stat6 } from "fs/promises";
-import { join as join10, dirname as dirname5 } from "path";
-async function readPackageManagerField(dir) {
-  try {
-    const raw = await readFile8(join10(dir, "package.json"), "utf-8");
-    const pkg = JSON.parse(raw);
-    if (typeof pkg.packageManager !== "string") return null;
-    const name = pkg.packageManager.split("@")[0];
-    return VALID_PMS.has(name) ? name : null;
-  } catch {
-    return null;
+// src/utils/bundler-detect.ts
+import { join as join12 } from "path";
+async function detectAllBundlers(projectDir) {
+  const checks = BUNDLER_CONFIGS.flatMap(
+    ([type, configFiles]) => configFiles.map(async (configFile) => ({
+      type,
+      configFile: join12(projectDir, configFile),
+      found: await exists(join12(projectDir, configFile))
+    }))
+  );
+  const all = await Promise.all(checks);
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const { type, configFile, found } of all) {
+    if (found && !seen.has(type)) {
+      seen.add(type);
+      results.push({ type, configFile });
+    }
   }
-}
-async function detectPackageManager(projectDir) {
-  let dir = projectDir;
-  for (; ; ) {
-    const fromField = await readPackageManagerField(dir);
-    if (fromField) return fromField;
-    const results = await Promise.all(
-      LOCKFILES.map(async ([lockfile, pm]) => {
-        try {
-          await stat6(join10(dir, lockfile));
-          return pm;
-        } catch {
-          return null;
-        }
-      })
-    );
-    const found = results.find((pm) => pm !== null);
-    if (found) return found;
-    const parent = dirname5(dir);
-    if (parent === dir) return "npm";
-    dir = parent;
-  }
-}
-async function detectYarnNodeLinker(projectDir) {
-  let dir = projectDir;
-  for (; ; ) {
-    let content;
-    try {
-      content = await readFile8(join10(dir, ".yarnrc.yml"), "utf-8");
-    } catch {
-      const parent = dirname5(dir);
-      if (parent === dir) return null;
-      dir = parent;
-      continue;
-    }
-    for (const line of content.split("\n")) {
-      const trimmed = line.trim();
-      if (trimmed.startsWith("#") || !trimmed.includes("nodeLinker")) continue;
-      const match = trimmed.match(/^nodeLinker:\s*(.+)$/);
-      if (match) {
-        const value = match[1].trim().replace(/^["']|["']$/g, "");
-        if (value === "node-modules" || value === "pnpm" || value === "pnp") {
-          return value;
-        }
-      }
-    }
-    return null;
-  }
-}
-var VALID_PMS, LOCKFILES;
-var init_pm_detect = __esm({
-  "src/utils/pm-detect.ts"() {
-    "use strict";
-    VALID_PMS = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "bun"]);
-    LOCKFILES = [
-      ["pnpm-lock.yaml", "pnpm"],
-      ["bun.lockb", "bun"],
-      ["bun.lock", "bun"],
-      ["yarn.lock", "yarn"],
-      ["package-lock.json", "npm"]
-    ];
-  }
-});
-
-// src/utils/bundler-detect.ts
-import { join as join11 } from "path";
-async function detectAllBundlers(projectDir) {
-  const checks = BUNDLER_CONFIGS.flatMap(
-    ([type, configFiles]) => configFiles.map(async (configFile) => ({
-      type,
-      configFile: join11(projectDir, configFile),
-      found: await exists(join11(projectDir, configFile))
-    }))
-  );
-  const all = await Promise.all(checks);
-  const seen = /* @__PURE__ */ new Set();
-  const results = [];
-  for (const { type, configFile, found } of all) {
-    if (found && !seen.has(type)) {
-      seen.add(type);
-      results.push({ type, configFile });
-    }
-  }
-  return results;
+  return results;
 }
 var BUNDLER_CONFIGS;
 var init_bundler_detect = __esm({
@@ -2120,27 +2540,29 @@ var init_bundler_detect = __esm({
 });
 
 // src/utils/bundler-cache.ts
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 async function invalidateBundlerCache(consumerPath) {
   if (isDryRun()) {
     verbose(`[dry-run] would invalidate bundler caches for ${consumerPath}`);
     recordMutation({ type: "cache-invalidate", path: consumerPath });
-    return;
+    return 0;
   }
   let bundlers = bundlerCache.get(consumerPath);
   if (!bundlers) {
     bundlers = await detectAllBundlers(consumerPath);
     bundlerCache.set(consumerPath, bundlers);
   }
+  let invalidated = 0;
   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 = join12(consumerPath, dir);
+      const cacheDir = join13(consumerPath, dir);
       if (await exists(cacheDir)) {
         try {
           await removeDir(cacheDir);
+          invalidated++;
           verbose(`[inject] Invalidated ${bundler.type} cache: ${dir}`);
         } catch {
           verbose(`[inject] Could not clear ${bundler.type} cache: ${dir} (locked?)`);
@@ -2148,6 +2570,7 @@ async function invalidateBundlerCache(consumerPath) {
       }
     }
   }
+  return invalidated;
 }
 var CACHE_DIRS, bundlerCache;
 var init_bundler_cache = __esm({
@@ -2166,59 +2589,78 @@ var init_bundler_cache = __esm({
 });
 
 // src/core/injector.ts
-import { readFile as readFile9, readdir as readdir6, realpath, stat as stat7 } from "fs/promises";
-import { join as join13, resolve as resolve6 } from "path";
+import { lstat as lstat2, readFile as readFile10, readdir as readdir6, realpath, rm as rm4, symlink as symlink2 } from "fs/promises";
+import { dirname as dirname6, isAbsolute as isAbsolute2, join as join14, relative as relative8, resolve as resolve6 } from "path";
+import { platform as platform3 } from "os";
 async function inject(storeEntry, consumerPath, pm, options = {}) {
-  const targetDir = await resolveTargetDir(
+  const targetDir = await resolveInjectionTarget(
     consumerPath,
     storeEntry.name,
     pm,
-    storeEntry.version
+    storeEntry.version,
+    { repairMissingLink: true }
   );
   verbose(`[inject] ${storeEntry.name}@${storeEntry.version} \u2192 ${targetDir}`);
   await ensureDir(targetDir);
+  const previousPkg = await readPackageJson(targetDir);
   const { copied, removed, skipped } = await incrementalCopy(
     storeEntry.packageDir,
     targetDir,
     { force: options.force }
   );
   verbose(`[inject] ${copied} copied, ${removed} removed, ${skipped} skipped`);
-  if (copied > 0 || removed > 0) {
-    await invalidateBundlerCache(consumerPath);
-  }
+  const cacheInvalidations = copied > 0 || removed > 0 ? await invalidateBundlerCache(consumerPath) : 0;
   const pkg = await readPackageJson(storeEntry.packageDir);
+  if (previousPkg) {
+    await removeBinLinks(consumerPath, previousPkg);
+  }
   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 };
+  return { copied, removed, skipped, binLinks, cacheInvalidations };
 }
 async function backupExisting(consumerPath, packageName, pm) {
-  const installedDir = await resolveTargetDir(consumerPath, packageName, pm);
+  const installedDir = await resolveInjectionTarget(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) {
+async function restoreBackup(consumerPath, packageName, pm, version) {
   const backupDir = getConsumerBackupPath(consumerPath, packageName);
   if (!await exists(backupDir)) return false;
-  const targetDir = await resolveTargetDir(consumerPath, packageName, pm);
+  const targetDir = await resolveInjectionTarget(consumerPath, packageName, pm, version);
+  const currentPkg = await readPackageJson(targetDir);
+  if (currentPkg) {
+    await removeBinLinks(consumerPath, currentPkg);
+  }
   await removeDir(targetDir);
   await copyDir(backupDir, targetDir);
+  const restoredPkg = await readPackageJson(isDryRun() ? backupDir : targetDir);
+  if (restoredPkg) {
+    const binLinks = await createBinLinks(consumerPath, packageName, restoredPkg);
+    if (binLinks > 0) {
+      verbose(`[restore] Restored ${binLinks} original bin link(s) for ${packageName}`);
+    }
+  }
   await removeDir(backupDir);
   return true;
 }
-async function removeInjected(consumerPath, packageName, pm) {
-  const targetDir = await resolveTargetDir(consumerPath, packageName, pm);
+async function removeInjected(consumerPath, packageName, pm, version) {
+  const directPath = getNodeModulesPackagePath(consumerPath, packageName);
+  const targetDir = await resolveInjectionTarget(consumerPath, packageName, pm, version);
   const pkg = await readPackageJson(targetDir);
   if (pkg) {
     await removeBinLinks(consumerPath, pkg);
   }
   await removeDir(targetDir);
+  if (resolve6(targetDir) !== resolve6(directPath)) {
+    await removeDir(directPath);
+  }
 }
-async function checkMissingDeps(storeEntry, consumerPath) {
+async function checkMissingDeps(storeEntry, consumerPath, pm) {
   const pkg = await readPackageJson(storeEntry.packageDir);
   if (!pkg) return [];
   const allDeps = {
@@ -2234,75 +2676,455 @@ async function checkMissingDeps(storeEntry, consumerPath) {
   const results = await Promise.all(
     depNames.map(async (dep) => ({
       dep,
-      installed: await exists(join13(consumerPath, "node_modules", dep))
+      installed: await isDependencyInstalledForPackage(dep, storeEntry, consumerPath, pm)
     }))
   );
   return results.filter((r) => !r.installed).map((r) => r.dep);
 }
-async function resolveTargetDir(consumerPath, packageName, pm, version) {
+async function isDependencyInstalledForPackage(dependencyName, storeEntry, consumerPath, pm) {
+  if (await exists(join14(consumerPath, "node_modules", dependencyName))) {
+    return true;
+  }
+  if (!pm) return false;
+  const targetDir = await resolveInjectionTarget(
+    consumerPath,
+    storeEntry.name,
+    pm,
+    storeEntry.version,
+    { warnOnFallback: false }
+  );
+  return dependencyVisibleFromDirectory(targetDir, dependencyName);
+}
+async function dependencyVisibleFromDirectory(startDir, dependencyName) {
+  const realStart = await realpath(startDir).catch((err) => {
+    if (isNodeError(err) && err.code === "ENOENT") return startDir;
+    throw err;
+  });
+  let dir = realStart;
+  for (; ; ) {
+    if (await exists(join14(dir, "node_modules", dependencyName))) {
+      return true;
+    }
+    const parent = dirname6(dir);
+    if (parent === dir) return false;
+    dir = parent;
+  }
+}
+async function resolveInjectionTarget(consumerPath, packageName, pm, version, options = {}) {
   const directPath = getNodeModulesPackagePath(consumerPath, packageName);
-  const needsSymlinkResolution = pm === "pnpm" || pm === "yarn" && await detectYarnNodeLinker(consumerPath) === "pnpm";
-  if (!needsSymlinkResolution) {
+  const currentPm = await detectPackageManagerInfo(consumerPath);
+  const useTrackedPm = currentPm.source === "default";
+  const effectiveYarn = currentPm.packageManager === "yarn" || useTrackedPm && pm === "yarn";
+  if (await hasYarnPnpMarkers(consumerPath) || effectiveYarn && await isYarnPnpProject(consumerPath)) {
+    throw new Error(
+      "Yarn PnP mode is not compatible with Knarr. Set `nodeLinker: node-modules` or `nodeLinker: pnpm` in .yarnrc.yml, then run `yarn install`."
+    );
+  }
+  const yarnLinker = effectiveYarn ? await detectYarnNodeLinker(consumerPath) : null;
+  const storeKind = getEffectiveStoreKind(
+    pm,
+    currentPm.packageManager,
+    currentPm.source,
+    yarnLinker
+  );
+  const effectiveBun = currentPm.packageManager === "bun" || useTrackedPm && pm === "bun";
+  if (!storeKind) {
+    if (effectiveBun) {
+      return resolveBunTarget(consumerPath, directPath, packageName, version);
+    }
     return directPath;
   }
+  const virtualStoreDirs = storeKind === "pnpm" ? await getPnpmVirtualStoreDirs(consumerPath) : await getYarnPnpmStoreDirs(consumerPath);
   try {
-    const realPath = await resolveRealPath(directPath);
-    if (realPath !== resolve6(directPath)) {
-      verbose(`[inject] pnpm: resolved symlink \u2192 ${realPath}`);
+    const realPath = await resolvePackageEntrySymlink(directPath);
+    if (realPath) {
+      const valid = storeKind === "pnpm" ? await isPnpmVirtualStorePackageRealPath(virtualStoreDirs, packageName, realPath) : await isYarnPnpmStorePackageRealPath(virtualStoreDirs, realPath);
+      if (!valid) {
+        throw new Error(
+          `Refusing to inject ${packageName}: node_modules entry resolves outside a configured ${storeKindLabel(storeKind)} virtual store (${realPath})`
+        );
+      }
+      await validateResolvedPackageIdentity(realPath, packageName, version, storeKind);
+      verbose(`[inject] ${storeKindLabel(storeKind)}: resolved symlink \u2192 ${realPath}`);
       return realPath;
     }
   } catch (err) {
-    if (isNodeError(err) && err.code !== "ENOENT") {
-      consola.debug(`pnpm symlink resolution error: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-  const pnpmDir = join13(consumerPath, "node_modules", ".pnpm");
-  if (await exists(pnpmDir)) {
-    verbose(`[inject] pnpm: scanning .pnpm/ for ${packageName}`);
-    const encodedName = packageName.replaceAll("/", "+");
-    if (version) {
-      const exactEntry = `${encodedName}@${version}`;
-      const candidate = join13(pnpmDir, exactEntry, "node_modules", packageName);
-      if (await exists(candidate)) {
-        verbose(`[inject] pnpm: exact version match in .pnpm/ \u2192 ${candidate}`);
-        return candidate;
+    if (isNodeError(err) && err.code === "ENOENT") {
+    } else {
+      if (isNodeError(err)) {
+        verbose(`${storeKindLabel(storeKind)} symlink resolution error: ${err instanceof Error ? err.message : String(err)}`);
       }
+      throw err;
     }
-    const entries = await readdir6(pnpmDir);
-    for (const entry of entries) {
-      if (entry.startsWith(encodedName + "@")) {
-        const candidate = join13(
-          pnpmDir,
-          entry,
-          "node_modules",
-          packageName
+  }
+  const existingStoreDirs = [];
+  for (const storeDir of virtualStoreDirs) {
+    if (await exists(storeDir)) {
+      existingStoreDirs.push(storeDir);
+    }
+  }
+  if (existingStoreDirs.length > 0) {
+    if (!await isDeclaredConsumerDependency(consumerPath, packageName)) {
+      verbose(
+        `[inject] ${storeKindLabel(storeKind)}: ${packageName} is not declared by the consumer, skipping virtual store scan`
+      );
+      return directPath;
+    }
+    if (storeKind === "yarn-pnpm") {
+      const matches = [];
+      for (const storeDir of existingStoreDirs) {
+        verbose(`[inject] yarn-pnpm: scanning ${relative8(consumerPath, storeDir) || "."} for ${packageName}`);
+        const candidate2 = await resolveYarnPnpmCandidate(
+          storeDir,
+          packageName,
+          version
         );
-        if (await exists(candidate)) {
-          verbose(`[inject] pnpm: found in .pnpm/ \u2192 ${candidate}`);
+        if (candidate2) {
+          matches.push(candidate2);
+        }
+      }
+      const candidate = requireSingleVirtualStoreCandidate(packageName, storeKind, matches);
+      if (candidate) {
+        verbose(`[inject] yarn-pnpm: found in virtual store \u2192 ${candidate}`);
+        if (options.repairMissingLink) {
+          await repairMissingVirtualStoreLink(directPath, candidate, packageName, storeKind);
+        }
+        return candidate;
+      }
+    }
+    if (storeKind === "pnpm") {
+      const encodedName = packageName.replaceAll("/", "+");
+      for (const pnpmDir of existingStoreDirs) {
+        verbose(`[inject] pnpm: scanning ${relative8(consumerPath, pnpmDir) || "."} for ${packageName}`);
+        if (version) {
+          const exactEntry = `${encodedName}@${version}`;
+          const candidate2 = await resolvePnpmCandidate(
+            pnpmDir,
+            packageName,
+            version,
+            join14(pnpmDir, exactEntry, "node_modules", packageName)
+          );
+          if (candidate2) {
+            verbose(`[inject] pnpm: exact version match in virtual store \u2192 ${candidate2}`);
+            if (options.repairMissingLink) {
+              await repairMissingVirtualStoreLink(directPath, candidate2, packageName, storeKind);
+            }
+            return candidate2;
+          }
+        }
+        const entries = await readdir6(pnpmDir);
+        const matches = [];
+        for (const entry of entries) {
+          if (matchesPnpmPackageEntry(encodedName, version, entry)) {
+            const candidate2 = await resolvePnpmCandidate(
+              pnpmDir,
+              packageName,
+              version,
+              join14(pnpmDir, entry, "node_modules", packageName)
+            );
+            if (candidate2) {
+              matches.push(candidate2);
+            }
+          }
+        }
+        const candidate = requireSingleVirtualStoreCandidate(packageName, storeKind, matches);
+        if (candidate) {
+          verbose(`[inject] pnpm: found in virtual store \u2192 ${candidate}`);
+          if (options.repairMissingLink) {
+            await repairMissingVirtualStoreLink(directPath, candidate, packageName, storeKind);
+          }
           return candidate;
         }
       }
     }
   }
-  consola.warn(
-    `pnpm: Could not find ${packageName} in .pnpm/ virtual store, using direct node_modules path. If this causes issues, run 'pnpm install' to rebuild the virtual store, then 'knarr add' again.`
-  );
+  if (options.warnOnFallback !== false) {
+    consola.warn(
+      `${storeKindLabel(storeKind)}: Could not find ${packageName} in a configured virtual store, using direct node_modules path. If this causes issues, run your package manager's install command to rebuild the virtual store, then 'knarr add' again.`
+    );
+  }
   return directPath;
 }
-async function resolveRealPath(linkPath) {
+function storeKindLabel(kind) {
+  return kind === "pnpm" ? "pnpm" : "Yarn pnpm-linker";
+}
+async function resolveBunTarget(consumerPath, directPath, packageName, version) {
   try {
-    await stat7(linkPath);
-    return await realpath(linkPath);
+    const linkStat = await lstat2(directPath);
+    if (!linkStat.isSymbolicLink()) return directPath;
   } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") {
-      return resolve6(linkPath);
+    if (isNodeError(err) && err.code === "ENOENT") return directPath;
+    throw err;
+  }
+  const realPath = await realpath(directPath);
+  const bunStoreDir = join14(consumerPath, "node_modules", ".bun");
+  const bunStoreRoot = await realpath(bunStoreDir).catch((err) => {
+    if (isNodeError(err) && err.code === "ENOENT") return bunStoreDir;
+    throw err;
+  });
+  if (!isPathInside(bunStoreRoot, realPath)) {
+    throw new Error(
+      `Refusing to inject ${packageName}: Bun target resolves outside the local node_modules/.bun store (${realPath})`
+    );
+  }
+  await validateResolvedPackageIdentity(realPath, packageName, version, "Bun isolated");
+  verbose(`[inject] Bun isolated: resolved symlink \u2192 ${realPath}`);
+  return realPath;
+}
+function isPathInside(parentDir, childPath) {
+  const rel = relative8(resolve6(parentDir), resolve6(childPath));
+  return rel === "" || !!rel && !rel.startsWith("..") && !isAbsolute2(rel);
+}
+function getEffectiveStoreKind(storedPm, currentPm, currentSource, yarnLinker) {
+  if (currentSource !== "default") {
+    if (currentPm === "yarn") {
+      return yarnLinker === "pnpm" ? "yarn-pnpm" : null;
     }
+    return currentPm === "pnpm" ? "pnpm" : null;
+  }
+  if (storedPm === "yarn") {
+    return yarnLinker === "pnpm" ? "yarn-pnpm" : null;
+  }
+  return storedPm === "pnpm" ? "pnpm" : null;
+}
+async function resolvePackageEntrySymlink(linkPath) {
+  const linkStat = await lstat2(linkPath);
+  if (!linkStat.isSymbolicLink()) return null;
+  return realpath(linkPath);
+}
+async function validateResolvedPackageIdentity(targetDir, packageName, version, storeKind) {
+  const label = storeKind === "Bun isolated" ? storeKind : storeKindLabel(storeKind);
+  const pkg = await readPackageJson(targetDir);
+  if (!pkg) return;
+  if (pkg.name && pkg.name !== packageName) {
+    throw new Error(
+      `Refusing to inject ${packageName}: ${label} target contains package "${pkg.name}"`
+    );
+  }
+  if (version && pkg.version && pkg.version !== version) {
+    throw new Error(
+      `Refusing to inject ${packageName}@${version}: ${label} target contains version ${pkg.version}`
+    );
+  }
+}
+async function repairMissingVirtualStoreLink(directPath, targetDir, packageName, storeKind) {
+  let removeDanglingSymlink = false;
+  try {
+    const directStat = await lstat2(directPath);
+    if (!directStat.isSymbolicLink()) return;
+    removeDanglingSymlink = true;
+  } catch (err) {
+    if (!isNodeError(err) || err.code !== "ENOENT") throw err;
+  }
+  const linkParent = dirname6(directPath);
+  if (isDryRun()) {
+    const targetRelative2 = relative8(linkParent, targetDir);
+    verbose(
+      `[inject] ${storeKindLabel(storeKind)}: would restore node_modules symlink for ${packageName} \u2192 ${targetRelative2}`
+    );
+    recordMutation({
+      type: "write",
+      path: directPath,
+      dest: targetDir,
+      detail: `${storeKindLabel(storeKind)} package symlink`
+    });
+    return;
+  }
+  const isWindows = platform3() === "win32";
+  await ensureDir(linkParent);
+  const linkParentReal = await realpath(linkParent).catch(() => linkParent);
+  const targetRelative = relative8(linkParentReal, targetDir);
+  verbose(
+    `[inject] ${storeKindLabel(storeKind)}: restoring node_modules symlink for ${packageName} \u2192 ${targetRelative}`
+  );
+  if (removeDanglingSymlink) {
+    await rm4(directPath, { force: true });
+  }
+  await symlink2(
+    isWindows ? targetDir : targetRelative,
+    directPath,
+    isWindows ? "junction" : "dir"
+  );
+}
+async function resolvePnpmCandidate(pnpmDir, packageName, version, candidatePath) {
+  if (!isPnpmVirtualStorePackagePathFromRoot(pnpmDir, packageName, candidatePath)) {
+    return null;
+  }
+  try {
+    const [pnpmRoot, realPath] = await Promise.all([
+      realpath(pnpmDir),
+      realpath(candidatePath)
+    ]);
+    if (!isPnpmVirtualStorePackagePathFromRoot(pnpmRoot, packageName, realPath)) {
+      throw new Error(
+        `Refusing to inject ${packageName}: virtual store candidate resolves outside a configured pnpm virtual store (${realPath})`
+      );
+    }
+    await validateResolvedPackageIdentity(realPath, packageName, version, "pnpm");
+    return realPath;
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") return null;
     throw err;
   }
 }
+async function resolveYarnPnpmCandidate(storeDir, packageName, version) {
+  const entries = await readdir6(storeDir);
+  const matches = [];
+  for (const entry of entries) {
+    const candidatePath = join14(storeDir, entry, "package");
+    const pkg = await readPackageJson(candidatePath);
+    if (!pkg || pkg.name !== packageName) continue;
+    if (version && pkg.version !== version) continue;
+    const [storeRoot, realPath] = await Promise.all([
+      realpath(storeDir),
+      realpath(candidatePath)
+    ]);
+    if (!isYarnPnpmStorePackagePathFromRoot(storeRoot, realPath)) {
+      throw new Error(
+        `Refusing to inject ${packageName}: virtual store candidate resolves outside a configured Yarn pnpm-linker virtual store (${realPath})`
+      );
+    }
+    matches.push(realPath);
+  }
+  return requireSingleVirtualStoreCandidate(packageName, "yarn-pnpm", matches);
+}
+function matchesPnpmPackageEntry(encodedName, version, entry) {
+  if (!version) return entry.startsWith(`${encodedName}@`);
+  const exactEntry = `${encodedName}@${version}`;
+  return entry === exactEntry || entry.startsWith(`${exactEntry}_`);
+}
+function isInside(root, target) {
+  const rel = relative8(resolve6(root), resolve6(target));
+  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
+}
+function requireSingleVirtualStoreCandidate(packageName, storeKind, matches) {
+  if (matches.length === 0) return null;
+  if (matches.length === 1) return matches[0];
+  throw new Error(
+    `Refusing to repair ${packageName}: multiple ${storeKindLabel(storeKind)} virtual-store entries match. Run your package manager's install command, then try again.`
+  );
+}
+async function getPnpmVirtualStoreDirs(consumerPath) {
+  const nodeModulesDir = join14(consumerPath, "node_modules");
+  const dirs = [];
+  const defaultDir = join14(nodeModulesDir, ".pnpm");
+  if (await isLocalVirtualStoreDir(consumerPath, defaultDir)) {
+    dirs.push(defaultDir);
+  }
+  const configured = await readConfiguredPnpmVirtualStoreDir(nodeModulesDir);
+  if (!configured) return dirs;
+  const configuredDir = isAbsolute2(configured) ? configured : resolve6(nodeModulesDir, configured);
+  if (!await isLocalVirtualStoreDir(consumerPath, configuredDir)) {
+    verbose(`[inject] pnpm: ignoring external virtualStoreDir ${configuredDir}`);
+    return dirs;
+  }
+  if (!dirs.some((dir) => resolve6(dir) === resolve6(configuredDir))) {
+    dirs.push(configuredDir);
+  }
+  return dirs;
+}
+async function getYarnPnpmStoreDirs(consumerPath) {
+  const nodeModulesDir = join14(consumerPath, "node_modules");
+  const dirs = [];
+  const defaultDir = join14(nodeModulesDir, ".store");
+  if (await isLocalVirtualStoreDir(consumerPath, defaultDir)) {
+    dirs.push(defaultDir);
+  }
+  const configured = await detectYarnPnpmStoreFolder(consumerPath);
+  if (!configured) return dirs;
+  const configuredDir = isAbsolute2(configured) ? configured : resolve6(consumerPath, configured);
+  if (!await isLocalVirtualStoreDir(consumerPath, configuredDir)) {
+    verbose(`[inject] yarn-pnpm: ignoring external pnpmStoreFolder ${configuredDir}`);
+    return dirs;
+  }
+  if (!dirs.some((dir) => resolve6(dir) === resolve6(configuredDir))) {
+    dirs.push(configuredDir);
+  }
+  return dirs;
+}
+async function isLocalVirtualStoreDir(consumerPath, storeDir) {
+  const consumerRoot = await realpath(consumerPath).catch(() => resolve6(consumerPath));
+  const storeRoot = await realpath(storeDir).catch((err) => {
+    if (isNodeError(err) && err.code === "ENOENT") return resolve6(storeDir);
+    throw err;
+  });
+  return isInside(consumerRoot, storeRoot);
+}
+async function readConfiguredPnpmVirtualStoreDir(nodeModulesDir) {
+  try {
+    const content = await readFile10(join14(nodeModulesDir, ".modules.yaml"), "utf-8");
+    return parsePnpmVirtualStoreDir(content);
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+function parsePnpmVirtualStoreDir(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (typeof parsed.virtualStoreDir === "string" && parsed.virtualStoreDir.trim()) {
+      return parsed.virtualStoreDir.trim();
+    }
+  } catch {
+  }
+  const match = content.match(/^virtualStoreDir:\s*(.+?)\s*$/m);
+  if (!match) return null;
+  let value = match[1].trim().replace(/\s+#.*$/, "");
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    value = value.slice(1, -1);
+  }
+  return value || null;
+}
+async function isPnpmVirtualStorePackageRealPath(pnpmDirs, packageName, targetPath) {
+  for (const pnpmDir of pnpmDirs) {
+    try {
+      const pnpmRoot = await realpath(pnpmDir);
+      if (isPnpmVirtualStorePackagePathFromRoot(pnpmRoot, packageName, targetPath)) {
+        return true;
+      }
+    } catch (err) {
+      if (isNodeError(err) && err.code === "ENOENT") continue;
+      throw err;
+    }
+  }
+  return false;
+}
+async function isYarnPnpmStorePackageRealPath(storeDirs, targetPath) {
+  for (const storeDir of storeDirs) {
+    try {
+      const storeRoot = await realpath(storeDir);
+      if (isYarnPnpmStorePackagePathFromRoot(storeRoot, targetPath)) {
+        return true;
+      }
+    } catch (err) {
+      if (isNodeError(err) && err.code === "ENOENT") continue;
+      throw err;
+    }
+  }
+  return false;
+}
+function isPnpmVirtualStorePackagePathFromRoot(pnpmDir, packageName, targetPath) {
+  if (!isInside(pnpmDir, targetPath)) return false;
+  const rel = relative8(pnpmDir, targetPath).replace(/\\/g, "/");
+  const suffix = `node_modules/${packageName}`.replace(/\\/g, "/");
+  return rel === suffix || rel.endsWith(`/${suffix}`);
+}
+function isYarnPnpmStorePackagePathFromRoot(storeDir, targetPath) {
+  if (!isInside(storeDir, targetPath)) return false;
+  const rel = relative8(storeDir, targetPath).replace(/\\/g, "/");
+  const parts = rel.split("/");
+  return parts.length === 2 && parts[1] === "package";
+}
+async function isDeclaredConsumerDependency(consumerPath, packageName) {
+  const pkg = await readPackageJson(consumerPath);
+  if (!pkg) return false;
+  return Boolean(
+    pkg.dependencies?.[packageName] || pkg.devDependencies?.[packageName] || pkg.optionalDependencies?.[packageName] || pkg.peerDependencies?.[packageName]
+  );
+}
 async function readPackageJson(dir) {
   try {
-    const content = await readFile9(join13(dir, "package.json"), "utf-8");
+    const content = await readFile10(join14(dir, "package.json"), "utf-8");
     return JSON.parse(content);
   } catch (err) {
     if (isNodeError(err) && err.code !== "ENOENT") {
@@ -2319,14 +3141,15 @@ var init_injector = __esm({
     init_fs();
     init_bin_linker();
     init_logger();
+    init_dry_run();
     init_pm_detect();
     init_bundler_cache();
   }
 });
 
 // src/core/tracker.ts
-import { readFile as readFile10 } from "fs/promises";
-import { dirname as dirname6 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { dirname as dirname7 } from "path";
 async function readConsumerState(consumerPath) {
   const { state } = await readConsumerStateSafe(consumerPath);
   return state;
@@ -2334,7 +3157,7 @@ async function readConsumerState(consumerPath) {
 async function readConsumerStateSafe(consumerPath) {
   const statePath = getConsumerStatePath(consumerPath);
   try {
-    const content = await readFile10(statePath, "utf-8");
+    const content = await readFile11(statePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!isConsumerState(parsed)) {
       consola.warn(`Invalid consumer state in ${statePath}, using defaults`);
@@ -2387,7 +3210,7 @@ async function getLink(consumerPath, packageName) {
 async function readConsumersRegistry() {
   const regPath = getConsumersPath();
   try {
-    const content = await readFile10(regPath, "utf-8");
+    const content = await readFile11(regPath, "utf-8");
     const parsed = JSON.parse(content);
     if (!isConsumersRegistry(parsed)) {
       consola.warn(`Invalid consumers registry, using empty registry`);
@@ -2403,7 +3226,7 @@ async function readConsumersRegistry() {
 }
 async function writeConsumersRegistry(registry) {
   const regPath = getConsumersPath();
-  await ensurePrivateDir(dirname6(getConsumersPath()));
+  await ensurePrivateDir(dirname7(getConsumersPath()));
   await atomicWriteFile(regPath, JSON.stringify(registry, null, 2));
 }
 async function registerConsumer(packageName, consumerPath) {
@@ -2439,22 +3262,37 @@ async function getConsumers(packageName) {
   const registry = await readConsumersRegistry();
   return registry[packageName] ?? [];
 }
-async function cleanStaleConsumers() {
+async function cleanStaleConsumers(options = {}) {
   const regPath = getConsumersPath();
   let removedConsumers = 0;
   let removedPackages = 0;
+  let removedMissingLinks = 0;
+  let skippedUnreliableConsumers = 0;
   await withFileLock(regPath, async () => {
     const registry = await readConsumersRegistry();
     const updated = {};
     for (const [pkgName, consumers] of Object.entries(registry)) {
       const results = await Promise.all(
-        consumers.map(async (consumerPath) => ({
-          consumerPath,
-          valid: await exists(consumerPath)
-        }))
+        consumers.map(async (consumerPath) => {
+          if (!await exists(consumerPath)) {
+            return { consumerPath, valid: false, reason: "missing-dir" };
+          }
+          if (options.removeMissingLinks) {
+            const { state, reliable } = await readConsumerStateSafe(consumerPath);
+            if (!reliable) {
+              skippedUnreliableConsumers++;
+              return { consumerPath, valid: true, reason: "unreliable-state" };
+            }
+            if (!state.links[pkgName]) {
+              return { consumerPath, valid: false, reason: "missing-link" };
+            }
+          }
+          return { consumerPath, valid: true, reason: null };
+        })
       );
       const validConsumers = results.filter((r) => r.valid).map((r) => r.consumerPath);
       removedConsumers += consumers.length - validConsumers.length;
+      removedMissingLinks += results.filter((r) => r.reason === "missing-link").length;
       if (validConsumers.length > 0) {
         updated[pkgName] = validConsumers;
       } else {
@@ -2463,7 +3301,12 @@ async function cleanStaleConsumers() {
     }
     await writeConsumersRegistry(updated);
   });
-  return { removedConsumers, removedPackages };
+  return {
+    removedConsumers,
+    removedPackages,
+    removedMissingLinks,
+    skippedUnreliableConsumers
+  };
 }
 var init_tracker = __esm({
   "src/core/tracker.ts"() {
@@ -2477,13 +3320,13 @@ var init_tracker = __esm({
 });
 
 // src/utils/build-detect.ts
-import { readFile as readFile11 } from "fs/promises";
-import { join as join14 } from "path";
+import { readFile as readFile12 } from "fs/promises";
+import { join as join15 } from "path";
 async function detectBuildCommand(packageDir, pm) {
-  const runPrefix = pm === "npm" ? "npm run " : `${pm} `;
+  const runPrefix = pm === "npm" || pm === "bun" ? `${pm} run ` : `${pm} `;
   try {
     const pkg = JSON.parse(
-      await readFile11(join14(packageDir, "package.json"), "utf-8")
+      await readFile12(join15(packageDir, "package.json"), "utf-8")
     );
     const scripts = pkg.scripts || {};
     for (const name of ["build", "compile", "bundle", "tsc"]) {
@@ -2502,11 +3345,11 @@ var init_build_detect = __esm({
 });
 
 // src/utils/config.ts
-import { readFile as readFile12 } from "fs/promises";
-import { join as join15 } from "path";
+import { readFile as readFile13 } from "fs/promises";
+import { join as join16 } from "path";
 async function loadKnarrConfig(projectDir) {
   try {
-    const raw = await readFile12(join15(projectDir, "package.json"), "utf-8");
+    const raw = await readFile13(join16(projectDir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     const source = pkg.knarr;
     if (!source || typeof source !== "object") return {};
@@ -2569,6 +3412,19 @@ var init_timer = __esm({
 // src/utils/output.ts
 function output(data) {
   if (isJsonOutput()) {
+    if (isDryRun()) {
+      markDryRunJsonReportPrinted();
+      if (data && typeof data === "object" && !Array.isArray(data)) {
+        console.log(JSON.stringify({
+          ...data,
+          dryRun: true,
+          mutations: getMutations()
+        }, null, 2));
+      } else {
+        console.log(JSON.stringify({ data, dryRun: true, mutations: getMutations() }, null, 2));
+      }
+      return;
+    }
     console.log(JSON.stringify(data, null, 2));
   }
 }
@@ -2576,6 +3432,7 @@ var init_output = __esm({
   "src/utils/output.ts"() {
     "use strict";
     init_logger();
+    init_dry_run();
   }
 });
 
@@ -2669,8 +3526,8 @@ var init_errors = __esm({
 });
 
 // src/core/push-engine.ts
-import { readFile as readFile13 } from "fs/promises";
-import { join as join16 } from "path";
+import { readFile as readFile14 } from "fs/promises";
+import { join as join17 } from "path";
 async function doPush(packageDir, options = {}) {
   const timer = new Timer();
   const result = await publish(packageDir, {
@@ -2679,96 +3536,240 @@ async function doPush(packageDir, options = {}) {
     historyLimit: options.historyLimit
   });
   if (result.skipped) {
-    consola.info("No changes to push");
-    return;
+    const entry2 = await getStoreEntry(result.name, result.version);
+    if (entry2) {
+      return pushStoreEntry(entry2, {
+        force: options.force,
+        timer,
+        noConsumersStatus: "available",
+        noChange: true,
+        skippedReason: "content unchanged"
+      });
+    } else {
+      const summary = createEmptySummary(result.name, result.version, result.buildId, timer.elapsedMs());
+      summary.noChange = true;
+      summary.skippedReason = "content unchanged";
+      consola.info(
+        `No changes to push for ${result.name}@${result.version}` + (result.buildId ? ` [${result.buildId}]` : "")
+      );
+      output(summary);
+      return summary;
+    }
+  }
+  if (isDryRun()) {
+    const consumers = await getConsumers(result.name);
+    const summary = createEmptySummary(result.name, result.version, result.buildId, timer.elapsedMs());
+    summary.skippedReason = "dry-run";
+    summary.consumers = consumers.length;
+    summary.skippedConsumers = consumers.length;
+    summary.consumerResults = consumers.map((consumerPath) => ({
+      consumerPath,
+      status: "skipped",
+      copied: 0,
+      removed: 0,
+      skipped: 0,
+      binLinks: 0,
+      cacheInvalidations: 0,
+      reason: "dry-run publish preview; store entry was not written"
+    }));
+    consola.info(
+      `Dry-run: would publish ${result.name}@${result.version}` + (result.buildId ? ` [${result.buildId}]` : "") + ". Skipping consumer injection preview because the store entry was not written."
+    );
+    output(summary);
+    return summary;
   }
   const entry = await getStoreEntry(result.name, result.version);
   if (!entry) {
     errorWithSuggestion(
       `Failed to read store entry for ${result.name}@${result.version} after publish`
     );
-    return;
+    const summary = createEmptySummary(result.name, result.version, result.buildId, timer.elapsedMs());
+    summary.failedConsumers = 1;
+    summary.consumerResults = [
+      {
+        consumerPath: packageDir,
+        status: "failed",
+        copied: 0,
+        removed: 0,
+        skipped: 0,
+        binLinks: 0,
+        cacheInvalidations: 0,
+        error: "store entry missing after publish"
+      }
+    ];
+    return summary;
   }
-  const consumers = await getConsumers(result.name);
+  return pushStoreEntry(entry, {
+    force: options.force,
+    timer,
+    noConsumersStatus: "published"
+  });
+}
+async function pushStoreEntry(entry, options = {}) {
+  const timer = options.timer ?? new Timer();
+  const consumers = await getConsumers(entry.name);
   if (consumers.length === 0) {
-    consola.success(
-      `Published ${result.name}@${result.version} to store`
-    );
+    const status = options.noConsumersStatus ?? "available";
+    consola.success(`${entry.name}@${entry.version} ${status} in store`);
     consola.info(
-      "No consumers registered yet. Run 'knarr add " + result.name + "' in a consumer project to start receiving pushes."
+      "No consumers registered yet. Run 'knarr add " + entry.name + "' in a consumer project to start receiving pushes."
     );
-    output({
-      name: result.name,
-      version: result.version,
-      buildId: result.buildId,
-      consumers: 0,
-      failedConsumers: 0,
-      copied: 0,
-      skipped: 0,
-      elapsed: timer.elapsedMs()
-    });
-    return;
+    const summary2 = createEmptySummary(
+      entry.name,
+      entry.version,
+      entry.meta.buildId ?? "",
+      timer.elapsedMs()
+    );
+    summary2.noChange = options.noChange ?? false;
+    summary2.skippedReason = options.skippedReason;
+    if (options.emitOutput !== false) output(summary2);
+    return summary2;
   }
   let totalCopied = 0;
+  let totalRemoved = 0;
   let totalSkipped = 0;
-  let pushCount = 0;
+  let totalBinLinks = 0;
+  let totalCacheInvalidations = 0;
+  let updatedCount = 0;
+  let skippedCount = 0;
   let failedCount = 0;
   const results = await Promise.all(
     consumers.map(
       (consumerPath) => consumerLimit(async () => {
-        const link = await getLink(consumerPath, result.name);
+        const link = await getLink(consumerPath, entry.name);
         if (!link) {
           verbose(
-            `[push] No link found for ${result.name} in ${consumerPath}, skipping`
+            `[push] No link found for ${entry.name} in ${consumerPath}, skipping`
           );
-          return null;
+          return {
+            consumerPath,
+            status: "skipped",
+            copied: 0,
+            removed: 0,
+            skipped: 0,
+            binLinks: 0,
+            cacheInvalidations: 0,
+            reason: "not linked in consumer state"
+          };
         }
         try {
+          const currentPm = await detectPackageManagerInfo(consumerPath);
+          const packageManager = currentPm.source === "default" ? link.packageManager : currentPm.packageManager;
           const injectResult = await inject(
             entry,
             consumerPath,
-            link.packageManager,
+            packageManager,
             { force: options.force }
           );
-          await addLink(consumerPath, result.name, {
+          await addLink(consumerPath, entry.name, {
             ...link,
             contentHash: entry.meta.contentHash,
             linkedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            buildId: entry.meta.buildId ?? ""
+            buildId: entry.meta.buildId ?? "",
+            packageManager
           });
-          return injectResult;
+          return {
+            consumerPath,
+            status: "updated",
+            copied: injectResult.copied,
+            removed: injectResult.removed,
+            skipped: injectResult.skipped,
+            binLinks: injectResult.binLinks,
+            cacheInvalidations: injectResult.cacheInvalidations
+          };
         } catch (err) {
+          const message2 = err instanceof Error ? err.message : String(err);
           consola.warn(
-            `Failed to push to ${consumerPath}: ${err instanceof Error ? err.message : String(err)}`
+            `Failed to push to ${consumerPath}: ${message2}`
           );
-          return null;
+          return {
+            consumerPath,
+            status: "failed",
+            copied: 0,
+            removed: 0,
+            skipped: 0,
+            binLinks: 0,
+            cacheInvalidations: 0,
+            error: message2
+          };
         }
       })
     )
   );
   for (const r of results) {
-    if (r) {
+    if (r.status === "updated") {
       totalCopied += r.copied;
+      totalRemoved += r.removed;
       totalSkipped += r.skipped;
-      pushCount++;
+      totalBinLinks += r.binLinks;
+      totalCacheInvalidations += r.cacheInvalidations;
+      updatedCount++;
+    } else if (r.status === "skipped") {
+      skippedCount++;
     } else {
       failedCount++;
     }
   }
-  const buildTag = result.buildId ? ` [${result.buildId}]` : "";
-  consola.success(
-    `Pushed ${result.name}@${result.version}${buildTag} to ${pushCount} consumer(s) in ${timer.elapsed()} (${totalCopied} files changed, ${totalSkipped} unchanged)`
-  );
-  output({
-    name: result.name,
-    version: result.version,
-    buildId: result.buildId,
-    consumers: pushCount,
+  const buildId = entry.meta.buildId ?? "";
+  const buildTag = buildId ? ` [${buildId}]` : "";
+  const detailParts = [
+    `${totalCopied} copied`,
+    `${totalRemoved} removed`,
+    `${totalSkipped} unchanged`
+  ];
+  if (totalBinLinks > 0) detailParts.push(`${totalBinLinks} bin links`);
+  if (totalCacheInvalidations > 0) {
+    detailParts.push(`${totalCacheInvalidations} cache invalidations`);
+  }
+  if (skippedCount > 0) detailParts.push(`${skippedCount} consumer(s) skipped`);
+  if (failedCount > 0) detailParts.push(`${failedCount} failed`);
+  const consumerLabel = failedCount > 0 || skippedCount > 0 ? `${updatedCount}/${consumers.length} consumer(s)` : `${updatedCount} consumer(s)`;
+  const message = `Pushed ${entry.name}@${entry.version}${buildTag} to ${consumerLabel} in ${timer.elapsed()} (${detailParts.join(", ")})`;
+  if (failedCount > 0) {
+    consola.warn(message);
+  } else {
+    consola.success(message);
+  }
+  const summary = {
+    name: entry.name,
+    version: entry.version,
+    buildId,
+    noChange: false,
+    consumers: consumers.length,
+    updatedConsumers: updatedCount,
     failedConsumers: failedCount,
+    skippedConsumers: skippedCount,
     copied: totalCopied,
+    removed: totalRemoved,
     skipped: totalSkipped,
-    elapsed: timer.elapsedMs()
-  });
+    binLinks: totalBinLinks,
+    cacheInvalidations: totalCacheInvalidations,
+    elapsed: timer.elapsedMs(),
+    consumerResults: results
+  };
+  summary.noChange = options.noChange ?? false;
+  summary.skippedReason = options.skippedReason;
+  if (options.emitOutput !== false) output(summary);
+  return summary;
+}
+function createEmptySummary(name, version, buildId, elapsed) {
+  return {
+    name,
+    version,
+    buildId,
+    noChange: false,
+    consumers: 0,
+    updatedConsumers: 0,
+    failedConsumers: 0,
+    skippedConsumers: 0,
+    copied: 0,
+    removed: 0,
+    skipped: 0,
+    binLinks: 0,
+    cacheInvalidations: 0,
+    elapsed,
+    consumerResults: []
+  };
 }
 async function resolveWatchConfig(packageDir, args, config) {
   let buildCmd = args.build;
@@ -2786,22 +3787,24 @@ async function resolveWatchConfig(packageDir, args, config) {
       consola.info(`Auto-detected build command: ${detected}`);
     }
   }
-  if (buildCmd) {
+  if (buildCmd && !patterns) {
     const { exists: exists3 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
     const candidates = ["src", "lib", "source", "app", "pages", "components"];
     const existing = (await Promise.all(
       candidates.map(async (dir) => ({
         dir,
-        exists: await exists3(join16(packageDir, dir))
+        exists: await exists3(join17(packageDir, dir))
       }))
     )).filter((c) => c.exists).map((c) => c.dir);
     patterns = existing.length > 0 ? existing : ["src", "lib"];
     verbose(`[watch] Using source patterns with build command: ${patterns.join(", ")}`);
+  } else if (buildCmd && patterns) {
+    verbose(`[watch] Using configured watch patterns with build command: ${patterns.join(", ")}`);
   } else {
     consola.info("No build command detected \u2014 watching output directories directly");
     try {
       const pkg = JSON.parse(
-        await readFile13(join16(packageDir, "package.json"), "utf-8")
+        await readFile14(join17(packageDir, "package.json"), "utf-8")
       );
       if (pkg.files && pkg.files.length > 0) {
         patterns = pkg.files;
@@ -2920,14 +3923,16 @@ __export(watcher_exports, {
   startWatcher: () => startWatcher
 });
 import { spawn as spawn2 } from "child_process";
-import { readdir as readdir7, stat as stat8 } from "fs/promises";
-import { platform as platform3 } from "os";
-import { join as join17 } from "path";
+import { readdir as readdir7, stat as stat7 } from "fs/promises";
+import { platform as platform4 } from "os";
+import { join as join18 } from "path";
 function killActiveBuild() {
-  if (activeChild && !activeChild.killed) {
-    activeChild.kill("SIGTERM");
-    activeChild = null;
+  for (const child of activeChildren) {
+    if (!child.killed) {
+      child.kill("SIGTERM");
+    }
   }
+  activeChildren.clear();
 }
 async function walkDir(dir, snapshot) {
   let entries;
@@ -2938,12 +3943,12 @@ async function walkDir(dir, snapshot) {
   }
   for (const entry of entries) {
     if (IGNORED_DIRS.has(entry.name)) continue;
-    const fullPath = join17(dir, entry.name);
+    const fullPath = join18(dir, entry.name);
     if (entry.isDirectory()) {
       await walkDir(fullPath, snapshot);
     } else {
       try {
-        const st = await stat8(fullPath);
+        const st = await stat7(fullPath);
         snapshot.set(fullPath, st.mtimeMs);
       } catch {
       }
@@ -2954,7 +3959,7 @@ async function buildSnapshot(watchPaths) {
   const snapshot = /* @__PURE__ */ new Map();
   for (const p of watchPaths) {
     try {
-      const st = await stat8(p);
+      const st = await stat7(p);
       if (st.isDirectory()) {
         await walkDir(p, snapshot);
       } else {
@@ -2977,6 +3982,8 @@ async function startWatcher(watchDir, options, onChange) {
   let closed = false;
   let running = false;
   let lastBuildEndTime = 0;
+  let cycle = 0;
+  let lastSuccessfulPush = null;
   let hasPendingChanges = false;
   const doBuild = async () => {
     if (closed || running) return;
@@ -2992,11 +3999,15 @@ async function startWatcher(watchDir, options, onChange) {
     }
     running = true;
     hasPendingChanges = false;
+    cycle++;
     try {
+      consola.info(`Change cycle #${cycle} started`);
       if (options.buildCmd) {
         const success = await runBuildCommand(options.buildCmd, watchDir);
         if (!success) {
-          consola.warn("Build failed (see output above), skipping push");
+          consola.warn(
+            "Build failed (see output above), skipping push" + (lastSuccessfulPush ? `. Last successful push: ${lastSuccessfulPush.toLocaleTimeString()}` : ". No successful push yet.")
+          );
           if (options.notify) {
             const { ringBell: ringBell2 } = await Promise.resolve().then(() => (init_bell(), bell_exports));
             ringBell2(true);
@@ -3005,6 +4016,7 @@ async function startWatcher(watchDir, options, onChange) {
         }
       }
       await onChange();
+      lastSuccessfulPush = /* @__PURE__ */ new Date();
       if (options.notify) ringBell(true);
     } catch (err) {
       consola.error(`Push failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -3110,7 +4122,7 @@ async function startWatcher(watchDir, options, onChange) {
 }
 function runBuildCommand(cmd, cwd) {
   return new Promise((resolve8) => {
-    const isWin = platform3() === "win32";
+    const isWin = platform4() === "win32";
     const shell = isWin ? "cmd" : "sh";
     const shellFlag = isWin ? "/c" : "-c";
     consola.start(`Running: ${cmd}`);
@@ -3118,9 +4130,9 @@ function runBuildCommand(cmd, cwd) {
       cwd,
       stdio: "inherit"
     });
-    activeChild = child;
+    activeChildren.add(child);
     child.on("close", (code) => {
-      activeChild = null;
+      activeChildren.delete(child);
       if (code === 0) {
         consola.success("Build succeeded");
         resolve8(true);
@@ -3130,35 +4142,39 @@ function runBuildCommand(cmd, cwd) {
       }
     });
     child.on("error", (err) => {
-      activeChild = null;
+      activeChildren.delete(child);
       consola.error(`Build error: ${err.message}`);
       resolve8(false);
     });
   });
 }
-var activeChild, activeWatcher, IGNORED_DIRS;
+var activeChildren, activeWatcher, IGNORED_DIRS;
 var init_watcher = __esm({
   "src/core/watcher.ts"() {
     "use strict";
     init_console();
     init_bell();
-    activeChild = null;
+    activeChildren = /* @__PURE__ */ new Set();
     activeWatcher = null;
     IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".knarr"]);
   }
 });
 
 // src/core/watch-orchestrator.ts
-var cascadeLimit, WatchOrchestrator;
+function assertPushSucceeded(summary, packageName) {
+  if (summary.failedConsumers === 0) return;
+  throw new Error(
+    `Push for ${packageName} failed for ${summary.failedConsumers} consumer(s)`
+  );
+}
+var WatchOrchestrator;
 var init_watch_orchestrator = __esm({
   "src/core/watch-orchestrator.ts"() {
     "use strict";
-    init_concurrency();
     init_console();
     init_logger();
     init_config();
     init_push_engine();
-    cascadeLimit = pLimit(2);
     WatchOrchestrator = class {
       packages = /* @__PURE__ */ new Map();
       dependents = /* @__PURE__ */ new Map();
@@ -3169,14 +4185,23 @@ var init_watch_orchestrator = __esm({
       }
       async start(startDir, args, pushOptions) {
         this.pushOptions = pushOptions;
-        const { buildWorkspaceGraph: buildWorkspaceGraph2, buildReverseAdjacency: buildReverseAdjacency2 } = await Promise.resolve().then(() => (init_workspace(), workspace_exports));
+        const {
+          buildWorkspaceGraph: buildWorkspaceGraph2,
+          buildReverseAdjacency: buildReverseAdjacency2,
+          filterPublishableWorkspaceGraph: filterPublishableWorkspaceGraph2
+        } = await Promise.resolve().then(() => (init_workspace(), workspace_exports));
         const { topoSort: topoSort2, CycleError: CycleError2 } = await Promise.resolve().then(() => (init_topo_sort(), topo_sort_exports));
         const { startWatcher: startWatcher2 } = await Promise.resolve().then(() => (init_watcher(), watcher_exports));
-        const graph = await buildWorkspaceGraph2(startDir);
+        const discovered = await buildWorkspaceGraph2(startDir);
+        const graph = filterPublishableWorkspaceGraph2(discovered);
         if (graph.packages.length === 0) {
-          consola.warn("No workspace packages found");
+          consola.warn("No publishable workspace packages found");
           return;
         }
+        const privateCount = discovered.packages.length - graph.packages.length;
+        if (privateCount > 0) {
+          consola.info(`Skipping ${privateCount} private workspace package(s)`);
+        }
         let ordered;
         try {
           ordered = topoSort2(graph.adjacency);
@@ -3199,14 +4224,25 @@ var init_watch_orchestrator = __esm({
           const { buildCmd, patterns } = await resolveWatchConfig(dir, args, config);
           const notify = args.notify ?? config.notify ?? false;
           const wrappedOnChange = async () => {
-            await doPush(dir, pushOptions);
-            await this.onPackagePushed(name);
+            await this.runExclusive(name, async () => {
+              const summary = await doPush(dir, pushOptions);
+              assertPushSucceeded(summary, name);
+              await this.onPackagePushed(name);
+            });
           };
           const parseMs = (v) => {
             if (!v) return void 0;
             const n = parseInt(v, 10);
             return Number.isFinite(n) ? n : void 0;
           };
+          const entry = {
+            dir,
+            buildCmd,
+            state: "idle",
+            watcher: { close: async () => {
+            } }
+          };
+          this.packages.set(name, entry);
           const watcher = await startWatcher2(
             dir,
             {
@@ -3218,7 +4254,7 @@ var init_watch_orchestrator = __esm({
             },
             wrappedOnChange
           );
-          this.packages.set(name, { dir, buildCmd, state: "idle", watcher });
+          entry.watcher = watcher;
         }
         consola.info(`Watching ${this.packages.size} workspace packages`);
         await new Promise((resolve8) => {
@@ -3236,12 +4272,11 @@ var init_watch_orchestrator = __esm({
         const deps = this.dependents.get(name);
         if (!deps || deps.size === 0) return;
         verbose(`[cascade] ${name} pushed, triggering dependents: ${[...deps].join(", ")}`);
-        const tasks = [...deps].map(
-          (depName) => cascadeLimit(() => this.requestRebuild(depName))
-        );
-        await Promise.all(tasks);
+        for (const depName of deps) {
+          await this.requestRebuild(depName);
+        }
       }
-      async requestRebuild(name) {
+      async runExclusive(name, task) {
         const entry = this.packages.get(name);
         if (!entry) return;
         if (entry.state === "queued") {
@@ -3254,30 +4289,35 @@ var init_watch_orchestrator = __esm({
           return;
         }
         entry.state = "building";
-        verbose(`[cascade] Rebuilding ${name}`);
         try {
+          await task(entry);
+        } finally {
+          const wasQueued = entry.state === "queued";
+          entry.state = "idle";
+          if (wasQueued) {
+            await this.requestRebuild(name);
+          }
+        }
+      }
+      async requestRebuild(name) {
+        await this.runExclusive(name, async (entry) => {
+          verbose(`[cascade] Rebuilding ${name}`);
           if (entry.buildCmd) {
             const { runBuildCommand: runBuildCommand2 } = await Promise.resolve().then(() => (init_watcher(), watcher_exports));
             const success = await runBuildCommand2(entry.buildCmd, entry.dir);
             if (!success) {
               consola.warn(`[cascade] Build failed for ${name}, skipping dependents`);
-              entry.state = "idle";
               return;
             }
           }
-          await doPush(entry.dir, this.pushOptions);
+          const summary = await doPush(entry.dir, this.pushOptions);
+          assertPushSucceeded(summary, name);
           await this.onPackagePushed(name);
-        } catch (err) {
+        }).catch((err) => {
           consola.warn(
             `[cascade] Push failed for ${name}: ${err instanceof Error ? err.message : String(err)}`
           );
-        } finally {
-          const wasQueued = entry.state === "queued";
-          entry.state = "idle";
-          if (wasQueued) {
-            await this.requestRebuild(name);
-          }
-        }
+        });
       }
       async close() {
         await Promise.all(
@@ -3305,42 +4345,82 @@ init_timer();
 init_logger();
 async function doPushAll(startDir, options = {}) {
   const timer = new Timer();
-  const graph = await buildWorkspaceGraph(startDir);
+  const discovered = await buildWorkspaceGraph(startDir);
+  const graph = filterPublishableWorkspaceGraph(discovered);
   if (graph.packages.length === 0) {
-    consola.warn("No workspace packages found");
+    consola.warn("No publishable workspace packages found");
     return;
   }
+  const privateCount = discovered.packages.length - graph.packages.length;
+  if (privateCount > 0) {
+    consola.info(`Skipping ${privateCount} private workspace package(s)`);
+  }
   let ordered;
   try {
     ordered = topoSort(graph.adjacency);
   } catch (err) {
     if (err instanceof CycleError) {
       consola.error(`Cannot push: ${err.message}`);
-      return;
+      throw err;
     }
     throw err;
   }
   const nameToDir = new Map(graph.packages.map((p) => [p.name, p.dir]));
   consola.info(`Pushing ${ordered.length} packages in dependency order`);
   verbose(`[batch-push] Order: ${ordered.join(" \u2192 ")}`);
+  const reverseAdjacency = buildReverseAdjacency(graph.adjacency);
+  const blocked = new Set(options.skipPackages ?? []);
+  for (const name of [...blocked]) {
+    markTransitiveDependentsBlocked(name, reverseAdjacency, blocked);
+  }
   let success = 0;
   let failed = 0;
+  let skipped = 0;
   for (const name of ordered) {
     const dir = nameToDir.get(name);
     if (!dir) continue;
+    if (blocked.has(name)) {
+      verbose(`[batch-push] Skipping ${name}: dependency build/push failed`);
+      skipped++;
+      continue;
+    }
     try {
-      await doPush(dir, options);
-      success++;
+      const summary = await doPush(dir, options);
+      if (summary.failedConsumers > 0) {
+        failed++;
+        markTransitiveDependentsBlocked(name, reverseAdjacency, blocked);
+      } else {
+        success++;
+      }
     } catch (err) {
       consola.warn(
         `Failed to push ${name}: ${err instanceof Error ? err.message : String(err)}`
       );
       failed++;
+      markTransitiveDependentsBlocked(name, reverseAdjacency, blocked);
     }
   }
-  consola.success(
-    `Pushed ${success}/${ordered.length} packages in ${timer.elapsed()}${failed > 0 ? ` (${failed} failed)` : ""}`
-  );
+  const details = [
+    failed > 0 ? `${failed} failed` : null,
+    skipped > 0 ? `${skipped} skipped` : null
+  ].filter((part) => part !== null);
+  const summaryMessage = `Pushed ${success}/${ordered.length} packages in ${timer.elapsed()}` + (details.length > 0 ? ` (${details.join(", ")})` : "");
+  if (failed > 0) {
+    consola.warn(summaryMessage);
+    throw new Error(`Failed to push ${failed} workspace package(s)`);
+  }
+  if (skipped > 0) {
+    consola.warn(summaryMessage);
+    return;
+  }
+  consola.success(summaryMessage);
+}
+function markTransitiveDependentsBlocked(name, reverseAdjacency, blocked) {
+  for (const dependent of reverseAdjacency.get(name) ?? []) {
+    if (blocked.has(dependent)) continue;
+    blocked.add(dependent);
+    markTransitiveDependentsBlocked(dependent, reverseAdjacency, blocked);
+  }
 }
 
 // src/index.ts
@@ -3354,13 +4434,13 @@ init_workspace();
 
 // src/utils/preflight.ts
 init_logger();
-import { readFile as readFile14, stat as stat9 } from "fs/promises";
-import { join as join18, resolve as resolve7 } from "path";
+import { readFile as readFile15, stat as stat8 } from "fs/promises";
+import { join as join19, resolve as resolve7 } from "path";
 async function runPreflightChecks(packageDir) {
   const issues = [];
   let pkgContent;
   try {
-    pkgContent = await readFile14(join18(packageDir, "package.json"), "utf-8");
+    pkgContent = await readFile15(join19(packageDir, "package.json"), "utf-8");
   } catch {
     issues.push({
       code: "NO_PACKAGE_JSON",
@@ -3418,7 +4498,7 @@ async function runPreflightChecks(packageDir) {
 }
 async function fileExists(filePath) {
   try {
-    const s = await stat9(filePath);
+    const s = await stat8(filePath);
     return s.isFile();
   } catch {
     return false;
@@ -3506,7 +4586,7 @@ init_paths();
 init_dry_run();
 
 // src/utils/vite-config.ts
-import { readFile as readFile15 } from "fs/promises";
+import { readFile as readFile16 } from "fs/promises";
 function defineConfigUsesTernary(content) {
   const callRegex = /(^|[^A-Za-z0-9_$])defineConfig\s*\(/g;
   let match;
@@ -3592,6 +4672,7 @@ export {
   cleanStaleConsumers,
   clearHistory,
   detectPackageManager,
+  detectPackageManagerInfo,
   doPush,
   doPushAll,
   findStoreEntry,