@pubm/core 0.4.4 → 0.4.5

package/dist/index.js

@@ -20111,6 +20111,10 @@ async function openUrl(url) {
 var init_open_url = () => {};
 
 // src/plugin/runner.ts
+function isDefined(value) {
+  return value !== undefined;
+}
+
 class PluginRunner {
   plugins;
   constructor(plugins) {
@@ -20148,7 +20152,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;
@@ -20158,7 +20162,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];
@@ -20173,17 +20177,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 = "";
@@ -20193,7 +20198,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;
@@ -20203,7 +20208,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 = [];
@@ -20219,7 +20224,7 @@ class PluginRunner {
 }
 
 // src/tasks/runner.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync8, rmSync as rmSync2 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync9, rmSync as rmSync2 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import path10, { join as join9 } from "node:path";
 import process17 from "node:process";
@@ -22860,6 +22865,7 @@ function createKeyResolver(packages) {
 }
 
 // src/ecosystem/js.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { readFile as readFile3, writeFile } from "node:fs/promises";
 import path5 from "node:path";
 
@@ -22964,7 +22970,7 @@ function isValidPackageName(packageName) {
 // package.json
 var package_default = {
   name: "@pubm/core",
-  version: "0.4.4",
+  version: "0.4.5",
   type: "module",
   description: "Core SDK for pubm - publish manager for multiple registries",
   types: "./dist/index.d.ts",
@@ -23038,7 +23044,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.5", package_default.version);
 var PUBM_ENGINES = {
   node: resolveDefine(">=24", coreEngines.node ?? ">=18"),
   git: resolveDefine(">=2.11.0", coreEngines.git ?? ">=2.11.0"),
@@ -24038,6 +24044,8 @@ async function getPackageManager() {
 }
 
 // src/ecosystem/ecosystem.ts
+import { writeFileSync as writeFileSync3 } from "node:fs";
+
 class Ecosystem {
   packagePath;
   constructor(packagePath) {
@@ -24081,6 +24089,14 @@ class Ecosystem {
   async syncLockfile() {
     return;
   }
+  async resolvePublishDependencies(_workspaceVersions) {
+    return new Map;
+  }
+  restorePublishDependencies(backups) {
+    for (const [filePath, content] of backups) {
+      writeFileSync3(filePath, content, "utf-8");
+    }
+  }
 }
 
 // src/ecosystem/descriptor.ts
@@ -24151,6 +24167,48 @@ class JsEcosystem extends Ecosystem {
   supportedRegistries() {
     return ["npm", "jsr"];
   }
+  async resolvePublishDependencies(workspaceVersions) {
+    const backups = new Map;
+    const manifestPath = path5.join(this.packagePath, "package.json");
+    if (!existsSync3(manifestPath))
+      return backups;
+    const original = readFileSync4(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);
+      writeFileSync4(manifestPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf-8");
+    }
+    return backups;
+  }
   async createDescriptor() {
     const npmReader = NpmPackageRegistry.reader;
     const jsrReader = JsrPackageRegistry.reader;
@@ -25600,12 +25658,12 @@ async function writeVersionsForEcosystem(ecosystems, versions) {
 }
 
 // src/monorepo/resolve-workspace.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join7 } from "node:path";
 
 // src/monorepo/discover.ts
 var import_micromatch2 = __toESM(require_micromatch(), 1);
-import { readdirSync as readdirSync3, statSync as statSync2 } from "node:fs";
+import { lstatSync, readdirSync as readdirSync3 } from "node:fs";
 import path8 from "node:path";
 
 // src/ecosystem/infer.ts
@@ -25681,6 +25739,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
@@ -25785,7 +25846,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),
@@ -25837,6 +25898,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 readFile5(path8, "utf-8");
@@ -25886,8 +25953,8 @@ async function inferJsRegistries(packagePath, rootPath) {
     return [];
   }
   const packageJson = await readJsonSafe(join5(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;
@@ -25928,7 +25995,7 @@ async function inferRegistries(packagePath, ecosystemKey, rootPath) {
 }
 
 // src/monorepo/workspace.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "node:fs";
 import { join as join6 } from "node:path";
 
 // ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
@@ -26740,15 +26807,15 @@ function detectWorkspace(cwd) {
   const root = cwd ?? process.cwd();
   const workspaces = [];
   const pnpmWorkspacePath = join6(root, "pnpm-workspace.yaml");
-  if (existsSync3(pnpmWorkspacePath)) {
-    const content = readFileSync4(pnpmWorkspacePath, "utf-8");
+  if (existsSync4(pnpmWorkspacePath)) {
+    const content = readFileSync5(pnpmWorkspacePath, "utf-8");
     const parsed = $parse(content);
     const packages = parsed?.packages ?? [];
     workspaces.push({ type: "pnpm", patterns: packages });
   }
   const cargoTomlPath = join6(root, "Cargo.toml");
-  if (existsSync3(cargoTomlPath)) {
-    const content = readFileSync4(cargoTomlPath, "utf-8");
+  if (existsSync4(cargoTomlPath)) {
+    const content = readFileSync5(cargoTomlPath, "utf-8");
     try {
       const parsed = parse(content);
       const workspace = parsed.workspace;
@@ -26763,8 +26830,8 @@ function detectWorkspace(cwd) {
   }
   for (const denoFile of ["deno.json", "deno.jsonc"]) {
     const denoPath = join6(root, denoFile);
-    if (existsSync3(denoPath)) {
-      const content = readFileSync4(denoPath, "utf-8");
+    if (existsSync4(denoPath)) {
+      const content = readFileSync5(denoPath, "utf-8");
       try {
         const parsed = denoFile.endsWith(".jsonc") ? parse3(content) : JSON.parse(content);
         if (Array.isArray(parsed?.workspace)) {
@@ -26777,12 +26844,12 @@ function detectWorkspace(cwd) {
   }
   if (!workspaces.some((w2) => w2.type === "pnpm")) {
     const packageJsonPath = join6(root, "package.json");
-    if (existsSync3(packageJsonPath)) {
-      const content = readFileSync4(packageJsonPath, "utf-8");
+    if (existsSync4(packageJsonPath)) {
+      const content = readFileSync5(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.workspaces) {
         const bunfigPath = join6(root, "bunfig.toml");
-        const isBun2 = existsSync3(bunfigPath);
+        const isBun2 = existsSync4(bunfigPath);
         if (Array.isArray(pkg.workspaces)) {
           workspaces.push({
             type: isBun2 ? "bun" : "npm",
@@ -26814,16 +26881,32 @@ function matchesIgnore(pkgPath, ignorePatterns) {
     return regex3.test(normalized);
   });
 }
-function resolvePatterns(cwd, patterns) {
-  const entries = readdirSync3(cwd, { recursive: true, encoding: "utf-8" });
-  const dirs = entries.filter((entry) => {
-    const fullPath = path8.join(cwd, entry);
+function readdirRecursiveNoSymlinks(dir, root) {
+  const results = [];
+  let entries;
+  try {
+    entries = readdirSync3(dir, { encoding: "utf-8" });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (entry === "node_modules" || entry === ".git")
+      continue;
+    const fullPath = path8.join(dir, entry);
     try {
-      return statSync2(fullPath).isDirectory();
-    } catch {
-      return false;
-    }
-  });
+      const stat5 = lstatSync(fullPath);
+      if (stat5.isSymbolicLink())
+        continue;
+      if (stat5.isDirectory()) {
+        results.push(path8.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) => path8.resolve(cwd, d3));
@@ -26920,31 +27003,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);
@@ -26956,10 +27014,10 @@ function collectWorkspaceVersions(cwd) {
     const dirs = resolvePatterns(cwd, workspace.patterns);
     for (const dir of dirs) {
       const pkgJsonPath = join7(dir, "package.json");
-      if (!existsSync4(pkgJsonPath))
+      if (!existsSync5(pkgJsonPath))
         continue;
       try {
-        const content = readFileSync5(pkgJsonPath, "utf-8");
+        const content = readFileSync6(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);
@@ -26969,44 +27027,9 @@ function collectWorkspaceVersions(cwd) {
   }
   return versions;
 }
-function resolveWorkspaceProtocolsInManifests(packagePaths, workspaceVersions) {
-  const backups = new Map;
-  for (const pkgPath of packagePaths) {
-    const manifestPath = join7(pkgPath, "package.json");
-    const original = readFileSync5(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);
-      writeFileSync3(manifestPath, `${JSON.stringify(pkg, null, 2)}
-`, "utf-8");
-    }
-  }
-  return backups;
-}
 function restoreManifests(backups) {
   for (const [filePath, content] of backups) {
-    writeFileSync3(filePath, content, "utf-8");
+    writeFileSync5(filePath, content, "utf-8");
   }
 }
 
@@ -27310,7 +27333,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: {
@@ -27397,9 +27421,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",
@@ -27410,7 +27435,7 @@ async function withTokenRetry(registryKey, ctx, task, action) {
         return newToken;
       })();
     }
-    await ctx.runtime[retryKey];
+    await retryPromises[registryKey];
     await action();
   }
 }
@@ -27467,7 +27492,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;
   }));
@@ -27518,7 +27547,7 @@ function createCratesDryRunPublishTask(packagePath, siblingPaths) {
 init_error();
 init_git();
 var import_semver2 = __toESM(require_semver2(), 1);
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 var { prerelease } = import_semver2.default;
 
 class GitHubReleaseError extends AbstractError {
@@ -27587,7 +27616,7 @@ async function createGitHubRelease(_ctx, options) {
   const uploadUrl = release.upload_url.replace(/\{[^}]*\}/, "");
   const releaseAssets = [];
   for (const asset of options.assets) {
-    const archiveContent = readFileSync6(asset.filePath);
+    const archiveContent = readFileSync7(asset.filePath);
     const uploadResponse = await fetch(`${uploadUrl}?name=${encodeURIComponent(asset.name)}`, {
       method: "POST",
       headers: {
@@ -27836,7 +27865,7 @@ init_error();
 init_exec();
 
 // src/utils/gh-secrets-sync-state.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "node:fs";
 import path9 from "node:path";
 var SYNC_HASH_FILENAME = "gh-secrets-sync-hash";
 function syncHashFilePath() {
@@ -27844,14 +27873,14 @@ function syncHashFilePath() {
 }
 function readGhSecretsSyncHash() {
   try {
-    const value = readFileSync7(syncHashFilePath(), "utf8").trim();
+    const value = readFileSync8(syncHashFilePath(), "utf8").trim();
     return value || null;
   } catch {
     return null;
   }
 }
 function writeGhSecretsSyncHash(hash) {
-  writeFileSync4(syncHashFilePath(), `${hash}
+  writeFileSync6(syncHashFilePath(), `${hash}
 `, "utf8");
 }
 
@@ -28239,12 +28268,26 @@ 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 = path10.resolve(ctx.cwd ?? process17.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 };
   });
@@ -28263,17 +28306,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) => path10.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 = path10.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 = path10.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) {
@@ -28393,8 +28457,8 @@ ${[...plan.packages].map(([pkgPath, ver]) => `  ${getPackageName(ctx, pkgPath)}:
   }
   return "";
 }
-function shouldRenderLiveCommandOutput(ctx) {
-  return ctx.options.mode !== "ci" && !m && Boolean(process17.stdout.isTTY);
+function shouldRenderLiveCommandOutput(_ctx) {
+  return !m && Boolean(process17.stdout.isTTY);
 }
 function normalizeLiveCommandOutputLine(line) {
   const normalized = stripVTControlCharacters2(line).trimEnd();
@@ -28475,7 +28539,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,
@@ -28557,7 +28621,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();
@@ -28624,7 +28688,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,
@@ -28690,7 +28754,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) {
@@ -28914,7 +28978,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);
@@ -28927,7 +28991,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;
         }
       },
@@ -28944,7 +29012,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)`;
@@ -28958,7 +29026,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;
         }
       },
@@ -28966,7 +29038,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;
         }
       },
@@ -28993,7 +29069,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) {
@@ -29039,8 +29115,8 @@ ${[...plan.packages].map(([pkgPath, ver]) => `- ${getPackageName(ctx2, pkgPath)}
                 const pkgConfig = ctx2.config.packages.find((p2) => p2.path === pkgPath);
                 if (pkgConfig) {
                   const changelogPath = join9(process17.cwd(), pkgConfig.path, "CHANGELOG.md");
-                  if (existsSync5(changelogPath)) {
-                    const section = parseChangelogSection(readFileSync8(changelogPath, "utf-8"), pkgVersion);
+                  if (existsSync6(changelogPath)) {
+                    const section = parseChangelogSection(readFileSync9(changelogPath, "utf-8"), pkgVersion);
                     if (section)
                       changelogBody = section;
                   }
@@ -29086,8 +29162,8 @@ ${[...plan.packages].map(([pkgPath, ver]) => `- ${getPackageName(ctx2, pkgPath)}
                   if (!pkgConfig)
                     continue;
                   const changelogPath = join9(process17.cwd(), pkgConfig.path, "CHANGELOG.md");
-                  if (existsSync5(changelogPath)) {
-                    const section = parseChangelogSection(readFileSync8(changelogPath, "utf-8"), pkgVersion);
+                  if (existsSync6(changelogPath)) {
+                    const section = parseChangelogSection(readFileSync9(changelogPath, "utf-8"), pkgVersion);
                     if (section) {
                       sections.push(`## ${pkgName} v${pkgVersion}
 
@@ -29104,8 +29180,8 @@ ${section}`);
                 }
               } else {
                 const changelogPath = join9(process17.cwd(), "CHANGELOG.md");
-                if (existsSync5(changelogPath)) {
-                  const section = parseChangelogSection(readFileSync8(changelogPath, "utf-8"), version);
+                if (existsSync6(changelogPath)) {
+                  const section = parseChangelogSection(readFileSync9(changelogPath, "utf-8"), version);
                   if (section)
                     changelogBody = section;
                 }
@@ -29245,13 +29321,13 @@ function maxBump(a3, b2) {
   return BUMP_ORDER[a3] >= BUMP_ORDER[b2] ? a3 : b2;
 }
 // src/changeset/migrate.ts
-import { copyFileSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readdirSync as readdirSync4 } from "node:fs";
+import { copyFileSync, existsSync as existsSync7, mkdirSync as mkdirSync3, readdirSync as readdirSync4 } from "node:fs";
 import path11 from "node:path";
 import process18 from "node:process";
 var SKIPPED_FILES = new Set(["config.json", "README.md"]);
 function migrateFromChangesets(cwd = process18.cwd()) {
   const changesetDir = path11.join(cwd, ".changeset");
-  if (!existsSync6(changesetDir)) {
+  if (!existsSync7(changesetDir)) {
     return {
       success: false,
       error: ".changeset/ directory not found",
@@ -29352,7 +29428,7 @@ function calculateVersionBumps(currentVersions, cwd = process20.cwd(), resolveKe
   return result;
 }
 // src/changeset/writer.ts
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync7 } from "node:fs";
 import path12 from "node:path";
 import process21 from "node:process";
 var adjectives = [
@@ -29455,7 +29531,7 @@ function writeChangeset(releases, summary, cwd = process21.cwd()) {
   const fileName = `${id}.md`;
   const filePath = path12.join(changesetsDir, fileName);
   const content = generateChangesetContent(releases, summary);
-  writeFileSync5(filePath, content, "utf-8");
+  writeFileSync7(filePath, content, "utf-8");
   return filePath;
 }
 // src/config/defaults.ts
@@ -30217,17 +30293,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 = path13.resolve(cwd, configPath);
+    try {
+      if (!(await stat5(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 errors2 = [];
   try {
-    return await importConfigModule(configPath);
+    return await importConfigModule(resolvedConfigPath);
   } catch (error2) {
     errors2.push(formatStageError("native import", error2));
   }
-  const output = await buildConfig(configPath);
+  const output = await buildConfig(resolvedConfigPath);
   if (!output.success) {
     errors2.push(formatStageError("bundled build", output.logs.map((log) => log.message).join(`
 `)));
@@ -30246,11 +30337,11 @@ ${errors2.join(`
   }
   const bundledSource = await entrypoint.text();
   try {
-    return await importBundledConfig(bundledSource, configPath, output.optionalDependencies);
+    return await importBundledConfig(bundledSource, resolvedConfigPath, output.optionalDependencies);
   } catch (error2) {
     errors2.push(formatStageError("bundled import", error2));
   }
-  const vmOutput = await buildConfigWithFormat(configPath, "cjs");
+  const vmOutput = await buildConfigWithFormat(resolvedConfigPath, "cjs");
   if (!vmOutput.success) {
     errors2.push(formatStageError("bundled vm build", vmOutput.logs.map((log) => log.message).join(`
 `)));
@@ -30268,7 +30359,7 @@ ${errors2.join(`
 `)}`);
   }
   try {
-    return await executeBundledConfigInVm(await vmEntrypoint.text(), configPath);
+    return await executeBundledConfigInVm(await vmEntrypoint.text(), resolvedConfigPath);
   } catch (error2) {
     errors2.push(formatStageError("bundled vm", error2));
     throw new Error(`Failed to load config:
@@ -30688,6 +30779,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;
       }
@@ -31031,7 +31125,7 @@ import { homedir as homedir2 } from "os";
 import { join as join10 } from "path";
 import os2 from "os";
 import path32 from "path";
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { readFile as readFile22 } from "fs/promises";
 import { dirname, join as join22, resolve as resolve2, sep } from "path";
 import { fileURLToPath } from "url";
@@ -32611,7 +32705,7 @@ function findPackageJsonSync(startDir) {
   for (;; ) {
     const candidate = join22(current, "package.json");
     try {
-      const content = readFileSync9(candidate, "utf-8");
+      const content = readFileSync10(candidate, "utf-8");
       const result = parsePackageJson(content, candidate);
       if (result)
         return result;
@@ -33014,11 +33108,11 @@ function isBun2() {
 init_ui();
 
 // src/validate/entry-points.ts
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 import path15 from "node:path";
 var SIMPLE_FIELDS = ["main", "module", "types", "typings"];
 function checkPath(filePath, cwd) {
-  return existsSync7(path15.resolve(cwd, filePath));
+  return existsSync8(path15.resolve(cwd, filePath));
 }
 function validateExports(exports, cwd, prefix = "exports") {
   const errors2 = [];