@pubm/core 0.4.4 → 0.4.6

package/dist/index.cjs

@@ -20263,6 +20263,10 @@ __export(exports_src, {
 module.exports = __toCommonJS(exports_src);
 
 // src/plugin/runner.ts
+function isDefined(value) {
+  return value !== undefined;
+}
+
 class PluginRunner {
   plugins;
   constructor(plugins) {
@@ -20300,7 +20304,7 @@ class PluginRunner {
   }
   collectAssetHooks() {
     const collected = {};
-    const resolveChain = this.plugins.map((p) => p.hooks?.resolveAssets).filter(Boolean);
+    const resolveChain = this.plugins.map((p) => p.hooks?.resolveAssets).filter(isDefined);
     if (resolveChain.length > 0) {
       collected.resolveAssets = async (assets, ctx) => {
         let result = assets;
@@ -20310,7 +20314,7 @@ class PluginRunner {
         return result;
       };
     }
-    const transformChain = this.plugins.map((p) => p.hooks?.transformAsset).filter(Boolean);
+    const transformChain = this.plugins.map((p) => p.hooks?.transformAsset).filter(isDefined);
     if (transformChain.length > 0) {
       collected.transformAsset = async (asset, ctx) => {
         let items = [asset];
@@ -20325,17 +20329,18 @@ class PluginRunner {
         return items.length === 1 ? items[0] : items;
       };
     }
-    const compressChain = this.plugins.map((p) => p.hooks?.compressAsset).filter(Boolean);
+    const compressChain = this.plugins.map((p) => p.hooks?.compressAsset).filter(isDefined);
     if (compressChain.length > 0) {
       collected.compressAsset = async (asset, ctx) => {
-        let result = asset;
-        for (const hook of compressChain) {
+        const [firstHook, ...restHooks] = compressChain;
+        let result = await firstHook(asset, ctx);
+        for (const hook of restHooks) {
           result = await hook(result, ctx);
         }
         return result;
       };
     }
-    const nameChain = this.plugins.map((p) => p.hooks?.nameAsset).filter(Boolean);
+    const nameChain = this.plugins.map((p) => p.hooks?.nameAsset).filter(isDefined);
     if (nameChain.length > 0) {
       collected.nameAsset = (asset, ctx) => {
         let result = "";
@@ -20345,7 +20350,7 @@ class PluginRunner {
         return result;
       };
     }
-    const checksumChain = this.plugins.map((p) => p.hooks?.generateChecksums).filter(Boolean);
+    const checksumChain = this.plugins.map((p) => p.hooks?.generateChecksums).filter(isDefined);
     if (checksumChain.length > 0) {
       collected.generateChecksums = async (assets, ctx) => {
         let result = assets;
@@ -20355,7 +20360,7 @@ class PluginRunner {
         return result;
       };
     }
-    const uploadHooks = this.plugins.map((p) => p.hooks?.uploadAssets).filter(Boolean);
+    const uploadHooks = this.plugins.map((p) => p.hooks?.uploadAssets).filter(isDefined);
     if (uploadHooks.length > 0) {
       collected.uploadAssets = async (assets, ctx) => {
         const allResults = [];
@@ -20371,7 +20376,7 @@ class PluginRunner {
 }
 
 // src/tasks/runner.ts
-var import_node_fs11 = require("node:fs");
+var import_node_fs13 = require("node:fs");
 var import_node_os4 = require("node:os");
 var import_node_path20 = __toESM(require("node:path"));
 var import_node_process15 = __toESM(require("node:process"));
@@ -22967,6 +22972,7 @@ function createKeyResolver(packages) {
 }
 
 // src/ecosystem/js.ts
+var import_node_fs7 = require("node:fs");
 var import_promises4 = require("node:fs/promises");
 var import_node_path11 = __toESM(require("node:path"));
 
@@ -23071,7 +23077,7 @@ function isValidPackageName(packageName) {
 // package.json
 var package_default = {
   name: "@pubm/core",
-  version: "0.4.4",
+  version: "0.4.6",
   type: "module",
   description: "Core SDK for pubm - publish manager for multiple registries",
   types: "./dist/index.d.ts",
@@ -23145,7 +23151,7 @@ var coreEngines = package_default.engines ?? {};
 function resolveDefine(injected, fallback) {
   return typeof injected === "string" ? injected : fallback;
 }
-var PUBM_VERSION = resolveDefine("0.4.4", package_default.version);
+var PUBM_VERSION = resolveDefine("0.4.6", package_default.version);
 var PUBM_ENGINES = {
   node: resolveDefine(">=24", coreEngines.node ?? ">=18"),
   git: resolveDefine(">=2.11.0", coreEngines.git ?? ">=2.11.0"),
@@ -24098,6 +24104,9 @@ async function npmPackageRegistry(packagePath) {
   return new NpmPackageRegistry(manifest.name, packagePath);
 }
 
+// src/ecosystem/js.ts
+init_exec();
+
 // src/utils/package.ts
 var import_promises3 = require("node:fs/promises");
 var import_node_path10 = __toESM(require("node:path"));
@@ -24121,16 +24130,28 @@ async function findOutFile(file, { cwd = import_node_process10.default.cwd() } =
 }
 
 // src/utils/package-manager.ts
-var lockFile = {
+var lockFiles = {
   bun: ["bun.lock", "bun.lockb"],
   npm: ["package-lock.json", "npm-shrinkwrap.json"],
   pnpm: ["pnpm-lock.yaml"],
   yarn: ["yarn.lock"]
 };
+function getInstallCommand(pm, isYarnBerry) {
+  switch (pm) {
+    case "bun":
+      return ["bun", "install", "--lockfile-only"];
+    case "npm":
+      return ["npm", "install", "--package-lock-only"];
+    case "pnpm":
+      return ["pnpm", "install", "--lockfile-only"];
+    case "yarn":
+      return isYarnBerry ? ["yarn", "install", "--mode", "update-lockfile"] : ["yarn", "install"];
+  }
+}
 async function getPackageManager() {
-  for (const [packageManager, lockFiles] of Object.entries(lockFile)) {
-    for (const lockFile2 of lockFiles) {
-      if (await findOutFile(lockFile2))
+  for (const [packageManager, files] of Object.entries(lockFiles)) {
+    for (const file of files) {
+      if (await findOutFile(file))
         return packageManager;
     }
   }
@@ -24139,6 +24160,8 @@ async function getPackageManager() {
 }
 
 // src/ecosystem/ecosystem.ts
+var import_node_fs6 = require("node:fs");
+
 class Ecosystem {
   packagePath;
   constructor(packagePath) {
@@ -24179,9 +24202,17 @@ class Ecosystem {
   async updateSiblingDependencyVersions(_siblingVersions) {
     return false;
   }
-  async syncLockfile() {
+  async syncLockfile(_mode = "optional") {
     return;
   }
+  async resolvePublishDependencies(_workspaceVersions) {
+    return new Map;
+  }
+  restorePublishDependencies(backups) {
+    for (const [filePath, content] of backups) {
+      import_node_fs6.writeFileSync(filePath, content, "utf-8");
+    }
+  }
 }
 
 // src/ecosystem/descriptor.ts
@@ -24252,6 +24283,97 @@ class JsEcosystem extends Ecosystem {
   supportedRegistries() {
     return ["npm", "jsr"];
   }
+  async syncLockfile(mode = "optional") {
+    if (mode === "skip")
+      return;
+    const found = await this.findLockfile();
+    if (!found)
+      return;
+    const { lockfilePath, packageManager } = found;
+    const lockfileDir = import_node_path11.default.dirname(lockfilePath);
+    try {
+      let isYarnBerry;
+      if (packageManager === "yarn") {
+        const yarnrcPath = import_node_path11.default.join(lockfileDir, ".yarnrc.yml");
+        try {
+          isYarnBerry = (await import_promises4.stat(yarnrcPath)).isFile();
+        } catch {
+          isYarnBerry = false;
+        }
+      }
+      const [cmd, ...args] = getInstallCommand(packageManager, isYarnBerry);
+      await exec3(cmd, args, { nodeOptions: { cwd: lockfileDir } });
+      return lockfilePath;
+    } catch (error2) {
+      if (mode === "required")
+        throw error2;
+      console.warn(`Warning: Failed to sync lockfile at ${lockfilePath}: ${error2 instanceof Error ? error2.message : error2}`);
+      return;
+    }
+  }
+  async findLockfile() {
+    let dir = this.packagePath;
+    const { root } = import_node_path11.default.parse(dir);
+    while (dir !== root) {
+      for (const [pm, files] of Object.entries(lockFiles)) {
+        for (const file of files) {
+          const candidate = import_node_path11.default.join(dir, file);
+          try {
+            if ((await import_promises4.stat(candidate)).isFile()) {
+              return {
+                lockfilePath: candidate,
+                packageManager: pm
+              };
+            }
+          } catch {}
+        }
+      }
+      dir = import_node_path11.default.dirname(dir);
+    }
+    return;
+  }
+  async resolvePublishDependencies(workspaceVersions) {
+    const backups = new Map;
+    const manifestPath = import_node_path11.default.join(this.packagePath, "package.json");
+    if (!import_node_fs7.existsSync(manifestPath))
+      return backups;
+    const original = import_node_fs7.readFileSync(manifestPath, "utf-8");
+    const pkg = JSON.parse(original);
+    let modified = false;
+    const WORKSPACE_PREFIX = "workspace:";
+    const DEPENDENCY_FIELDS = [
+      "dependencies",
+      "devDependencies",
+      "optionalDependencies",
+      "peerDependencies"
+    ];
+    for (const field of DEPENDENCY_FIELDS) {
+      const deps = pkg[field];
+      if (!deps)
+        continue;
+      for (const [depName, spec] of Object.entries(deps)) {
+        if (!spec.startsWith(WORKSPACE_PREFIX))
+          continue;
+        const range = spec.slice(WORKSPACE_PREFIX.length);
+        if (range === "*" || range === "^" || range === "~") {
+          const version = workspaceVersions.get(depName);
+          if (!version) {
+            throw new Error(`Cannot resolve "${spec}" for dependency "${depName}": package not found in workspace`);
+          }
+          deps[depName] = range === "*" ? version : range === "^" ? `^${version}` : `~${version}`;
+        } else {
+          deps[depName] = range;
+        }
+        modified = true;
+      }
+    }
+    if (modified) {
+      backups.set(manifestPath, original);
+      import_node_fs7.writeFileSync(manifestPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf-8");
+    }
+    return backups;
+  }
   async createDescriptor() {
     const npmReader = NpmPackageRegistry.reader;
     const jsrReader = JsrPackageRegistry.reader;
@@ -25587,15 +25709,24 @@ class RustEcosystem extends Ecosystem {
     }
     return modified;
   }
-  async syncLockfile() {
+  async syncLockfile(mode = "optional") {
+    if (mode === "skip")
+      return;
     const lockfilePath = await this.findLockfile();
     if (!lockfilePath)
       return;
-    const name = await this.packageName();
-    await exec3("cargo", ["update", "--package", name], {
-      nodeOptions: { cwd: import_node_path13.default.dirname(lockfilePath) }
-    });
-    return lockfilePath;
+    try {
+      const name = await this.packageName();
+      await exec3("cargo", ["update", "--package", name], {
+        nodeOptions: { cwd: import_node_path13.default.dirname(lockfilePath) }
+      });
+      return lockfilePath;
+    } catch (error2) {
+      if (mode === "required")
+        throw error2;
+      console.warn(`Warning: Failed to sync lockfile at ${lockfilePath}: ${error2 instanceof Error ? error2.message : error2}`);
+      return;
+    }
   }
   async findLockfile() {
     let dir = this.packagePath;
@@ -25671,7 +25802,7 @@ init_error();
 init_git();
 
 // src/manifest/write-versions.ts
-async function writeVersionsForEcosystem(ecosystems, versions) {
+async function writeVersionsForEcosystem(ecosystems, versions, lockfileSync) {
   const modifiedFiles = [];
   for (const { eco, pkg } of ecosystems) {
     const version = versions.get(pkg.path);
@@ -25692,20 +25823,23 @@ async function writeVersionsForEcosystem(ecosystems, versions) {
     }
     await Promise.all(ecosystems.map(({ eco }) => eco.updateSiblingDependencyVersions(nameKeyedVersions)));
   }
+  const syncedLockfiles = new Set;
   for (const { eco } of ecosystems) {
-    const lockfilePath = await eco.syncLockfile();
-    if (lockfilePath)
+    const lockfilePath = await eco.syncLockfile(lockfileSync);
+    if (lockfilePath && !syncedLockfiles.has(lockfilePath)) {
+      syncedLockfiles.add(lockfilePath);
       modifiedFiles.push(lockfilePath);
+    }
   }
   return modifiedFiles;
 }
 
 // src/monorepo/resolve-workspace.ts
-var import_node_fs8 = require("node:fs");
+var import_node_fs10 = require("node:fs");
 var import_node_path17 = require("node:path");
 
 // src/monorepo/discover.ts
-var import_node_fs7 = require("node:fs");
+var import_node_fs9 = require("node:fs");
 var import_node_path16 = __toESM(require("node:path"));
 var import_micromatch2 = __toESM(require_micromatch(), 1);
 
@@ -25782,6 +25916,9 @@ function normalizeRegistryUrl(url) {
 init_exec();
 class CustomPackageRegistry extends NpmPackageRegistry {
   async npm(args, cwd) {
+    if (!this.registry) {
+      throw new Error("Custom registry URL is required for npm operations.");
+    }
     const { stdout } = await exec3("npm", args.concat("--registry", this.registry), {
       throwOnError: true,
       nodeOptions: cwd ? { cwd } : undefined
@@ -25886,7 +26023,7 @@ registryCatalog.register({
     return token.trim().length >= 32;
   },
   resolveDisplayName: async (ctx) => {
-    return ctx.packages?.filter((pkg) => pkg.registries?.includes("crates")).map((pkg) => pkg.path) ?? ["crate"];
+    return ctx.packages?.filter((pkg) => pkg.registries?.includes("crates")).map((pkg) => pkg.name) ?? ["crate"];
   },
   concurrentPublish: false,
   orderPackages: (paths) => sortCratesByDependencyOrder(paths),
@@ -25938,6 +26075,12 @@ async function readJsonSafe(path8) {
     return null;
   }
 }
+function asRecord(value) {
+  return value !== null && typeof value === "object" ? value : null;
+}
+function readString(value) {
+  return typeof value === "string" ? value : undefined;
+}
 async function readFileSafe(path8) {
   try {
     return await import_promises6.readFile(path8, "utf-8");
@@ -25987,8 +26130,8 @@ async function inferJsRegistries(packagePath, rootPath) {
     return [];
   }
   const packageJson = await readJsonSafe(import_node_path14.join(packagePath, "package.json"));
-  const packageName = packageJson?.name;
-  const publishConfigRegistry = packageJson?.publishConfig?.registry;
+  const packageName = readString(packageJson?.name);
+  const publishConfigRegistry = readString(asRecord(packageJson?.publishConfig)?.registry);
   let npmRegistryUrl = null;
   if (publishConfigRegistry) {
     npmRegistryUrl = publishConfigRegistry;
@@ -26029,7 +26172,7 @@ async function inferRegistries(packagePath, ecosystemKey, rootPath) {
 }
 
 // src/monorepo/workspace.ts
-var import_node_fs6 = require("node:fs");
+var import_node_fs8 = require("node:fs");
 var import_node_path15 = require("node:path");
 
 // ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
@@ -26842,15 +26985,15 @@ function detectWorkspace(cwd) {
   const root = cwd ?? process.cwd();
   const workspaces = [];
   const pnpmWorkspacePath = import_node_path15.join(root, "pnpm-workspace.yaml");
-  if (import_node_fs6.existsSync(pnpmWorkspacePath)) {
-    const content = import_node_fs6.readFileSync(pnpmWorkspacePath, "utf-8");
+  if (import_node_fs8.existsSync(pnpmWorkspacePath)) {
+    const content = import_node_fs8.readFileSync(pnpmWorkspacePath, "utf-8");
     const parsed = import_yaml2.parse(content);
     const packages = parsed?.packages ?? [];
     workspaces.push({ type: "pnpm", patterns: packages });
   }
   const cargoTomlPath = import_node_path15.join(root, "Cargo.toml");
-  if (import_node_fs6.existsSync(cargoTomlPath)) {
-    const content = import_node_fs6.readFileSync(cargoTomlPath, "utf-8");
+  if (import_node_fs8.existsSync(cargoTomlPath)) {
+    const content = import_node_fs8.readFileSync(cargoTomlPath, "utf-8");
     try {
       const parsed = parse(content);
       const workspace = parsed.workspace;
@@ -26865,8 +27008,8 @@ function detectWorkspace(cwd) {
   }
   for (const denoFile of ["deno.json", "deno.jsonc"]) {
     const denoPath = import_node_path15.join(root, denoFile);
-    if (import_node_fs6.existsSync(denoPath)) {
-      const content = import_node_fs6.readFileSync(denoPath, "utf-8");
+    if (import_node_fs8.existsSync(denoPath)) {
+      const content = import_node_fs8.readFileSync(denoPath, "utf-8");
       try {
         const parsed = denoFile.endsWith(".jsonc") ? parse3(content) : JSON.parse(content);
         if (Array.isArray(parsed?.workspace)) {
@@ -26879,12 +27022,12 @@ function detectWorkspace(cwd) {
   }
   if (!workspaces.some((w2) => w2.type === "pnpm")) {
     const packageJsonPath = import_node_path15.join(root, "package.json");
-    if (import_node_fs6.existsSync(packageJsonPath)) {
-      const content = import_node_fs6.readFileSync(packageJsonPath, "utf-8");
+    if (import_node_fs8.existsSync(packageJsonPath)) {
+      const content = import_node_fs8.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.workspaces) {
         const bunfigPath = import_node_path15.join(root, "bunfig.toml");
-        const isBun2 = import_node_fs6.existsSync(bunfigPath);
+        const isBun2 = import_node_fs8.existsSync(bunfigPath);
         if (Array.isArray(pkg.workspaces)) {
           workspaces.push({
             type: isBun2 ? "bun" : "npm",
@@ -26916,16 +27059,32 @@ function matchesIgnore(pkgPath, ignorePatterns) {
     return regex3.test(normalized);
   });
 }
-function resolvePatterns(cwd, patterns) {
-  const entries = import_node_fs7.readdirSync(cwd, { recursive: true, encoding: "utf-8" });
-  const dirs = entries.filter((entry) => {
-    const fullPath = import_node_path16.default.join(cwd, entry);
+function readdirRecursiveNoSymlinks(dir, root) {
+  const results = [];
+  let entries;
+  try {
+    entries = import_node_fs9.readdirSync(dir, { encoding: "utf-8" });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (entry === "node_modules" || entry === ".git")
+      continue;
+    const fullPath = import_node_path16.default.join(dir, entry);
     try {
-      return import_node_fs7.statSync(fullPath).isDirectory();
-    } catch {
-      return false;
-    }
-  });
+      const stat6 = import_node_fs9.lstatSync(fullPath);
+      if (stat6.isSymbolicLink())
+        continue;
+      if (stat6.isDirectory()) {
+        results.push(import_node_path16.default.relative(root, fullPath));
+        results.push(...readdirRecursiveNoSymlinks(fullPath, root));
+      }
+    } catch {}
+  }
+  return results;
+}
+function resolvePatterns(cwd, patterns) {
+  const dirs = readdirRecursiveNoSymlinks(cwd, cwd);
   const normalizedDirs = dirs.map((d3) => d3.replace(/\\/g, "/"));
   const matched = import_micromatch2.default(normalizedDirs, patterns);
   return matched.map((d3) => import_node_path16.default.resolve(cwd, d3));
@@ -27022,31 +27181,6 @@ async function discoverPackages(options) {
 }
 
 // src/monorepo/resolve-workspace.ts
-var WORKSPACE_PREFIX = "workspace:";
-var DEPENDENCY_FIELDS = [
-  "dependencies",
-  "devDependencies",
-  "optionalDependencies",
-  "peerDependencies"
-];
-function resolveWorkspaceProtocol(spec, version) {
-  if (!spec.startsWith(WORKSPACE_PREFIX))
-    return spec;
-  const range = spec.slice(WORKSPACE_PREFIX.length);
-  switch (range) {
-    case "*":
-      return version;
-    case "^":
-      return `^${version}`;
-    case "~":
-      return `~${version}`;
-    default:
-      return range;
-  }
-}
-function isDynamicWorkspaceSpec(range) {
-  return range === "*" || range === "^" || range === "~";
-}
 function collectWorkspaceVersions(cwd) {
   const versions = new Map;
   const workspaces = detectWorkspace(cwd);
@@ -27058,10 +27192,10 @@ function collectWorkspaceVersions(cwd) {
     const dirs = resolvePatterns(cwd, workspace.patterns);
     for (const dir of dirs) {
       const pkgJsonPath = import_node_path17.join(dir, "package.json");
-      if (!import_node_fs8.existsSync(pkgJsonPath))
+      if (!import_node_fs10.existsSync(pkgJsonPath))
         continue;
       try {
-        const content = import_node_fs8.readFileSync(pkgJsonPath, "utf-8");
+        const content = import_node_fs10.readFileSync(pkgJsonPath, "utf-8");
         const pkg = JSON.parse(content);
         if (typeof pkg.name === "string" && pkg.name && typeof pkg.version === "string" && pkg.version) {
           versions.set(pkg.name, pkg.version);
@@ -27071,44 +27205,9 @@ function collectWorkspaceVersions(cwd) {
   }
   return versions;
 }
-function resolveWorkspaceProtocolsInManifests(packagePaths, workspaceVersions) {
-  const backups = new Map;
-  for (const pkgPath of packagePaths) {
-    const manifestPath = import_node_path17.join(pkgPath, "package.json");
-    const original = import_node_fs8.readFileSync(manifestPath, "utf-8");
-    const pkg = JSON.parse(original);
-    let modified = false;
-    for (const field of DEPENDENCY_FIELDS) {
-      const deps = pkg[field];
-      if (!deps)
-        continue;
-      for (const [depName, spec] of Object.entries(deps)) {
-        if (!spec.startsWith(WORKSPACE_PREFIX))
-          continue;
-        const range = spec.slice(WORKSPACE_PREFIX.length);
-        if (isDynamicWorkspaceSpec(range)) {
-          const version = workspaceVersions.get(depName);
-          if (!version) {
-            throw new Error(`Cannot resolve "${spec}" for dependency "${depName}": package not found in workspace`);
-          }
-          deps[depName] = resolveWorkspaceProtocol(spec, version);
-        } else {
-          deps[depName] = range;
-        }
-        modified = true;
-      }
-    }
-    if (modified) {
-      backups.set(manifestPath, original);
-      import_node_fs8.writeFileSync(manifestPath, `${JSON.stringify(pkg, null, 2)}
-`, "utf-8");
-    }
-  }
-  return backups;
-}
 function restoreManifests(backups) {
   for (const [filePath, content] of backups) {
-    import_node_fs8.writeFileSync(filePath, content, "utf-8");
+    import_node_fs10.writeFileSync(filePath, content, "utf-8");
   }
 }
 
@@ -27412,7 +27511,8 @@ function createContext(config, options, cwd) {
     tag: options.tag ?? "latest",
     promptEnabled: false,
     cleanWorkingTree: false,
-    pluginRunner: new PluginRunner([])
+    pluginRunner: new PluginRunner([]),
+    tokenRetryPromises: {}
   };
   const ctx = Object.defineProperties(Object.create(null), {
     config: {
@@ -27499,9 +27599,10 @@ async function withTokenRetry(registryKey, ctx, task, action) {
     if (!descriptor)
       throw error2;
     const config = descriptor.tokenConfig;
-    const retryKey = `_tokenRetry_${registryKey}`;
-    if (!ctx.runtime[retryKey]) {
-      ctx.runtime[retryKey] = (async () => {
+    const retryPromises = ctx.runtime.tokenRetryPromises ?? {};
+    ctx.runtime.tokenRetryPromises = retryPromises;
+    if (!retryPromises[registryKey]) {
+      retryPromises[registryKey] = (async () => {
         task.output = `Auth failed. Re-enter ${config.promptLabel}`;
         const newToken = await task.prompt(ListrEnquirerPromptAdapter).run({
           type: "password",
@@ -27512,7 +27613,7 @@ async function withTokenRetry(registryKey, ctx, task, action) {
         return newToken;
       })();
     }
-    await ctx.runtime[retryKey];
+    await retryPromises[registryKey];
     await action();
   }
 }
@@ -27569,7 +27670,11 @@ async function findUnpublishedSiblingDeps(packagePath, siblingPaths) {
   }));
   const siblingDeps = deps.filter((d3) => siblingNameToPath.has(d3));
   const results = await Promise.all(siblingDeps.map(async (name) => {
-    const registry = await cratesPackageRegistry(siblingNameToPath.get(name));
+    const siblingPath = siblingNameToPath.get(name);
+    if (!siblingPath) {
+      throw new Error(`Missing sibling crate path for dependency: ${name}`);
+    }
+    const registry = await cratesPackageRegistry(siblingPath);
     const published = await registry.isPublished();
     return published ? null : name;
   }));
@@ -27619,7 +27724,7 @@ function createCratesDryRunPublishTask(packagePath, siblingPaths) {
 // src/tasks/github-release.ts
 init_error();
 init_git();
-var import_node_fs9 = require("node:fs");
+var import_node_fs11 = require("node:fs");
 var import_semver2 = __toESM(require_semver2(), 1);
 var { prerelease } = import_semver2.default;
 
@@ -27689,7 +27794,7 @@ async function createGitHubRelease(_ctx, options) {
   const uploadUrl = release.upload_url.replace(/\{[^}]*\}/, "");
   const releaseAssets = [];
   for (const asset of options.assets) {
-    const archiveContent = import_node_fs9.readFileSync(asset.filePath);
+    const archiveContent = import_node_fs11.readFileSync(asset.filePath);
     const uploadResponse = await fetch(`${uploadUrl}?name=${encodeURIComponent(asset.name)}`, {
       method: "POST",
       headers: {
@@ -27938,7 +28043,7 @@ init_error();
 init_exec();
 
 // src/utils/gh-secrets-sync-state.ts
-var import_node_fs10 = require("node:fs");
+var import_node_fs12 = require("node:fs");
 var import_node_path18 = __toESM(require("node:path"));
 var SYNC_HASH_FILENAME = "gh-secrets-sync-hash";
 function syncHashFilePath() {
@@ -27946,14 +28051,14 @@ function syncHashFilePath() {
 }
 function readGhSecretsSyncHash() {
   try {
-    const value = import_node_fs10.readFileSync(syncHashFilePath(), "utf8").trim();
+    const value = import_node_fs12.readFileSync(syncHashFilePath(), "utf8").trim();
     return value || null;
   } catch {
     return null;
   }
 }
 function writeGhSecretsSyncHash(hash) {
-  import_node_fs10.writeFileSync(syncHashFilePath(), `${hash}
+  import_node_fs12.writeFileSync(syncHashFilePath(), `${hash}
 `, "utf8");
 }
 
@@ -28321,7 +28426,7 @@ async function prepareReleaseAssets(ctx, packageName, version, packagePath) {
   const normalizedGroups = normalizeConfig(assetConfig, ctx.config.compress);
   const relevantGroup = normalizedGroups.find((g) => !g.packagePath || g.packagePath === packagePath) ?? { files: [] };
   const tempDir = import_node_path20.join(import_node_os4.tmpdir(), `pubm-assets-${Date.now()}`);
-  import_node_fs11.mkdirSync(tempDir, { recursive: true });
+  import_node_fs13.mkdirSync(tempDir, { recursive: true });
   ctx.runtime.tempDir = tempDir;
   const resolvedAssets = resolveAssets(relevantGroup, ctx.config.compress, ctx.cwd);
   const preparedAssets = await runAssetPipeline(resolvedAssets, assetHooks, {
@@ -28341,16 +28446,30 @@ function isReleaseExcluded(config, pkgPath) {
 function getPackageName(ctx, packagePath) {
   return ctx.config.packages.find((p2) => p2.path === packagePath)?.name ?? packagePath;
 }
+function requirePackageEcosystem(pkg) {
+  if (!pkg.ecosystem) {
+    throw new Error(`Package ${pkg.path} is missing an ecosystem.`);
+  }
+  return pkg.ecosystem;
+}
+function requireVersionPlan(ctx) {
+  const { versionPlan } = ctx.runtime;
+  if (!versionPlan) {
+    throw new Error("Version plan is required before running release tasks.");
+  }
+  return versionPlan;
+}
 async function writeVersions(ctx, versions) {
   const ecosystems = ctx.config.packages.map((pkg) => {
     const absPath = import_node_path20.default.resolve(ctx.cwd ?? import_node_process15.default.cwd(), pkg.path);
-    const descriptor = ecosystemCatalog.get(pkg.ecosystem);
+    const ecosystem = requirePackageEcosystem(pkg);
+    const descriptor = ecosystemCatalog.get(ecosystem);
     if (!descriptor)
-      throw new Error(`Unknown ecosystem: ${pkg.ecosystem}`);
+      throw new Error(`Unknown ecosystem: ${ecosystem}`);
     const eco = new descriptor.ecosystemClass(absPath);
     return { eco, pkg };
   });
-  const lockfileChanges = await writeVersionsForEcosystem(ecosystems, versions);
+  const lockfileChanges = await writeVersionsForEcosystem(ecosystems, versions, ctx.config.lockfileSync);
   const manifestFiles = ecosystems.flatMap(({ eco }) => eco.manifestFiles().map((f2) => import_node_path20.default.resolve(eco.packagePath, f2)));
   return [...manifestFiles, ...lockfileChanges];
 }
@@ -28365,17 +28484,38 @@ function createPublishTaskForPath(registryKey, packagePath) {
     return { title: `Publish to ${registryKey}`, task: async () => {} };
   return factory(packagePath);
 }
-function resolveWorkspaceProtocols(ctx) {
+async function resolveWorkspaceProtocols(ctx) {
   if (!ctx.cwd)
     return;
   const workspaceVersions = collectWorkspaceVersions(ctx.cwd);
   if (workspaceVersions.size === 0)
     return;
-  const packagePaths = ctx.config.packages.map((pkg) => import_node_path20.default.resolve(ctx.cwd, pkg.path));
-  const backups = resolveWorkspaceProtocolsInManifests(packagePaths, workspaceVersions);
-  if (backups.size > 0) {
-    ctx.runtime.workspaceBackups = backups;
-    addRollback(async () => restoreManifests(backups), ctx);
+  const allBackups = new Map;
+  for (const pkg of ctx.config.packages) {
+    const absPath = import_node_path20.default.resolve(ctx.cwd, pkg.path);
+    const ecosystem = requirePackageEcosystem(pkg);
+    const descriptor = ecosystemCatalog.get(ecosystem);
+    if (!descriptor)
+      continue;
+    const eco = new descriptor.ecosystemClass(absPath);
+    const backups = await eco.resolvePublishDependencies(workspaceVersions);
+    for (const [k3, v2] of backups) {
+      allBackups.set(k3, v2);
+    }
+  }
+  if (allBackups.size > 0) {
+    ctx.runtime.workspaceBackups = allBackups;
+    addRollback(async () => {
+      for (const pkg of ctx.config.packages) {
+        const absPath = import_node_path20.default.resolve(ctx.cwd, pkg.path);
+        const ecosystem = requirePackageEcosystem(pkg);
+        const descriptor = ecosystemCatalog.get(ecosystem);
+        if (!descriptor)
+          continue;
+        const eco = new descriptor.ecosystemClass(absPath);
+        eco.restorePublishDependencies(allBackups);
+      }
+    }, ctx);
   }
 }
 async function applyVersionsForDryRun(ctx) {
@@ -28495,8 +28635,8 @@ ${[...plan.packages].map(([pkgPath, ver]) => `  ${getPackageName(ctx, pkgPath)}:
   }
   return "";
 }
-function shouldRenderLiveCommandOutput(ctx) {
-  return ctx.options.mode !== "ci" && !m && Boolean(import_node_process15.default.stdout.isTTY);
+function shouldRenderLiveCommandOutput(_ctx) {
+  return !m && Boolean(import_node_process15.default.stdout.isTTY);
 }
 function normalizeLiveCommandOutputLine(line) {
   const normalized = import_node_util3.stripVTControlCharacters(line).trimEnd();
@@ -28577,7 +28717,7 @@ async function run(ctx) {
       await requiredConditionsCheckTask({
         skip: ctx.options.skipConditionsCheck
       }).run(ctx);
-      const pipelineListrOptions2 = mode === "ci" || m ? createCiListrOptions() : undefined;
+      const pipelineListrOptions2 = m ? createCiListrOptions() : undefined;
       await createListr([
         {
           skip: ctx.options.skipTests,
@@ -28659,7 +28799,7 @@ async function run(ctx) {
           skip: () => dryRun,
           task: async (ctx2, task) => {
             const git = new Git;
-            const snapshotPlan = ctx2.runtime.versionPlan;
+            const snapshotPlan = requireVersionPlan(ctx2);
             const tagName = `v${snapshotPlan.mode !== "independent" ? snapshotPlan.version : ""}`;
             task.output = `Creating tag ${tagName}...`;
             const headCommit = await git.latestCommit();
@@ -28726,7 +28866,7 @@ async function run(ctx) {
         skip: ctx.options.skipConditionsCheck
       }).run(ctx);
     }
-    const pipelineListrOptions = mode === "ci" || m ? createCiListrOptions() : undefined;
+    const pipelineListrOptions = m ? createCiListrOptions() : undefined;
     await createListr([
       {
         skip: !hasPrepare || ctx.options.skipTests,
@@ -28792,7 +28932,7 @@ async function run(ctx) {
           const git = new Git;
           let tagCreated = false;
           let commited = false;
-          const plan = ctx2.runtime.versionPlan;
+          const plan = requireVersionPlan(ctx2);
           task.output = formatVersionPlan(ctx2);
           addRollback(async () => {
             if (tagCreated) {
@@ -29016,7 +29156,7 @@ ${[...plan.packages].map(([pkgPath, ver]) => `- ${getPackageName(ctx2, pkgPath)}
         task: async (ctx2, parentTask) => {
           parentTask.output = "Running plugin beforePublish hooks...";
           await ctx2.runtime.pluginRunner.runHook("beforePublish", ctx2);
-          resolveWorkspaceProtocols(ctx2);
+          await resolveWorkspaceProtocols(ctx2);
           const publishTasks = await collectPublishTasks(ctx2);
           parentTask.title = `Publishing (${countPublishTargets(ctx2)} targets)`;
           parentTask.output = formatRegistryGroupSummary("Concurrent publish tasks", ctx2, true);
@@ -29029,7 +29169,11 @@ ${[...plan.packages].map(([pkgPath, ver]) => `- ${getPackageName(ctx2, pkgPath)}
         skip: (ctx2) => !hasPublish || !!ctx2.options.skipPublish || dryRun || !ctx2.runtime.workspaceBackups?.size,
         title: "Restoring workspace protocols",
         task: (ctx2) => {
-          restoreManifests(ctx2.runtime.workspaceBackups);
+          const backups = ctx2.runtime.workspaceBackups;
+          if (!backups) {
+            throw new Error("Workspace backups are required for restore.");
+          }
+          restoreManifests(backups);
           ctx2.runtime.workspaceBackups = undefined;
         }
       },
@@ -29046,7 +29190,7 @@ ${[...plan.packages].map(([pkgPath, ver]) => `- ${getPackageName(ctx2, pkgPath)}
         skip: !dryRun && !(mode === "ci" && hasPrepare),
         title: "Validating publish (dry-run)",
         task: async (ctx2, parentTask) => {
-          resolveWorkspaceProtocols(ctx2);
+          await resolveWorkspaceProtocols(ctx2);
           await applyVersionsForDryRun(ctx2);
           const dryRunTasks = await collectDryRunPublishTasks(ctx2);
           parentTask.title = `Validating publish (${countRegistryTargets(collectEcosystemRegistryGroups(ctx2.config))} targets)`;
@@ -29060,7 +29204,11 @@ ${[...plan.packages].map(([pkgPath, ver]) => `- ${getPackageName(ctx2, pkgPath)}
         skip: (ctx2) => !dryRun && !(mode === "ci" && hasPrepare) || !ctx2.runtime.workspaceBackups?.size,
         title: "Restoring workspace protocols",
         task: (ctx2) => {
-          restoreManifests(ctx2.runtime.workspaceBackups);
+          const backups = ctx2.runtime.workspaceBackups;
+          if (!backups) {
+            throw new Error("Workspace backups are required for restore.");
+          }
+          restoreManifests(backups);
           ctx2.runtime.workspaceBackups = undefined;
         }
       },
@@ -29068,7 +29216,11 @@ ${[...plan.packages].map(([pkgPath, ver]) => `- ${getPackageName(ctx2, pkgPath)}
         skip: (ctx2) => !dryRun || !ctx2.runtime.dryRunVersionBackup?.size,
         title: "Restoring original versions (dry-run)",
         task: async (ctx2) => {
-          await writeVersions(ctx2, ctx2.runtime.dryRunVersionBackup);
+          const backupVersions = ctx2.runtime.dryRunVersionBackup;
+          if (!backupVersions) {
+            throw new Error("Dry-run version backup is required for restore.");
+          }
+          await writeVersions(ctx2, backupVersions);
           ctx2.runtime.dryRunVersionBackup = undefined;
         }
       },
@@ -29095,7 +29247,7 @@ ${[...plan.packages].map(([pkgPath, ver]) => `- ${getPackageName(ctx2, pkgPath)}
         skip: (ctx2) => !hasPublish || !!ctx2.options.skipReleaseDraft || dryRun,
         title: "Creating GitHub Release",
         task: async (ctx2, task) => {
-          const plan = ctx2.runtime.versionPlan;
+          const plan = requireVersionPlan(ctx2);
           const tokenResult = resolveGitHubToken();
           let hasToken = !!tokenResult;
           if (tokenResult) {
@@ -29141,8 +29293,8 @@ ${[...plan.packages].map(([pkgPath, ver]) => `- ${getPackageName(ctx2, pkgPath)}
                 const pkgConfig = ctx2.config.packages.find((p2) => p2.path === pkgPath);
                 if (pkgConfig) {
                   const changelogPath = import_node_path20.join(import_node_process15.default.cwd(), pkgConfig.path, "CHANGELOG.md");
-                  if (import_node_fs11.existsSync(changelogPath)) {
-                    const section = parseChangelogSection(import_node_fs11.readFileSync(changelogPath, "utf-8"), pkgVersion);
+                  if (import_node_fs13.existsSync(changelogPath)) {
+                    const section = parseChangelogSection(import_node_fs13.readFileSync(changelogPath, "utf-8"), pkgVersion);
                     if (section)
                       changelogBody = section;
                   }
@@ -29173,7 +29325,7 @@ ${[...plan.packages].map(([pkgPath, ver]) => `- ${getPackageName(ctx2, pkgPath)}
                   task.output = `Release already exists for ${tag}, skipped.`;
                 }
                 if (tempDir)
-                  import_node_fs11.rmSync(tempDir, { recursive: true, force: true });
+                  import_node_fs13.rmSync(tempDir, { recursive: true, force: true });
               }
             } else {
               const version = plan.version;
@@ -29188,8 +29340,8 @@ ${[...plan.packages].map(([pkgPath, ver]) => `- ${getPackageName(ctx2, pkgPath)}
                   if (!pkgConfig)
                     continue;
                   const changelogPath = import_node_path20.join(import_node_process15.default.cwd(), pkgConfig.path, "CHANGELOG.md");
-                  if (import_node_fs11.existsSync(changelogPath)) {
-                    const section = parseChangelogSection(import_node_fs11.readFileSync(changelogPath, "utf-8"), pkgVersion);
+                  if (import_node_fs13.existsSync(changelogPath)) {
+                    const section = parseChangelogSection(import_node_fs13.readFileSync(changelogPath, "utf-8"), pkgVersion);
                     if (section) {
                       sections.push(`## ${pkgName} v${pkgVersion}
 
@@ -29206,8 +29358,8 @@ ${section}`);
                 }
               } else {
                 const changelogPath = import_node_path20.join(import_node_process15.default.cwd(), "CHANGELOG.md");
-                if (import_node_fs11.existsSync(changelogPath)) {
-                  const section = parseChangelogSection(import_node_fs11.readFileSync(changelogPath, "utf-8"), version);
+                if (import_node_fs13.existsSync(changelogPath)) {
+                  const section = parseChangelogSection(import_node_fs13.readFileSync(changelogPath, "utf-8"), version);
                   if (section)
                     changelogBody = section;
                 }
@@ -29240,7 +29392,7 @@ ${section}`);
                 task.output = `Release already exists for ${tag}, skipped.`;
               }
               if (tempDir)
-                import_node_fs11.rmSync(tempDir, { recursive: true, force: true });
+                import_node_fs13.rmSync(tempDir, { recursive: true, force: true });
             }
           } else {
             const git = new Git;
@@ -29347,13 +29499,13 @@ function maxBump(a3, b2) {
   return BUMP_ORDER[a3] >= BUMP_ORDER[b2] ? a3 : b2;
 }
 // src/changeset/migrate.ts
-var import_node_fs12 = require("node:fs");
+var import_node_fs14 = require("node:fs");
 var import_node_path21 = __toESM(require("node:path"));
 var import_node_process16 = __toESM(require("node:process"));
 var SKIPPED_FILES = new Set(["config.json", "README.md"]);
 function migrateFromChangesets(cwd = import_node_process16.default.cwd()) {
   const changesetDir = import_node_path21.default.join(cwd, ".changeset");
-  if (!import_node_fs12.existsSync(changesetDir)) {
+  if (!import_node_fs14.existsSync(changesetDir)) {
     return {
       success: false,
       error: ".changeset/ directory not found",
@@ -29362,8 +29514,8 @@ function migrateFromChangesets(cwd = import_node_process16.default.cwd()) {
     };
   }
   const pubmDir = import_node_path21.default.join(cwd, ".pubm", "changesets");
-  import_node_fs12.mkdirSync(pubmDir, { recursive: true });
-  const files = import_node_fs12.readdirSync(changesetDir);
+  import_node_fs14.mkdirSync(pubmDir, { recursive: true });
+  const files = import_node_fs14.readdirSync(changesetDir);
   const migratedFiles = [];
   let configMigrated = false;
   for (const file of files) {
@@ -29375,14 +29527,14 @@ function migrateFromChangesets(cwd = import_node_process16.default.cwd()) {
       continue;
     }
     if (file === "pre.json") {
-      import_node_fs12.copyFileSync(import_node_path21.default.join(changesetDir, file), import_node_path21.default.resolve(cwd, ".pubm", "pre.json"));
+      import_node_fs14.copyFileSync(import_node_path21.default.join(changesetDir, file), import_node_path21.default.resolve(cwd, ".pubm", "pre.json"));
       migratedFiles.push(file);
       continue;
     }
     if (file.endsWith(".md")) {
       const src = import_node_path21.default.join(changesetDir, file);
       const dest = import_node_path21.default.join(pubmDir, file);
-      import_node_fs12.copyFileSync(src, dest);
+      import_node_fs14.copyFileSync(src, dest);
       migratedFiles.push(file);
     }
   }
@@ -29454,7 +29606,7 @@ function calculateVersionBumps(currentVersions, cwd = import_node_process18.defa
   return result;
 }
 // src/changeset/writer.ts
-var import_node_fs13 = require("node:fs");
+var import_node_fs15 = require("node:fs");
 var import_node_path22 = __toESM(require("node:path"));
 var import_node_process19 = __toESM(require("node:process"));
 var import_yaml3 = __toESM(require_dist(), 1);
@@ -29553,12 +29705,12 @@ ${summary}
 }
 function writeChangeset(releases, summary, cwd = import_node_process19.default.cwd()) {
   const changesetsDir = import_node_path22.default.join(cwd, ".pubm", "changesets");
-  import_node_fs13.mkdirSync(changesetsDir, { recursive: true });
+  import_node_fs15.mkdirSync(changesetsDir, { recursive: true });
   const id = generateChangesetId();
   const fileName = `${id}.md`;
   const filePath = import_node_path22.default.join(changesetsDir, fileName);
   const content = generateChangesetContent(releases, summary);
-  import_node_fs13.writeFileSync(filePath, content, "utf-8");
+  import_node_fs15.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
 // src/config/defaults.ts
@@ -29584,7 +29736,8 @@ var defaultConfig = {
   saveToken: true,
   releaseDraft: true,
   releaseNotes: true,
-  rollbackStrategy: "individual"
+  rollbackStrategy: "individual",
+  lockfileSync: "optional"
 };
 async function resolveConfig(config, cwd) {
   const resolvedCwd = cwd ?? process.cwd();
@@ -30313,17 +30466,32 @@ function formatStageError(stage, error2) {
   const message = error2 instanceof Error ? error2.stack ?? error2.message : String(error2);
   return `[${stage}] ${message}`;
 }
-async function loadConfig(cwd = process.cwd()) {
-  const configPath = await findConfigFile(cwd);
-  if (!configPath)
+async function loadConfig(cwd = process.cwd(), configPath) {
+  let resolvedConfigPath;
+  if (configPath) {
+    resolvedConfigPath = import_node_path23.default.resolve(cwd, configPath);
+    try {
+      if (!(await import_promises8.stat(resolvedConfigPath)).isFile()) {
+        throw new Error(`Config path is not a file: ${resolvedConfigPath}`);
+      }
+    } catch (e3) {
+      if (e3.code === "ENOENT") {
+        throw new Error(`Config file not found: ${resolvedConfigPath}`);
+      }
+      throw e3;
+    }
+  } else {
+    resolvedConfigPath = await findConfigFile(cwd);
+  }
+  if (!resolvedConfigPath)
     return null;
   const errors = [];
   try {
-    return await importConfigModule(configPath);
+    return await importConfigModule(resolvedConfigPath);
   } catch (error2) {
     errors.push(formatStageError("native import", error2));
   }
-  const output = await buildConfig(configPath);
+  const output = await buildConfig(resolvedConfigPath);
   if (!output.success) {
     errors.push(formatStageError("bundled build", output.logs.map((log) => log.message).join(`
 `)));
@@ -30342,11 +30510,11 @@ ${errors.join(`
   }
   const bundledSource = await entrypoint.text();
   try {
-    return await importBundledConfig(bundledSource, configPath, output.optionalDependencies);
+    return await importBundledConfig(bundledSource, resolvedConfigPath, output.optionalDependencies);
   } catch (error2) {
     errors.push(formatStageError("bundled import", error2));
   }
-  const vmOutput = await buildConfigWithFormat(configPath, "cjs");
+  const vmOutput = await buildConfigWithFormat(resolvedConfigPath, "cjs");
   if (!vmOutput.success) {
     errors.push(formatStageError("bundled vm build", vmOutput.logs.map((log) => log.message).join(`
 `)));
@@ -30364,7 +30532,7 @@ ${errors.join(`
 `)}`);
   }
   try {
-    return await executeBundledConfigInVm(await vmEntrypoint.text(), configPath);
+    return await executeBundledConfigInVm(await vmEntrypoint.text(), resolvedConfigPath);
   } catch (error2) {
     errors.push(formatStageError("bundled vm", error2));
     throw new Error(`Failed to load config:
@@ -30784,6 +30952,9 @@ async function handleMultiPackage(ctx, task, packageInfos) {
       if (result === "accepted")
         return;
       if (result === "add_packages") {
+        if (!bumps) {
+          throw new Error("Changeset bumps are required for add_packages.");
+        }
         await handleAddPackages(ctx, task, sortedPackageInfos, currentVersions, graph, bumps);
         return;
       }
@@ -30807,6 +30978,7 @@ async function handleRemainingPackages(ctx, task, remainingPackages, packageInfo
   const versions = new Map([...bumps].map(([p2, b2]) => [p2, b2.newVersion]));
   const publishPaths = new Set(bumps.keys());
   const reverseDeps = buildReverseDeps(graph);
+  let lastBumpType;
   for (const pkg of remainingPackages) {
     const currentVersion = currentVersions.get(pkg.path) ?? pkg.version;
     const deps = graph.get(pkg.path) ?? [];
@@ -30819,8 +30991,9 @@ async function handleRemainingPackages(ctx, task, remainingPackages, packageInfo
     if (pkgNotes.length > 0) {
       task.output = renderPackageVersionSummary(remainingPackages, currentVersions, versions, { activePackage: pkg.path, notes: new Map([[pkg.path, pkgNotes]]) });
     }
-    const result = await promptVersion(task, currentVersion, pkg.name);
+    const result = await promptVersion(task, currentVersion, pkg.name, undefined, lastBumpType);
     versions.set(pkg.path, result.version);
+    lastBumpType = result.bumpType;
     if (result.version !== currentVersion) {
       bumpedPackages.add(pkg.path);
       publishPaths.add(pkg.path);
@@ -33110,11 +33283,11 @@ function isBun2() {
 init_ui();
 
 // src/validate/entry-points.ts
-var import_node_fs14 = require("node:fs");
+var import_node_fs16 = require("node:fs");
 var import_node_path24 = __toESM(require("node:path"));
 var SIMPLE_FIELDS = ["main", "module", "types", "typings"];
 function checkPath(filePath, cwd) {
-  return import_node_fs14.existsSync(import_node_path24.default.resolve(cwd, filePath));
+  return import_node_fs16.existsSync(import_node_path24.default.resolve(cwd, filePath));
 }
 function validateExports(exports2, cwd, prefix = "exports") {
   const errors = [];