knarr 0.0.1

package/dist/index.mjs

@@ -0,0 +1,3530 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/console.ts
+import pc from "picocolors";
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+async function prompt(message, options) {
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    if (options.type === "confirm") {
+      const hint = options.initial !== false ? "Y/n" : "y/N";
+      const answer2 = await rl.question(
+        `${pc.cyan("?")} ${message} ${pc.dim(`(${hint})`)} `
+      );
+      const val = answer2.trim().toLowerCase();
+      if (val === "") return options.initial !== false;
+      return val === "y" || val === "yes";
+    }
+    if (options.type === "text") {
+      const hint = options.default ? pc.dim(` (${options.default})`) : "";
+      const answer2 = await rl.question(`${pc.cyan("?")} ${message}${hint} `);
+      return answer2.trim() || options.default || "";
+    }
+    console.log(`${pc.cyan("?")} ${message}`);
+    for (let i = 0; i < options.options.length; i++) {
+      console.log(`  ${pc.cyan(`${i + 1}.`)} ${options.options[i].label}`);
+    }
+    const answer = await rl.question(`${pc.dim("Enter number:")} `);
+    const idx = parseInt(answer, 10) - 1;
+    if (idx >= 0 && idx < options.options.length) {
+      return options.options[idx].value;
+    }
+    return options.options[0].value;
+  } finally {
+    rl.close();
+  }
+}
+var _level, consola;
+var init_console = __esm({
+  "src/utils/console.ts"() {
+    "use strict";
+    _level = 3;
+    consola = {
+      get level() {
+        return _level;
+      },
+      set level(n) {
+        _level = n;
+      },
+      info(msg, ...args) {
+        if (_level >= 3) console.log(pc.cyan("i"), msg, ...args);
+      },
+      success(msg, ...args) {
+        if (_level >= 3) console.log(pc.green("OK"), msg, ...args);
+      },
+      warn(msg, ...args) {
+        if (_level >= 2) console.warn(pc.yellow("!"), msg, ...args);
+      },
+      error(msg, ...args) {
+        if (_level >= 1) console.error(pc.red("x"), msg, ...args);
+      },
+      start(msg, ...args) {
+        if (_level >= 3) console.log(pc.cyan("..."), msg, ...args);
+      },
+      debug(msg, ...args) {
+        if (_level >= 4) console.debug(pc.dim("D"), msg, ...args);
+      },
+      /** Plain log (no icon) that still respects level suppression */
+      log(msg, ...args) {
+        if (_level >= 3) console.log(msg, ...args);
+      },
+      prompt
+    };
+  }
+});
+
+// src/utils/concurrency.ts
+function pLimit(concurrency) {
+  let active = 0;
+  const queue = [];
+  let head = 0;
+  const next = () => {
+    if (head < queue.length && active < concurrency) {
+      active++;
+      queue[head++]();
+    }
+    if (head > 0 && head === queue.length) {
+      queue.length = 0;
+      head = 0;
+    }
+  };
+  return (fn) => new Promise((resolve7, reject) => {
+    const run = () => {
+      fn().then(
+        (val) => {
+          active--;
+          resolve7(val);
+          next();
+        },
+        (err) => {
+          active--;
+          reject(err);
+          next();
+        }
+      );
+    };
+    if (active < concurrency) {
+      active++;
+      run();
+    } else {
+      queue.push(run);
+    }
+  });
+}
+var init_concurrency = __esm({
+  "src/utils/concurrency.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+function getKnarrHome() {
+  return process.env.KNARR_HOME || join(homedir(), ".knarr");
+}
+function getStorePath() {
+  return join(getKnarrHome(), "store");
+}
+function getConsumersPath() {
+  return join(getKnarrHome(), "consumers.json");
+}
+function encodePackageName(name) {
+  return name.replace(/\//g, "+");
+}
+function decodePackageName(encoded) {
+  if (encoded.startsWith("@")) {
+    const plusIdx = encoded.indexOf("+");
+    if (plusIdx !== -1) {
+      return encoded.slice(0, plusIdx) + "/" + encoded.slice(plusIdx + 1);
+    }
+  }
+  return encoded;
+}
+function getStoreEntryPath(name, version) {
+  return join(getStorePath(), `${encodePackageName(name)}@${version}`);
+}
+function getStorePackagePath(name, version) {
+  return join(getStoreEntryPath(name, version), "package");
+}
+function getStoreMetaPath(name, version) {
+  return join(getStoreEntryPath(name, version), ".knarr-meta.json");
+}
+function getStoreHistoryPath(name, version) {
+  return join(getStoreEntryPath(name, version), "history");
+}
+function getHistoryEntryPath(name, version, buildId) {
+  return join(getStoreHistoryPath(name, version), buildId);
+}
+function getConsumerKnarrDir(consumerPath) {
+  return join(consumerPath, ".knarr");
+}
+function getConsumerStatePath(consumerPath) {
+  return join(consumerPath, ".knarr", "state.json");
+}
+function getConsumerBackupPath(consumerPath, packageName) {
+  return join(consumerPath, ".knarr", "backups", encodePackageName(packageName));
+}
+function normalizePath(p) {
+  return p.replace(/\\/g, "/");
+}
+function getNodeModulesPackagePath(consumerPath, packageName) {
+  return join(consumerPath, "node_modules", packageName);
+}
+var init_paths = __esm({
+  "src/utils/paths.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/logger.ts
+function isDryRun() {
+  return _dryRun;
+}
+function isJsonOutput() {
+  return _jsonOutput;
+}
+function verbose(msg, ...args) {
+  if (_verbose) consola.debug(msg, ...args);
+}
+var _verbose, _dryRun, _jsonOutput;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    init_console();
+    _verbose = false;
+    _dryRun = false;
+    _jsonOutput = false;
+  }
+});
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+import { readFile, stat } from "fs/promises";
+import { relative } from "path";
+import { availableParallelism } from "os";
+function getXXHash() {
+  if (!_xxhash) {
+    _xxhash = import("xxhash-wasm").then((mod) => mod.default()).catch((err) => {
+      _xxhash = null;
+      throw err;
+    });
+  }
+  return _xxhash;
+}
+async function computeContentHash(files, baseDir) {
+  const sorted = [...files].sort((a, b) => {
+    const relA = normalizePath(relative(baseDir, a));
+    const relB = normalizePath(relative(baseDir, b));
+    return relA.localeCompare(relB);
+  });
+  const currentFiles = new Set(sorted);
+  let cacheHits = 0;
+  const contents = await Promise.all(
+    sorted.map(
+      (file) => limit(async () => {
+        const rel = normalizePath(relative(baseDir, file));
+        const s = await stat(file);
+        const cached = _contentCache.get(file);
+        if (cached && cached.mtimeMs === s.mtimeMs && cached.size === s.size) {
+          cacheHits++;
+          return { rel, content: cached.content };
+        }
+        const content = await readFile(file);
+        _contentCache.set(file, { mtimeMs: s.mtimeMs, size: s.size, content });
+        return { rel, content };
+      })
+    )
+  );
+  for (const key of _contentCache.keys()) {
+    if (!currentFiles.has(key)) _contentCache.delete(key);
+  }
+  verbose(`[hash] Computing content hash for ${files.length} files (${cacheHits} cached)`);
+  const hash = createHash("sha256");
+  const lenBuf = Buffer.alloc(4);
+  for (const { rel, content } of contents) {
+    hash.update(rel);
+    hash.update("\0");
+    lenBuf.writeUInt32LE(content.length);
+    hash.update(lenBuf);
+    hash.update(content);
+  }
+  const result = "sha256v2:" + hash.digest("hex");
+  verbose(`[hash] Result: ${result.slice(0, 20)}...`);
+  return result;
+}
+async function hashFile(filePath, knownSize) {
+  const size = knownSize ?? (await stat(filePath)).size;
+  const xx = await getXXHash();
+  if (size > STREAM_THRESHOLD) {
+    return hashFileStream(filePath, xx);
+  }
+  const content = await readFile(filePath);
+  return xx.h64Raw(content).toString(16);
+}
+async function hashFileStream(filePath, xx) {
+  const { createReadStream } = await import("fs");
+  const hasher = xx.create64();
+  return new Promise((resolve7, reject) => {
+    const stream = createReadStream(filePath);
+    stream.on("data", (chunk) => hasher.update(chunk));
+    stream.on("end", () => resolve7(hasher.digest().toString(16)));
+    stream.on("error", reject);
+  });
+}
+var _xxhash, STREAM_THRESHOLD, limit, _contentCache;
+var init_hash = __esm({
+  "src/utils/hash.ts"() {
+    "use strict";
+    init_concurrency();
+    init_logger();
+    init_paths();
+    _xxhash = null;
+    STREAM_THRESHOLD = 1024 * 1024;
+    limit = pLimit(Math.max(availableParallelism(), 8));
+    _contentCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/utils/dry-run.ts
+function recordMutation(mutation) {
+  mutations.push(mutation);
+}
+function printDryRunReport() {
+  if (mutations.length === 0) {
+    consola.info("[dry-run] No mutations would be performed");
+    return;
+  }
+  if (isJsonOutput()) {
+    console.log(JSON.stringify({ dryRun: true, mutations }, null, 2));
+    return;
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const m of mutations) {
+    let list = grouped.get(m.type);
+    if (!list) {
+      list = [];
+      grouped.set(m.type, list);
+    }
+    list.push(m);
+  }
+  consola.info(`
+[dry-run] ${mutations.length} mutation(s) would be performed:
+`);
+  const labels = {
+    copy: "Copy",
+    remove: "Remove",
+    move: "Move",
+    mkdir: "Create directory",
+    write: "Write file",
+    "bin-link": "Create bin link",
+    "bin-unlink": "Remove bin link",
+    "cache-invalidate": "Invalidate cache",
+    "lock-skip": "Skip lock",
+    "lifecycle-skip": "Skip lifecycle hook"
+  };
+  for (const [type, items] of grouped) {
+    consola.info(`  ${labels[type]} (${items.length}):`);
+    for (const item of items.slice(0, 20)) {
+      const dest = item.dest ? ` \u2192 ${item.dest}` : "";
+      const detail = item.detail ? ` (${item.detail})` : "";
+      consola.info(`    ${item.path}${dest}${detail}`);
+    }
+    if (items.length > 20) {
+      consola.info(`    ... and ${items.length - 20} more`);
+    }
+  }
+}
+function resetMutations() {
+  mutations.length = 0;
+}
+var mutations;
+var init_dry_run = __esm({
+  "src/utils/dry-run.ts"() {
+    "use strict";
+    init_logger();
+    init_console();
+    mutations = [];
+  }
+});
+
+// src/utils/fs.ts
+var fs_exports = {};
+__export(fs_exports, {
+  atomicWriteFile: () => atomicWriteFile,
+  collectFiles: () => collectFiles,
+  copyDir: () => copyDir,
+  copyWithCoW: () => copyWithCoW,
+  dirSize: () => dirSize,
+  ensureDir: () => ensureDir,
+  ensurePrivateDir: () => ensurePrivateDir,
+  exists: () => exists,
+  incrementalCopy: () => incrementalCopy,
+  isNodeError: () => isNodeError,
+  moveDir: () => moveDir,
+  removeDir: () => removeDir
+});
+import {
+  copyFile,
+  cp,
+  mkdir,
+  readdir,
+  rename,
+  rm,
+  stat as stat2,
+  utimes,
+  writeFile,
+  constants
+} from "fs/promises";
+import { join as join2, dirname, relative as relative2, parse as parsePath } from "path";
+import { availableParallelism as availableParallelism2 } from "os";
+function isNodeError(err) {
+  return err instanceof Error && "code" in err;
+}
+function volumeRoot(filePath) {
+  const { root } = parsePath(filePath);
+  return root || "/";
+}
+async function copyWithCoW(src, dest, options) {
+  if (isDryRun()) {
+    verbose(`[dry-run] would copy ${src} \u2192 ${dest}`);
+    recordMutation({ type: "copy", path: src, dest });
+    return;
+  }
+  if (options?.ensureParent !== false) {
+    await mkdir(dirname(dest), { recursive: true });
+  }
+  const root = volumeRoot(dest);
+  const supportsReflink = reflinkSupported.get(root);
+  if (supportsReflink === false) {
+    await copyFile(src, dest);
+    return;
+  }
+  if (supportsReflink === true) {
+    await copyFile(src, dest, constants.COPYFILE_FICLONE);
+    return;
+  }
+  try {
+    await copyFile(src, dest, constants.COPYFILE_FICLONE_FORCE);
+    reflinkSupported.set(root, true);
+  } catch {
+    reflinkSupported.set(root, false);
+    verbose(`[copy] reflink not supported on ${root}, using plain copy`);
+    await copyFile(src, dest);
+  }
+}
+async function collectFiles(dir) {
+  const entries = await readdir(dir, { recursive: true, withFileTypes: true });
+  return entries.filter((e) => e.isFile()).map((e) => join2(e.parentPath, e.name));
+}
+async function incrementalCopy(srcDir, destDir, options = {}) {
+  const srcFilesPromise = collectFiles(srcDir);
+  const destFilesPromise = collectFiles(destDir).catch((err) => {
+    if (isNodeError(err) && err.code === "ENOENT") return [];
+    throw err;
+  });
+  const [srcFiles, destFiles] = await Promise.all([srcFilesPromise, destFilesPromise]);
+  let copied = 0;
+  let removed = 0;
+  let skipped = 0;
+  const results = await Promise.all(
+    srcFiles.map(
+      (srcFile) => ioLimit(async () => {
+        const rel = relative2(srcDir, srcFile);
+        const destFile = join2(destDir, rel);
+        let needsCopy = true;
+        let srcTimes = null;
+        if (options.force) {
+          verbose(`[copy] ${rel} (forced)`);
+        } else {
+          try {
+            const [srcStat, destStat] = await Promise.all([
+              stat2(srcFile),
+              stat2(destFile)
+            ]);
+            srcTimes = { atime: srcStat.atime, mtime: srcStat.mtime };
+            if (srcStat.size !== destStat.size) {
+              verbose(`[copy] ${rel} (size differs: ${srcStat.size} vs ${destStat.size})`);
+            } else if (srcStat.mtimeMs === destStat.mtimeMs) {
+              needsCopy = false;
+              verbose(`[skip] ${rel} (size+mtime match)`);
+            } else {
+              const [srcHash, destHash] = await Promise.all([
+                hashFile(srcFile, srcStat.size),
+                hashFile(destFile, destStat.size)
+              ]);
+              if (srcHash === destHash) {
+                needsCopy = false;
+                verbose(`[skip] ${rel} (unchanged)`);
+              } else {
+                verbose(`[copy] ${rel} (hash differs)`);
+              }
+            }
+          } catch (err) {
+            if (isNodeError(err) && err.code === "ENOENT") {
+              verbose(`[copy] ${rel} (new file)`);
+            } else {
+              throw err;
+            }
+          }
+        }
+        if (needsCopy) {
+          await copyWithCoW(srcFile, destFile);
+          if (!srcTimes) {
+            const s = await stat2(srcFile);
+            srcTimes = { atime: s.atime, mtime: s.mtime };
+          }
+          await utimes(destFile, srcTimes.atime, srcTimes.mtime);
+          return "copied";
+        }
+        return "skipped";
+      })
+    )
+  );
+  for (const r of results) {
+    if (r === "copied") copied++;
+    else skipped++;
+  }
+  const srcRelPaths = new Set(srcFiles.map((f) => relative2(srcDir, f)));
+  const filesToRemove = destFiles.filter(
+    (f) => !srcRelPaths.has(relative2(destDir, f))
+  );
+  await Promise.all(
+    filesToRemove.map(
+      (destFile) => ioLimit(async () => {
+        verbose(`[remove] ${relative2(destDir, destFile)} (no longer in source)`);
+        if (isDryRun()) {
+          recordMutation({ type: "remove", path: destFile });
+        } else {
+          await rm(destFile);
+        }
+      })
+    )
+  );
+  removed = filesToRemove.length;
+  return { copied, removed, skipped };
+}
+async function moveDir(src, dest) {
+  if (isDryRun()) {
+    verbose(`[dry-run] would move ${src} \u2192 ${dest}`);
+    recordMutation({ type: "move", path: src, dest });
+    return;
+  }
+  try {
+    await rename(src, dest);
+  } catch (err) {
+    if (isNodeError(err) && err.code === "EXDEV") {
+      await cp(src, dest, { recursive: true });
+      await rm(src, { recursive: true, force: true });
+    } else {
+      throw err;
+    }
+  }
+}
+async function removeDir(dir) {
+  if (isDryRun()) {
+    verbose(`[dry-run] would remove ${dir}`);
+    recordMutation({ type: "remove", path: dir });
+    return;
+  }
+  await rm(dir, { recursive: true, force: true });
+}
+async function ensureDir(dir) {
+  if (isDryRun()) {
+    verbose(`[dry-run] would ensure dir ${dir}`);
+    recordMutation({ type: "mkdir", path: dir });
+    return;
+  }
+  await mkdir(dir, { recursive: true });
+}
+async function ensurePrivateDir(dir) {
+  if (isDryRun()) {
+    verbose(`[dry-run] would ensure private dir ${dir}`);
+    recordMutation({ type: "mkdir", path: dir });
+    return;
+  }
+  await mkdir(dir, { recursive: true, mode: 448 });
+}
+async function exists(path) {
+  try {
+    await stat2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function atomicWriteFile(filePath, data) {
+  if (isDryRun()) {
+    verbose(`[dry-run] would write ${filePath}`);
+    recordMutation({ type: "write", path: filePath });
+    return;
+  }
+  const tmpPath = filePath + `.tmp-${process.pid}-${Date.now()}`;
+  await writeFile(tmpPath, data);
+  await rename(tmpPath, filePath);
+}
+async function dirSize(dir) {
+  try {
+    const files = await collectFiles(dir);
+    const stats = await Promise.all(
+      files.map((f) => stat2(f).then((s) => s.size).catch(() => 0))
+    );
+    return stats.reduce((sum, s) => sum + s, 0);
+  } catch {
+    return 0;
+  }
+}
+async function copyDir(src, dest) {
+  await cp(src, dest, { recursive: true });
+}
+var ioLimit, reflinkSupported;
+var init_fs = __esm({
+  "src/utils/fs.ts"() {
+    "use strict";
+    init_concurrency();
+    init_hash();
+    init_logger();
+    init_logger();
+    init_dry_run();
+    ioLimit = pLimit(Math.max(availableParallelism2(), 8));
+    reflinkSupported = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/utils/pack-list.ts
+import { readFile as readFile2, readdir as readdir2, stat as stat3 } from "fs/promises";
+import { join as join3, relative as relative3, resolve, sep } from "path";
+import picomatch from "picomatch";
+async function resolvePackFiles(packageDir, pkg) {
+  const files = [];
+  const absDir = resolve(packageDir);
+  files.push(join3(absDir, "package.json"));
+  const allFiles = await collectAllFiles(absDir, absDir);
+  const allRelPaths = allFiles.map((f) => normalizePath(relative3(absDir, f)));
+  if (pkg.files && pkg.files.length > 0) {
+    for (const pattern of pkg.files) {
+      const target = join3(absDir, pattern);
+      const resolved = resolve(target);
+      if (!resolved.startsWith(absDir + sep) && resolved !== absDir) {
+        consola.warn(`files pattern "${pattern}" escapes package directory, skipping`);
+        continue;
+      }
+      let matched = false;
+      try {
+        const s = await stat3(target);
+        if (s.isDirectory()) {
+          const prefix = normalizePath(relative3(absDir, target)) + "/";
+          for (let i = 0; i < allRelPaths.length; i++) {
+            if (allRelPaths[i].startsWith(prefix)) {
+              files.push(allFiles[i]);
+            }
+          }
+          matched = true;
+        } else {
+          files.push(target);
+          matched = true;
+        }
+      } catch (err) {
+        if (isNodeError(err) && err.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      if (!matched) {
+        const isMatch = picomatch(pattern, { dot: true });
+        let globMatched = 0;
+        for (let i = 0; i < allRelPaths.length; i++) {
+          if (isMatch(allRelPaths[i])) {
+            const absFile = resolve(allFiles[i]);
+            if (!absFile.startsWith(absDir + sep) && absFile !== absDir) continue;
+            files.push(allFiles[i]);
+            globMatched++;
+          }
+        }
+        if (globMatched === 0) {
+          consola.warn(`files pattern "${pattern}" matched no files`);
+        }
+      }
+    }
+  } else {
+    const ignoreMatchers = await loadNpmIgnore(absDir);
+    for (let i = 0; i < allRelPaths.length; i++) {
+      if (!shouldIgnore(allRelPaths[i], ignoreMatchers)) {
+        files.push(allFiles[i]);
+      }
+    }
+  }
+  const fileSet = new Set(files);
+  const allFileSet = new Set(allFiles);
+  for (const name of ["README.md", "README", "LICENSE", "LICENCE", "CHANGELOG.md"]) {
+    const p = join3(absDir, name);
+    if (fileSet.has(p)) continue;
+    if (!allFileSet.has(p)) continue;
+    files.push(p);
+    fileSet.add(p);
+  }
+  return [...fileSet];
+}
+function shouldIgnore(relPath, matchers) {
+  for (const isMatch of matchers.negations) {
+    if (isMatch(relPath)) return false;
+  }
+  const parts = relPath.split(/[\\/]/);
+  for (const part of parts) {
+    if (DEFAULT_IGNORES.has(part)) return true;
+    if (matchers.literals.has(part)) return true;
+  }
+  if (matchers.literals.has(relPath)) return true;
+  for (const isMatch of matchers.patterns) {
+    if (isMatch(relPath)) return true;
+  }
+  return false;
+}
+async function loadNpmIgnore(dir) {
+  const matchers = { literals: /* @__PURE__ */ new Set(), patterns: [], negations: [] };
+  try {
+    const content = await readFile2(join3(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 }));
+      } else {
+        matchers.literals.add(trimmed.replace(/\/$/, ""));
+      }
+    }
+  } catch (err) {
+    if (isNodeError(err) && err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+  return matchers;
+}
+function hasGlobChars(pattern) {
+  return /[*?[\]{}()]/.test(pattern);
+}
+async function collectAllFiles(dir, rootDir) {
+  const results = [];
+  try {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join3(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === ".git") continue;
+        if (dir === rootDir && entry.name === "node_modules") continue;
+        if (entry.isSymbolicLink()) continue;
+        results.push(...await collectAllFiles(full, rootDir));
+      } else if (!entry.isSymbolicLink()) {
+        results.push(full);
+      }
+    }
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") {
+      return [];
+    }
+    throw err;
+  }
+  return results;
+}
+var DEFAULT_IGNORES;
+var init_pack_list = __esm({
+  "src/utils/pack-list.ts"() {
+    "use strict";
+    init_console();
+    init_fs();
+    init_paths();
+    DEFAULT_IGNORES = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      ".svn",
+      ".hg",
+      ".DS_Store",
+      ".npmrc",
+      ".knarr",
+      "test",
+      "tests",
+      "__tests__",
+      ".github",
+      ".vscode",
+      ".idea",
+      "coverage",
+      ".nyc_output",
+      "tsconfig.json",
+      "tsconfig.build.json",
+      ".eslintrc",
+      ".eslintrc.js",
+      ".eslintrc.json",
+      ".prettierrc",
+      ".prettierrc.js",
+      "jest.config.js",
+      "jest.config.ts",
+      "vitest.config.ts",
+      "vitest.config.js"
+    ]);
+  }
+});
+
+// src/utils/validators.ts
+import { readFile as readFile3 } from "fs/promises";
+import { join as join4 } from "path";
+function isKnarrMeta(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v.contentHash === "string" && typeof v.publishedAt === "string" && typeof v.sourcePath === "string" && (v.buildId === void 0 || typeof v.buildId === "string") && (v.schemaVersion === void 0 || typeof v.schemaVersion === "number");
+}
+function isLinkEntry(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v.version === "string" && typeof v.contentHash === "string" && typeof v.linkedAt === "string" && typeof v.sourcePath === "string" && typeof v.backupExists === "boolean" && typeof v.packageManager === "string" && ["npm", "pnpm", "yarn", "bun"].includes(v.packageManager) && (v.buildId === void 0 || typeof v.buildId === "string");
+}
+function isConsumerState(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  if (v.version !== "1") return false;
+  if (typeof v.links !== "object" || v.links === null) return false;
+  const links = v.links;
+  for (const entry of Object.values(links)) {
+    if (!isLinkEntry(entry)) return false;
+  }
+  return true;
+}
+function isConsumersRegistry(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  for (const val of Object.values(v)) {
+    if (!Array.isArray(val)) return false;
+    for (const item of val) {
+      if (typeof item !== "string") return false;
+    }
+  }
+  return true;
+}
+var init_validators = __esm({
+  "src/utils/validators.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/store.ts
+import { readFile as readFile4, readdir as readdir3 } from "fs/promises";
+import "path";
+async function readMeta(name, version) {
+  const metaPath = getStoreMetaPath(name, version);
+  try {
+    const content = await readFile4(metaPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!isKnarrMeta(parsed)) {
+      consola.warn(`Invalid metadata for ${name}@${version}, ignoring`);
+      return null;
+    }
+    return parsed;
+  } catch (err) {
+    if (isNodeError(err) && err.code !== "ENOENT") {
+      consola.warn(`Failed to read metadata for ${name}@${version}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return null;
+  }
+}
+async function getStoreEntry(name, version) {
+  const packageDir = getStorePackagePath(name, version);
+  const meta = await readMeta(name, version);
+  if (!meta) return null;
+  if (!await exists(packageDir)) return null;
+  return { name, version, packageDir, meta };
+}
+async function findStoreEntry(name) {
+  const storePath = getStorePath();
+  if (!await exists(storePath)) return null;
+  const encodedPrefix = encodePackageName(name) + "@";
+  const dirs = await readdir3(storePath, { withFileTypes: true });
+  const candidates = dirs.filter(
+    (d) => d.isDirectory() && d.name.startsWith(encodedPrefix)
+  );
+  const results = await Promise.all(
+    candidates.map(async (dir) => {
+      const version = dir.name.slice(encodedPrefix.length);
+      const meta = await readMeta(name, version);
+      if (!meta) return null;
+      return {
+        name,
+        version,
+        packageDir: getStorePackagePath(name, version),
+        meta
+      };
+    })
+  );
+  const matching = results.filter((r) => r !== null);
+  if (matching.length === 0) return null;
+  return matching.reduce(
+    (latest, entry) => new Date(entry.meta.publishedAt).getTime() > new Date(latest.meta.publishedAt).getTime() ? entry : latest
+  );
+}
+async function listStoreEntries() {
+  const storePath = getStorePath();
+  if (!await exists(storePath)) return [];
+  const dirs = await readdir3(storePath, { withFileTypes: true });
+  const candidates = dirs.filter((d) => {
+    if (!d.isDirectory()) return false;
+    const atIdx = d.name.lastIndexOf("@");
+    return atIdx > 0;
+  });
+  const results = await Promise.all(
+    candidates.map(async (dir) => {
+      const atIdx = dir.name.lastIndexOf("@");
+      const encodedName = dir.name.slice(0, atIdx);
+      const version = dir.name.slice(atIdx + 1);
+      const name = decodePackageName(encodedName);
+      const meta = await readMeta(name, version);
+      if (!meta) return null;
+      return {
+        name,
+        version,
+        packageDir: getStorePackagePath(name, version),
+        meta
+      };
+    })
+  );
+  return results.filter((r) => r !== null);
+}
+var init_store = __esm({
+  "src/core/store.ts"() {
+    "use strict";
+    init_console();
+    init_paths();
+    init_fs();
+    init_validators();
+  }
+});
+
+// src/utils/lockfile.ts
+import { mkdir as mkdir2, stat as stat4, rm as rm2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+import { setTimeout as sleep } from "timers/promises";
+async function withFileLock(filePath, fn, lockOptions) {
+  if (isDryRun()) {
+    recordMutation({ type: "lock-skip", path: filePath });
+    return fn();
+  }
+  await mkdir2(dirname2(filePath), { recursive: true });
+  const lockDir = filePath + ".lk";
+  const stale = lockOptions?.stale ?? DEFAULTS.stale;
+  let acquired = false;
+  for (let attempt = 0; attempt <= DEFAULTS.retries; attempt++) {
+    try {
+      await mkdir2(lockDir);
+      acquired = true;
+      break;
+    } catch (err) {
+      if (isNodeError(err) && err.code === "EEXIST") {
+        try {
+          const s = await stat4(lockDir);
+          if (Date.now() - s.mtimeMs > stale) {
+            await rm2(lockDir, { recursive: true, force: true });
+            continue;
+          }
+        } catch {
+          continue;
+        }
+        if (attempt < DEFAULTS.retries) {
+          const delay = Math.min(
+            DEFAULTS.minTimeout * DEFAULTS.factor ** attempt,
+            DEFAULTS.maxTimeout
+          );
+          await sleep(delay);
+        }
+      } else {
+        throw err;
+      }
+    }
+  }
+  if (!acquired) {
+    throw new Error(
+      `Failed to acquire lock after ${DEFAULTS.retries} attempts. Another Knarr process may be running. If this persists, delete ${lockDir} and retry.`
+    );
+  }
+  try {
+    return await fn();
+  } finally {
+    await rm2(lockDir, { recursive: true, force: true });
+  }
+}
+var DEFAULTS;
+var init_lockfile = __esm({
+  "src/utils/lockfile.ts"() {
+    "use strict";
+    init_fs();
+    init_logger();
+    init_dry_run();
+    DEFAULTS = {
+      retries: 5,
+      minTimeout: 100,
+      maxTimeout: 1e3,
+      factor: 2,
+      stale: 3e4
+    };
+  }
+});
+
+// src/core/history.ts
+var history_exports = {};
+__export(history_exports, {
+  captureHistory: () => captureHistory,
+  clearHistory: () => clearHistory,
+  getHistoryEntry: () => getHistoryEntry,
+  listHistory: () => listHistory,
+  pruneHistory: () => pruneHistory,
+  resolveHistoryLimit: () => resolveHistoryLimit,
+  restoreHistoryEntry: () => restoreHistoryEntry
+});
+import { readdir as readdir4, readFile as readFile5, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { join as join6 } from "path";
+async function captureHistory(name, version, oldEntryDir, historyLimit) {
+  const metaPath = join6(oldEntryDir, ".knarr-meta.json");
+  let meta;
+  try {
+    meta = JSON.parse(await readFile5(metaPath, "utf-8"));
+  } catch {
+    verbose(`[history] Could not read meta from ${metaPath}, skipping history capture`);
+    return;
+  }
+  const buildId = meta.buildId;
+  if (!buildId) {
+    verbose(`[history] No buildId in meta, skipping history capture`);
+    return;
+  }
+  const historyDir = getStoreHistoryPath(name, version);
+  const entryDir = getHistoryEntryPath(name, version, buildId);
+  if (await exists(entryDir)) {
+    verbose(`[history] Build ${buildId} already in history, skipping`);
+    return;
+  }
+  await ensureDir(historyDir);
+  const tmpHistoryEntry = entryDir + `.tmp-${process.pid}`;
+  try {
+    await ensureDir(tmpHistoryEntry);
+    const oldPkgDir = join6(oldEntryDir, "package");
+    if (await exists(oldPkgDir)) {
+      await moveDir(oldPkgDir, join6(tmpHistoryEntry, "package"));
+    }
+    await writeFile2(
+      join6(tmpHistoryEntry, ".knarr-meta.json"),
+      JSON.stringify(meta, null, 2)
+    );
+    await rename2(tmpHistoryEntry, entryDir);
+    verbose(`[history] Captured build ${buildId} to history`);
+  } catch (err) {
+    verbose(`[history] Failed to capture history: ${err instanceof Error ? err.message : String(err)}`);
+    await removeDir(tmpHistoryEntry);
+  }
+  const limit2 = historyLimit ?? DEFAULT_HISTORY_LIMIT;
+  await pruneHistory(name, version, limit2);
+}
+async function listHistory(name, version) {
+  const historyDir = getStoreHistoryPath(name, version);
+  if (!await exists(historyDir)) return [];
+  let entries;
+  try {
+    entries = await readdir4(historyDir);
+  } catch {
+    return [];
+  }
+  const result = [];
+  for (const buildId of entries) {
+    const entryDir = join6(historyDir, buildId);
+    const metaPath = join6(entryDir, ".knarr-meta.json");
+    try {
+      const meta = JSON.parse(await readFile5(metaPath, "utf-8"));
+      result.push({
+        buildId: meta.buildId ?? buildId,
+        contentHash: meta.contentHash,
+        publishedAt: meta.publishedAt,
+        sourcePath: meta.sourcePath,
+        packageDir: join6(entryDir, "package")
+      });
+    } catch {
+    }
+  }
+  result.sort((a, b) => new Date(b.publishedAt).getTime() - new Date(a.publishedAt).getTime());
+  return result;
+}
+async function getHistoryEntry(name, version, buildId) {
+  const entryDir = getHistoryEntryPath(name, version, buildId);
+  const metaPath = join6(entryDir, ".knarr-meta.json");
+  try {
+    const meta = JSON.parse(await readFile5(metaPath, "utf-8"));
+    return {
+      buildId: meta.buildId ?? buildId,
+      contentHash: meta.contentHash,
+      publishedAt: meta.publishedAt,
+      sourcePath: meta.sourcePath,
+      packageDir: join6(entryDir, "package")
+    };
+  } catch {
+    return null;
+  }
+}
+async function restoreHistoryEntry(name, version, buildId, historyLimit) {
+  const entry = await getHistoryEntry(name, version, buildId);
+  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");
+  if (await exists(storeEntryDir)) {
+    await captureHistory(name, version, storeEntryDir, historyLimit);
+  }
+  const storePkg = join6(storeEntryDir, "package");
+  const storeMeta = join6(storeEntryDir, ".knarr-meta.json");
+  if (await exists(storePkg)) await removeDir(storePkg);
+  if (await exists(historyPkg)) {
+    await moveDir(historyPkg, storePkg);
+  }
+  await writeFile2(storeMeta, metaContent);
+  await removeDir(historyEntryDir);
+  verbose(`[history] Restored build ${buildId} as current`);
+  return entry;
+}
+async function pruneHistory(name, version, limit2) {
+  if (limit2 < 0) return 0;
+  const entries = await listHistory(name, version);
+  if (entries.length <= limit2) return 0;
+  const toRemove = entries.slice(limit2);
+  let removed = 0;
+  for (const entry of toRemove) {
+    const entryDir = getHistoryEntryPath(name, version, entry.buildId);
+    try {
+      await removeDir(entryDir);
+      removed++;
+      verbose(`[history] Pruned old build ${entry.buildId}`);
+    } catch {
+    }
+  }
+  return removed;
+}
+async function clearHistory(name, version) {
+  const historyDir = getStoreHistoryPath(name, version);
+  if (await exists(historyDir)) {
+    await removeDir(historyDir);
+  }
+}
+function resolveHistoryLimit(configValue) {
+  return configValue ?? DEFAULT_HISTORY_LIMIT;
+}
+var DEFAULT_HISTORY_LIMIT;
+var init_history = __esm({
+  "src/core/history.ts"() {
+    "use strict";
+    init_fs();
+    init_paths();
+    init_logger();
+    DEFAULT_HISTORY_LIMIT = 3;
+  }
+});
+
+// src/utils/workspace.ts
+var workspace_exports = {};
+__export(workspace_exports, {
+  buildReverseAdjacency: () => buildReverseAdjacency,
+  buildWorkspaceGraph: () => buildWorkspaceGraph,
+  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 resolve2, relative as relative4 } from "path";
+import picomatch2 from "picomatch";
+async function findWorkspaceRoot(startDir) {
+  let dir = startDir;
+  for (; ; ) {
+    if (await exists(join7(dir, "pnpm-workspace.yaml"))) {
+      return dir;
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+async function parseCatalogs(workspaceRoot) {
+  const result = { default: {}, named: {} };
+  const filePath = join7(workspaceRoot, "pnpm-workspace.yaml");
+  let content;
+  try {
+    content = await readFile6(filePath, "utf-8");
+  } catch {
+    return result;
+  }
+  const lines = content.split(/\r?\n/);
+  let state = "top";
+  let currentNamedCatalog = "";
+  for (const line of lines) {
+    if (line.trim() === "" || line.trim().startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    if (indent === 0) {
+      if (line.startsWith("catalog:")) {
+        state = "default-catalog";
+        continue;
+      }
+      if (line.startsWith("catalogs:")) {
+        state = "named-catalogs";
+        continue;
+      }
+      state = "top";
+      continue;
+    }
+    if (state === "default-catalog" && indent >= 2) {
+      const kv = parseKeyValue(line);
+      if (kv) result.default[kv[0]] = kv[1];
+      continue;
+    }
+    if (state === "named-catalogs" && indent >= 2 && indent < 4) {
+      const trimmed = line.trim();
+      if (trimmed.endsWith(":")) {
+        currentNamedCatalog = trimmed.slice(0, -1);
+        result.named[currentNamedCatalog] = {};
+        state = "named-catalog-entries";
+      }
+      continue;
+    }
+    if (state === "named-catalog-entries" && indent >= 4) {
+      const kv = parseKeyValue(line);
+      if (kv && currentNamedCatalog) {
+        result.named[currentNamedCatalog][kv[0]] = kv[1];
+      }
+      continue;
+    }
+    if (state === "named-catalog-entries" && indent >= 2 && indent < 4) {
+      const trimmed = line.trim();
+      if (trimmed.endsWith(":")) {
+        currentNamedCatalog = trimmed.slice(0, -1);
+        result.named[currentNamedCatalog] = {};
+      } else {
+        state = "named-catalogs";
+      }
+      continue;
+    }
+  }
+  return result;
+}
+async function findWorkspacePackages(startDir) {
+  const pnpmRoot = await findWorkspaceRoot(startDir);
+  if (pnpmRoot) {
+    const allPatterns = await parsePnpmWorkspacePackages(pnpmRoot);
+    const positive = allPatterns.filter((p) => !p.startsWith("!"));
+    const negations = allPatterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
+    if (positive.length > 0) {
+      return resolveWorkspaceGlobs(pnpmRoot, positive, negations);
+    }
+  }
+  const rootDir = pnpmRoot ?? await findPackageJsonWorkspaceRoot(startDir);
+  if (!rootDir) return [];
+  try {
+    const rootPkg = JSON.parse(await readFile6(join7(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("!"));
+    const negations = workspaces.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
+    return resolveWorkspaceGlobs(rootDir, positive, negations);
+  } catch {
+    return [];
+  }
+}
+async function parsePnpmWorkspacePackages(workspaceRoot) {
+  const filePath = join7(workspaceRoot, "pnpm-workspace.yaml");
+  let content;
+  try {
+    content = await readFile6(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const patterns = [];
+  let inPackages = false;
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    if (indent === 0) {
+      inPackages = trimmed === "packages:";
+      continue;
+    }
+    if (inPackages && indent >= 2) {
+      const match = trimmed.match(/^-\s+["']?([^"']+)["']?$/);
+      if (match) {
+        patterns.push(match[1]);
+      }
+    }
+  }
+  return patterns;
+}
+async function findPackageJsonWorkspaceRoot(startDir) {
+  let dir = startDir;
+  for (; ; ) {
+    try {
+      const pkg = JSON.parse(await readFile6(join7(dir, "package.json"), "utf-8"));
+      if (pkg.workspaces) return dir;
+    } catch {
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+async function resolveWorkspaceGlobs(rootDir, patterns, negations = []) {
+  const results = [];
+  for (const pattern of patterns) {
+    if (pattern.includes("*")) {
+      const parts = pattern.split("/");
+      let staticPrefix = rootDir;
+      const globParts = [];
+      let foundGlob = false;
+      for (const part of parts) {
+        if (foundGlob || part.includes("*")) {
+          foundGlob = true;
+          globParts.push(part);
+        } else {
+          staticPrefix = join7(staticPrefix, part);
+        }
+      }
+      if (globParts.length === 1 && globParts[0] === "*") {
+        try {
+          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"))) {
+                results.push(pkgDir);
+              }
+            }
+          }
+        } catch {
+        }
+      } else {
+        const isMatch = picomatch2(pattern);
+        const candidates = await collectDirs(rootDir, 8);
+        for (const candidate of candidates) {
+          const rel = normalizePath(relative4(rootDir, candidate));
+          if (isMatch(rel) && await exists(join7(candidate, "package.json"))) {
+            results.push(candidate);
+          }
+        }
+      }
+    } else {
+      const pkgDir = resolve2(rootDir, pattern);
+      if (await exists(join7(pkgDir, "package.json"))) {
+        results.push(pkgDir);
+      }
+    }
+  }
+  const unique = [...new Set(results)];
+  if (negations.length === 0) return unique;
+  const isExcluded = picomatch2(negations);
+  return unique.filter((dir) => {
+    const rel = normalizePath(relative4(rootDir, dir));
+    return !isExcluded(rel);
+  });
+}
+async function collectDirs(dir, maxDepth) {
+  if (maxDepth <= 0) return [];
+  const results = [];
+  try {
+    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);
+      results.push(full);
+      results.push(...await collectDirs(full, maxDepth - 1));
+    }
+  } catch {
+  }
+  return results;
+}
+async function buildWorkspaceGraph(startDir) {
+  const dirs = await findWorkspacePackages(startDir);
+  const packages = [];
+  for (const dir of dirs) {
+    try {
+      const pkg = JSON.parse(
+        await readFile6(join7(dir, "package.json"), "utf-8")
+      );
+      if (pkg.name && pkg.version) {
+        packages.push({ name: pkg.name, version: pkg.version, dir, pkg });
+      }
+    } catch {
+    }
+  }
+  const wsNames = new Set(packages.map((p) => p.name));
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const wp of packages) {
+    const deps = /* @__PURE__ */ new Set();
+    for (const field of ["dependencies", "devDependencies"]) {
+      const depMap = wp.pkg[field];
+      if (!depMap) continue;
+      for (const depName of Object.keys(depMap)) {
+        if (wsNames.has(depName)) {
+          deps.add(depName);
+        }
+      }
+    }
+    adjacency.set(wp.name, deps);
+  }
+  return { packages, adjacency };
+}
+function buildReverseAdjacency(adjacency) {
+  const reverse = /* @__PURE__ */ new Map();
+  for (const name of adjacency.keys()) {
+    reverse.set(name, /* @__PURE__ */ new Set());
+  }
+  for (const [name, deps] of adjacency) {
+    for (const dep of deps) {
+      let set = reverse.get(dep);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        reverse.set(dep, set);
+      }
+      set.add(name);
+    }
+  }
+  return reverse;
+}
+function parseKeyValue(line) {
+  const trimmed = line.trim();
+  const colonIdx = trimmed.indexOf(":");
+  if (colonIdx <= 0) return null;
+  const key = trimmed.slice(0, colonIdx).trim();
+  const value = trimmed.slice(colonIdx + 1).trim();
+  if (!key || !value) return null;
+  const unquoted = value.replace(/^["']|["']$/g, "");
+  return [key, unquoted];
+}
+var init_workspace = __esm({
+  "src/utils/workspace.ts"() {
+    "use strict";
+    init_fs();
+    init_paths();
+  }
+});
+
+// src/core/publisher.ts
+import { readFile as readFile7, writeFile as writeFile3, rename as rename3, stat as stat5 } from "fs/promises";
+import { join as join8, relative as relative5, dirname as dirname4, resolve as resolve3 } 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");
+  let pkgContent;
+  try {
+    pkgContent = await readFile7(pkgPath, "utf-8");
+  } catch {
+    throw new Error(`No package.json found in ${packageDir}`);
+  }
+  const pkg = JSON.parse(pkgContent);
+  if (!pkg.name) throw new Error("package.json missing 'name' field");
+  if (!pkg.version) throw new Error("package.json missing 'version' field");
+  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");
+  }
+  let publishDir = packageDir;
+  if (pkg.publishConfig?.directory) {
+    publishDir = resolve3(packageDir, pkg.publishConfig.directory);
+    try {
+      const s = await stat5(publishDir);
+      if (!s.isDirectory()) {
+        throw new Error(`publishConfig.directory "${pkg.publishConfig.directory}" is not a directory`);
+      }
+    } catch (err) {
+      if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+        throw new Error(`publishConfig.directory "${pkg.publishConfig.directory}" does not exist`);
+      }
+      throw err;
+    }
+    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);
+  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);
+  if (!options.force) {
+    const existingMeta = await readMeta(pkg.name, pkg.version);
+    if (existingMeta && existingMeta.contentHash === contentHash) {
+      consola.info(`${pkg.name}@${pkg.version} already up to date (no changes since last publish)`);
+      return {
+        name: pkg.name,
+        version: pkg.version,
+        fileCount: files.length,
+        skipped: true,
+        contentHash,
+        buildId: existingMeta.buildId ?? ""
+      };
+    }
+  }
+  const storeEntryDir = getStoreEntryPath(pkg.name, pkg.version);
+  const result = await withFileLock(
+    storeEntryDir + ".lock",
+    async () => {
+      if (!options.force) {
+        const metaUnderLock = await readMeta(pkg.name, pkg.version);
+        if (metaUnderLock && metaUnderLock.contentHash === contentHash) {
+          consola.info(`${pkg.name}@${pkg.version} already up to date (no changes since last publish)`);
+          return {
+            name: pkg.name,
+            version: pkg.version,
+            fileCount: files.length,
+            skipped: true,
+            contentHash,
+            buildId: metaUnderLock.buildId ?? ""
+          };
+        }
+      }
+      const tmpDir = storeEntryDir + `.tmp-${process.pid}-${Date.now()}`;
+      const tmpPackageDir = join8(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, relative5(publishDir, file))))
+        );
+        await Promise.all([...uniqueDirs].map((d) => ensureDir(d)));
+        await Promise.all(
+          files.map(
+            (file) => copyLimit(async () => {
+              const rel = relative5(publishDir, file);
+              const dest = join8(tmpPackageDir, rel);
+              if (rel === "package.json" && processedPkg !== pkg) {
+                await writeFile3(dest, JSON.stringify(processedPkg, null, 2));
+              } else {
+                await copyWithCoW(file, dest, { ensureParent: false });
+              }
+            })
+          )
+        );
+        if (publishDir !== packageDir) {
+          await writeFile3(
+            join8(tmpPackageDir, "package.json"),
+            JSON.stringify(processedPkg, null, 2)
+          );
+        }
+        const meta = {
+          schemaVersion: 1,
+          contentHash,
+          publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          sourcePath: packageDir,
+          buildId
+        };
+        await writeFile3(
+          join8(tmpDir, ".knarr-meta.json"),
+          JSON.stringify(meta, null, 2)
+        );
+        const hadOld = await exists(storeEntryDir);
+        const oldDir = storeEntryDir + ".old-" + Date.now();
+        if (hadOld) await rename3(storeEntryDir, oldDir);
+        await moveDir(tmpDir, storeEntryDir);
+        if (hadOld) {
+          try {
+            const { captureHistory: captureHistory2 } = await Promise.resolve().then(() => (init_history(), history_exports));
+            await captureHistory2(pkg.name, pkg.version, oldDir, options.historyLimit);
+          } catch (err) {
+            verbose(`[publish] History capture failed: ${err instanceof Error ? err.message : String(err)}`);
+          }
+          await removeDir(oldDir);
+        }
+        verbose(`[publish] Stored at ${storeEntryDir}`);
+      } catch (err) {
+        await removeDir(tmpDir);
+        throw err;
+      }
+      return {
+        name: pkg.name,
+        version: pkg.version,
+        fileCount: files.length,
+        skipped: false,
+        contentHash,
+        buildId
+      };
+    },
+    { stale: 6e4 }
+  );
+  if (result.skipped) return result;
+  if (options.runScripts !== false) {
+    await runLifecycleHook(packageDir, pkg, "postpack");
+  }
+  await runLifecycleHook(packageDir, pkg, "postknarr");
+  consola.success(
+    `Published ${pkg.name}@${pkg.version} (${files.length} files) [${result.buildId}]`
+  );
+  return result;
+}
+async function runLifecycleHook(packageDir, pkg, hookName) {
+  const script = pkg.scripts?.[hookName];
+  if (!script) return;
+  if (isDryRun()) {
+    recordMutation({
+      type: "lifecycle-skip",
+      path: packageDir,
+      detail: `${hookName}: ${script}`
+    });
+    return;
+  }
+  verbose(`[lifecycle] Running ${hookName}: ${script}`);
+  return new Promise((resolve7, reject) => {
+    const isWin = platform() === "win32";
+    const shell = isWin ? "cmd" : "sh";
+    const shellFlag = isWin ? "/c" : "-c";
+    const child = spawn(shell, [shellFlag, script], {
+      cwd: packageDir,
+      stdio: "inherit"
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(new Error(`${hookName} script timed out after ${HOOK_TIMEOUT / 1e3}s. Increase KNARR_HOOK_TIMEOUT env var if the script needs more time.`));
+    }, HOOK_TIMEOUT);
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) {
+        resolve7();
+      } else {
+        reject(new Error(`${hookName} script failed with exit code ${code}`));
+      }
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(new Error(`${hookName} script error: ${err.message}`));
+    });
+  });
+}
+function applyPublishConfig(pkg) {
+  if (!pkg.publishConfig) return pkg;
+  const result = { ...pkg };
+  for (const field of PUBLISH_CONFIG_OVERRIDES) {
+    if (field in pkg.publishConfig) {
+      result[field] = pkg.publishConfig[field];
+    }
+  }
+  delete result.publishConfig;
+  return result;
+}
+function rewriteProtocolVersions(pkg) {
+  let changed = false;
+  const result = { ...pkg };
+  let catalogs = null;
+  let catalogsLoaded = false;
+  for (const depField of [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies"
+  ]) {
+    const deps = pkg[depField];
+    if (!deps) continue;
+    let fieldChanged = false;
+    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;
+        }
+        fieldChanged = true;
+        changed = true;
+      } else if (version.startsWith("catalog:")) {
+        if (!catalogsLoaded) {
+          catalogs = loadCatalogsFromCache();
+          catalogsLoaded = true;
+        }
+        if (catalogs) {
+          const resolved = resolveCatalogVersion(version, name, catalogs);
+          if (resolved) {
+            newDeps[name] = resolved;
+            fieldChanged = true;
+            changed = true;
+          } else {
+            consola.warn(`catalog: specifier for "${name}" could not be resolved \u2014 published package.json will contain "${version}" which may cause install failures`);
+          }
+        } else {
+          verbose(`[publish] No pnpm-workspace.yaml found, cannot resolve catalog: for "${name}"`);
+        }
+      }
+    }
+    if (fieldChanged) {
+      result[depField] = newDeps;
+    }
+  }
+  return changed ? result : pkg;
+}
+function resolveCatalogVersion(specifier, depName, catalogs) {
+  const catalogRef = specifier.slice("catalog:".length);
+  if (catalogRef === "" || catalogRef === "default") {
+    return catalogs.default[depName] ?? null;
+  }
+  return catalogs.named[catalogRef]?.[depName] ?? null;
+}
+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);
+  _cachedWorkspaceRoot = { dir: packageDir, root };
+  return root;
+}
+async function preloadWorkspaceVersions(pkg, packageDir) {
+  const hasWorkspace = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies"
+  ].some((field) => {
+    const deps = pkg[field];
+    return deps && Object.values(deps).some((v) => v.startsWith("workspace:"));
+  });
+  if (!hasWorkspace) return;
+  const root = await getWorkspaceRoot(packageDir);
+  if (!root) {
+    _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();
+  await Promise.all(
+    pkgDirs.map(async (dir) => {
+      try {
+        const depPkg = JSON.parse(
+          await readFile7(join8(dir, "package.json"), "utf-8")
+        );
+        if (depPkg.name && depPkg.version) {
+          versions.set(depPkg.name, depPkg.version);
+        }
+      } catch {
+      }
+    })
+  );
+  _cachedWorkspaceVersions = { root, versions };
+}
+function loadCatalogsFromCache() {
+  return _cachedCatalogs?.catalogs ?? null;
+}
+async function preloadCatalogs(pkg, packageDir) {
+  const hasCatalog = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"].some(
+    (field) => {
+      const deps = pkg[field];
+      return deps && Object.values(deps).some((v) => v.startsWith("catalog:"));
+    }
+  );
+  if (!hasCatalog) return;
+  const root = await getWorkspaceRoot(packageDir);
+  if (!root) {
+    _cachedCatalogs = null;
+    return;
+  }
+  const workspaceFile = join8(root, "pnpm-workspace.yaml");
+  const mtimeMs = (await stat5(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);
+  _cachedCatalogs = { root, mtimeMs, catalogs };
+}
+var copyLimit, HOOK_TIMEOUT, PUBLISH_CONFIG_OVERRIDES, _cachedWorkspaceRoot, _cachedWorkspaceVersions, _cachedCatalogs;
+var init_publisher = __esm({
+  "src/core/publisher.ts"() {
+    "use strict";
+    init_console();
+    init_concurrency();
+    init_paths();
+    init_pack_list();
+    init_hash();
+    init_fs();
+    init_store();
+    init_lockfile();
+    init_logger();
+    init_dry_run();
+    copyLimit = pLimit(Math.max(availableParallelism3(), 8));
+    HOOK_TIMEOUT = parseInt(process.env.KNARR_HOOK_TIMEOUT ?? "30000", 10);
+    PUBLISH_CONFIG_OVERRIDES = [
+      "main",
+      "module",
+      "exports",
+      "types",
+      "typings",
+      "browser",
+      "bin"
+    ];
+    _cachedWorkspaceRoot = null;
+    _cachedWorkspaceVersions = null;
+    _cachedCatalogs = null;
+  }
+});
+
+// src/utils/bin-linker.ts
+import { mkdir as mkdir3, symlink, writeFile as writeFile4, chmod, rm as rm3 } from "fs/promises";
+import { join as join9, relative as relative6, resolve as resolve4, sep as sep2 } from "path";
+import { platform as platform2 } from "os";
+function resolveBinEntries(pkg) {
+  if (!pkg.bin) return {};
+  if (typeof pkg.bin === "string") {
+    const binName = pkg.name.startsWith("@") ? pkg.name.split("/")[1] : pkg.name;
+    return { [binName]: pkg.bin };
+  }
+  return pkg.bin;
+}
+async function createBinLinks(consumerPath, packageName, pkg) {
+  const entries = resolveBinEntries(pkg);
+  if (Object.keys(entries).length === 0) return 0;
+  if (isDryRun()) {
+    for (const binName of Object.keys(entries)) {
+      recordMutation({ type: "bin-link", path: join9(consumerPath, "node_modules", ".bin", binName), detail: packageName });
+    }
+    verbose(`[dry-run] would create ${Object.keys(entries).length} bin link(s) for ${packageName}`);
+    return Object.keys(entries).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 = resolve4(targetAbsolute);
+    if (!resolvedTarget.startsWith(resolve4(packageRoot) + sep2) && resolvedTarget !== resolve4(packageRoot)) {
+      consola.warn(`bin "${binName}" points outside package directory, skipping`);
+      continue;
+    }
+    const targetRelative = normalizePath(relative6(binDir, targetAbsolute));
+    if (isWindows) {
+      const cmdPath = join9(binDir, `${binName}.cmd`);
+      const targetWindows = targetRelative.replace(/\//g, "\\");
+      const cmdContent = `@ECHO off\r
+GOTO start\r
+:find_dp0\r
+SET dp0=%~dp0\r
+EXIT /b\r
+:start\r
+CALL :find_dp0\r
+"%dp0%\\${targetWindows}" %*\r
+`;
+      await writeFile4(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
+exit $LASTEXITCODE
+`;
+      await writeFile4(ps1Path, ps1Content);
+      const shPath = join9(binDir, binName);
+      const shContent = `#!/bin/sh
+exec node "${targetRelative}" "$@"
+`;
+      await writeFile4(shPath, shContent);
+    } else {
+      const linkPath = join9(binDir, binName);
+      try {
+        await rm3(linkPath, { force: true });
+      } catch {
+      }
+      try {
+        await symlink(targetRelative, linkPath);
+        await chmod(targetAbsolute, 493);
+      } catch (err) {
+        if (isNodeError(err) && (err.code === "EPERM" || err.code === "EACCES")) {
+          verbose(`[bin-linker] Symlink failed (${err.code}), using shell wrapper for ${binName}`);
+          const shContent = `#!/bin/sh
+exec node "${targetRelative}" "$@"
+`;
+          await writeFile4(linkPath, shContent);
+          await chmod(linkPath, 493);
+        } else {
+          throw err;
+        }
+      }
+    }
+    count++;
+  }
+  return count;
+}
+async function removeBinLinks(consumerPath, pkg) {
+  const entries = resolveBinEntries(pkg);
+  if (isDryRun()) {
+    for (const binName of Object.keys(entries)) {
+      recordMutation({ type: "bin-unlink", path: join9(consumerPath, "node_modules", ".bin", binName) });
+    }
+    verbose(`[dry-run] would remove ${Object.keys(entries).length} bin link(s)`);
+    return;
+  }
+  const binDir = join9(consumerPath, "node_modules", ".bin");
+  const isWindows = platform2() === "win32";
+  for (const binName of Object.keys(entries)) {
+    try {
+      await rm3(join9(binDir, binName), { force: true });
+      if (isWindows) {
+        await rm3(join9(binDir, `${binName}.cmd`), { force: true });
+        await rm3(join9(binDir, `${binName}.ps1`), { force: true });
+      }
+    } catch {
+    }
+  }
+}
+var init_bin_linker = __esm({
+  "src/utils/bin-linker.ts"() {
+    "use strict";
+    init_console();
+    init_fs();
+    init_logger();
+    init_paths();
+    init_dry_run();
+  }
+});
+
+// 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;
+  }
+}
+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;
+}
+var BUNDLER_CONFIGS;
+var init_bundler_detect = __esm({
+  "src/utils/bundler-detect.ts"() {
+    "use strict";
+    init_fs();
+    BUNDLER_CONFIGS = [
+      ["vite", ["vite.config.ts", "vite.config.js", "vite.config.mts", "vite.config.mjs"]],
+      ["next", ["next.config.js", "next.config.ts", "next.config.mjs"]],
+      ["webpack", ["webpack.config.js", "webpack.config.ts"]],
+      ["turbo", ["turbo.json"]],
+      ["rollup", ["rollup.config.js", "rollup.config.ts", "rollup.config.mjs"]]
+    ];
+  }
+});
+
+// src/utils/bundler-cache.ts
+import { join as join12 } from "path";
+async function invalidateBundlerCache(consumerPath) {
+  if (isDryRun()) {
+    verbose(`[dry-run] would invalidate bundler caches for ${consumerPath}`);
+    recordMutation({ type: "cache-invalidate", path: consumerPath });
+    return;
+  }
+  let bundlers = bundlerCache.get(consumerPath);
+  if (!bundlers) {
+    bundlers = await detectAllBundlers(consumerPath);
+    bundlerCache.set(consumerPath, bundlers);
+  }
+  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);
+      if (await exists(cacheDir)) {
+        try {
+          await removeDir(cacheDir);
+          verbose(`[inject] Invalidated ${bundler.type} cache: ${dir}`);
+        } catch {
+          verbose(`[inject] Could not clear ${bundler.type} cache: ${dir} (locked?)`);
+        }
+      }
+    }
+  }
+}
+var CACHE_DIRS, bundlerCache;
+var init_bundler_cache = __esm({
+  "src/utils/bundler-cache.ts"() {
+    "use strict";
+    init_fs();
+    init_bundler_detect();
+    init_logger();
+    init_dry_run();
+    CACHE_DIRS = {
+      next: [".next/cache"],
+      webpack: ["node_modules/.cache"]
+    };
+    bundlerCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/core/injector.ts
+import { readFile as readFile9, readdir as readdir6, realpath, stat as stat7 } from "fs/promises";
+import { join as join13, resolve as resolve5 } from "path";
+async function inject(storeEntry, consumerPath, pm, options = {}) {
+  const targetDir = await resolveTargetDir(
+    consumerPath,
+    storeEntry.name,
+    pm,
+    storeEntry.version
+  );
+  verbose(`[inject] ${storeEntry.name}@${storeEntry.version} \u2192 ${targetDir}`);
+  await ensureDir(targetDir);
+  const { copied, removed, skipped } = await incrementalCopy(
+    storeEntry.packageDir,
+    targetDir,
+    { force: options.force }
+  );
+  verbose(`[inject] ${copied} copied, ${removed} removed, ${skipped} skipped`);
+  if (copied > 0 || removed > 0) {
+    await invalidateBundlerCache(consumerPath);
+  }
+  const pkg = await readPackageJson(storeEntry.packageDir);
+  const binLinks = pkg ? await createBinLinks(consumerPath, storeEntry.name, pkg) : 0;
+  if (binLinks > 0) {
+    verbose(`[inject] Created ${binLinks} bin link(s)`);
+  }
+  return { copied, removed, skipped, binLinks };
+}
+async function backupExisting(consumerPath, packageName, pm) {
+  const installedDir = await resolveTargetDir(consumerPath, packageName, pm);
+  if (!await exists(installedDir)) return false;
+  const backupDir = getConsumerBackupPath(consumerPath, packageName);
+  await removeDir(backupDir);
+  await copyDir(installedDir, backupDir);
+  return true;
+}
+async function restoreBackup(consumerPath, packageName, pm) {
+  const backupDir = getConsumerBackupPath(consumerPath, packageName);
+  if (!await exists(backupDir)) return false;
+  const targetDir = await resolveTargetDir(consumerPath, packageName, pm);
+  await removeDir(targetDir);
+  await copyDir(backupDir, targetDir);
+  await removeDir(backupDir);
+  return true;
+}
+async function removeInjected(consumerPath, packageName, pm) {
+  const targetDir = await resolveTargetDir(consumerPath, packageName, pm);
+  const pkg = await readPackageJson(targetDir);
+  if (pkg) {
+    await removeBinLinks(consumerPath, pkg);
+  }
+  await removeDir(targetDir);
+}
+async function checkMissingDeps(storeEntry, consumerPath) {
+  const pkg = await readPackageJson(storeEntry.packageDir);
+  if (!pkg) return [];
+  const allDeps = {
+    ...pkg.dependencies,
+    ...Object.fromEntries(
+      Object.entries(pkg.peerDependencies ?? {}).filter(
+        ([name]) => !pkg.peerDependenciesMeta?.[name]?.optional
+      )
+    )
+  };
+  if (Object.keys(allDeps).length === 0) return [];
+  const depNames = Object.keys(allDeps);
+  const results = await Promise.all(
+    depNames.map(async (dep) => ({
+      dep,
+      installed: await exists(join13(consumerPath, "node_modules", dep))
+    }))
+  );
+  return results.filter((r) => !r.installed).map((r) => r.dep);
+}
+async function resolveTargetDir(consumerPath, packageName, pm, version) {
+  const directPath = getNodeModulesPackagePath(consumerPath, packageName);
+  const needsSymlinkResolution = pm === "pnpm" || pm === "yarn" && await detectYarnNodeLinker(consumerPath) === "pnpm";
+  if (!needsSymlinkResolution) {
+    return directPath;
+  }
+  try {
+    const realPath = await resolveRealPath(directPath);
+    if (realPath !== resolve5(directPath)) {
+      verbose(`[inject] pnpm: resolved symlink \u2192 ${realPath}`);
+      return realPath;
+    }
+  } catch (err) {
+    if (isNodeError(err) && err.code !== "ENOENT") {
+      consola.debug(`pnpm symlink resolution error: ${err 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;
+      }
+    }
+    const entries = await readdir6(pnpmDir);
+    for (const entry of entries) {
+      if (entry.startsWith(encodedName + "@")) {
+        const candidate = join13(
+          pnpmDir,
+          entry,
+          "node_modules",
+          packageName
+        );
+        if (await exists(candidate)) {
+          verbose(`[inject] pnpm: found in .pnpm/ \u2192 ${candidate}`);
+          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.`
+  );
+  return directPath;
+}
+async function resolveRealPath(linkPath) {
+  try {
+    await stat7(linkPath);
+    return await realpath(linkPath);
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") {
+      return resolve5(linkPath);
+    }
+    throw err;
+  }
+}
+async function readPackageJson(dir) {
+  try {
+    const content = await readFile9(join13(dir, "package.json"), "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    if (isNodeError(err) && err.code !== "ENOENT") {
+      consola.warn(`Failed to read package.json in ${dir}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return null;
+  }
+}
+var init_injector = __esm({
+  "src/core/injector.ts"() {
+    "use strict";
+    init_console();
+    init_paths();
+    init_fs();
+    init_bin_linker();
+    init_logger();
+    init_pm_detect();
+    init_bundler_cache();
+  }
+});
+
+// src/core/tracker.ts
+import { readFile as readFile10 } from "fs/promises";
+import { dirname as dirname6 } from "path";
+async function readConsumerState(consumerPath) {
+  const { state } = await readConsumerStateSafe(consumerPath);
+  return state;
+}
+async function readConsumerStateSafe(consumerPath) {
+  const statePath = getConsumerStatePath(consumerPath);
+  try {
+    const content = await readFile10(statePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!isConsumerState(parsed)) {
+      consola.warn(`Invalid consumer state in ${statePath}, using defaults`);
+      return { state: { version: "1", links: {} }, reliable: false };
+    }
+    return { state: parsed, reliable: true };
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") {
+      return { state: { version: "1", links: {} }, reliable: true };
+    }
+    consola.warn(`Failed to read consumer state: ${err instanceof Error ? err.message : String(err)}`);
+    return { state: { version: "1", links: {} }, reliable: false };
+  }
+}
+async function writeConsumerState(consumerPath, state) {
+  await ensureDir(getConsumerKnarrDir(consumerPath));
+  const statePath = getConsumerStatePath(consumerPath);
+  await atomicWriteFile(statePath, JSON.stringify(state, null, 2));
+}
+async function addLink(consumerPath, packageName, entry) {
+  const statePath = getConsumerStatePath(consumerPath);
+  await withFileLock(statePath, async () => {
+    const { state, reliable } = await readConsumerStateSafe(consumerPath);
+    if (!reliable) {
+      throw new Error(
+        `Consumer state in ${statePath} is corrupt \u2014 refusing to write to avoid destroying existing links. Delete .knarr/state.json and re-run 'knarr add' for each package.`
+      );
+    }
+    state.links[packageName] = entry;
+    await writeConsumerState(consumerPath, state);
+  });
+}
+async function removeLink(consumerPath, packageName) {
+  const statePath = getConsumerStatePath(consumerPath);
+  await withFileLock(statePath, async () => {
+    const { state, reliable } = await readConsumerStateSafe(consumerPath);
+    if (!reliable) {
+      throw new Error(
+        `Consumer state in ${statePath} is corrupt \u2014 refusing to write to avoid destroying existing links. Delete .knarr/state.json and re-run 'knarr add' for each package.`
+      );
+    }
+    delete state.links[packageName];
+    await writeConsumerState(consumerPath, state);
+  });
+}
+async function getLink(consumerPath, packageName) {
+  const state = await readConsumerState(consumerPath);
+  return state.links[packageName] ?? null;
+}
+async function readConsumersRegistry() {
+  const regPath = getConsumersPath();
+  try {
+    const content = await readFile10(regPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!isConsumersRegistry(parsed)) {
+      consola.warn(`Invalid consumers registry, using empty registry`);
+      return {};
+    }
+    return parsed;
+  } catch (err) {
+    if (isNodeError(err) && err.code !== "ENOENT") {
+      consola.warn(`Failed to read consumers registry: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return {};
+  }
+}
+async function writeConsumersRegistry(registry) {
+  const regPath = getConsumersPath();
+  await ensurePrivateDir(dirname6(getConsumersPath()));
+  await atomicWriteFile(regPath, JSON.stringify(registry, null, 2));
+}
+async function registerConsumer(packageName, consumerPath) {
+  const regPath = getConsumersPath();
+  await withFileLock(regPath, async () => {
+    const registry = await readConsumersRegistry();
+    if (!registry[packageName]) {
+      registry[packageName] = [];
+    }
+    const normalized = normalizePath(consumerPath);
+    if (!registry[packageName].includes(normalized)) {
+      registry[packageName].push(normalized);
+    }
+    await writeConsumersRegistry(registry);
+  });
+}
+async function unregisterConsumer(packageName, consumerPath) {
+  const regPath = getConsumersPath();
+  await withFileLock(regPath, async () => {
+    const registry = await readConsumersRegistry();
+    if (!registry[packageName]) return;
+    const normalized = normalizePath(consumerPath);
+    registry[packageName] = registry[packageName].filter(
+      (p) => p !== normalized
+    );
+    if (registry[packageName].length === 0) {
+      delete registry[packageName];
+    }
+    await writeConsumersRegistry(registry);
+  });
+}
+async function getConsumers(packageName) {
+  const registry = await readConsumersRegistry();
+  return registry[packageName] ?? [];
+}
+async function cleanStaleConsumers() {
+  const regPath = getConsumersPath();
+  let removedConsumers = 0;
+  let removedPackages = 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)
+        }))
+      );
+      const validConsumers = results.filter((r) => r.valid).map((r) => r.consumerPath);
+      removedConsumers += consumers.length - validConsumers.length;
+      if (validConsumers.length > 0) {
+        updated[pkgName] = validConsumers;
+      } else {
+        removedPackages++;
+      }
+    }
+    await writeConsumersRegistry(updated);
+  });
+  return { removedConsumers, removedPackages };
+}
+var init_tracker = __esm({
+  "src/core/tracker.ts"() {
+    "use strict";
+    init_console();
+    init_paths();
+    init_fs();
+    init_lockfile();
+    init_validators();
+  }
+});
+
+// src/utils/build-detect.ts
+import { readFile as readFile11 } from "fs/promises";
+import { join as join14 } from "path";
+async function detectBuildCommand(packageDir, pm) {
+  const runPrefix = pm === "npm" ? "npm run " : `${pm} `;
+  try {
+    const pkg = JSON.parse(
+      await readFile11(join14(packageDir, "package.json"), "utf-8")
+    );
+    const scripts = pkg.scripts || {};
+    for (const name of ["build", "compile", "bundle", "tsc"]) {
+      if (scripts[name]) {
+        return `${runPrefix}${name}`;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+var init_build_detect = __esm({
+  "src/utils/build-detect.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/config.ts
+import { readFile as readFile12 } from "fs/promises";
+import { join as join15 } from "path";
+async function loadKnarrConfig(projectDir) {
+  try {
+    const raw = await readFile12(join15(projectDir, "package.json"), "utf-8");
+    const pkg = JSON.parse(raw);
+    const source = pkg.knarr;
+    if (!source || typeof source !== "object") return {};
+    const config = {};
+    const p = source;
+    if (typeof p.buildCmd === "string") config.buildCmd = p.buildCmd;
+    if (Array.isArray(p.watchPatterns)) {
+      config.watchPatterns = p.watchPatterns.filter(
+        (v) => typeof v === "string"
+      );
+    }
+    if (typeof p.debounce === "number" && Number.isFinite(p.debounce)) {
+      config.debounce = p.debounce;
+    }
+    if (typeof p.cooldown === "number" && Number.isFinite(p.cooldown)) {
+      config.cooldown = p.cooldown;
+    }
+    if (typeof p.historyLimit === "number" && Number.isFinite(p.historyLimit)) {
+      config.historyLimit = Math.max(0, Math.floor(p.historyLimit));
+    }
+    if (typeof p.notify === "boolean") {
+      config.notify = p.notify;
+    }
+    verbose(`[config] Loaded knarr config from package.json: ${JSON.stringify(config)}`);
+    return config;
+  } catch {
+    return {};
+  }
+}
+var init_config = __esm({
+  "src/utils/config.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/utils/timer.ts
+var Timer;
+var init_timer = __esm({
+  "src/utils/timer.ts"() {
+    "use strict";
+    Timer = class {
+      start = performance.now();
+      /** Return elapsed time in ms */
+      elapsedMs() {
+        return performance.now() - this.start;
+      }
+      /** Return human-readable elapsed time (e.g., "1.2s" or "150ms") */
+      elapsed() {
+        const ms = this.elapsedMs();
+        if (ms >= 1e3) {
+          return `${(ms / 1e3).toFixed(1)}s`;
+        }
+        return `${Math.round(ms)}ms`;
+      }
+    };
+  }
+});
+
+// src/utils/output.ts
+function output(data) {
+  if (isJsonOutput()) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+var init_output = __esm({
+  "src/utils/output.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/utils/errors.ts
+import pc2 from "picocolors";
+function errorWithSuggestion(message) {
+  consola.error(message);
+  for (const { pattern, message: suggestion } of SUGGESTIONS) {
+    if (pattern.test(message)) {
+      consola.info(`${pc2.dim("Suggestion:")} ${suggestion}`);
+      break;
+    }
+  }
+}
+var SUGGESTIONS;
+var init_errors = __esm({
+  "src/utils/errors.ts"() {
+    "use strict";
+    init_console();
+    SUGGESTIONS = [
+      {
+        pattern: /not found in store/i,
+        message: "Run 'knarr publish' in the package directory first, or use --from <path>."
+      },
+      {
+        pattern: /is not linked/i,
+        message: "Run 'knarr add <package>' to link it first."
+      },
+      {
+        pattern: /No package\.json/i,
+        message: "Make sure you're in a valid package directory with a package.json."
+      },
+      {
+        pattern: /missing 'name'/i,
+        message: "Add a 'name' field to your package.json."
+      },
+      {
+        pattern: /missing 'version'/i,
+        message: "Add a 'version' field to your package.json."
+      },
+      {
+        pattern: /store entry missing/i,
+        message: "Re-publish the package with 'knarr publish'."
+      },
+      {
+        pattern: /EACCES|EPERM/i,
+        message: "Permission denied. Try running with elevated privileges or check file ownership."
+      },
+      {
+        pattern: /ENOSPC/i,
+        message: "Disk is full. Free up some space and try again."
+      },
+      {
+        pattern: /No publishable files/i,
+        message: "Check the 'files' field in package.json, or ensure the build output exists."
+      },
+      {
+        pattern: /private.*package/i,
+        message: "Use --private flag to publish private packages."
+      },
+      {
+        pattern: /Failed to read store entry/i,
+        message: "The store may be corrupted. Try 'knarr clean' then re-publish."
+      },
+      {
+        pattern: /Failed to acquire lock/i,
+        message: "Another Knarr process may be running. Wait or delete stale .lk directories."
+      },
+      {
+        pattern: /not a directory/i,
+        message: "Check that the path exists and is a directory."
+      },
+      {
+        pattern: /timed out/i,
+        message: "Set KNARR_HOOK_TIMEOUT to a higher value (in ms) if your scripts need more time."
+      },
+      {
+        pattern: /state.*corrupt|corrupt.*state/i,
+        message: "Delete .knarr/state.json and re-run 'knarr add' for each package."
+      },
+      {
+        pattern: /EBUSY/i,
+        message: "A file is locked by another process (e.g. dev server). Stop the process and retry."
+      },
+      {
+        pattern: /Invalid package name/i,
+        message: "Package names must be non-empty. Use format: package-name or @scope/package-name."
+      }
+    ];
+  }
+});
+
+// src/core/push-engine.ts
+import { readFile as readFile13 } from "fs/promises";
+import { join as join16 } from "path";
+async function doPush(packageDir, options = {}) {
+  const timer = new Timer();
+  const result = await publish(packageDir, {
+    runScripts: options.runScripts,
+    force: options.force,
+    historyLimit: options.historyLimit
+  });
+  if (result.skipped) {
+    consola.info("No changes to push");
+    return;
+  }
+  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 consumers = await getConsumers(result.name);
+  if (consumers.length === 0) {
+    consola.success(
+      `Published ${result.name}@${result.version} to store`
+    );
+    consola.info(
+      "No consumers registered yet. Run 'knarr add " + result.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;
+  }
+  let totalCopied = 0;
+  let totalSkipped = 0;
+  let pushCount = 0;
+  let failedCount = 0;
+  const results = await Promise.all(
+    consumers.map(
+      (consumerPath) => consumerLimit(async () => {
+        const link = await getLink(consumerPath, result.name);
+        if (!link) {
+          verbose(
+            `[push] No link found for ${result.name} in ${consumerPath}, skipping`
+          );
+          return null;
+        }
+        try {
+          const injectResult = await inject(
+            entry,
+            consumerPath,
+            link.packageManager,
+            { force: options.force }
+          );
+          await addLink(consumerPath, result.name, {
+            ...link,
+            contentHash: entry.meta.contentHash,
+            linkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            buildId: entry.meta.buildId ?? ""
+          });
+          return injectResult;
+        } catch (err) {
+          consola.warn(
+            `Failed to push to ${consumerPath}: ${err instanceof Error ? err.message : String(err)}`
+          );
+          return null;
+        }
+      })
+    )
+  );
+  for (const r of results) {
+    if (r) {
+      totalCopied += r.copied;
+      totalSkipped += r.skipped;
+      pushCount++;
+    } 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,
+    failedConsumers: failedCount,
+    copied: totalCopied,
+    skipped: totalSkipped,
+    elapsed: timer.elapsedMs()
+  });
+}
+async function resolveWatchConfig(packageDir, args, config) {
+  let buildCmd = args.build;
+  let patterns = config?.watchPatterns;
+  if (args.build) {
+  } else if (args["skip-build"]) {
+  } else if (config?.buildCmd) {
+    buildCmd = config.buildCmd;
+    consola.info(`Using build command from config: ${buildCmd}`);
+  } else {
+    const pm = await detectPackageManager(packageDir);
+    const detected = await detectBuildCommand(packageDir, pm);
+    if (detected) {
+      buildCmd = detected;
+      consola.info(`Auto-detected build command: ${detected}`);
+    }
+  }
+  if (buildCmd) {
+    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))
+      }))
+    )).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 {
+    consola.info("No build command detected \u2014 watching output directories directly");
+    try {
+      const pkg = JSON.parse(
+        await readFile13(join16(packageDir, "package.json"), "utf-8")
+      );
+      if (pkg.files && pkg.files.length > 0) {
+        patterns = pkg.files;
+        consola.info(`Watching from package.json "files": ${patterns.join(", ")}`);
+      } else {
+        consola.warn(
+          `No "files" field in package.json \u2014 falling back to watching src/ and lib/. Add a "files" field or use --build to specify a build command.`
+        );
+      }
+    } catch (err) {
+      verbose(
+        `[watch] Could not read package.json: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return { buildCmd, patterns };
+}
+var consumerLimit;
+var init_push_engine = __esm({
+  "src/core/push-engine.ts"() {
+    "use strict";
+    init_concurrency();
+    init_publisher();
+    init_store();
+    init_injector();
+    init_tracker();
+    init_build_detect();
+    init_pm_detect();
+    init_timer();
+    init_output();
+    init_errors();
+    init_logger();
+    init_console();
+    consumerLimit = pLimit(4);
+  }
+});
+
+// src/utils/topo-sort.ts
+var topo_sort_exports = {};
+__export(topo_sort_exports, {
+  CycleError: () => CycleError,
+  topoSort: () => topoSort
+});
+function topoSort(graph) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const node of graph.keys()) {
+    if (!inDegree.has(node)) inDegree.set(node, 0);
+    if (!dependents.has(node)) dependents.set(node, []);
+  }
+  for (const [node, deps] of graph) {
+    for (const dep of deps) {
+      if (!graph.has(dep)) continue;
+      inDegree.set(node, (inDegree.get(node) ?? 0) + 1);
+      const list = dependents.get(dep);
+      if (list) list.push(node);
+      else dependents.set(dep, [node]);
+    }
+  }
+  const queue = [];
+  for (const [node, degree] of inDegree) {
+    if (degree === 0) queue.push(node);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    sorted.push(node);
+    for (const dependent of dependents.get(node) ?? []) {
+      const newDegree = (inDegree.get(dependent) ?? 1) - 1;
+      inDegree.set(dependent, newDegree);
+      if (newDegree === 0) queue.push(dependent);
+    }
+  }
+  if (sorted.length !== graph.size) {
+    const remaining = [...graph.keys()].filter((n) => !sorted.includes(n));
+    throw new CycleError(remaining);
+  }
+  return sorted;
+}
+var CycleError;
+var init_topo_sort = __esm({
+  "src/utils/topo-sort.ts"() {
+    "use strict";
+    CycleError = class extends Error {
+      cycle;
+      constructor(cycle) {
+        super(`Dependency cycle detected: ${cycle.join(" \u2192 ")}`);
+        this.name = "CycleError";
+        this.cycle = cycle;
+      }
+    };
+  }
+});
+
+// src/utils/bell.ts
+var bell_exports = {};
+__export(bell_exports, {
+  ringBell: () => ringBell
+});
+function ringBell(enabled) {
+  if (enabled) {
+    process.stderr.write("\x07");
+  }
+}
+var init_bell = __esm({
+  "src/utils/bell.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/watcher.ts
+var watcher_exports = {};
+__export(watcher_exports, {
+  killActiveBuild: () => killActiveBuild,
+  runBuildCommand: () => runBuildCommand,
+  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";
+function killActiveBuild() {
+  if (activeChild && !activeChild.killed) {
+    activeChild.kill("SIGTERM");
+    activeChild = null;
+  }
+}
+async function walkDir(dir, snapshot) {
+  let entries;
+  try {
+    entries = await readdir7(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (IGNORED_DIRS.has(entry.name)) continue;
+    const fullPath = join17(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkDir(fullPath, snapshot);
+    } else {
+      try {
+        const st = await stat8(fullPath);
+        snapshot.set(fullPath, st.mtimeMs);
+      } catch {
+      }
+    }
+  }
+}
+async function buildSnapshot(watchPaths) {
+  const snapshot = /* @__PURE__ */ new Map();
+  for (const p of watchPaths) {
+    try {
+      const st = await stat8(p);
+      if (st.isDirectory()) {
+        await walkDir(p, snapshot);
+      } else {
+        snapshot.set(p, st.mtimeMs);
+      }
+    } catch {
+    }
+  }
+  return snapshot;
+}
+async function startWatcher(watchDir, options, onChange) {
+  const { watch } = await import("chokidar");
+  const patterns = options.patterns ?? ["src", "lib"];
+  const watchPaths = patterns.map(
+    (p) => p.startsWith("/") || p.includes(":") ? p : `${watchDir}/${p}`
+  );
+  const debounceMs = options.debounce ?? 500;
+  const cooldownMs = options.cooldown ?? 500;
+  let debounceTimer = null;
+  let closed = false;
+  let running = false;
+  let lastBuildEndTime = 0;
+  let hasPendingChanges = false;
+  const doBuild = async () => {
+    if (closed || running) return;
+    const timeSinceLastBuild = Date.now() - lastBuildEndTime;
+    if (lastBuildEndTime > 0 && timeSinceLastBuild < cooldownMs) {
+      const remaining = cooldownMs - timeSinceLastBuild;
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        debounceTimer = null;
+        doBuild();
+      }, remaining);
+      return;
+    }
+    running = true;
+    hasPendingChanges = false;
+    try {
+      if (options.buildCmd) {
+        const success = await runBuildCommand(options.buildCmd, watchDir);
+        if (!success) {
+          consola.warn("Build failed (see output above), skipping push");
+          if (options.notify) {
+            const { ringBell: ringBell2 } = await Promise.resolve().then(() => (init_bell(), bell_exports));
+            ringBell2(true);
+          }
+          return;
+        }
+      }
+      await onChange();
+      if (options.notify) ringBell(true);
+    } catch (err) {
+      consola.error(`Push failed: ${err instanceof Error ? err.message : String(err)}`);
+      if (options.notify) ringBell(true);
+    } finally {
+      running = false;
+      lastBuildEndTime = Date.now();
+      if (hasPendingChanges && !closed) {
+        hasPendingChanges = false;
+        debounceTimer = setTimeout(() => {
+          debounceTimer = null;
+          doBuild();
+        }, cooldownMs);
+      }
+    }
+  };
+  const onFileEvent = (path) => {
+    if (closed) return;
+    if (running) {
+      hasPendingChanges = true;
+      return;
+    }
+    const timeSinceLastBuild = Date.now() - lastBuildEndTime;
+    if (lastBuildEndTime > 0 && timeSinceLastBuild < cooldownMs) {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      const remainingCooldown = cooldownMs - timeSinceLastBuild;
+      debounceTimer = setTimeout(() => {
+        debounceTimer = null;
+        doBuild();
+      }, remainingCooldown + debounceMs);
+      return;
+    }
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      doBuild();
+    }, debounceMs);
+  };
+  const awfOption = options.buildCmd ? false : options.awaitWriteFinish ?? {
+    stabilityThreshold: 200,
+    pollInterval: 50
+  };
+  const usePolling = !!process.versions?.webcontainer;
+  const watcher = watch(watchPaths, {
+    ignoreInitial: true,
+    ignored: [
+      /[/\\]node_modules[/\\]/,
+      /[/\\]\.git[/\\]/,
+      /[/\\]\.knarr[/\\]/
+    ],
+    awaitWriteFinish: awfOption,
+    usePolling,
+    ...usePolling && { interval: 1e3 }
+  });
+  watcher.on("change", onFileEvent);
+  watcher.on("add", onFileEvent);
+  watcher.on("unlink", onFileEvent);
+  watcher.on("error", (err) => {
+    consola.error(`Watcher error: ${err instanceof Error ? err.message : String(err)}`);
+  });
+  let pollInterval = null;
+  if (usePolling) {
+    let lastSnapshot = await buildSnapshot(watchPaths);
+    pollInterval = setInterval(async () => {
+      if (closed) return;
+      try {
+        const current = await buildSnapshot(watchPaths);
+        for (const [path, mtime] of current) {
+          const prev = lastSnapshot.get(path);
+          if (prev === void 0 || prev !== mtime) {
+            onFileEvent(path);
+            break;
+          }
+        }
+        if (!closed) {
+          for (const path of lastSnapshot.keys()) {
+            if (!current.has(path)) {
+              onFileEvent(path);
+              break;
+            }
+          }
+        }
+        lastSnapshot = current;
+      } catch {
+      }
+    }, 1e3);
+  }
+  const watcherHandle = {
+    close: async () => {
+      closed = true;
+      if (pollInterval) clearInterval(pollInterval);
+      if (debounceTimer) clearTimeout(debounceTimer);
+      killActiveBuild();
+      await watcher.close();
+      activeWatcher = null;
+    }
+  };
+  activeWatcher = watcherHandle;
+  consola.info(`Watching for changes in: ${patterns.join(", ")}`);
+  return watcherHandle;
+}
+function runBuildCommand(cmd, cwd) {
+  return new Promise((resolve7) => {
+    const isWin = platform3() === "win32";
+    const shell = isWin ? "cmd" : "sh";
+    const shellFlag = isWin ? "/c" : "-c";
+    consola.start(`Running: ${cmd}`);
+    const child = spawn2(shell, [shellFlag, cmd], {
+      cwd,
+      stdio: "inherit"
+    });
+    activeChild = child;
+    child.on("close", (code) => {
+      activeChild = null;
+      if (code === 0) {
+        consola.success("Build succeeded");
+        resolve7(true);
+      } else {
+        consola.error(`Build failed with code ${code}`);
+        resolve7(false);
+      }
+    });
+    child.on("error", (err) => {
+      activeChild = null;
+      consola.error(`Build error: ${err.message}`);
+      resolve7(false);
+    });
+  });
+}
+var activeChild, activeWatcher, IGNORED_DIRS;
+var init_watcher = __esm({
+  "src/core/watcher.ts"() {
+    "use strict";
+    init_console();
+    init_bell();
+    activeChild = null;
+    activeWatcher = null;
+    IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".knarr"]);
+  }
+});
+
+// src/core/watch-orchestrator.ts
+var cascadeLimit, 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();
+      cascade;
+      pushOptions = {};
+      constructor(cascade) {
+        this.cascade = cascade;
+      }
+      async start(startDir, args, pushOptions) {
+        this.pushOptions = pushOptions;
+        const { buildWorkspaceGraph: buildWorkspaceGraph2, buildReverseAdjacency: buildReverseAdjacency2 } = 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);
+        if (graph.packages.length === 0) {
+          consola.warn("No workspace packages found");
+          return;
+        }
+        let ordered;
+        try {
+          ordered = topoSort2(graph.adjacency);
+        } catch (err) {
+          if (err instanceof CycleError2) {
+            consola.error(`Cannot watch: ${err.message}`);
+            return;
+          }
+          throw err;
+        }
+        if (this.cascade) {
+          this.dependents = buildReverseAdjacency2(graph.adjacency);
+          consola.info("Cascade mode enabled");
+        }
+        const nameToDir = new Map(graph.packages.map((p) => [p.name, p.dir]));
+        for (const name of ordered) {
+          const dir = nameToDir.get(name);
+          if (!dir) continue;
+          const config = await loadKnarrConfig(dir);
+          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);
+          };
+          const parseMs = (v) => {
+            if (!v) return void 0;
+            const n = parseInt(v, 10);
+            return Number.isFinite(n) ? n : void 0;
+          };
+          const watcher = await startWatcher2(
+            dir,
+            {
+              patterns,
+              buildCmd,
+              debounce: parseMs(args.debounce) ?? config.debounce,
+              cooldown: parseMs(args.cooldown) ?? config.cooldown,
+              notify
+            },
+            wrappedOnChange
+          );
+          this.packages.set(name, { dir, state: "idle", watcher });
+        }
+        consola.info(`Watching ${this.packages.size} workspace packages`);
+        await new Promise((resolve7) => {
+          const cleanup = async () => {
+            consola.info("Stopping watchers...");
+            await this.close();
+            resolve7();
+          };
+          process.once("SIGINT", cleanup);
+          process.once("SIGTERM", cleanup);
+        });
+      }
+      async onPackagePushed(name) {
+        if (!this.cascade) return;
+        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);
+      }
+      async requestRebuild(name) {
+        const entry = this.packages.get(name);
+        if (!entry) return;
+        if (entry.state === "queued") {
+          verbose(`[cascade] ${name} already queued, skipping`);
+          return;
+        }
+        if (entry.state === "building") {
+          verbose(`[cascade] ${name} is building, marking as queued`);
+          entry.state = "queued";
+          return;
+        }
+        entry.state = "building";
+        verbose(`[cascade] Rebuilding ${name}`);
+        try {
+          const config = await loadKnarrConfig(entry.dir);
+          const buildCmd = config.buildCmd;
+          if (buildCmd) {
+            const { runBuildCommand: runBuildCommand2 } = await Promise.resolve().then(() => (init_watcher(), watcher_exports));
+            const success = await runBuildCommand2(buildCmd, entry.dir);
+            if (!success) {
+              consola.warn(`[cascade] Build failed for ${name}, skipping dependents`);
+              entry.state = "idle";
+              return;
+            }
+          }
+          await doPush(entry.dir, this.pushOptions);
+          await this.onPackagePushed(name);
+        } 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(
+          [...this.packages.values()].map((p) => p.watcher.close())
+        );
+        this.packages.clear();
+      }
+    };
+  }
+});
+
+// src/index.ts
+init_publisher();
+init_injector();
+init_store();
+init_tracker();
+init_push_engine();
+
+// src/core/batch-push.ts
+init_console();
+init_workspace();
+init_topo_sort();
+init_push_engine();
+init_timer();
+init_logger();
+async function doPushAll(startDir, options = {}) {
+  const timer = new Timer();
+  const graph = await buildWorkspaceGraph(startDir);
+  if (graph.packages.length === 0) {
+    consola.warn("No workspace packages found");
+    return;
+  }
+  let ordered;
+  try {
+    ordered = topoSort(graph.adjacency);
+  } catch (err) {
+    if (err instanceof CycleError) {
+      consola.error(`Cannot push: ${err.message}`);
+      return;
+    }
+    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 ")}`);
+  let success = 0;
+  let failed = 0;
+  for (const name of ordered) {
+    const dir = nameToDir.get(name);
+    if (!dir) continue;
+    try {
+      await doPush(dir, options);
+      success++;
+    } catch (err) {
+      consola.warn(
+        `Failed to push ${name}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      failed++;
+    }
+  }
+  consola.success(
+    `Pushed ${success}/${ordered.length} packages in ${timer.elapsed()}${failed > 0 ? ` (${failed} failed)` : ""}`
+  );
+}
+
+// src/index.ts
+init_history();
+init_watcher();
+init_watch_orchestrator();
+init_pm_detect();
+init_config();
+init_topo_sort();
+init_workspace();
+
+// src/utils/preflight.ts
+init_logger();
+import { readFile as readFile14, stat as stat9 } from "fs/promises";
+import { join as join18, resolve as resolve6 } from "path";
+async function runPreflightChecks(packageDir) {
+  const issues = [];
+  let pkgContent;
+  try {
+    pkgContent = await readFile14(join18(packageDir, "package.json"), "utf-8");
+  } catch {
+    issues.push({
+      code: "NO_PACKAGE_JSON",
+      severity: "error",
+      message: "No package.json found"
+    });
+    return issues;
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(pkgContent);
+  } catch {
+    issues.push({
+      code: "INVALID_PACKAGE_JSON",
+      severity: "error",
+      message: "package.json is not valid JSON"
+    });
+    return issues;
+  }
+  const files = pkg.files;
+  if (!files || files.length === 0) {
+    issues.push({
+      code: "EMPTY_FILES",
+      severity: "warn",
+      message: 'No "files" field in package.json \u2014 npm will include almost everything. Consider adding a "files" field to control what gets published.'
+    });
+  }
+  if (typeof pkg.main === "string") {
+    await checkPath(packageDir, pkg.main, "main", issues);
+  }
+  if (typeof pkg.module === "string") {
+    await checkPath(packageDir, pkg.module, "module", issues);
+  }
+  if (typeof pkg.types === "string") {
+    await checkPath(packageDir, pkg.types, "types", issues);
+  } else if (typeof pkg.typings === "string") {
+    await checkPath(packageDir, pkg.typings, "typings", issues);
+  }
+  if (typeof pkg.exports === "string") {
+    await checkPath(packageDir, pkg.exports, "exports", issues);
+  } else if (pkg.exports && typeof pkg.exports === "object") {
+    await checkExports(packageDir, pkg.exports, issues);
+  }
+  if (typeof pkg.bin === "string") {
+    await checkPath(packageDir, pkg.bin, "bin", issues);
+  } else if (pkg.bin && typeof pkg.bin === "object") {
+    for (const [name, binPath] of Object.entries(pkg.bin)) {
+      if (typeof binPath === "string") {
+        await checkPath(packageDir, binPath, `bin.${name}`, issues);
+      }
+    }
+  }
+  verbose(`[preflight] ${issues.length} issue(s) found in ${packageDir}`);
+  return issues;
+}
+async function fileExists(filePath) {
+  try {
+    const s = await stat9(filePath);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+async function checkPath(packageDir, filePath, field, issues) {
+  const resolved = resolve6(packageDir, filePath);
+  if (!await fileExists(resolved)) {
+    issues.push({
+      code: "MISSING_PATH",
+      severity: "warn",
+      message: `"${field}" points to "${filePath}" which does not exist`
+    });
+  }
+}
+async function checkExports(packageDir, exports, issues) {
+  for (const [key, value] of Object.entries(exports)) {
+    if (typeof value === "string") {
+      if (value.startsWith(".")) {
+        const resolved = resolve6(packageDir, value);
+        if (!await fileExists(resolved)) {
+          issues.push({
+            code: "EXPORTS_PATH_MISSING",
+            severity: "warn",
+            message: `exports["${key}"] points to "${value}" which does not exist`
+          });
+        }
+      }
+    } else if (value && typeof value === "object") {
+      await checkExportsConditions(
+        packageDir,
+        key,
+        value,
+        issues
+      );
+    }
+  }
+}
+async function checkExportsConditions(packageDir, exportKey, conditions, issues) {
+  const keys = Object.keys(conditions);
+  const typesIdx = keys.indexOf("types");
+  const importIdx = keys.indexOf("import");
+  const requireIdx = keys.indexOf("require");
+  const defaultIdx = keys.indexOf("default");
+  if (typesIdx !== -1) {
+    const firstCodeIdx = Math.min(
+      importIdx === -1 ? Infinity : importIdx,
+      requireIdx === -1 ? Infinity : requireIdx,
+      defaultIdx === -1 ? Infinity : defaultIdx
+    );
+    if (typesIdx > firstCodeIdx && firstCodeIdx !== Infinity) {
+      issues.push({
+        code: "TYPES_CONDITION_ORDER",
+        severity: "warn",
+        message: `exports["${exportKey}"].types should come before import/require/default for TypeScript to resolve it correctly`
+      });
+    }
+  }
+  for (const [condition, value] of Object.entries(conditions)) {
+    if (typeof value === "string" && value.startsWith(".")) {
+      const resolved = resolve6(packageDir, value);
+      if (!await fileExists(resolved)) {
+        issues.push({
+          code: "EXPORTS_PATH_MISSING",
+          severity: "warn",
+          message: `exports["${exportKey}"].${condition} points to "${value}" which does not exist`
+        });
+      }
+    } else if (value && typeof value === "object") {
+      await checkExportsConditions(
+        packageDir,
+        exportKey,
+        value,
+        issues
+      );
+    }
+  }
+}
+
+// src/index.ts
+init_bell();
+init_timer();
+init_fs();
+init_paths();
+init_dry_run();
+
+// src/utils/vite-config.ts
+import { readFile as readFile15 } from "fs/promises";
+function defineConfigUsesTernary(content) {
+  const callRegex = /(^|[^A-Za-z0-9_$])defineConfig\s*\(/g;
+  let match;
+  while ((match = callRegex.exec(content)) !== null) {
+    const parenStart = match.index + match[0].length - 1;
+    let depth = 1;
+    let i = parenStart + 1;
+    let inString = false;
+    let escaped = false;
+    while (i < content.length && depth > 0) {
+      const ch = content[i];
+      if (escaped) {
+        escaped = false;
+        i++;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        i++;
+        continue;
+      }
+      if (inString) {
+        if (ch === inString) inString = false;
+        i++;
+        continue;
+      }
+      if (ch === '"' || ch === "'" || ch === "`") {
+        inString = ch;
+        i++;
+        continue;
+      }
+      if (ch === "/" && content[i + 1] === "/") {
+        const newline = content.indexOf("\n", i);
+        i = newline === -1 ? content.length : newline + 1;
+        continue;
+      }
+      if (ch === "/" && content[i + 1] === "*") {
+        const end = content.indexOf("*/", i + 2);
+        i = end === -1 ? content.length : end + 2;
+        continue;
+      }
+      if (ch === "?") {
+        const next = content[i + 1];
+        if (next === "." || next === "?") {
+          i += 2;
+          continue;
+        }
+        return true;
+      }
+      if (ch === "(") depth++;
+      if (ch === ")") depth--;
+      i++;
+    }
+    callRegex.lastIndex = i;
+  }
+  return false;
+}
+function isComplexConfig(content) {
+  if (defineConfigUsesTernary(content)) {
+    return { complex: true, reason: "conditional defineConfig" };
+  }
+  if (/export\s+default\s+function/.test(content)) {
+    return { complex: true, reason: "dynamic export (function)" };
+  }
+  if (/plugins\s*:\s*\[\s*\.\.\./.test(content)) {
+    return { complex: true, reason: "spread operator in plugins array" };
+  }
+  if (/defineConfig\s*\(\s*async/.test(content) || /mergeConfig\s*\(/.test(content)) {
+    return { complex: true, reason: "async or merged config" };
+  }
+  return { complex: false };
+}
+export {
+  CycleError,
+  Timer,
+  WatchOrchestrator,
+  addLink,
+  backupExisting,
+  buildReverseAdjacency,
+  buildWorkspaceGraph,
+  captureHistory,
+  checkMissingDeps,
+  cleanStaleConsumers,
+  clearHistory,
+  detectPackageManager,
+  doPush,
+  doPushAll,
+  findStoreEntry,
+  getConsumers,
+  getHistoryEntry,
+  getLink,
+  getStoreEntry,
+  inject,
+  isComplexConfig,
+  isNodeError,
+  killActiveBuild,
+  listHistory,
+  listStoreEntries,
+  loadKnarrConfig,
+  normalizePath,
+  printDryRunReport,
+  pruneHistory,
+  publish,
+  readConsumerState,
+  readConsumerStateSafe,
+  recordMutation,
+  registerConsumer,
+  removeInjected,
+  removeLink,
+  resetMutations,
+  resolveHistoryLimit,
+  restoreBackup,
+  restoreHistoryEntry,
+  ringBell,
+  runBuildCommand,
+  runPreflightChecks,
+  startWatcher,
+  topoSort,
+  unregisterConsumer
+};