@olegkuibar/plunk 0.2.3 → 0.3.0-canary.0807dec

package/dist/index.mjs

@@ -8,8 +8,120 @@ var __export = (target, 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("\u2139"), msg, ...args);
+      },
+      success(msg, ...args) {
+        if (_level >= 3) console.log(pc.green("\u2714"), msg, ...args);
+      },
+      warn(msg, ...args) {
+        if (_level >= 2) console.warn(pc.yellow("\u26A0"), msg, ...args);
+      },
+      error(msg, ...args) {
+        if (_level >= 1) console.error(pc.red("\u2716"), msg, ...args);
+      },
+      start(msg, ...args) {
+        if (_level >= 3) console.log(pc.cyan("\u25D0"), 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 = [];
+  const next = () => {
+    if (queue.length > 0 && active < concurrency) {
+      active++;
+      queue.shift()();
+    }
+  };
+  return (fn) => new Promise((resolve6, reject) => {
+    const run = () => {
+      fn().then(
+        (val) => {
+          active--;
+          resolve6(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/logger.ts
-import { consola } from "consola";
 function isDryRun() {
   return _dryRun;
 }
@@ -20,6 +132,7 @@ var _verbose, _dryRun;
 var init_logger = __esm({
   "src/utils/logger.ts"() {
     "use strict";
+    init_console();
     _verbose = false;
     _dryRun = false;
   }
@@ -30,33 +143,7 @@ import { createHash } from "crypto";
 import { createReadStream } from "fs";
 import { readFile, stat } from "fs/promises";
 import { relative } from "path";
-import pLimit from "p-limit";
 import { availableParallelism } from "os";
-import xxhash from "xxhash-wasm";
-async function getXxhash() {
-  if (!xxh) xxh = await xxhash();
-  return xxh;
-}
-async function getPool() {
-  if (poolFailed) return null;
-  if (pool) return pool;
-  try {
-    const { default: Tinypool } = await import("tinypool");
-    const poolSize = Math.min(Math.max(availableParallelism(), 2), 8);
-    const workerUrl = new URL("./hash-worker.mjs", import.meta.url);
-    pool = new Tinypool({
-      filename: workerUrl.href,
-      minThreads: 0,
-      maxThreads: poolSize
-    });
-    verbose(`[hash] Worker pool initialized (max ${poolSize} threads)`);
-    return pool;
-  } catch {
-    poolFailed = true;
-    verbose("[hash] Worker pool unavailable, using main-thread hashing");
-    return null;
-  }
-}
 async function computeContentHash(files, baseDir) {
   const sorted = [...files].sort((a, b) => {
     const relA = relative(baseDir, a).replace(/\\/g, "/");
@@ -73,60 +160,43 @@ async function computeContentHash(files, baseDir) {
   );
   verbose(`[hash] Computing content hash for ${files.length} files`);
   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 = "sha256:" + hash.digest("hex");
+  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;
-  if (size <= WORKER_THRESHOLD) {
-    return hashFileMainThread(filePath, size);
-  }
-  const p = await getPool();
-  if (p) {
-    try {
-      return await p.run([filePath, size]);
-    } catch {
-    }
-  }
-  return hashFileMainThread(filePath, size);
-}
-async function hashFileMainThread(filePath, size) {
   if (size > STREAM_THRESHOLD) {
     return hashFileStream(filePath);
   }
-  const { h64Raw } = await getXxhash();
   const content = await readFile(filePath);
-  return h64Raw(content).toString(16);
+  return createHash("sha256").update(content).digest("hex");
 }
 function hashFileStream(filePath) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve6, reject) => {
     const hash = createHash("sha256");
     const stream = createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
-    stream.on("end", () => resolve4(hash.digest("hex")));
+    stream.on("end", () => resolve6(hash.digest("hex")));
     stream.on("error", reject);
   });
 }
-var STREAM_THRESHOLD, WORKER_THRESHOLD, limit, xxh, pool, poolFailed;
+var STREAM_THRESHOLD, limit;
 var init_hash = __esm({
   "src/utils/hash.ts"() {
     "use strict";
+    init_concurrency();
     init_logger();
     STREAM_THRESHOLD = 1024 * 1024;
-    WORKER_THRESHOLD = 64 * 1024;
     limit = pLimit(Math.max(availableParallelism(), 8));
-    xxh = null;
-    pool = null;
-    poolFailed = false;
-    process.on("exit", () => {
-      pool?.destroy();
-    });
   }
 });
 
@@ -143,7 +213,6 @@ import {
   constants
 } from "fs/promises";
 import { join as join2, dirname, relative as relative2, parse as parsePath } from "path";
-import pLimit2 from "p-limit";
 import { availableParallelism as availableParallelism2 } from "os";
 function isNodeError(err) {
   return err instanceof Error && "code" in err;
@@ -178,21 +247,8 @@ async function copyWithCoW(src, dest) {
   }
 }
 async function collectFiles(dir) {
-  const entries = await readdir(dir, { recursive: true });
-  const results = await Promise.all(
-    entries.map(
-      (entry) => ioLimit(async () => {
-        const full = join2(dir, entry);
-        try {
-          const s = await stat2(full);
-          return s.isFile() ? full : null;
-        } catch {
-          return null;
-        }
-      })
-    )
-  );
-  return results.filter((f) => f !== null);
+  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) {
   const srcFiles = await collectFiles(srcDir);
@@ -246,16 +302,18 @@ async function incrementalCopy(srcDir, destDir) {
   try {
     const destFiles = await collectFiles(destDir);
     const srcRelPaths = new Set(srcFiles.map((f) => relative2(srcDir, f)));
-    for (const destFile of destFiles) {
-      const rel = relative2(destDir, destFile);
-      if (!srcRelPaths.has(rel)) {
-        verbose(`[remove] ${rel} (no longer in source)`);
-        if (!isDryRun()) {
-          await rm(destFile);
-        }
-        removed++;
-      }
-    }
+    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()) await rm(destFile);
+        })
+      )
+    );
+    removed = filesToRemove.length;
   } catch (err) {
     if (isNodeError(err) && err.code === "ENOENT") {
     } else {
@@ -313,10 +371,11 @@ var ioLimit, reflinkSupported;
 var init_fs = __esm({
   "src/utils/fs.ts"() {
     "use strict";
+    init_concurrency();
     init_hash();
     init_logger();
     init_logger();
-    ioLimit = pLimit2(Math.max(availableParallelism2(), 8));
+    ioLimit = pLimit(Math.max(availableParallelism2(), 8));
     reflinkSupported = /* @__PURE__ */ new Map();
   }
 });
@@ -324,11 +383,13 @@ var init_fs = __esm({
 // src/utils/workspace.ts
 var workspace_exports = {};
 __export(workspace_exports, {
+  findWorkspacePackages: () => findWorkspacePackages,
   findWorkspaceRoot: () => findWorkspaceRoot,
   parseCatalogs: () => parseCatalogs
 });
-import { readFile as readFile4 } from "fs/promises";
-import { join as join5, dirname as dirname3 } from "path";
+import { readFile as readFile4, readdir as readdir4 } from "fs/promises";
+import { join as join5, dirname as dirname3, resolve as resolve2, relative as relative4 } from "path";
+import picomatch2 from "picomatch";
 async function findWorkspaceRoot(startDir) {
   let dir = startDir;
   for (; ; ) {
@@ -401,6 +462,130 @@ async function parseCatalogs(workspaceRoot) {
   }
   return result;
 }
+async function findWorkspacePackages(startDir) {
+  const pnpmRoot = await findWorkspaceRoot(startDir);
+  if (pnpmRoot) {
+    const patterns = await parsePnpmWorkspacePackages(pnpmRoot);
+    if (patterns.length > 0) {
+      return resolveWorkspaceGlobs(pnpmRoot, patterns);
+    }
+  }
+  const rootDir = pnpmRoot ?? await findPackageJsonWorkspaceRoot(startDir);
+  if (!rootDir) return [];
+  try {
+    const rootPkg = JSON.parse(await readFile4(join5(rootDir, "package.json"), "utf-8"));
+    const workspaces = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces : rootPkg.workspaces?.packages ?? [];
+    if (workspaces.length === 0) return [];
+    return resolveWorkspaceGlobs(rootDir, workspaces);
+  } catch {
+    return [];
+  }
+}
+async function parsePnpmWorkspacePackages(workspaceRoot) {
+  const filePath = join5(workspaceRoot, "pnpm-workspace.yaml");
+  let content;
+  try {
+    content = await readFile4(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) {
+        if (!match[1].startsWith("!")) {
+          patterns.push(match[1]);
+        }
+      }
+    }
+  }
+  return patterns;
+}
+async function findPackageJsonWorkspaceRoot(startDir) {
+  let dir = startDir;
+  for (; ; ) {
+    try {
+      const pkg = JSON.parse(await readFile4(join5(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) {
+  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 = join5(staticPrefix, part);
+        }
+      }
+      if (globParts.length === 1 && globParts[0] === "*") {
+        try {
+          const entries = await readdir4(staticPrefix, { withFileTypes: true });
+          for (const entry of entries) {
+            if (entry.isDirectory()) {
+              const pkgDir = join5(staticPrefix, entry.name);
+              if (await exists(join5(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 = relative4(rootDir, candidate).replace(/\\/g, "/");
+          if (isMatch(rel) && await exists(join5(candidate, "package.json"))) {
+            results.push(candidate);
+          }
+        }
+      }
+    } else {
+      const pkgDir = resolve2(rootDir, pattern);
+      if (await exists(join5(pkgDir, "package.json"))) {
+        results.push(pkgDir);
+      }
+    }
+  }
+  return [...new Set(results)];
+}
+async function collectDirs(dir, maxDepth) {
+  if (maxDepth <= 0) return [];
+  const results = [];
+  try {
+    const entries = await readdir4(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name === "node_modules" || entry.name === ".git") continue;
+      const full = join5(dir, entry.name);
+      results.push(full);
+      results.push(...await collectDirs(full, maxDepth - 1));
+    }
+  } catch {
+  }
+  return results;
+}
 function parseKeyValue(line) {
   const trimmed = line.trim();
   const colonIdx = trimmed.indexOf(":");
@@ -419,13 +604,13 @@ var init_workspace = __esm({
 });
 
 // src/core/publisher.ts
-import { readFile as readFile5, writeFile as writeFile3, rename as rename2 } from "fs/promises";
+init_console();
+init_concurrency();
+import { readFile as readFile5, writeFile as writeFile2, rename as rename2, stat as stat5 } from "fs/promises";
 import { randomBytes } from "crypto";
-import { join as join6, relative as relative4, dirname as dirname4 } from "path";
+import { join as join6, relative as relative5, dirname as dirname4, resolve as resolve3 } from "path";
 import { spawn } from "child_process";
 import { platform } from "os";
-import { consola as consola4 } from "consola";
-import pLimit3 from "p-limit";
 import { availableParallelism as availableParallelism3 } from "os";
 
 // src/utils/paths.ts
@@ -475,23 +660,23 @@ function getNodeModulesPackagePath(consumerPath, packageName) {
 }
 
 // src/utils/pack-list.ts
+init_console();
 init_fs();
 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";
-import { consola as consola2 } from "consola";
 async function resolvePackFiles(packageDir, pkg) {
   const files = [];
   const absDir = resolve(packageDir);
   files.push(join3(absDir, "package.json"));
-  const allFiles = await collectAllFiles(absDir);
+  const allFiles = await collectAllFiles(absDir, absDir);
   const allRelPaths = allFiles.map((f) => relative3(absDir, f).replace(/\\/g, "/"));
   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) {
-        consola2.warn(`files pattern "${pattern}" escapes package directory, skipping`);
+        consola.warn(`files pattern "${pattern}" escapes package directory, skipping`);
         continue;
       }
       let matched = false;
@@ -526,7 +711,7 @@ async function resolvePackFiles(packageDir, pkg) {
           }
         }
         if (globMatched === 0) {
-          consola2.warn(`files pattern "${pattern}" matched no files`);
+          consola.warn(`files pattern "${pattern}" matched no files`);
         }
       }
     }
@@ -583,6 +768,9 @@ var DEFAULT_IGNORES = /* @__PURE__ */ new Set([
   "vitest.config.js"
 ]);
 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;
@@ -592,9 +780,6 @@ function shouldIgnore(relPath, matchers) {
   for (const isMatch of matchers.patterns) {
     if (isMatch(relPath)) return true;
   }
-  for (const isMatch of matchers.negations) {
-    if (isMatch(relPath)) return false;
-  }
   return false;
 }
 async function loadNpmIgnore(dir) {
@@ -627,16 +812,17 @@ async function loadNpmIgnore(dir) {
 function hasGlobChars(pattern) {
   return /[*?[\]{}()]/.test(pattern);
 }
-async function collectAllFiles(dir) {
+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 === "node_modules" || entry.name === ".git") continue;
+        if (entry.name === ".git") continue;
+        if (dir === rootDir && entry.name === "node_modules") continue;
         if (entry.isSymbolicLink()) continue;
-        results.push(...await collectAllFiles(full));
+        results.push(...await collectAllFiles(full, rootDir));
       } else if (!entry.isSymbolicLink()) {
         results.push(full);
       }
@@ -655,16 +841,16 @@ init_hash();
 init_fs();
 
 // src/core/store.ts
+init_console();
 import { readFile as readFile3, readdir as readdir3 } from "fs/promises";
 import "path";
-import { consola as consola3 } from "consola";
 init_fs();
 
 // src/utils/validators.ts
 function isPlunkMeta(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");
+  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;
@@ -697,20 +883,27 @@ function isConsumersRegistry(value) {
 // src/core/store.ts
 async function readMeta(name, version) {
   const metaPath = getStoreMetaPath(name, version);
-  try {
-    const content = await readFile3(metaPath, "utf-8");
-    const parsed = JSON.parse(content);
-    if (!isPlunkMeta(parsed)) {
-      consola3.warn(`Invalid metadata for ${name}@${version}, ignoring`);
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const content = await readFile3(metaPath, "utf-8");
+      const parsed = JSON.parse(content);
+      if (!isPlunkMeta(parsed)) {
+        consola.warn(`Invalid metadata for ${name}@${version}, ignoring`);
+        return null;
+      }
+      return parsed;
+    } catch (err) {
+      if (isNodeError(err) && err.code === "ENOENT" && attempt === 0) {
+        await new Promise((r) => setTimeout(r, 100));
+        continue;
+      }
+      if (isNodeError(err) && err.code !== "ENOENT") {
+        consola.warn(`Failed to read metadata for ${name}@${version}: ${err instanceof Error ? err.message : String(err)}`);
+      }
       return null;
     }
-    return parsed;
-  } catch (err) {
-    if (isNodeError(err) && err.code !== "ENOENT") {
-      consola3.warn(`Failed to read metadata for ${name}@${version}: ${err}`);
-    }
-    return null;
   }
+  return null;
 }
 async function getStoreEntry(name, version) {
   const packageDir = getStorePackagePath(name, version);
@@ -742,10 +935,9 @@ async function findStoreEntry(name) {
   );
   const matching = results.filter((r) => r !== null);
   if (matching.length === 0) return null;
-  matching.sort(
-    (a, b) => new Date(b.meta.publishedAt).getTime() - new Date(a.meta.publishedAt).getTime()
+  return matching.reduce(
+    (latest, entry) => new Date(entry.meta.publishedAt).getTime() > new Date(latest.meta.publishedAt).getTime() ? entry : latest
   );
-  return matching[0];
 }
 async function listStoreEntries() {
   const storePath = getStorePath();
@@ -777,44 +969,64 @@ async function listStoreEntries() {
 
 // src/utils/lockfile.ts
 init_fs();
-import { lock } from "proper-lockfile";
+import { mkdir as mkdir2, stat as stat4, rm as rm2 } from "fs/promises";
 import { dirname as dirname2 } from "path";
-import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-var LOCK_OPTIONS = {
-  retries: {
-    retries: 5,
-    minTimeout: 100,
-    maxTimeout: 1e3,
-    factor: 2
-  },
-  stale: 1e4,
-  realpath: false
+import { setTimeout as sleep } from "timers/promises";
+var DEFAULTS = {
+  retries: 5,
+  minTimeout: 100,
+  maxTimeout: 1e3,
+  factor: 2,
+  stale: 1e4
 };
 async function withFileLock(filePath, fn, lockOptions) {
   await mkdir2(dirname2(filePath), { recursive: true });
-  try {
-    await writeFile2(filePath, "", { flag: "wx" });
-  } catch (err) {
-    if (isNodeError(err) && err.code === "EEXIST") {
-    } else {
-      throw err;
+  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;
+      }
     }
   }
-  const opts = lockOptions ? { ...LOCK_OPTIONS, ...lockOptions } : LOCK_OPTIONS;
-  let release;
+  if (!acquired) {
+    throw new Error(
+      `Failed to acquire lock after ${DEFAULTS.retries} attempts. Another plunk process may be running. If this persists, delete ${lockDir} and retry.`
+    );
+  }
   try {
-    release = await lock(filePath, opts);
     return await fn();
   } finally {
-    if (release) {
-      await release();
-    }
+    await rm2(lockDir, { recursive: true, force: true });
   }
 }
 
 // src/core/publisher.ts
 init_logger();
-var copyLimit = pLimit3(Math.max(availableParallelism3(), 8));
+var copyLimit = pLimit(Math.max(availableParallelism3(), 8));
 async function publish(packageDir, options = {}) {
   const pkgPath = join6(packageDir, "package.json");
   let pkgContent;
@@ -832,16 +1044,37 @@ async function publish(packageDir, options = {}) {
     );
   }
   await runLifecycleHook(packageDir, pkg, "preplunk");
-  const files = await resolvePackFiles(packageDir, pkg);
+  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 readFile5(join6(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, packageDir);
+  const contentHash = await computeContentHash(files, publishDir);
+  await preloadWorkspaceVersions(pkg, packageDir);
   await preloadCatalogs(pkg, packageDir);
   const existingMeta = await readMeta(pkg.name, pkg.version);
   if (existingMeta && existingMeta.contentHash === contentHash) {
-    consola4.info(`${pkg.name}@${pkg.version} already up to date`);
+    consola.info(`${pkg.name}@${pkg.version} already up to date (no changes since last publish)`);
     return {
       name: pkg.name,
       version: pkg.version,
@@ -857,7 +1090,7 @@ async function publish(packageDir, options = {}) {
     async () => {
       const metaUnderLock = await readMeta(pkg.name, pkg.version);
       if (metaUnderLock && metaUnderLock.contentHash === contentHash) {
-        consola4.info(`${pkg.name}@${pkg.version} already up to date`);
+        consola.info(`${pkg.name}@${pkg.version} already up to date (no changes since last publish)`);
         return {
           name: pkg.name,
           version: pkg.version,
@@ -872,32 +1105,40 @@ async function publish(packageDir, options = {}) {
       const buildId = randomBytes(4).toString("hex");
       try {
         await ensurePrivateDir(tmpPackageDir);
-        const processedPkg = rewriteProtocolVersions(pkg, packageDir);
+        let processedPkg = rewriteProtocolVersions(pkg, packageDir);
+        processedPkg = applyPublishConfig(processedPkg);
         verbose(`[publish] Copying files to temp store...`);
         const uniqueDirs = new Set(
-          files.map((file) => dirname4(join6(tmpPackageDir, relative4(packageDir, file))))
+          files.map((file) => dirname4(join6(tmpPackageDir, relative5(publishDir, file))))
         );
         await Promise.all([...uniqueDirs].map((d) => ensureDir(d)));
         await Promise.all(
           files.map(
             (file) => copyLimit(async () => {
-              const rel = relative4(packageDir, file);
+              const rel = relative5(publishDir, file);
               const dest = join6(tmpPackageDir, rel);
               if (rel === "package.json" && processedPkg !== pkg) {
-                await writeFile3(dest, JSON.stringify(processedPkg, null, 2));
+                await writeFile2(dest, JSON.stringify(processedPkg, null, 2));
               } else {
                 await copyWithCoW(file, dest);
               }
             })
           )
         );
+        if (publishDir !== packageDir) {
+          await writeFile2(
+            join6(tmpPackageDir, "package.json"),
+            JSON.stringify(processedPkg, null, 2)
+          );
+        }
         const meta = {
+          schemaVersion: 1,
           contentHash,
           publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
           sourcePath: packageDir,
           buildId
         };
-        await writeFile3(
+        await writeFile2(
           join6(tmpDir, ".plunk-meta.json"),
           JSON.stringify(meta, null, 2)
         );
@@ -923,8 +1164,11 @@ async function publish(packageDir, options = {}) {
     { stale: 6e4 }
   );
   if (result.skipped) return result;
+  if (options.runScripts !== false) {
+    await runLifecycleHook(packageDir, pkg, "postpack");
+  }
   await runLifecycleHook(packageDir, pkg, "postplunk");
-  consola4.success(
+  consola.success(
     `Published ${pkg.name}@${pkg.version} (${files.length} files) [${result.buildId}]`
   );
   return result;
@@ -934,7 +1178,7 @@ async function runLifecycleHook(packageDir, pkg, hookName) {
   const script = pkg.scripts?.[hookName];
   if (!script) return;
   verbose(`[lifecycle] Running ${hookName}: ${script}`);
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve6, reject) => {
     const isWin = platform() === "win32";
     const shell = isWin ? "cmd" : "sh";
     const shellFlag = isWin ? "/c" : "-c";
@@ -944,12 +1188,12 @@ async function runLifecycleHook(packageDir, pkg, hookName) {
     });
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
-      reject(new Error(`${hookName} script timed out after ${HOOK_TIMEOUT}ms`));
+      reject(new Error(`${hookName} script timed out after ${HOOK_TIMEOUT / 1e3}s. Increase PLUNK_HOOK_TIMEOUT env var if the script needs more time.`));
     }, HOOK_TIMEOUT);
     child.on("close", (code) => {
       clearTimeout(timer);
       if (code === 0) {
-        resolve4();
+        resolve6();
       } else {
         reject(new Error(`${hookName} script failed with exit code ${code}`));
       }
@@ -960,6 +1204,26 @@ async function runLifecycleHook(packageDir, pkg, hookName) {
     });
   });
 }
+var PUBLISH_CONFIG_OVERRIDES = [
+  "main",
+  "module",
+  "exports",
+  "types",
+  "typings",
+  "browser",
+  "bin"
+];
+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, packageDir) {
   let changed = false;
   const result = { ...pkg };
@@ -968,7 +1232,8 @@ function rewriteProtocolVersions(pkg, packageDir) {
   for (const depField of [
     "dependencies",
     "devDependencies",
-    "peerDependencies"
+    "peerDependencies",
+    "optionalDependencies"
   ]) {
     const deps = pkg[depField];
     if (!deps) continue;
@@ -978,7 +1243,8 @@ function rewriteProtocolVersions(pkg, packageDir) {
       if (version.startsWith("workspace:")) {
         const versionPart = version.slice("workspace:".length);
         if (versionPart === "*" || versionPart === "^" || versionPart === "~") {
-          newDeps[name] = versionPart === "*" ? pkg.version : versionPart + pkg.version;
+          const depVersion = _cachedWorkspaceVersions?.versions.get(name) ?? pkg.version;
+          newDeps[name] = versionPart === "*" ? depVersion : versionPart + depVersion;
         } else {
           newDeps[name] = versionPart;
         }
@@ -986,7 +1252,7 @@ function rewriteProtocolVersions(pkg, packageDir) {
         changed = true;
       } else if (version.startsWith("catalog:")) {
         if (!catalogsLoaded) {
-          catalogs = loadCatalogsSync(packageDir);
+          catalogs = loadCatalogsFromCache();
           catalogsLoaded = true;
         }
         if (catalogs) {
@@ -1016,12 +1282,48 @@ function resolveCatalogVersion(specifier, depName, catalogs) {
   }
   return catalogs.named[catalogRef]?.[depName] ?? null;
 }
+var _cachedWorkspaceVersions = null;
+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 { findWorkspaceRoot: findWorkspaceRoot2, findWorkspacePackages: findWorkspacePackages2 } = await Promise.resolve().then(() => (init_workspace(), workspace_exports));
+  const root = await findWorkspaceRoot2(packageDir);
+  if (!root) {
+    _cachedWorkspaceVersions = null;
+    return;
+  }
+  if (_cachedWorkspaceVersions?.root === root) return;
+  const pkgDirs = await findWorkspacePackages2(root);
+  const versions = /* @__PURE__ */ new Map();
+  await Promise.all(
+    pkgDirs.map(async (dir) => {
+      try {
+        const depPkg = JSON.parse(
+          await readFile5(join6(dir, "package.json"), "utf-8")
+        );
+        if (depPkg.name && depPkg.version) {
+          versions.set(depPkg.name, depPkg.version);
+        }
+      } catch {
+      }
+    })
+  );
+  _cachedWorkspaceVersions = { root, versions };
+}
 var _cachedCatalogs = null;
-function loadCatalogsSync(packageDir) {
+function loadCatalogsFromCache() {
   return _cachedCatalogs?.catalogs ?? null;
 }
 async function preloadCatalogs(pkg, packageDir) {
-  const hasCatalog = ["dependencies", "devDependencies", "peerDependencies"].some(
+  const hasCatalog = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"].some(
     (field) => {
       const deps = pkg[field];
       return deps && Object.values(deps).some((v) => v.startsWith("catalog:"));
@@ -1034,24 +1336,26 @@ async function preloadCatalogs(pkg, packageDir) {
     _cachedCatalogs = null;
     return;
   }
-  if (_cachedCatalogs?.root === root) return;
+  const workspaceFile = join6(root, "pnpm-workspace.yaml");
+  const mtimeMs = (await stat5(workspaceFile).catch(() => null))?.mtimeMs ?? 0;
+  if (_cachedCatalogs?.root === root && _cachedCatalogs.mtimeMs === mtimeMs) return;
   const catalogs = await parseCatalogs2(root);
-  _cachedCatalogs = { root, catalogs };
+  _cachedCatalogs = { root, mtimeMs, catalogs };
 }
 
 // src/core/injector.ts
-import { readFile as readFile7, readdir as readdir4, realpath, stat as stat5 } from "fs/promises";
-import { join as join11, resolve as resolve3 } from "path";
-import { consola as consola6 } from "consola";
+init_console();
+import { readFile as readFile7, readdir as readdir5, realpath, stat as stat7 } from "fs/promises";
+import { join as join11, resolve as resolve5 } from "path";
 init_fs();
 
 // src/utils/bin-linker.ts
+init_console();
 init_fs();
 init_logger();
-import { mkdir as mkdir3, symlink, writeFile as writeFile4, chmod, rm as rm2 } from "fs/promises";
-import { join as join7, relative as relative5, resolve as resolve2, sep as sep2 } from "path";
+import { mkdir as mkdir3, symlink, writeFile as writeFile3, chmod, rm as rm3 } from "fs/promises";
+import { join as join7, relative as relative6, resolve as resolve4, sep as sep2 } from "path";
 import { platform as platform2 } from "os";
-import { consola as consola5 } from "consola";
 function resolveBinEntries(pkg) {
   if (!pkg.bin) return {};
   if (typeof pkg.bin === "string") {
@@ -1070,12 +1374,12 @@ async function createBinLinks(consumerPath, packageName, pkg) {
   for (const [binName, binPath] of Object.entries(entries)) {
     const packageRoot = join7(consumerPath, "node_modules", packageName);
     const targetAbsolute = join7(packageRoot, binPath);
-    const resolvedTarget = resolve2(targetAbsolute);
-    if (!resolvedTarget.startsWith(resolve2(packageRoot) + sep2) && resolvedTarget !== resolve2(packageRoot)) {
-      consola5.warn(`bin "${binName}" points outside package directory, skipping`);
+    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 = relative5(binDir, targetAbsolute).replace(
+    const targetRelative = relative6(binDir, targetAbsolute).replace(
       /\\/g,
       "/"
     );
@@ -1090,16 +1394,16 @@ EXIT /b\r
 CALL :find_dp0\r
 "%dp0%\\${targetRelative}" %*\r
 `;
-      await writeFile4(cmdPath, cmdContent);
+      await writeFile3(cmdPath, cmdContent);
       const shPath = join7(binDir, binName);
       const shContent = `#!/bin/sh
 exec node "${targetRelative}" "$@"
 `;
-      await writeFile4(shPath, shContent);
+      await writeFile3(shPath, shContent);
     } else {
       const linkPath = join7(binDir, binName);
       try {
-        await rm2(linkPath, { force: true });
+        await rm3(linkPath, { force: true });
       } catch {
       }
       try {
@@ -1111,7 +1415,7 @@ exec node "${targetRelative}" "$@"
           const shContent = `#!/bin/sh
 exec node "${targetRelative}" "$@"
 `;
-          await writeFile4(linkPath, shContent);
+          await writeFile3(linkPath, shContent);
           await chmod(linkPath, 493);
         } else {
           throw err;
@@ -1128,9 +1432,9 @@ async function removeBinLinks(consumerPath, pkg) {
   const isWindows = platform2() === "win32";
   for (const binName of Object.keys(entries)) {
     try {
-      await rm2(join7(binDir, binName), { force: true });
+      await rm3(join7(binDir, binName), { force: true });
       if (isWindows) {
-        await rm2(join7(binDir, `${binName}.cmd`), { force: true });
+        await rm3(join7(binDir, `${binName}.cmd`), { force: true });
       }
     } catch {
     }
@@ -1141,8 +1445,8 @@ async function removeBinLinks(consumerPath, pkg) {
 init_logger();
 
 // src/utils/pm-detect.ts
-import { readFile as readFile6, stat as stat4 } from "fs/promises";
-import { join as join8 } from "path";
+import { readFile as readFile6, stat as stat6 } from "fs/promises";
+import { join as join8, dirname as dirname5 } from "path";
 var LOCKFILES = [
   ["pnpm-lock.yaml", "pnpm"],
   ["bun.lockb", "bun"],
@@ -1151,37 +1455,50 @@ var LOCKFILES = [
   ["package-lock.json", "npm"]
 ];
 async function detectPackageManager(projectDir) {
-  const results = await Promise.all(
-    LOCKFILES.map(async ([lockfile, pm]) => {
-      try {
-        await stat4(join8(projectDir, lockfile));
-        return pm;
-      } catch {
-        return null;
-      }
-    })
-  );
-  return results.find((pm) => pm !== null) ?? "npm";
+  let dir = projectDir;
+  for (; ; ) {
+    const results = await Promise.all(
+      LOCKFILES.map(async ([lockfile, pm]) => {
+        try {
+          await stat6(join8(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 content;
-  try {
-    content = await readFile6(join8(projectDir, ".yarnrc.yml"), "utf-8");
-  } catch {
-    return null;
-  }
-  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;
+  let dir = projectDir;
+  for (; ; ) {
+    let content;
+    try {
+      content = await readFile6(join8(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;
   }
-  return null;
 }
 
 // src/utils/bundler-cache.ts
@@ -1218,8 +1535,13 @@ var CACHE_DIRS = {
   next: [".next/cache"],
   webpack: ["node_modules/.cache"]
 };
+var bundlerCache = /* @__PURE__ */ new Map();
 async function invalidateBundlerCache(consumerPath) {
-  const bundlers = await detectAllBundlers(consumerPath);
+  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];
@@ -1300,14 +1622,14 @@ async function checkMissingDeps(storeEntry, consumerPath) {
     )
   };
   if (Object.keys(allDeps).length === 0) return [];
-  const missing = [];
-  for (const dep of Object.keys(allDeps)) {
-    const depPath = join11(consumerPath, "node_modules", dep);
-    if (!await exists(depPath)) {
-      missing.push(dep);
-    }
-  }
-  return missing;
+  const depNames = Object.keys(allDeps);
+  const results = await Promise.all(
+    depNames.map(async (dep) => ({
+      dep,
+      installed: await exists(join11(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);
@@ -1317,13 +1639,13 @@ async function resolveTargetDir(consumerPath, packageName, pm, version) {
   }
   try {
     const realPath = await resolveRealPath(directPath);
-    if (realPath !== resolve3(directPath)) {
+    if (realPath !== resolve5(directPath)) {
       verbose(`[inject] pnpm: resolved symlink \u2192 ${realPath}`);
       return realPath;
     }
   } catch (err) {
     if (isNodeError(err) && err.code !== "ENOENT") {
-      consola6.debug(`pnpm symlink resolution error: ${err}`);
+      consola.debug(`pnpm symlink resolution error: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
   const pnpmDir = join11(consumerPath, "node_modules", ".pnpm");
@@ -1338,7 +1660,7 @@ async function resolveTargetDir(consumerPath, packageName, pm, version) {
         return candidate;
       }
     }
-    const entries = await readdir4(pnpmDir);
+    const entries = await readdir5(pnpmDir);
     for (const entry of entries) {
       if (entry.startsWith(encodedName + "@")) {
         const candidate = join11(
@@ -1354,16 +1676,16 @@ async function resolveTargetDir(consumerPath, packageName, pm, version) {
       }
     }
   }
-  consola6.warn(`pnpm: falling back to direct node_modules path for ${packageName}`);
+  consola.warn(`pnpm: Could not find ${packageName} in .pnpm/ virtual store, using direct node_modules path`);
   return directPath;
 }
 async function resolveRealPath(linkPath) {
   try {
-    await stat5(linkPath);
+    await stat7(linkPath);
     return await realpath(linkPath);
   } catch (err) {
     if (isNodeError(err) && err.code === "ENOENT") {
-      return resolve3(linkPath);
+      return resolve5(linkPath);
     }
     throw err;
   }
@@ -1374,16 +1696,16 @@ async function readPackageJson(dir) {
     return JSON.parse(content);
   } catch (err) {
     if (isNodeError(err) && err.code !== "ENOENT") {
-      consola6.warn(`Failed to read package.json in ${dir}: ${err}`);
+      consola.warn(`Failed to read package.json in ${dir}: ${err instanceof Error ? err.message : String(err)}`);
     }
     return null;
   }
 }
 
 // src/core/tracker.ts
+init_console();
 import { readFile as readFile8 } from "fs/promises";
-import { dirname as dirname5 } from "path";
-import { consola as consola7 } from "consola";
+import { dirname as dirname6 } from "path";
 init_fs();
 async function readConsumerState(consumerPath) {
   const statePath = getConsumerStatePath(consumerPath);
@@ -1391,13 +1713,13 @@ async function readConsumerState(consumerPath) {
     const content = await readFile8(statePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!isConsumerState(parsed)) {
-      consola7.warn(`Invalid consumer state in ${statePath}, using defaults`);
+      consola.warn(`Invalid consumer state in ${statePath}, using defaults`);
       return { version: "1", links: {} };
     }
     return parsed;
   } catch (err) {
     if (isNodeError(err) && err.code !== "ENOENT") {
-      consola7.warn(`Failed to read consumer state: ${err}`);
+      consola.warn(`Failed to read consumer state: ${err instanceof Error ? err.message : String(err)}`);
     }
     return { version: "1", links: {} };
   }
@@ -1429,20 +1751,20 @@ async function readConsumersRegistry() {
     const content = await readFile8(regPath, "utf-8");
     const parsed = JSON.parse(content);
     if (!isConsumersRegistry(parsed)) {
-      consola7.warn(`Invalid consumers registry, using empty registry`);
+      consola.warn(`Invalid consumers registry, using empty registry`);
       return {};
     }
     return parsed;
   } catch (err) {
     if (isNodeError(err) && err.code !== "ENOENT") {
-      consola7.warn(`Failed to read consumers registry: ${err}`);
+      consola.warn(`Failed to read consumers registry: ${err instanceof Error ? err.message : String(err)}`);
     }
     return {};
   }
 }
 async function writeConsumersRegistry(registry) {
   const regPath = getConsumersPath();
-  await ensurePrivateDir(dirname5(getConsumersPath()));
+  await ensurePrivateDir(dirname6(getConsumersPath()));
   await atomicWriteFile(regPath, JSON.stringify(registry, null, 2));
 }
 async function registerConsumer(packageName, consumerPath) {
@@ -1486,14 +1808,14 @@ async function cleanStaleConsumers() {
     const registry = await readConsumersRegistry();
     const updated = {};
     for (const [pkgName, consumers] of Object.entries(registry)) {
-      const validConsumers = [];
-      for (const consumerPath of consumers) {
-        if (await exists(consumerPath)) {
-          validConsumers.push(consumerPath);
-        } else {
-          removedConsumers++;
-        }
-      }
+      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 {
@@ -1506,9 +1828,9 @@ async function cleanStaleConsumers() {
 }
 
 // src/core/watcher.ts
+init_console();
 import { spawn as spawn2 } from "child_process";
 import { platform as platform3 } from "os";
-import { consola as consola8 } from "consola";
 var activeChild = null;
 var activeWatcher = null;
 function killActiveBuild() {
@@ -1525,12 +1847,14 @@ async function startWatcher(watchDir, options, onChange) {
   );
   const debounceMs = options.debounce ?? 100;
   let coalesceTimer = null;
+  let closed = false;
   let running = false;
   let pendingWhileRunning = false;
   const scheduleFlush = () => {
     if (coalesceTimer) return;
     coalesceTimer = setTimeout(async () => {
       coalesceTimer = null;
+      if (closed) return;
       if (running) {
         pendingWhileRunning = true;
         return;
@@ -1540,13 +1864,13 @@ async function startWatcher(watchDir, options, onChange) {
         if (options.buildCmd) {
           const success = await runBuildCommand(options.buildCmd, watchDir);
           if (!success) {
-            consola8.warn("Build failed, skipping push");
+            consola.warn("Build failed (see output above), skipping push");
             return;
           }
         }
         await onChange();
       } catch (err) {
-        consola8.error("Push failed:", err);
+        consola.error(`Push failed: ${err instanceof Error ? err.message : String(err)}`);
       } finally {
         running = false;
         if (pendingWhileRunning) {
@@ -1579,8 +1903,12 @@ async function startWatcher(watchDir, options, onChange) {
   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)}`);
+  });
   const watcherHandle = {
     close: async () => {
+      closed = true;
       if (coalesceTimer) clearTimeout(coalesceTimer);
       killActiveBuild();
       await watcher.close();
@@ -1589,21 +1917,21 @@ async function startWatcher(watchDir, options, onChange) {
   };
   activeWatcher = watcherHandle;
   const cleanup = async () => {
-    consola8.info("Stopping watcher...");
+    consola.info("Stopping watcher...");
     await watcherHandle.close();
     process.exit(0);
   };
   process.once("SIGINT", cleanup);
   process.once("SIGTERM", cleanup);
-  consola8.info(`Watching for changes in: ${patterns.join(", ")}`);
+  consola.info(`Watching for changes in: ${patterns.join(", ")}`);
   return watcherHandle;
 }
 function runBuildCommand(cmd, cwd) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve6) => {
     const isWin = platform3() === "win32";
     const shell = isWin ? "cmd" : "sh";
     const shellFlag = isWin ? "/c" : "-c";
-    consola8.start(`Running: ${cmd}`);
+    consola.start(`Running: ${cmd}`);
     const child = spawn2(shell, [shellFlag, cmd], {
       cwd,
       stdio: "inherit"
@@ -1612,17 +1940,17 @@ function runBuildCommand(cmd, cwd) {
     child.on("close", (code) => {
       activeChild = null;
       if (code === 0) {
-        consola8.success("Build succeeded");
-        resolve4(true);
+        consola.success("Build succeeded");
+        resolve6(true);
       } else {
-        consola8.error(`Build failed with code ${code}`);
-        resolve4(false);
+        consola.error(`Build failed with code ${code}`);
+        resolve6(false);
       }
     });
     child.on("error", (err) => {
       activeChild = null;
-      consola8.error(`Build error: ${err.message}`);
-      resolve4(false);
+      consola.error(`Build error: ${err.message}`);
+      resolve6(false);
     });
   });
 }