@pubm/core 0.5.2 → 0.5.5

package/dist/index.cjs

@@ -14356,6 +14356,8 @@ var init_de = __esm(() => {
     "task.release.resolvingMetadata": "Repository-Metadaten für den Release-Entwurf werden aufgelöst...",
     "task.release.openingDraft": "Release-Entwurf für {tag} wird geöffnet...",
     "task.release.collectedCommits": "{count} Commits für {tag} gesammelt.",
+    "task.release.copiedToClipboard": "Release-Notizen in die Zwischenablage kopiert — in den Release-Text einfügen",
+    "task.release.truncated": "Release-Notizen wurden aufgrund der URL-Längenbeschränkung gekürzt",
     "task.publish.registryLabel": "In {registry} veröffentlichen",
     "task.dryRun.registryLabel": "Dry-run {registry}",
     "output.ciPrepareComplete": "CI-Vorbereitung abgeschlossen. Release-Tags gepusht — CI sollte die Veröffentlichung übernehmen.",
@@ -14525,6 +14527,7 @@ Token von {url} generieren`,
     "prompt.add.bumpMinor": "minor — Neue Funktionen, rückwärtskompatibel",
     "prompt.add.bumpMajor": "major — Nicht rückwärtskompatible Änderungen",
     "prompt.add.selectBump": "Hochstufungstyp für {name} auswählen",
+    "prompt.add.selectBumpAll": "Hochstufungstyp für alle Pakete auswählen",
     "prompt.add.summary": "Zusammenfassung der Änderungen",
     "cmd.status.description": "Status der ausstehenden Changesets anzeigen",
     "cmd.status.optionVerbose": "Vollständige Changeset-Inhalte anzeigen",
@@ -14781,6 +14784,8 @@ var init_en = __esm(() => {
     "task.release.resolvingMetadata": "Resolving repository metadata for the release draft...",
     "task.release.openingDraft": "Opening release draft for {tag}...",
     "task.release.collectedCommits": "Collected {count} commits for {tag}.",
+    "task.release.copiedToClipboard": "Release notes copied to clipboard — paste into the release body",
+    "task.release.truncated": "Release notes were truncated due to URL length limit",
     "task.publish.registryLabel": "Publish to {registry}",
     "task.dryRun.registryLabel": "Dry-run {registry}",
     "output.ciPrepareComplete": "CI prepare completed. Release tags pushed — CI should pick up the publish.",
@@ -14950,6 +14955,7 @@ Generate a token from {url}`,
     "prompt.add.bumpMinor": "minor — New features, backward compatible",
     "prompt.add.bumpMajor": "major — Breaking changes",
     "prompt.add.selectBump": "Select bump type for {name}",
+    "prompt.add.selectBumpAll": "Select bump type for all packages",
     "prompt.add.summary": "Summary of changes",
     "cmd.status.description": "Show pending changeset status",
     "cmd.status.optionVerbose": "Show full changeset contents",
@@ -15206,6 +15212,8 @@ var init_es = __esm(() => {
     "task.release.resolvingMetadata": "Resolviendo metadatos del repositorio para el borrador de publicación...",
     "task.release.openingDraft": "Abriendo borrador de publicación para {tag}...",
     "task.release.collectedCommits": "{count} commits recopilados para {tag}.",
+    "task.release.copiedToClipboard": "Notas de la versión copiadas al portapapeles — pégalas en el cuerpo del release",
+    "task.release.truncated": "Las notas de la versión fueron truncadas debido al límite de longitud de la URL",
     "task.publish.registryLabel": "Publicar en {registry}",
     "task.dryRun.registryLabel": "Dry-run {registry}",
     "output.ciPrepareComplete": "Preparación de CI completada. Etiquetas de publicación enviadas — CI debería encargarse de la publicación.",
@@ -15375,6 +15383,7 @@ Generar un token desde {url}`,
     "prompt.add.bumpMinor": "minor — Nuevas características, compatible con versiones anteriores",
     "prompt.add.bumpMajor": "major — Cambios incompatibles con versiones anteriores",
     "prompt.add.selectBump": "Seleccionar tipo de incremento para {name}",
+    "prompt.add.selectBumpAll": "Seleccionar tipo de incremento para todos los paquetes",
     "prompt.add.summary": "Resumen de los cambios",
     "cmd.status.description": "Mostrar el estado de los changesets pendientes",
     "cmd.status.optionVerbose": "Mostrar el contenido completo del changeset",
@@ -15631,6 +15640,8 @@ var init_fr = __esm(() => {
     "task.release.resolvingMetadata": "Résolution des métadonnées du dépôt pour le brouillon de publication...",
     "task.release.openingDraft": "Ouverture du brouillon de publication pour {tag}...",
     "task.release.collectedCommits": "{count} commits collectés pour {tag}.",
+    "task.release.copiedToClipboard": "Notes de version copiées dans le presse-papiers — collez-les dans le corps de la release",
+    "task.release.truncated": "Les notes de version ont été tronquées en raison de la limite de longueur de l'URL",
     "task.publish.registryLabel": "Publier vers {registry}",
     "task.dryRun.registryLabel": "Dry-run {registry}",
     "output.ciPrepareComplete": "Préparation CI terminée. Tags de publication poussés — CI devrait prendre en charge la publication.",
@@ -15800,6 +15811,7 @@ Générer un token depuis {url}`,
     "prompt.add.bumpMinor": "minor — Nouvelles fonctionnalités, rétrocompatible",
     "prompt.add.bumpMajor": "major — Changements non rétrocompatibles",
     "prompt.add.selectBump": "Sélectionner le type d'incrément pour {name}",
+    "prompt.add.selectBumpAll": "Sélectionner le type d'incrément pour tous les paquets",
     "prompt.add.summary": "Résumé des modifications",
     "cmd.status.description": "Afficher le statut des changesets en attente",
     "cmd.status.optionVerbose": "Afficher le contenu complet des changesets",
@@ -16056,6 +16068,8 @@ var init_ko = __esm(() => {
     "task.release.resolvingMetadata": "릴리스 초안을 위한 저장소 메타데이터 확인 중...",
     "task.release.openingDraft": "{tag} 릴리스 초안 열기 중...",
     "task.release.collectedCommits": "{tag}에 대한 {count}개 커밋 수집됨.",
+    "task.release.copiedToClipboard": "릴리즈 노트가 클립보드에 복사되었습니다 — 릴리즈 본문에 붙여넣기 하세요",
+    "task.release.truncated": "URL 길이 제한으로 릴리즈 노트가 잘렸습니다",
     "task.publish.registryLabel": "{registry}에 배포",
     "task.dryRun.registryLabel": "{registry} Dry-run",
     "output.ciPrepareComplete": "CI 준비 완료. 릴리스 태그가 푸시되었습니다 — CI가 배포를 처리합니다.",
@@ -16225,6 +16239,7 @@ var init_ko = __esm(() => {
     "prompt.add.bumpMinor": "minor — 새 기능, 하위 호환",
     "prompt.add.bumpMajor": "major — 호환성이 깨지는 변경",
     "prompt.add.selectBump": "{name}의 버전 업 유형 선택",
+    "prompt.add.selectBumpAll": "모든 패키지의 버전 업 유형 선택",
     "prompt.add.summary": "변경사항 요약",
     "cmd.status.description": "대기 중인 changeset 상태 표시",
     "cmd.status.optionVerbose": "전체 changeset 내용 표시",
@@ -16481,6 +16496,8 @@ var init_zh_cn = __esm(() => {
     "task.release.resolvingMetadata": "正在解析发布草稿的仓库元数据...",
     "task.release.openingDraft": "正在打开 {tag} 的发布草稿...",
     "task.release.collectedCommits": "已为 {tag} 收集 {count} 个提交。",
+    "task.release.copiedToClipboard": "发布说明已复制到剪贴板 — 请粘贴到发布正文中",
+    "task.release.truncated": "由于URL长度限制，发布说明已被截断",
     "task.publish.registryLabel": "发布到 {registry}",
     "task.dryRun.registryLabel": "{registry} Dry-run",
     "output.ciPrepareComplete": "CI 准备完成。发布标签已推送 — CI 应处理发布。",
@@ -16650,6 +16667,7 @@ var init_zh_cn = __esm(() => {
     "prompt.add.bumpMinor": "minor — 新功能，向后兼容",
     "prompt.add.bumpMajor": "major — 破坏性变更",
     "prompt.add.selectBump": "选择 {name} 的升级类型",
+    "prompt.add.selectBumpAll": "选择所有包的升级类型",
     "prompt.add.summary": "变更摘要",
     "cmd.status.description": "显示待处理的 changeset 状态",
     "cmd.status.optionVerbose": "显示完整的 changeset 内容",
@@ -17641,7 +17659,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@pubm/core",
-    version: "0.5.2",
+    version: "0.5.5",
     type: "module",
     description: "Core SDK for pubm - publish manager for multiple registries",
     types: "./dist/index.d.ts",
@@ -17720,7 +17738,7 @@ var coreEngines, PUBM_VERSION, PUBM_ENGINES;
 var init_pubm_metadata = __esm(() => {
   init_package();
   coreEngines = package_default.engines ?? {};
-  PUBM_VERSION = resolveDefine("0.5.2", package_default.version);
+  PUBM_VERSION = resolveDefine("0.5.5", package_default.version);
   PUBM_ENGINES = {
     node: resolveDefine(">=24", coreEngines.node ?? ">=18"),
     git: resolveDefine(">=2.11.0", coreEngines.git ?? ">=2.11.0"),
@@ -22375,9 +22393,11 @@ function createNpmPublishTask(packagePath) {
       task.output = t("task.npm.publishing");
       try {
         if (ctx.runtime.promptEnabled) {
-          const result = await npm.publish(ctx.runtime.npmOtp);
+          const result = await npm.publish(ctx.runtime.npmOtp, ctx.runtime.tag);
           if (!result) {
+            let isOtpCreator = false;
             if (!ctx.runtime.npmOtpPromise) {
+              isOtpCreator = true;
               ctx.runtime.npmOtpPromise = (async () => {
                 task.title = t("task.npm.otpTitle", { name: npm.packageName });
                 const maxAttempts = 3;
@@ -22391,7 +22411,7 @@ function createNpmPublishTask(packagePath) {
                       }) : ""
                     })
                   });
-                  const success2 = await npm.publish(otp2);
+                  const success2 = await npm.publish(otp2, ctx.runtime.tag);
                   if (success2) {
                     ctx.runtime.npmOtp = otp2;
                     task.title = t("task.npm.otpPassed", {
@@ -22407,8 +22427,8 @@ function createNpmPublishTask(packagePath) {
               })();
             }
             const otp = await ctx.runtime.npmOtpPromise;
-            if (!ctx.runtime.npmOtp || ctx.runtime.npmOtp !== otp) {
-              await npm.publish(otp);
+            if (!isOtpCreator) {
+              await npm.publish(otp, ctx.runtime.tag);
             }
           }
         } else {
@@ -22416,7 +22436,7 @@ function createNpmPublishTask(packagePath) {
           if (!npmTokenEnv) {
             throw new NpmAvailableError(t("error.npm.noAuthToken"));
           }
-          const result = await npm.publishProvenance();
+          const result = await npm.publishProvenance(ctx.runtime.tag);
           if (!result) {
             throw new NpmAvailableError(t("error.npm.2faInCi", { name: npm.packageName }));
           }
@@ -22544,7 +22564,7 @@ function createNpmDryRunPublishTask(packagePath) {
       }
       task.output = t("task.dryRun.npm.running");
       await withTokenRetry("npm", ctx, task, async () => {
-        await npm.dryRunPublish();
+        await npm.dryRunPublish(ctx.runtime.tag);
       });
     }
   };
@@ -23143,6 +23163,43 @@ function spawnInteractive(command) {
 }
 
 // src/registry/npm.ts
+function validateNpmLoginUrl(rawUrl) {
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    return null;
+  }
+  if (parsed.origin !== "https://www.npmjs.com") {
+    return null;
+  }
+  if (parsed.pathname.startsWith("/auth/cli/")) {
+    const authPath2 = parsed.pathname.slice("/auth/cli/".length);
+    return authPath2 ? rawUrl : null;
+  }
+  if (parsed.pathname !== "/login") {
+    return null;
+  }
+  const next = parsed.searchParams.get("next");
+  if (!next?.startsWith("/login/cli/")) {
+    return null;
+  }
+  const authPath = next.slice("/login/cli/".length);
+  return authPath ? rawUrl : null;
+}
+function extractNpmLoginUrl(text) {
+  const matches = text.match(/https:\/\/www\.npmjs\.com\/[^\s"'`<>]+/g);
+  if (!matches) {
+    return null;
+  }
+  for (const match of matches) {
+    const validUrl = validateNpmLoginUrl(match);
+    if (validUrl) {
+      return validUrl;
+    }
+  }
+  return null;
+}
 async function runNpm(args, cwd) {
   const { stdout } = await exec3("npm", args, {
     throwOnError: true,
@@ -23157,7 +23214,7 @@ async function npmPackageRegistry(packagePath) {
   const manifest = await NpmPackageRegistry.reader.read(packagePath);
   return new NpmPackageRegistry(manifest.name, packagePath);
 }
-var import_promises4, import_node_os3, import_node_path6, import_node_process12, NpmError, NpmConnector, NpmPackageRegistry;
+var import_promises4, import_node_os3, import_node_path6, import_node_process12, NpmError, NPM_OFFICIAL_REGISTRY = "https://registry.npmjs.org", NpmConnector, NpmPackageRegistry;
 var init_npm2 = __esm(() => {
   init_dist();
   init_error4();
@@ -23349,8 +23406,11 @@ var init_npm2 = __esm(() => {
         throw new NpmError(`Failed to run \`npm view ${this.packageName} dist-tags --json\``, { cause: error4 });
       }
     }
-    async publish(otp) {
+    async publish(otp, tag) {
       const args = otp ? ["publish", "--otp", otp] : ["publish"];
+      if (tag && tag !== "latest") {
+        args.push("--tag", tag);
+      }
       try {
         await this.npm(args, this.packagePath);
         return true;
@@ -23361,16 +23421,20 @@ var init_npm2 = __esm(() => {
         throw this.classifyPublishError(error4);
       }
     }
-    async publishProvenance() {
+    async publishProvenance(tag) {
+      const args = ["publish", "--provenance", "--access", "public"];
+      if (tag && tag !== "latest") {
+        args.push("--tag", tag);
+      }
       try {
-        await this.npm(["publish", "--provenance", "--access", "public"], this.packagePath);
+        await this.npm(args, this.packagePath);
         return true;
       } catch (error4) {
         if (error4 instanceof NonZeroExitError && error4.output?.stderr.includes("EOTP")) {
           return false;
         }
         if (this.isProvenanceError(error4)) {
-          return this.publish();
+          return this.publish(undefined, tag);
         }
         throw this.classifyPublishError(error4);
       }
@@ -23381,9 +23445,13 @@ var init_npm2 = __esm(() => {
     async unpublish(packageName, version) {
       await this.npm(["unpublish", `${packageName}@${version}`], this.packagePath);
     }
-    async dryRunPublish() {
+    async dryRunPublish(tag) {
+      const args = ["publish", "--dry-run"];
+      if (tag && tag !== "latest") {
+        args.push("--tag", tag);
+      }
       try {
-        await exec3("npm", ["publish", "--dry-run"], {
+        await exec3("npm", args, {
           throwOnError: true,
           nodeOptions: {
             cwd: this.packagePath,
@@ -23415,44 +23483,21 @@ ${stderr}` : ""}`, { cause: error4 });
       if (!await this.isLoggedIn()) {
         if (ctx.runtime.promptEnabled) {
           try {
-            task.output = "Launching npm login...";
-            const { spawnInteractive: spawnInteractive2 } = await Promise.resolve().then(() => exports_spawn_interactive);
-            const child = spawnInteractive2(["npm", "login"]);
-            let opened = false;
-            const readStream = async (stream, onData) => {
-              const reader = stream.getReader();
-              const decoder = new TextDecoder;
-              try {
-                while (true) {
-                  const { done, value } = await reader.read();
-                  if (done)
-                    break;
-                  onData(decoder.decode(value));
+            let loginPromise = ctx.runtime.npmLoginPromise;
+            if (!loginPromise) {
+              loginPromise = this.runInteractiveLogin(task).finally(() => {
+                if (ctx.runtime.npmLoginPromise === loginPromise) {
+                  ctx.runtime.npmLoginPromise = undefined;
                 }
-              } finally {
-                reader.releaseLock();
-              }
-            };
-            await new Promise((resolve, reject) => {
-              const onData = (text) => {
-                const urlMatch = text.match(/https:\/\/www\.npmjs\.com\/login[^\s]*/);
-                if (urlMatch && !opened) {
-                  opened = true;
-                  task.output = `Login at: ${color.cyan(urlMatch[0])}`;
-                  Promise.resolve().then(() => (init_open_url(), exports_open_url)).then(({ openUrl: openUrl2 }) => openUrl2(urlMatch[0]));
-                  child.stdin.write(`
-`);
-                  child.stdin.flush();
-                }
-              };
-              Promise.all([
-                readStream(child.stdout, onData),
-                readStream(child.stderr, onData)
-              ]).catch(reject);
-              child.exited.then((code) => code === 0 ? resolve() : reject(new Error(`npm login exited with code ${code}`))).catch(reject);
-            });
+              });
+              ctx.runtime.npmLoginPromise = loginPromise;
+            } else {
+              task.output = "Waiting for npm login...";
+            }
+            await loginPromise;
           } catch (error4) {
-            throw new NpmError("npm login failed. Please run `npm login` manually and try again.", { cause: error4 });
+            const detail = error4 instanceof Error ? `: ${error4.message}` : "";
+            throw new NpmError(`npm login failed${detail}. Please run \`npm login\` manually and try again.`, { cause: error4 });
           }
           if (!await this.isLoggedIn()) {
             throw new NpmError("Still not logged in after npm login. Please verify your credentials.");
@@ -23482,6 +23527,11 @@ ${stderr}` : ""}`, { cause: error4 });
         requiredManifest: "package.json"
       };
     }
+    isOfficialNpmRegistry() {
+      if (!this.registry)
+        return true;
+      return normalizeRegistryUrl(this.registry) === "registry.npmjs.org";
+    }
     isProvenanceError(error4) {
       if (!(error4 instanceof NonZeroExitError))
         return false;
@@ -23507,6 +23557,110 @@ ${stderr}` : ""}`, { cause: error4 });
       }
       return new NpmError("Failed to publish to npm", { cause: error4 });
     }
+    async runDirectWebLogin(task) {
+      task.output = "Launching npm login...";
+      const isValidUrl = (url) => {
+        try {
+          return /^https?:$/.test(new URL(url).protocol);
+        } catch {
+          return false;
+        }
+      };
+      const loginEndpoint = `${NPM_OFFICIAL_REGISTRY}/-/v1/login`;
+      const res = await fetch(loginEndpoint, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({})
+      });
+      if (!res.ok) {
+        throw new NpmError(`npm web login initiation failed (HTTP ${res.status})`);
+      }
+      const body = await res.json();
+      const { loginUrl, doneUrl } = body;
+      if (!loginUrl || !doneUrl || !isValidUrl(loginUrl) || !isValidUrl(doneUrl)) {
+        throw new NpmError("npm web login response missing valid loginUrl or doneUrl");
+      }
+      task.output = `Login at: ${color.cyan(loginUrl)}`;
+      const { openUrl: openUrl2 } = await Promise.resolve().then(() => (init_open_url(), exports_open_url));
+      openUrl2(loginUrl).catch(() => {});
+      while (true) {
+        const pollRes = await fetch(doneUrl);
+        if (pollRes.status === 200) {
+          const pollBody = await pollRes.json();
+          if (!pollBody.token) {
+            throw new NpmError("npm web login completed but no token received");
+          }
+          try {
+            await exec3("npm", [
+              "config",
+              "set",
+              "//registry.npmjs.org/:_authToken",
+              pollBody.token,
+              "--location=user"
+            ], { throwOnError: true });
+          } catch (error4) {
+            throw new NpmError("Failed to save npm auth token", { cause: error4 });
+          }
+          return;
+        }
+        if (pollRes.status === 202) {
+          const retryAfter = Number(pollRes.headers.get("retry-after")) * 1000;
+          const delay2 = retryAfter > 0 ? retryAfter : 1000;
+          await new Promise((resolve) => setTimeout(resolve, delay2));
+          continue;
+        }
+        throw new NpmError(`npm web login polling failed (HTTP ${pollRes.status})`);
+      }
+    }
+    async runInteractiveLogin(task) {
+      if (this.isOfficialNpmRegistry()) {
+        return this.runDirectWebLogin(task);
+      }
+      task.output = "Launching npm login...";
+      const [{ spawnInteractive: spawnInteractive2 }, { openUrl: openUrl2 }] = await Promise.all([
+        Promise.resolve().then(() => exports_spawn_interactive),
+        Promise.resolve().then(() => (init_open_url(), exports_open_url))
+      ]);
+      const child = spawnInteractive2(["npm", "login"]);
+      let openedUrl = null;
+      let bufferedText = "";
+      const onData = (text) => {
+        bufferedText = `${bufferedText}${text}`.slice(-4096);
+        const canonicalUrl = extractNpmLoginUrl(bufferedText);
+        if (!canonicalUrl || openedUrl) {
+          return;
+        }
+        openedUrl = canonicalUrl;
+        task.output = `Login at: ${color.cyan(canonicalUrl)}`;
+        openUrl2(canonicalUrl);
+      };
+      await Promise.all([
+        this.readInteractiveStream(child.stdout, onData),
+        this.readInteractiveStream(child.stderr, onData),
+        child.exited.then((code) => {
+          if (code !== 0) {
+            throw new Error(`npm login exited with code ${code}`);
+          }
+        })
+      ]);
+      if (!openedUrl) {
+        throw new Error("npm login did not provide a supported web login URL.");
+      }
+    }
+    async readInteractiveStream(stream, onData) {
+      const reader = stream.getReader();
+      const decoder = new TextDecoder;
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          onData(decoder.decode(value));
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    }
   };
 });
 
@@ -33656,7 +33810,7 @@ __export(exports_src, {
 module.exports = __toCommonJS(exports_src);
 
 // src/tasks/runner.ts
-var import_node_process19 = __toESM(require("node:process"));
+var import_node_process20 = __toESM(require("node:process"));
 
 // ../../node_modules/.bun/std-env@4.0.0/node_modules/std-env/dist/index.mjs
 var e2 = globalThis.process?.env || Object.create(null);
@@ -35999,29 +36153,11 @@ function createPublishTasks(hasPublish, dryRun, skipPublish) {
 
 // src/tasks/phases/push-release.ts
 init_dist2();
-var import_node_fs14 = require("node:fs");
-var import_node_path23 = require("node:path");
-var import_node_process17 = __toESM(require("node:process"));
-var import_semver4 = __toESM(require_semver2(), 1);
-
-// src/changeset/changelog-parser.ts
-function parseChangelogSection(changelog, version) {
-  const normalizedVersion = version.replace(/^v/, "");
-  const escapedVersion = normalizedVersion.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const headerPattern = new RegExp(`^## v?${escapedVersion}\\b[^\\n]*\\n`, "m");
-  const headerMatch = headerPattern.exec(changelog);
-  if (!headerMatch)
-    return null;
-  const start = headerMatch.index + headerMatch[0].length;
-  const nextHeader = changelog.indexOf(`
-## `, start);
-  const end = nextHeader === -1 ? changelog.length : nextHeader;
-  return changelog.slice(start, end).trim();
-}
-
-// src/tasks/phases/push-release.ts
 init_git();
 init_i18n();
+var import_node_fs15 = require("node:fs");
+var import_node_process18 = __toESM(require("node:process"));
+var import_semver4 = __toESM(require_semver2(), 1);
 
 // src/utils/github-token.ts
 init_secure_store();
@@ -36058,13 +36194,6 @@ var { prerelease } = import_semver3.default;
 class GitHubReleaseError extends AbstractError {
   name = t("error.githubRelease.name");
 }
-function formatReleaseNotes(commits, repositoryUrl, previousTag, latestTag) {
-  const lines = commits.map(({ id, message }) => `- ${message.replace(/#(\d+)/g, `[#$1](${repositoryUrl}/issues/$1)`)} ([${id.slice(0, 7)}](${repositoryUrl}/commit/${id}))`);
-  lines.push("");
-  lines.push(`**Full Changelog**: ${repositoryUrl}/compare/${previousTag}...${latestTag}`);
-  return lines.join(`
-`);
-}
 async function createGitHubRelease(_ctx, options) {
   const token = process.env.GITHUB_TOKEN;
   if (!token) {
@@ -36072,16 +36201,7 @@ async function createGitHubRelease(_ctx, options) {
   }
   const git = new Git;
   const remoteUrl = await git.repository();
-  const repositoryUrl = remoteUrl.replace(/^git@github\.com:/, "https://github.com/").replace(/\.git$/, "");
   const { owner, repo } = parseOwnerRepo(remoteUrl);
-  const previousTag = await git.previousTag(options.tag) || await git.firstCommit();
-  let body;
-  if (options.changelogBody) {
-    body = options.changelogBody;
-  } else {
-    const commits = (await git.commits(previousTag, options.tag)).slice(1);
-    body = formatReleaseNotes(commits, repositoryUrl, previousTag, options.tag);
-  }
   const createResponse = await fetch(`https://api.github.com/repos/${owner}/${repo}/releases`, {
     method: "POST",
     headers: {
@@ -36092,7 +36212,7 @@ async function createGitHubRelease(_ctx, options) {
     body: JSON.stringify({
       tag_name: options.tag,
       name: options.tag,
-      body,
+      body: options.body,
       draft: !!options.draft,
       prerelease: !!prerelease(options.version)
     })
@@ -36174,65 +36294,446 @@ async function deleteGitHubRelease(releaseId) {
   }
 }
 
-// src/tasks/runner-utils/version-pr.ts
+// src/tasks/release-notes.ts
 var import_node_fs13 = require("node:fs");
-var import_node_path22 = __toESM(require("node:path"));
-var import_node_process16 = __toESM(require("node:process"));
-init_error4();
-init_git();
-init_i18n();
+var import_node_path23 = require("node:path");
 
-// src/tasks/create-version-pr.ts
-init_error4();
-init_i18n();
-init_exec();
+// src/conventional-commit/types.ts
+var DEFAULT_TYPE_BUMP_MAP = {
+  feat: "minor",
+  fix: "patch",
+  perf: "patch",
+  chore: false,
+  docs: false,
+  test: false,
+  ci: false,
+  style: false,
+  refactor: false
+};
+var COMMIT_TYPE_CATEGORY_MAP = {
+  feat: "Features",
+  fix: "Bug Fixes",
+  perf: "Performance",
+  refactor: "Refactoring",
+  docs: "Documentation"
+};
+var DEFAULT_CATEGORY = "Other Changes";
 
-class VersionPrError extends AbstractError {
-  name = "Version PR Error";
-}
-async function createVersionPr(options) {
-  try {
-    return await createPrViaGhCli(options);
-  } catch {
-    return await createPrViaApi(options);
+// src/changelog/conventional-commit-writer.ts
+var CATEGORY_ORDER = [
+  "Features",
+  "Bug Fixes",
+  "Performance",
+  "Refactoring",
+  "Documentation",
+  "Other Changes"
+];
+
+class ConventionalCommitChangelogWriter {
+  formatEntries(entries) {
+    if (entries.length === 0)
+      return [];
+    const groups = new Map;
+    for (const entry of entries) {
+      const category = entry.type && COMMIT_TYPE_CATEGORY_MAP[entry.type] || DEFAULT_CATEGORY;
+      const hashSuffix = entry.hash ? ` (${entry.hash})` : "";
+      const item = `- ${entry.summary}${hashSuffix}`;
+      const existing = groups.get(category);
+      if (existing) {
+        existing.push(item);
+      } else {
+        groups.set(category, [item]);
+      }
+    }
+    const sections = [];
+    for (const category of CATEGORY_ORDER) {
+      const items = groups.get(category);
+      if (items)
+        sections.push({ category, items });
+    }
+    return sections;
   }
 }
-async function closeVersionPr(options) {
-  try {
-    await closePrViaGhCli(options);
-  } catch {
-    await closePrViaApi(options);
-  }
+
+// src/changeset/changelog-parser.ts
+function parseChangelogSection(changelog, version) {
+  const normalizedVersion = version.replace(/^v/, "");
+  const escapedVersion = normalizedVersion.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const headerPattern = new RegExp(`^## v?${escapedVersion}\\b[^\\n]*\\n`, "m");
+  const headerMatch = headerPattern.exec(changelog);
+  if (!headerMatch)
+    return null;
+  const start = headerMatch.index + headerMatch[0].length;
+  const nextHeader = changelog.indexOf(`
+## `, start);
+  const end = nextHeader === -1 ? changelog.length : nextHeader;
+  return changelog.slice(start, end).trim();
 }
-async function createPrViaGhCli(options) {
-  const args = [
-    "pr",
-    "create",
-    "--title",
-    options.title,
-    "--body",
-    options.body,
-    "--base",
-    options.base,
-    "--head",
-    options.branch
-  ];
-  if (options.labels && options.labels.length > 0) {
-    args.push("--label", options.labels.join(","));
+
+// src/conventional-commit/git-log.ts
+var import_node_child_process = require("node:child_process");
+var COMMIT_START_MARKER = "COMMIT_START";
+var COMMIT_FILES_MARKER = "COMMIT_FILES";
+function findLastReleaseRef(cwd, packageName) {
+  if (packageName) {
+    const scopedTags = execGit(cwd, [
+      "tag",
+      "--list",
+      `${packageName}@[0-9]*.[0-9]*.[0-9]*`,
+      "--sort=-v:refname"
+    ]);
+    if (scopedTags.length > 0)
+      return scopedTags[0];
   }
-  const { stdout } = await exec3("gh", args, { throwOnError: true });
-  const url = stdout.trim();
-  const numberMatch = url.match(/\/pull\/(\d+)/);
-  const number2 = numberMatch ? Number.parseInt(numberMatch[1], 10) : 0;
-  return { url, number: number2 };
+  const vTags = execGit(cwd, [
+    "tag",
+    "--list",
+    "v[0-9]*.[0-9]*.[0-9]*",
+    "--sort=-v:refname"
+  ]);
+  if (vTags.length > 0)
+    return vTags[0];
+  const versionCommit = execGit(cwd, [
+    "log",
+    "--format=%H",
+    "--grep=^Version Packages$",
+    "-1"
+  ]);
+  if (versionCommit.length > 0)
+    return versionCommit[0];
+  return;
 }
-async function createPrViaApi(options) {
-  const response = await fetch(`https://api.github.com/repos/${options.owner}/${options.repo}/pulls`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${options.token}`,
-      Accept: "application/vnd.github+json",
-      "X-GitHub-Api-Version": "2022-11-28"
+function getCommitsSinceRef(cwd, ref, toRef) {
+  const range = ref ? `${ref}..${toRef ?? "HEAD"}` : toRef ?? "HEAD";
+  const format3 = `${COMMIT_START_MARKER} %h%n%B%n${COMMIT_FILES_MARKER}`;
+  const output = execGitRaw(cwd, [
+    "log",
+    `--format=${format3}`,
+    "--name-only",
+    range
+  ]);
+  if (!output.trim())
+    return [];
+  const commits = [];
+  const lines = output.split(`
+`);
+  let i2 = 0;
+  while (i2 < lines.length) {
+    if (!lines[i2].startsWith(COMMIT_START_MARKER)) {
+      i2++;
+      continue;
+    }
+    const hash = lines[i2].slice(COMMIT_START_MARKER.length + 1).trim();
+    i2++;
+    const messageLines = [];
+    while (i2 < lines.length && !lines[i2].startsWith(COMMIT_FILES_MARKER)) {
+      if (lines[i2].startsWith(COMMIT_START_MARKER))
+        break;
+      messageLines.push(lines[i2]);
+      i2++;
+    }
+    if (i2 < lines.length && lines[i2].startsWith(COMMIT_FILES_MARKER)) {
+      i2++;
+    }
+    const files = [];
+    while (i2 < lines.length && !lines[i2].startsWith(COMMIT_START_MARKER)) {
+      const file = lines[i2].trim();
+      if (file)
+        files.push(file);
+      i2++;
+    }
+    const message = messageLines.join(`
+`).trim();
+    if (hash && message) {
+      commits.push({ hash, message, files });
+    }
+  }
+  return commits;
+}
+function execGit(cwd, args) {
+  return execGitRaw(cwd, args).split(`
+`).map((l3) => l3.trim()).filter(Boolean);
+}
+function execGitRaw(cwd, args) {
+  try {
+    return import_node_child_process.execFileSync("git", args, { cwd, encoding: "utf-8" });
+  } catch {
+    return "";
+  }
+}
+
+// src/conventional-commit/parser.ts
+var HEADER_REGEX = /^(\w+)(?:\(([^)]+)\))?(!)?\s*:\s*(.+)$/;
+var FOOTER_REGEX = /^([\w-]+|BREAKING CHANGE)\s*:\s*(.+)$/;
+function parseConventionalCommit(hash, message, files = []) {
+  const lines = message.split(`
+`);
+  const firstLine = lines[0];
+  const headerMatch = firstLine.match(HEADER_REGEX);
+  if (!headerMatch)
+    return null;
+  const [, type, scope, bang, description] = headerMatch;
+  let body;
+  const footers = new Map;
+  let breaking = bang === "!";
+  if (lines.length > 1) {
+    const rest = lines.slice(1);
+    let footerStartIndex = rest.length;
+    for (let i2 = rest.length - 1;i2 >= 0; i2--) {
+      if (rest[i2] === "") {
+        footerStartIndex = i2 + 1;
+        break;
+      }
+    }
+    const bodyStartIndex = rest.findIndex((line) => line !== "");
+    if (bodyStartIndex !== -1 && bodyStartIndex < footerStartIndex) {
+      const bodyLines = rest.slice(bodyStartIndex, footerStartIndex - 1);
+      const bodyText = bodyLines.join(`
+`).trim();
+      if (bodyText)
+        body = bodyText;
+    }
+    let currentFooterKey;
+    for (let i2 = footerStartIndex;i2 < rest.length; i2++) {
+      const footerMatch = rest[i2].match(FOOTER_REGEX);
+      if (footerMatch) {
+        const [, key, value] = footerMatch;
+        footers.set(key, value);
+        currentFooterKey = key;
+        if (key === "BREAKING CHANGE" || key === "BREAKING-CHANGE") {
+          breaking = true;
+        }
+      } else if (currentFooterKey && rest[i2].startsWith("  ")) {
+        const existing = footers.get(currentFooterKey) ?? "";
+        footers.set(currentFooterKey, `${existing}
+${rest[i2].trimStart()}`);
+      }
+    }
+  }
+  return { hash, type, scope, breaking, description, body, footers, files };
+}
+
+// src/conventional-commit/scope-resolver.ts
+var import_node_path22 = __toESM(require("node:path"));
+function resolveCommitPackages(commit, packagePaths) {
+  const matched = new Set;
+  if (commit.scope) {
+    for (const pkgPath of packagePaths) {
+      const dirName = import_node_path22.default.basename(pkgPath);
+      if (dirName === commit.scope) {
+        matched.add(pkgPath);
+      }
+    }
+    if (matched.size > 0)
+      return [...matched];
+  }
+  for (const file of commit.files) {
+    const normalized = file.replace(/\\/g, "/");
+    for (const pkgPath of packagePaths) {
+      if (pkgPath === ".") {
+        matched.add(pkgPath);
+        continue;
+      }
+      const normalizedPkg = pkgPath.replace(/\\/g, "/");
+      if (normalized.startsWith(`${normalizedPkg}/`) || normalized === normalizedPkg) {
+        matched.add(pkgPath);
+      }
+    }
+  }
+  return [...matched];
+}
+
+// src/tasks/release-notes.ts
+init_git();
+
+// src/utils/clipboard.ts
+var import_node_process16 = __toESM(require("node:process"));
+async function copyToClipboard(text) {
+  const commands = getClipboardCommands();
+  for (const cmd of commands) {
+    try {
+      const proc = Bun.spawn(cmd, {
+        stdin: "pipe",
+        stdout: "ignore",
+        stderr: "ignore"
+      });
+      proc.stdin.write(text);
+      proc.stdin.end();
+      const exitCode = await proc.exited;
+      if (exitCode === 0)
+        return true;
+    } catch {}
+  }
+  return false;
+}
+function getClipboardCommands() {
+  switch (import_node_process16.default.platform) {
+    case "darwin":
+      return [["pbcopy"]];
+    case "win32":
+      return [["clip"]];
+    default:
+      return [["xclip", "-selection", "clipboard"], ["wl-copy"]];
+  }
+}
+
+// src/tasks/release-notes.ts
+function renderReleaseNoteSections(sections) {
+  if (sections.length === 0)
+    return "";
+  const parts = [];
+  for (const section of sections) {
+    if (section.category) {
+      parts.push(`### ${section.category}
+
+${section.items.join(`
+`)}`);
+    } else {
+      parts.push(section.items.join(`
+`));
+    }
+  }
+  return parts.join(`
+
+`);
+}
+async function buildReleaseBody(ctx, options) {
+  const { pkgPath, version, tag, repositoryUrl } = options;
+  const appendCompareLink = options.appendCompareLink ?? true;
+  const git = new Git;
+  const previousTag = options.previousTag ?? (await git.previousTag(tag) || await git.firstCommit());
+  const compareLink = `**Full Changelog**: ${repositoryUrl}/compare/${previousTag}...${tag}`;
+  const changelogBody = extractChangelog(ctx, pkgPath, version);
+  if (changelogBody) {
+    return appendCompareLink ? `${changelogBody}
+
+${compareLink}` : changelogBody;
+  }
+  const commits = await git.commits(previousTag, tag);
+  if (commits.length === 0) {
+    return appendCompareLink ? compareLink : "";
+  }
+  const rawCommits = getCommitsSinceRef(ctx.cwd, previousTag, tag);
+  const parsed = rawCommits.map((c2) => parseConventionalCommit(c2.hash, c2.message, c2.files)).filter((c2) => c2 !== null);
+  const filtered = pkgPath ? parsed.filter((c2) => {
+    const packages = resolveCommitPackages(c2, [pkgPath]);
+    return packages.length > 0;
+  }) : parsed;
+  if (filtered.length > 0) {
+    const entries = filtered.map((c2) => ({
+      summary: c2.description,
+      type: c2.type,
+      hash: c2.hash.slice(0, 7)
+    }));
+    const writer = new ConventionalCommitChangelogWriter;
+    const sections = writer.formatEntries(entries);
+    const body2 = renderReleaseNoteSections(sections);
+    return appendCompareLink ? `${body2}
+
+${compareLink}` : body2;
+  }
+  const lines = commits.map(({ id, message }) => `- ${message} (${id.slice(0, 7)})`);
+  const body = lines.join(`
+`);
+  return appendCompareLink ? `${body}
+
+${compareLink}` : body;
+}
+function extractChangelog(ctx, pkgPath, version) {
+  const changelogPath = pkgPath ? import_node_path23.join(ctx.cwd, pkgPath, "CHANGELOG.md") : import_node_path23.join(ctx.cwd, "CHANGELOG.md");
+  if (!import_node_fs13.existsSync(changelogPath))
+    return null;
+  return parseChangelogSection(import_node_fs13.readFileSync(changelogPath, "utf-8"), version);
+}
+var MAX_URL_LENGTH = 8000;
+async function truncateForUrl(body, baseUrl) {
+  const testUrl = `${baseUrl}${encodeURIComponent(body)}`;
+  if (testUrl.length <= MAX_URL_LENGTH) {
+    return { body, truncated: false, clipboardCopied: false };
+  }
+  const clipboardCopied = await copyToClipboard(body);
+  const suffix = clipboardCopied ? `
+
+... (truncated, full notes copied to clipboard)` : `
+
+... (truncated)`;
+  const availableLength = MAX_URL_LENGTH - baseUrl.length - encodeURIComponent(suffix).length;
+  let lo = 0;
+  let hi = body.length;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (encodeURIComponent(body.slice(0, mid)).length <= availableLength) {
+      lo = mid;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return {
+    body: body.slice(0, lo) + suffix,
+    truncated: true,
+    clipboardCopied
+  };
+}
+
+// src/tasks/runner-utils/version-pr.ts
+var import_node_fs14 = require("node:fs");
+var import_node_path24 = __toESM(require("node:path"));
+var import_node_process17 = __toESM(require("node:process"));
+init_error4();
+init_git();
+init_i18n();
+
+// src/tasks/create-version-pr.ts
+init_error4();
+init_i18n();
+init_exec();
+
+class VersionPrError extends AbstractError {
+  name = "Version PR Error";
+}
+async function createVersionPr(options) {
+  try {
+    return await createPrViaGhCli(options);
+  } catch {
+    return await createPrViaApi(options);
+  }
+}
+async function closeVersionPr(options) {
+  try {
+    await closePrViaGhCli(options);
+  } catch {
+    await closePrViaApi(options);
+  }
+}
+async function createPrViaGhCli(options) {
+  const args = [
+    "pr",
+    "create",
+    "--title",
+    options.title,
+    "--body",
+    options.body,
+    "--base",
+    options.base,
+    "--head",
+    options.branch
+  ];
+  if (options.labels && options.labels.length > 0) {
+    args.push("--label", options.labels.join(","));
+  }
+  const { stdout } = await exec3("gh", args, { throwOnError: true });
+  const url = stdout.trim();
+  const numberMatch = url.match(/\/pull\/(\d+)/);
+  const number2 = numberMatch ? Number.parseInt(numberMatch[1], 10) : 0;
+  return { url, number: number2 };
+}
+async function createPrViaApi(options) {
+  const response = await fetch(`https://api.github.com/repos/${options.owner}/${options.repo}/pulls`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${options.token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28"
     },
     body: JSON.stringify({
       title: options.title,
@@ -36329,7 +36830,7 @@ async function pushViaPr(ctx, git, task) {
   const prBody = buildPrBodyFromContext(ctx, plan);
   const remoteUrl = await git.repository();
   const { owner, repo } = parseOwnerRepo(remoteUrl);
-  const token = import_node_process16.default.env.GITHUB_TOKEN;
+  const token = import_node_process17.default.env.GITHUB_TOKEN;
   if (!token) {
     throw new AbstractError(t("error.githubRelease.tokenRequired"));
   }
@@ -36361,10 +36862,10 @@ function buildPrBodyFromContext(ctx, plan) {
       const pkgConfig = ctx.config.packages.find((p2) => p2.path === pkgPath);
       const name = pkgConfig?.name ?? pkgPath;
       packages.push({ name, version: pkgVersion, bump: "" });
-      const changelogDir = pkgConfig ? import_node_path22.default.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
-      const changelogPath = import_node_path22.default.join(changelogDir, "CHANGELOG.md");
-      if (import_node_fs13.existsSync(changelogPath)) {
-        const section = parseChangelogSection(import_node_fs13.readFileSync(changelogPath, "utf-8"), pkgVersion);
+      const changelogDir = pkgConfig ? import_node_path24.default.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
+      const changelogPath = import_node_path24.default.join(changelogDir, "CHANGELOG.md");
+      if (import_node_fs14.existsSync(changelogPath)) {
+        const section = parseChangelogSection(import_node_fs14.readFileSync(changelogPath, "utf-8"), pkgVersion);
         if (section)
           changelogs.set(name, section);
       }
@@ -36375,17 +36876,17 @@ function buildPrBodyFromContext(ctx, plan) {
       packages.push({ name: pkg.name, version, bump: "" });
     }
     if (plan.mode === "single") {
-      const changelogPath = import_node_path22.default.join(ctx.cwd, "CHANGELOG.md");
-      if (import_node_fs13.existsSync(changelogPath)) {
-        const section = parseChangelogSection(import_node_fs13.readFileSync(changelogPath, "utf-8"), version);
+      const changelogPath = import_node_path24.default.join(ctx.cwd, "CHANGELOG.md");
+      if (import_node_fs14.existsSync(changelogPath)) {
+        const section = parseChangelogSection(import_node_fs14.readFileSync(changelogPath, "utf-8"), version);
         if (section)
           changelogs.set(packages[0]?.name ?? "", section);
       }
     } else {
       for (const pkg of ctx.config.packages) {
-        const changelogPath = import_node_path22.default.join(ctx.cwd, pkg.path, "CHANGELOG.md");
-        if (import_node_fs13.existsSync(changelogPath)) {
-          const section = parseChangelogSection(import_node_fs13.readFileSync(changelogPath, "utf-8"), version);
+        const changelogPath = import_node_path24.default.join(ctx.cwd, pkg.path, "CHANGELOG.md");
+        if (import_node_fs14.existsSync(changelogPath)) {
+          const section = parseChangelogSection(import_node_fs14.readFileSync(changelogPath, "utf-8"), version);
           if (section)
             changelogs.set(pkg.name, section);
         }
@@ -36443,7 +36944,7 @@ function createReleaseTask(hasPublish, dryRun, mode, skipReleaseDraft) {
       const tokenResult = resolveGitHubToken();
       let hasToken = !!tokenResult;
       if (tokenResult) {
-        import_node_process17.default.env.GITHUB_TOKEN = tokenResult.token;
+        import_node_process18.default.env.GITHUB_TOKEN = tokenResult.token;
       } else if (mode !== "ci") {
         const answer = await task.prompt(ListrEnquirerPromptAdapter).run({
           type: "select",
@@ -36463,7 +36964,7 @@ function createReleaseTask(hasPublish, dryRun, mode, skipReleaseDraft) {
             message: t("task.release.tokenPrompt")
           });
           if (token) {
-            import_node_process17.default.env.GITHUB_TOKEN = token;
+            import_node_process18.default.env.GITHUB_TOKEN = token;
             saveGitHubToken(token);
             hasToken = true;
           }
@@ -36483,22 +36984,20 @@ function createReleaseTask(hasPublish, dryRun, mode, skipReleaseDraft) {
             const pkgName = getPackageName(ctx, pkgPath);
             const tag = `${pkgName}@${pkgVersion}`;
             task.output = t("task.release.creating", { tag });
-            let changelogBody;
-            const pkgConfig = ctx.config.packages.find((p2) => p2.path === pkgPath);
-            if (pkgConfig) {
-              const changelogPath = import_node_path23.join(ctx.cwd, pkgConfig.path, "CHANGELOG.md");
-              if (import_node_fs14.existsSync(changelogPath)) {
-                const section = parseChangelogSection(import_node_fs14.readFileSync(changelogPath, "utf-8"), pkgVersion);
-                if (section)
-                  changelogBody = section;
-              }
-            }
+            const git = new Git;
+            const repositoryUrl = (await git.repository()).replace(/^git@github\.com:/, "https://github.com/").replace(/\.git$/, "");
+            const body = await buildReleaseBody(ctx, {
+              pkgPath,
+              version: pkgVersion,
+              tag,
+              repositoryUrl
+            });
             const { assets: preparedAssets, tempDir } = await prepareReleaseAssets(ctx, pkgName, pkgVersion, pkgPath);
             const result = await createGitHubRelease(ctx, {
               displayLabel: pkgName,
               version: pkgVersion,
               tag,
-              changelogBody,
+              body,
               assets: preparedAssets,
               draft: !!ctx.options.releaseDraft
             });
@@ -36530,45 +37029,20 @@ function createReleaseTask(hasPublish, dryRun, mode, skipReleaseDraft) {
               task.output = t("task.release.alreadyExists", { tag });
             }
             if (tempDir)
-              import_node_fs14.rmSync(tempDir, { recursive: true, force: true });
+              import_node_fs15.rmSync(tempDir, { recursive: true, force: true });
           }
         } else {
           const version = plan.version;
           const tag = `v${version}`;
           task.output = t("task.release.creating", { tag });
-          let changelogBody;
-          if (plan.mode === "fixed") {
-            const sections = [];
-            for (const [pkgPath2, pkgVersion] of plan.packages) {
-              const pkgName = getPackageName(ctx, pkgPath2);
-              const pkgConfig = ctx.config.packages.find((p2) => p2.path === pkgPath2);
-              if (!pkgConfig)
-                continue;
-              const changelogPath = import_node_path23.join(ctx.cwd, pkgConfig.path, "CHANGELOG.md");
-              if (import_node_fs14.existsSync(changelogPath)) {
-                const section = parseChangelogSection(import_node_fs14.readFileSync(changelogPath, "utf-8"), pkgVersion);
-                if (section) {
-                  sections.push(`## ${pkgName} v${pkgVersion}
-
-${section}`);
-                }
-              }
-            }
-            if (sections.length > 0) {
-              changelogBody = sections.join(`
-
----
-
-`);
-            }
-          } else {
-            const changelogPath = import_node_path23.join(ctx.cwd, "CHANGELOG.md");
-            if (import_node_fs14.existsSync(changelogPath)) {
-              const section = parseChangelogSection(import_node_fs14.readFileSync(changelogPath, "utf-8"), version);
-              if (section)
-                changelogBody = section;
-            }
-          }
+          const git = new Git;
+          const repositoryUrl = (await git.repository()).replace(/^git@github\.com:/, "https://github.com/").replace(/\.git$/, "");
+          const body = await buildReleaseBody(ctx, {
+            pkgPath: plan.mode === "single" ? plan.packagePath : undefined,
+            version,
+            tag,
+            repositoryUrl
+          });
           const packageName = plan.mode === "single" ? getPackageName(ctx, plan.packagePath) : ctx.config.packages[0]?.name ?? "";
           const pkgPath = plan.mode === "single" ? plan.packagePath : ctx.config.packages[0]?.path;
           const { assets: preparedAssets, tempDir } = await prepareReleaseAssets(ctx, packageName, version, pkgPath);
@@ -36576,7 +37050,7 @@ ${section}`);
             displayLabel: packageName,
             version,
             tag,
-            changelogBody,
+            body,
             assets: preparedAssets,
             draft: !!ctx.options.releaseDraft
           });
@@ -36606,7 +37080,7 @@ ${section}`);
             task.output = t("task.release.alreadyExists", { tag });
           }
           if (tempDir)
-            import_node_fs14.rmSync(tempDir, { recursive: true, force: true });
+            import_node_fs15.rmSync(tempDir, { recursive: true, force: true });
         }
       } else {
         const git = new Git;
@@ -36622,21 +37096,31 @@ ${section}`);
               continue;
             const pkgName = getPackageName(ctx, pkgPath);
             const tag = `${pkgName}@${pkgVersion}`;
-            const lastRev = await git.previousTag(tag) || await git.firstCommit();
-            const commits = (await git.commits(lastRev, tag)).slice(1);
-            let body = commits.map(({ id, message }) => `- ${message.replace(/#/g, `${repositoryUrl}/issues/`)} ${repositoryUrl}/commit/${id}`).join(`
-`);
-            body += `
-
-${repositoryUrl}/compare/${lastRev}...${tag}`;
+            const body = await buildReleaseBody(ctx, {
+              pkgPath,
+              version: pkgVersion,
+              tag,
+              repositoryUrl
+            });
             const releaseDraftUrl = new URL(`${repositoryUrl}/releases/new`);
             releaseDraftUrl.searchParams.set("tag", tag);
-            releaseDraftUrl.searchParams.set("body", body);
             releaseDraftUrl.searchParams.set("prerelease", `${!!prerelease2(pkgVersion)}`);
+            const baseUrl = `${releaseDraftUrl.toString()}&body=`;
+            const truncated = await truncateForUrl(body, baseUrl);
+            releaseDraftUrl.searchParams.set("body", truncated.body);
             const linkUrl = ui.link(tag, releaseDraftUrl.toString());
             task.title += ` ${linkUrl}`;
             if (first) {
-              task.output = t("task.release.openingDraft", { tag });
+              const openingMsg = t("task.release.openingDraft", { tag });
+              if (truncated.clipboardCopied) {
+                task.output = `${t("task.release.copiedToClipboard")}
+${openingMsg}`;
+              } else if (truncated.truncated) {
+                task.output = `${t("task.release.truncated")}
+${openingMsg}`;
+              } else {
+                task.output = openingMsg;
+              }
               await openUrl(releaseDraftUrl.toString());
               first = false;
             }
@@ -36644,24 +37128,30 @@ ${repositoryUrl}/compare/${lastRev}...${tag}`;
         } else {
           const version = plan.version;
           const tag = `v${version}`;
-          const lastRev = await git.previousTag(tag) || await git.firstCommit();
-          const commits = (await git.commits(lastRev, tag)).slice(1);
-          task.output = t("task.release.collectedCommits", {
-            count: commits.length,
-            tag
+          const body = await buildReleaseBody(ctx, {
+            pkgPath: plan.mode === "single" ? plan.packagePath : undefined,
+            version,
+            tag,
+            repositoryUrl
           });
-          let body = commits.map(({ id, message }) => `- ${message.replace(/#/g, `${repositoryUrl}/issues/`)} ${repositoryUrl}/commit/${id}`).join(`
-`);
-          body += `
-
-${repositoryUrl}/compare/${lastRev}...${tag}`;
           const releaseDraftUrl = new URL(`${repositoryUrl}/releases/new`);
           releaseDraftUrl.searchParams.set("tag", tag);
-          releaseDraftUrl.searchParams.set("body", body);
           releaseDraftUrl.searchParams.set("prerelease", `${!!prerelease2(version)}`);
+          const baseUrl = `${releaseDraftUrl.toString()}&body=`;
+          const truncated = await truncateForUrl(body, baseUrl);
+          releaseDraftUrl.searchParams.set("body", truncated.body);
           const linkUrl = ui.link("Link", releaseDraftUrl.toString());
           task.title += ` ${linkUrl}`;
-          task.output = t("task.release.openingDraft", { tag });
+          const openingMsg = t("task.release.openingDraft", { tag });
+          if (truncated.clipboardCopied) {
+            task.output = `${t("task.release.copiedToClipboard")}
+${openingMsg}`;
+          } else if (truncated.truncated) {
+            task.output = `${t("task.release.truncated")}
+${openingMsg}`;
+          } else {
+            task.output = openingMsg;
+          }
           await openUrl(releaseDraftUrl.toString());
         }
       }
@@ -36673,7 +37163,7 @@ ${repositoryUrl}/compare/${lastRev}...${tag}`;
 init_catalog2();
 init_error4();
 init_i18n();
-var import_node_path24 = __toESM(require("node:path"));
+var import_node_path25 = __toESM(require("node:path"));
 init_exec();
 var JS_WORKSPACE_TYPES = new Set(["pnpm", "npm", "yarn", "bun", "deno"]);
 var ECOSYSTEM_DEFAULTS = {
@@ -36758,7 +37248,7 @@ async function resolveExecutions(ctx, type) {
           });
         } else {
           for (const pkg of group.groupPackages) {
-            const pkgCwd = import_node_path24.default.resolve(ctx.cwd, pkg.path);
+            const pkgCwd = import_node_path25.default.resolve(ctx.cwd, pkg.path);
             executions.push({
               label: `${resolved.command} (${pkg.path})`,
               cmd: "sh",
@@ -36779,7 +37269,7 @@ async function resolveExecutions(ctx, type) {
           });
         } else {
           for (const pkg of group.groupPackages) {
-            const pkgCwd = import_node_path24.default.resolve(ctx.cwd, pkg.path);
+            const pkgCwd = import_node_path25.default.resolve(ctx.cwd, pkg.path);
             const instance = new descriptor.ecosystemClass(pkgCwd);
             const { cmd, args } = type === "test" ? await instance.resolveTestCommand(resolved.script) : await instance.resolveBuildCommand(resolved.script);
             executions.push({
@@ -36793,7 +37283,7 @@ async function resolveExecutions(ctx, type) {
       }
     }
     for (const pkg of group.individualPackages) {
-      const pkgCwd = import_node_path24.default.resolve(ctx.cwd, pkg.path);
+      const pkgCwd = import_node_path25.default.resolve(ctx.cwd, pkg.path);
       const resolved = resolveScript(pkg, group.ecosystemKey, ctx, type);
       if (resolved.command) {
         executions.push({
@@ -36891,16 +37381,16 @@ function createBuildTask(hasPrepare, skipBuild) {
 
 // src/tasks/phases/version.ts
 init_dist2();
-var import_node_path27 = __toESM(require("node:path"));
+var import_node_path28 = __toESM(require("node:path"));
 
 // src/changelog/file.ts
-var import_node_fs15 = require("node:fs");
-var import_node_path25 = __toESM(require("node:path"));
+var import_node_fs16 = require("node:fs");
+var import_node_path26 = __toESM(require("node:path"));
 function writeChangelogToFile(cwd, newContent) {
-  const changelogPath = import_node_path25.default.join(cwd, "CHANGELOG.md");
+  const changelogPath = import_node_path26.default.join(cwd, "CHANGELOG.md");
   let existing = "";
-  if (import_node_fs15.existsSync(changelogPath)) {
-    existing = import_node_fs15.readFileSync(changelogPath, "utf-8");
+  if (import_node_fs16.existsSync(changelogPath)) {
+    existing = import_node_fs16.readFileSync(changelogPath, "utf-8");
   }
   const header = `# Changelog
 
@@ -36909,7 +37399,7 @@ function writeChangelogToFile(cwd, newContent) {
 
 `);
   const body = existing.startsWith("# Changelog") && doubleNewline !== -1 ? existing.slice(doubleNewline + 2) : existing;
-  import_node_fs15.writeFileSync(changelogPath, `${header}${newContent}
+  import_node_fs16.writeFileSync(changelogPath, `${header}${newContent}
 ${body}`, "utf-8");
 }
 
@@ -36944,6 +37434,21 @@ function generateChangelog(version, entries, depUpdates) {
 `)}
 `;
 }
+var BUMP_PRIORITY = {
+  major: 3,
+  minor: 2,
+  patch: 1
+};
+function deduplicateEntries(entries) {
+  const map = new Map;
+  for (const entry of entries) {
+    const existing = map.get(entry.id);
+    if (!existing || (BUMP_PRIORITY[entry.type] ?? 0) > (BUMP_PRIORITY[existing.type] ?? 0)) {
+      map.set(entry.id, entry);
+    }
+  }
+  return [...map.values()];
+}
 function buildChangelogEntries(changesets, packagePath) {
   const entries = [];
   for (const changeset of changesets) {
@@ -36961,9 +37466,9 @@ function buildChangelogEntries(changesets, packagePath) {
 }
 
 // src/changeset/reader.ts
-var import_node_fs16 = require("node:fs");
-var import_node_path26 = __toESM(require("node:path"));
-var import_node_process18 = __toESM(require("node:process"));
+var import_node_fs17 = require("node:fs");
+var import_node_path27 = __toESM(require("node:path"));
+var import_node_process19 = __toESM(require("node:process"));
 
 // src/changeset/parser.ts
 var import_yaml2 = __toESM(require_dist(), 1);
@@ -36983,8 +37488,8 @@ function parseChangeset(content, fileName, resolveKey) {
       if (!VALID_BUMP_TYPES.has(type)) {
         throw new Error(`Invalid bump type "${type}" for package "${key}" in "${fileName}". Expected: patch, minor, or major.`);
       }
-      const path16 = resolveKey ? resolveKey(key) : key;
-      releases.push({ path: path16, type });
+      const path17 = resolveKey ? resolveKey(key) : key;
+      releases.push({ path: path17, type });
     }
   }
   const id = fileName.replace(/\.md$/, "");
@@ -36996,29 +37501,29 @@ function parseChangeset(content, fileName, resolveKey) {
 }
 
 // src/changeset/reader.ts
-function readChangesets(cwd = import_node_process18.default.cwd(), resolveKey) {
-  const changesetsDir = import_node_path26.default.join(cwd, ".pubm", "changesets");
-  if (!import_node_fs16.existsSync(changesetsDir)) {
+function readChangesets(cwd = import_node_process19.default.cwd(), resolveKey) {
+  const changesetsDir = import_node_path27.default.join(cwd, ".pubm", "changesets");
+  if (!import_node_fs17.existsSync(changesetsDir)) {
     return [];
   }
-  const files = import_node_fs16.readdirSync(changesetsDir);
+  const files = import_node_fs17.readdirSync(changesetsDir);
   const changesets = [];
   for (const file of files) {
     if (!file.endsWith(".md") || file === "README.md") {
       continue;
     }
-    const filePath = import_node_path26.default.join(changesetsDir, file);
-    const content = import_node_fs16.readFileSync(filePath, "utf-8");
+    const filePath = import_node_path27.default.join(changesetsDir, file);
+    const content = import_node_fs17.readFileSync(filePath, "utf-8");
     changesets.push(parseChangeset(content, file, resolveKey));
   }
   return changesets;
 }
 function deleteChangesetFiles(cwd, changesets) {
-  const changesetsDir = import_node_path26.default.join(cwd, ".pubm", "changesets");
+  const changesetsDir = import_node_path27.default.join(cwd, ".pubm", "changesets");
   for (const changeset of changesets) {
-    const filePath = import_node_path26.default.join(changesetsDir, `${changeset.id}.md`);
-    if (import_node_fs16.existsSync(filePath)) {
-      import_node_fs16.rmSync(filePath);
+    const filePath = import_node_path27.default.join(changesetsDir, `${changeset.id}.md`);
+    if (import_node_fs17.existsSync(filePath)) {
+      import_node_fs17.rmSync(filePath);
     }
   }
 }
@@ -37073,7 +37578,7 @@ function createVersionTask(hasPrepare, dryRun) {
           const changesets = readChangesets(ctx.cwd, resolver);
           if (changesets.length > 0) {
             registerChangesetBackups(ctx, changesets);
-            const changelogPath = import_node_path27.default.join(ctx.cwd, "CHANGELOG.md");
+            const changelogPath = import_node_path28.default.join(ctx.cwd, "CHANGELOG.md");
             registerChangelogBackup(ctx, changelogPath);
             const pkgPath = ctx.config.packages[0]?.path ?? "";
             const entries = buildChangelogEntries(changesets, pkgPath);
@@ -37130,9 +37635,9 @@ ${ctx.config.packages.map((pkg) => `- ${pkg.name}: ${plan.version}`).join(`
           const changesets = readChangesets(ctx.cwd, resolver);
           if (changesets.length > 0) {
             registerChangesetBackups(ctx, changesets);
-            const changelogPath = import_node_path27.default.join(ctx.cwd, "CHANGELOG.md");
+            const changelogPath = import_node_path28.default.join(ctx.cwd, "CHANGELOG.md");
             registerChangelogBackup(ctx, changelogPath);
-            const allEntries = [...plan.packages.keys()].flatMap((pkgPath) => buildChangelogEntries(changesets, pkgPath));
+            const allEntries = deduplicateEntries([...plan.packages.keys()].flatMap((pkgPath) => buildChangelogEntries(changesets, pkgPath)));
             if (allEntries.length > 0) {
               const changelogContent = generateChangelog(plan.version, allEntries);
               writeChangelogToFile(ctx.cwd, changelogContent);
@@ -37190,15 +37695,15 @@ ${[...plan.packages].map(([pkgPath]) => `- ${getPackageName(ctx, pkgPath)}: ${pl
             registerChangesetBackups(ctx, changesets);
             for (const [pkgPath] of plan.packages) {
               const pkgConfig = ctx.config.packages.find((p2) => p2.path === pkgPath);
-              const changelogDir = pkgConfig ? import_node_path27.default.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
-              const changelogPath = import_node_path27.default.join(changelogDir, "CHANGELOG.md");
+              const changelogDir = pkgConfig ? import_node_path28.default.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
+              const changelogPath = import_node_path28.default.join(changelogDir, "CHANGELOG.md");
               registerChangelogBackup(ctx, changelogPath);
             }
             for (const [pkgPath, pkgVersion] of plan.packages) {
               const entries = buildChangelogEntries(changesets, pkgPath);
               if (entries.length > 0) {
                 const pkgConfig = ctx.config.packages.find((p2) => p2.path === pkgPath);
-                const changelogDir = pkgConfig ? import_node_path27.default.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
+                const changelogDir = pkgConfig ? import_node_path28.default.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
                 writeChangelogToFile(changelogDir, generateChangelog(pkgVersion, entries));
               }
             }
@@ -37261,7 +37766,7 @@ function chainCleanup(existing, next) {
   };
 }
 async function run(ctx) {
-  ctx.runtime.promptEnabled = !m && import_node_process19.default.stdin.isTTY;
+  ctx.runtime.promptEnabled = !m && import_node_process20.default.stdin.isTTY;
   const mode = ctx.options.mode ?? "local";
   const phases = resolvePhases(ctx.options);
   const dryRun = !!ctx.options.dryRun;
@@ -37276,12 +37781,12 @@ async function run(ctx) {
       interactive: false,
       sigint: true
     });
-    import_node_process19.default.exit(130);
+    import_node_process20.default.exit(130);
   };
-  import_node_process19.default.on("SIGINT", onSigint);
+  import_node_process20.default.on("SIGINT", onSigint);
   try {
     if (ctx.options.contents)
-      import_node_process19.default.chdir(ctx.options.contents);
+      import_node_process20.default.chdir(ctx.options.contents);
     if (mode === "ci" && hasPrepare)
       await runCiPreparePreflight(ctx, chainCleanup, cleanupRef);
     if (mode === "local" && hasPrepare)
@@ -37309,7 +37814,7 @@ async function run(ctx) {
         parts.push(`${ui.chalk.bold(name)} on ${descriptor.label}`);
       }
     }
-    import_node_process19.default.removeListener("SIGINT", onSigint);
+    import_node_process20.default.removeListener("SIGINT", onSigint);
     if (mode === "ci" && hasPrepare && !hasPublish) {
       cleanupRef.current?.();
       console.log(`
@@ -37329,14 +37834,14 @@ async function run(ctx) {
     }
     await ctx.runtime.pluginRunner.runHook("onSuccess", ctx);
   } catch (e3) {
-    import_node_process19.default.removeListener("SIGINT", onSigint);
+    import_node_process20.default.removeListener("SIGINT", onSigint);
     cleanupRef.current?.();
     await ctx.runtime.pluginRunner.runErrorHook(ctx, e3);
     consoleError(e3);
     await ctx.runtime.rollback.execute(ctx, {
       interactive: ctx.runtime.promptEnabled
     });
-    import_node_process19.default.exit(1);
+    import_node_process20.default.exit(1);
   }
 }
 
@@ -37352,62 +37857,6 @@ class ChangesetChangelogWriter {
     ];
   }
 }
-// src/conventional-commit/types.ts
-var DEFAULT_TYPE_BUMP_MAP = {
-  feat: "minor",
-  fix: "patch",
-  perf: "patch",
-  chore: false,
-  docs: false,
-  test: false,
-  ci: false,
-  style: false,
-  refactor: false
-};
-var COMMIT_TYPE_CATEGORY_MAP = {
-  feat: "Features",
-  fix: "Bug Fixes",
-  perf: "Performance",
-  refactor: "Refactoring",
-  docs: "Documentation"
-};
-var DEFAULT_CATEGORY = "Other Changes";
-
-// src/changelog/conventional-commit-writer.ts
-var CATEGORY_ORDER = [
-  "Features",
-  "Bug Fixes",
-  "Performance",
-  "Refactoring",
-  "Documentation",
-  "Other Changes"
-];
-
-class ConventionalCommitChangelogWriter {
-  formatEntries(entries) {
-    if (entries.length === 0)
-      return [];
-    const groups = new Map;
-    for (const entry of entries) {
-      const category = entry.type && COMMIT_TYPE_CATEGORY_MAP[entry.type] || DEFAULT_CATEGORY;
-      const hashSuffix = entry.hash ? ` (${entry.hash})` : "";
-      const item = `- ${entry.summary}${hashSuffix}`;
-      const existing = groups.get(category);
-      if (existing) {
-        existing.push(item);
-      } else {
-        groups.set(category, [item]);
-      }
-    }
-    const sections = [];
-    for (const category of CATEGORY_ORDER) {
-      const items = groups.get(category);
-      if (items)
-        sections.push({ category, items });
-    }
-    return sections;
-  }
-}
 // src/changelog/renderer.ts
 var BUMP_HEADINGS = {
   major: "Major Changes",
@@ -37449,13 +37898,13 @@ function maxBump(a3, b2) {
   return BUMP_ORDER2[a3] >= BUMP_ORDER2[b2] ? a3 : b2;
 }
 // src/changeset/migrate.ts
-var import_node_fs17 = require("node:fs");
-var import_node_path28 = __toESM(require("node:path"));
-var import_node_process20 = __toESM(require("node:process"));
+var import_node_fs18 = require("node:fs");
+var import_node_path29 = __toESM(require("node:path"));
+var import_node_process21 = __toESM(require("node:process"));
 var SKIPPED_FILES = new Set(["config.json", "README.md"]);
-function migrateFromChangesets(cwd = import_node_process20.default.cwd()) {
-  const changesetDir = import_node_path28.default.join(cwd, ".changeset");
-  if (!import_node_fs17.existsSync(changesetDir)) {
+function migrateFromChangesets(cwd = import_node_process21.default.cwd()) {
+  const changesetDir = import_node_path29.default.join(cwd, ".changeset");
+  if (!import_node_fs18.existsSync(changesetDir)) {
     return {
       success: false,
       error: ".changeset/ directory not found",
@@ -37463,9 +37912,9 @@ function migrateFromChangesets(cwd = import_node_process20.default.cwd()) {
       configMigrated: false
     };
   }
-  const pubmDir = import_node_path28.default.join(cwd, ".pubm", "changesets");
-  import_node_fs17.mkdirSync(pubmDir, { recursive: true });
-  const files = import_node_fs17.readdirSync(changesetDir);
+  const pubmDir = import_node_path29.default.join(cwd, ".pubm", "changesets");
+  import_node_fs18.mkdirSync(pubmDir, { recursive: true });
+  const files = import_node_fs18.readdirSync(changesetDir);
   const migratedFiles = [];
   let configMigrated = false;
   for (const file of files) {
@@ -37477,14 +37926,14 @@ function migrateFromChangesets(cwd = import_node_process20.default.cwd()) {
       continue;
     }
     if (file === "pre.json") {
-      import_node_fs17.copyFileSync(import_node_path28.default.join(changesetDir, file), import_node_path28.default.resolve(cwd, ".pubm", "pre.json"));
+      import_node_fs18.copyFileSync(import_node_path29.default.join(changesetDir, file), import_node_path29.default.resolve(cwd, ".pubm", "pre.json"));
       migratedFiles.push(file);
       continue;
     }
     if (file.endsWith(".md")) {
-      const src = import_node_path28.default.join(changesetDir, file);
-      const dest = import_node_path28.default.join(pubmDir, file);
-      import_node_fs17.copyFileSync(src, dest);
+      const src = import_node_path29.default.join(changesetDir, file);
+      const dest = import_node_path29.default.join(pubmDir, file);
+      import_node_fs18.copyFileSync(src, dest);
       migratedFiles.push(file);
     }
   }
@@ -37495,8 +37944,8 @@ function migrateFromChangesets(cwd = import_node_process20.default.cwd()) {
   };
 }
 // src/changeset/status.ts
-var import_node_process21 = __toESM(require("node:process"));
-function getStatus(cwd = import_node_process21.default.cwd(), resolveKey) {
+var import_node_process22 = __toESM(require("node:process"));
+function getStatus(cwd = import_node_process22.default.cwd(), resolveKey) {
   const changesets = readChangesets(cwd, resolveKey);
   const packages = new Map;
   for (const changeset of changesets) {
@@ -37522,9 +37971,9 @@ function getStatus(cwd = import_node_process21.default.cwd(), resolveKey) {
   };
 }
 // src/changeset/version.ts
-var import_node_process22 = __toESM(require("node:process"));
+var import_node_process23 = __toESM(require("node:process"));
 var import_semver5 = __toESM(require_semver2(), 1);
-function calculateVersionBumps(currentVersions, cwd = import_node_process22.default.cwd(), resolveKey) {
+function calculateVersionBumps(currentVersions, cwd = import_node_process23.default.cwd(), resolveKey) {
   const changesets = readChangesets(cwd, resolveKey);
   const bumpTypes = new Map;
   for (const changeset of changesets) {
@@ -37556,9 +38005,9 @@ function calculateVersionBumps(currentVersions, cwd = import_node_process22.defa
   return result;
 }
 // src/changeset/writer.ts
-var import_node_fs18 = require("node:fs");
-var import_node_path29 = __toESM(require("node:path"));
-var import_node_process23 = __toESM(require("node:process"));
+var import_node_fs19 = require("node:fs");
+var import_node_path30 = __toESM(require("node:path"));
+var import_node_process24 = __toESM(require("node:process"));
 var import_yaml3 = __toESM(require_dist(), 1);
 var adjectives = [
   "brave",
@@ -37653,20 +38102,20 @@ ${summary}
   }
   return content;
 }
-function writeChangeset(releases, summary, cwd = import_node_process23.default.cwd()) {
-  const changesetsDir = import_node_path29.default.join(cwd, ".pubm", "changesets");
-  import_node_fs18.mkdirSync(changesetsDir, { recursive: true });
+function writeChangeset(releases, summary, cwd = import_node_process24.default.cwd()) {
+  const changesetsDir = import_node_path30.default.join(cwd, ".pubm", "changesets");
+  import_node_fs19.mkdirSync(changesetsDir, { recursive: true });
   const id = generateChangesetId();
   const fileName = `${id}.md`;
-  const filePath = import_node_path29.default.join(changesetsDir, fileName);
+  const filePath = import_node_path30.default.join(changesetsDir, fileName);
   const content = generateChangesetContent(releases, summary);
-  import_node_fs18.writeFileSync(filePath, content, "utf-8");
+  import_node_fs19.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
 // src/config/defaults.ts
 init_catalog2();
 init_i18n();
-var import_node_path30 = __toESM(require("node:path"));
+var import_node_path31 = __toESM(require("node:path"));
 var import_micromatch4 = __toESM(require_micromatch(), 1);
 init_catalog();
 var defaultValidate = {
@@ -37751,7 +38200,7 @@ async function resolveConfig(config, cwd) {
         if (import_micromatch4.default.scan(normalized).isGlob) {
           return import_micromatch4.default.isMatch(pkgPathForward, normalized);
         }
-        return import_node_path30.default.normalize(cp.path) === pkg.path;
+        return import_node_path31.default.normalize(cp.path) === pkg.path;
       });
       return {
         path: pkg.path,
@@ -37800,11 +38249,11 @@ function resolveEcosystemKey(pkg, _entry) {
   throw new Error(t("error.config.cannotInferEcosystem"));
 }
 // src/config/loader.ts
-var import_node_child_process = require("node:child_process");
+var import_node_child_process2 = require("node:child_process");
 var import_promises8 = require("node:fs/promises");
 var import_node_module2 = require("node:module");
 var import_node_os5 = require("node:os");
-var import_node_path31 = __toESM(require("node:path"));
+var import_node_path32 = __toESM(require("node:path"));
 var import_node_url = require("node:url");
 var import_node_vm = __toESM(require("node:vm"));
 var CONFIG_FILES = [
@@ -37857,7 +38306,7 @@ var CONFIG_MODULE_SHIMS = {
 };
 async function findConfigFile(cwd) {
   for (const file of CONFIG_FILES) {
-    const filePath = import_node_path31.default.join(cwd, file);
+    const filePath = import_node_path32.default.join(cwd, file);
     try {
       if ((await import_promises8.stat(filePath)).isFile()) {
         return filePath;
@@ -37878,15 +38327,15 @@ function isBareSpecifier(specifier) {
   return !specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.startsWith("file:") && !specifier.startsWith("node:");
 }
 async function findClosestPackageManifest(filePath) {
-  let current = import_node_path31.default.dirname(filePath);
+  let current = import_node_path32.default.dirname(filePath);
   while (true) {
-    const manifestPath = import_node_path31.default.join(current, "package.json");
+    const manifestPath = import_node_path32.default.join(current, "package.json");
     try {
       if ((await import_promises8.stat(manifestPath)).isFile()) {
         return manifestPath;
       }
     } catch {}
-    const parent = import_node_path31.default.dirname(current);
+    const parent = import_node_path32.default.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -37988,13 +38437,13 @@ async function collectOptionalDependenciesForInputs(inputPaths) {
 async function findInstalledPackagePath(startDir, dependency) {
   let current = startDir;
   while (true) {
-    const packageDir = import_node_path31.default.join(current, "node_modules", dependency);
+    const packageDir = import_node_path32.default.join(current, "node_modules", dependency);
     try {
       if ((await import_promises8.stat(packageDir)).isDirectory()) {
         return packageDir;
       }
     } catch {}
-    const parent = import_node_path31.default.dirname(current);
+    const parent = import_node_path32.default.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -38002,19 +38451,19 @@ async function findInstalledPackagePath(startDir, dependency) {
   }
 }
 async function writeOptionalDependencyStubs(moduleDir, resolveFromDir, optionalDependencies) {
-  const nodeModulesDir = import_node_path31.default.join(moduleDir, "node_modules");
+  const nodeModulesDir = import_node_path32.default.join(moduleDir, "node_modules");
   for (const dependency of optionalDependencies) {
     if (await findInstalledPackagePath(resolveFromDir, dependency)) {
       continue;
     }
-    const packageDir = import_node_path31.default.join(nodeModulesDir, dependency);
+    const packageDir = import_node_path32.default.join(nodeModulesDir, dependency);
     await import_promises8.mkdir(packageDir, { recursive: true });
-    await import_promises8.writeFile(import_node_path31.default.join(packageDir, "package.json"), JSON.stringify({
+    await import_promises8.writeFile(import_node_path32.default.join(packageDir, "package.json"), JSON.stringify({
       name: dependency,
       private: true,
       main: "./index.js"
     }, null, 2), "utf8");
-    await import_promises8.writeFile(import_node_path31.default.join(packageDir, "index.js"), createOptionalDependencyProxyPackage(dependency), "utf8");
+    await import_promises8.writeFile(import_node_path32.default.join(packageDir, "index.js"), createOptionalDependencyProxyPackage(dependency), "utf8");
   }
 }
 function createOptionalDependencyPlugin(specifiers) {
@@ -38126,10 +38575,10 @@ async function buildConfigWithFormat(entrypoint, format3) {
 }
 async function buildConfigWithChildProcess(entrypoint, format3 = "esm") {
   const extension = format3 === "esm" ? "mjs" : "cjs";
-  const tempDir = await import_promises8.mkdtemp(import_node_path31.default.join(import_node_os5.tmpdir(), "pubm-config-"));
-  const buildScript = import_node_path31.default.join(tempDir, "build-config.mjs");
-  const outfile = import_node_path31.default.join(tempDir, `pubm.config.${extension}`);
-  const resultFile = import_node_path31.default.join(tempDir, "build-result.json");
+  const tempDir = await import_promises8.mkdtemp(import_node_path32.default.join(import_node_os5.tmpdir(), "pubm-config-"));
+  const buildScript = import_node_path32.default.join(tempDir, "build-config.mjs");
+  const outfile = import_node_path32.default.join(tempDir, `pubm.config.${extension}`);
+  const resultFile = import_node_path32.default.join(tempDir, "build-result.json");
   try {
     await import_promises8.writeFile(buildScript, [
       'import { readFile, stat, writeFile } from "node:fs/promises";',
@@ -38372,7 +38821,7 @@ async function buildConfigWithChildProcess(entrypoint, format3 = "esm") {
     ].join(`
 `), "utf8");
     await new Promise((resolve2, reject) => {
-      import_node_child_process.execFile("bun", [buildScript], (error4, _stdout, stderr) => {
+      import_node_child_process2.execFile("bun", [buildScript], (error4, _stdout, stderr) => {
         if (error4) {
           reject(new Error(stderr || `Failed to build config via bun: ${error4.message}`));
           return;
@@ -38405,11 +38854,11 @@ async function buildConfigWithChildProcess(entrypoint, format3 = "esm") {
 }
 function rewriteImportMeta(source, configPath) {
   const replacements = [
-    ["import.meta.dirname", JSON.stringify(import_node_path31.default.dirname(configPath))],
+    ["import.meta.dirname", JSON.stringify(import_node_path32.default.dirname(configPath))],
     ["import.meta.filename", JSON.stringify(configPath)],
     ["import.meta.path", JSON.stringify(configPath)],
     ["import.meta.url", JSON.stringify(import_node_url.pathToFileURL(configPath).href)],
-    ["import.meta.dir", JSON.stringify(import_node_path31.default.dirname(configPath))]
+    ["import.meta.dir", JSON.stringify(import_node_path32.default.dirname(configPath))]
   ];
   let rewritten = source;
   for (const [pattern, value] of replacements) {
@@ -38425,10 +38874,10 @@ async function importConfigModule(configPath) {
   return normalizeConfigNamespace(namespace);
 }
 async function importBundledConfig(source, configPath, optionalDependencies) {
-  const tempDir = await import_promises8.mkdtemp(import_node_path31.default.join(import_node_path31.default.dirname(configPath), ".pubm-config-module-"));
-  const tempFile = import_node_path31.default.join(tempDir, "pubm.config.mjs");
+  const tempDir = await import_promises8.mkdtemp(import_node_path32.default.join(import_node_path32.default.dirname(configPath), ".pubm-config-module-"));
+  const tempFile = import_node_path32.default.join(tempDir, "pubm.config.mjs");
   try {
-    await writeOptionalDependencyStubs(tempDir, import_node_path31.default.dirname(configPath), optionalDependencies);
+    await writeOptionalDependencyStubs(tempDir, import_node_path32.default.dirname(configPath), optionalDependencies);
     await import_promises8.writeFile(tempFile, source, "utf8");
     return importConfigModule(tempFile);
   } finally {
@@ -38443,7 +38892,7 @@ async function executeBundledConfigInVm(source, configPath) {
     exports: module2.exports,
     require: require2,
     __filename: configPath,
-    __dirname: import_node_path31.default.dirname(configPath),
+    __dirname: import_node_path32.default.dirname(configPath),
     console,
     process,
     Buffer,
@@ -38474,7 +38923,7 @@ function formatStageError(stage, error4) {
 async function loadConfig(cwd = process.cwd(), configPath) {
   let resolvedConfigPath;
   if (configPath) {
-    resolvedConfigPath = import_node_path31.default.resolve(cwd, configPath);
+    resolvedConfigPath = import_node_path32.default.resolve(cwd, configPath);
     try {
       if (!(await import_promises8.stat(resolvedConfigPath)).isFile()) {
         throw new Error(`Config path is not a file: ${resolvedConfigPath}`);
@@ -38553,36 +39002,6 @@ function defineConfig(config) {
 // src/index.ts
 init_context();
 
-// src/conventional-commit/scope-resolver.ts
-var import_node_path32 = __toESM(require("node:path"));
-function resolveCommitPackages(commit, packagePaths) {
-  const matched = new Set;
-  if (commit.scope) {
-    for (const pkgPath of packagePaths) {
-      const dirName = import_node_path32.default.basename(pkgPath);
-      if (dirName === commit.scope) {
-        matched.add(pkgPath);
-      }
-    }
-    if (matched.size > 0)
-      return [...matched];
-  }
-  for (const file of commit.files) {
-    const normalized = file.replace(/\\/g, "/");
-    for (const pkgPath of packagePaths) {
-      if (pkgPath === ".") {
-        matched.add(pkgPath);
-        continue;
-      }
-      const normalizedPkg = pkgPath.replace(/\\/g, "/");
-      if (normalized.startsWith(`${normalizedPkg}/`) || normalized === normalizedPkg) {
-        matched.add(pkgPath);
-      }
-    }
-  }
-  return [...matched];
-}
-
 // src/conventional-commit/commit-analyzer.ts
 function analyzeCommits(commits, packagePaths, typeOverrides) {
   const typeMap = {
@@ -38623,147 +39042,6 @@ function resolveBumpType(commit, typeMap) {
     return null;
   return mapped;
 }
-// src/conventional-commit/git-log.ts
-var import_node_child_process2 = require("node:child_process");
-var COMMIT_START_MARKER = "COMMIT_START";
-var COMMIT_FILES_MARKER = "COMMIT_FILES";
-function findLastReleaseRef(cwd, packageName) {
-  if (packageName) {
-    const scopedTags = execGit(cwd, [
-      "tag",
-      "--list",
-      `${packageName}@[0-9]*.[0-9]*.[0-9]*`,
-      "--sort=-v:refname"
-    ]);
-    if (scopedTags.length > 0)
-      return scopedTags[0];
-  }
-  const vTags = execGit(cwd, [
-    "tag",
-    "--list",
-    "v[0-9]*.[0-9]*.[0-9]*",
-    "--sort=-v:refname"
-  ]);
-  if (vTags.length > 0)
-    return vTags[0];
-  const versionCommit = execGit(cwd, [
-    "log",
-    "--format=%H",
-    "--grep=^Version Packages$",
-    "-1"
-  ]);
-  if (versionCommit.length > 0)
-    return versionCommit[0];
-  return;
-}
-function getCommitsSinceRef(cwd, ref) {
-  const range = ref ? `${ref}..HEAD` : "HEAD";
-  const format3 = `${COMMIT_START_MARKER} %h%n%B%n${COMMIT_FILES_MARKER}`;
-  const output = execGitRaw(cwd, [
-    "log",
-    `--format=${format3}`,
-    "--name-only",
-    range
-  ]);
-  if (!output.trim())
-    return [];
-  const commits = [];
-  const lines = output.split(`
-`);
-  let i2 = 0;
-  while (i2 < lines.length) {
-    if (!lines[i2].startsWith(COMMIT_START_MARKER)) {
-      i2++;
-      continue;
-    }
-    const hash = lines[i2].slice(COMMIT_START_MARKER.length + 1).trim();
-    i2++;
-    const messageLines = [];
-    while (i2 < lines.length && !lines[i2].startsWith(COMMIT_FILES_MARKER)) {
-      if (lines[i2].startsWith(COMMIT_START_MARKER))
-        break;
-      messageLines.push(lines[i2]);
-      i2++;
-    }
-    if (i2 < lines.length && lines[i2].startsWith(COMMIT_FILES_MARKER)) {
-      i2++;
-    }
-    const files = [];
-    while (i2 < lines.length && !lines[i2].startsWith(COMMIT_START_MARKER)) {
-      const file = lines[i2].trim();
-      if (file)
-        files.push(file);
-      i2++;
-    }
-    const message = messageLines.join(`
-`).trim();
-    if (hash && message) {
-      commits.push({ hash, message, files });
-    }
-  }
-  return commits;
-}
-function execGit(cwd, args) {
-  return execGitRaw(cwd, args).split(`
-`).map((l3) => l3.trim()).filter(Boolean);
-}
-function execGitRaw(cwd, args) {
-  try {
-    return import_node_child_process2.execFileSync("git", args, { cwd, encoding: "utf-8" });
-  } catch {
-    return "";
-  }
-}
-// src/conventional-commit/parser.ts
-var HEADER_REGEX = /^(\w+)(?:\(([^)]+)\))?(!)?\s*:\s*(.+)$/;
-var FOOTER_REGEX = /^([\w-]+|BREAKING CHANGE)\s*:\s*(.+)$/;
-function parseConventionalCommit(hash, message, files = []) {
-  const lines = message.split(`
-`);
-  const firstLine = lines[0];
-  const headerMatch = firstLine.match(HEADER_REGEX);
-  if (!headerMatch)
-    return null;
-  const [, type, scope, bang, description] = headerMatch;
-  let body;
-  const footers = new Map;
-  let breaking = bang === "!";
-  if (lines.length > 1) {
-    const rest = lines.slice(1);
-    let footerStartIndex = rest.length;
-    for (let i2 = rest.length - 1;i2 >= 0; i2--) {
-      if (rest[i2] === "") {
-        footerStartIndex = i2 + 1;
-        break;
-      }
-    }
-    const bodyStartIndex = rest.findIndex((line) => line !== "");
-    if (bodyStartIndex !== -1 && bodyStartIndex < footerStartIndex) {
-      const bodyLines = rest.slice(bodyStartIndex, footerStartIndex - 1);
-      const bodyText = bodyLines.join(`
-`).trim();
-      if (bodyText)
-        body = bodyText;
-    }
-    let currentFooterKey;
-    for (let i2 = footerStartIndex;i2 < rest.length; i2++) {
-      const footerMatch = rest[i2].match(FOOTER_REGEX);
-      if (footerMatch) {
-        const [, key, value] = footerMatch;
-        footers.set(key, value);
-        currentFooterKey = key;
-        if (key === "BREAKING CHANGE" || key === "BREAKING-CHANGE") {
-          breaking = true;
-        }
-      } else if (currentFooterKey && rest[i2].startsWith("  ")) {
-        const existing = footers.get(currentFooterKey) ?? "";
-        footers.set(currentFooterKey, `${existing}
-${rest[i2].trimStart()}`);
-      }
-    }
-  }
-  return { hash, type, scope, breaking, description, body, footers, files };
-}
 // src/index.ts
 init_catalog2();
 init_js_descriptor();
@@ -38813,7 +39091,7 @@ function inspectPackages(config, cwd) {
 // src/manifest/index.ts
 init_manifest_reader();
 // src/migrate/adapters/changesets.ts
-var import_node_fs19 = require("node:fs");
+var import_node_fs20 = require("node:fs");
 var import_node_path33 = __toESM(require("node:path"));
 var SKIPPED_DIR_ENTRIES = new Set(["config.json", "README.md", ".gitkeep"]);
 var CHANGELOG_PRESET_MAP = {
@@ -38833,13 +39111,13 @@ var changesetsAdapter = {
   configFilePatterns: [".changeset/config.json"],
   async detect(cwd) {
     const configFile = import_node_path33.default.join(cwd, ".changeset", "config.json");
-    if (!import_node_fs19.existsSync(configFile)) {
+    if (!import_node_fs20.existsSync(configFile)) {
       return { found: false, configFiles: [], relatedFiles: [] };
     }
     const changesetDir = import_node_path33.default.dirname(configFile);
     const relatedFiles = [];
     try {
-      const entries = import_node_fs19.readdirSync(changesetDir, { encoding: "utf-8" });
+      const entries = import_node_fs20.readdirSync(changesetDir, { encoding: "utf-8" });
       for (const entry of entries) {
         if (SKIPPED_DIR_ENTRIES.has(entry))
           continue;
@@ -38859,7 +39137,7 @@ var changesetsAdapter = {
     if (configFile === undefined) {
       return { source: "changesets", unmappable: [] };
     }
-    const raw = import_node_fs19.readFileSync(configFile, "utf-8");
+    const raw = import_node_fs20.readFileSync(configFile, "utf-8");
     const config = JSON.parse(raw);
     const result = {
       source: "changesets",
@@ -38891,9 +39169,9 @@ var changesetsAdapter = {
         result.monorepo.updateInternalDeps = config.updateInternalDependencies;
     }
     const preJsonPath = import_node_path33.default.join(cwd, ".changeset", "pre.json");
-    if (import_node_fs19.existsSync(preJsonPath)) {
+    if (import_node_fs20.existsSync(preJsonPath)) {
       try {
-        const preRaw = import_node_fs19.readFileSync(preJsonPath, "utf-8");
+        const preRaw = import_node_fs20.readFileSync(preJsonPath, "utf-8");
         const preData = JSON.parse(preRaw);
         if (preData.mode === "pre") {
           result.prerelease = { active: true, tag: preData.tag };
@@ -38928,7 +39206,7 @@ var changesetsAdapter = {
   }
 };
 // src/migrate/adapters/np.ts
-var import_node_fs20 = require("node:fs");
+var import_node_fs21 = require("node:fs");
 var import_node_path34 = __toESM(require("node:path"));
 var import_node_url2 = require("node:url");
 var STANDALONE_CONFIG_FILES = [
@@ -38958,7 +39236,7 @@ async function readNpConfig(filePath, isPackageJson) {
       return {};
     }
   }
-  const raw = import_node_fs20.readFileSync(filePath, "utf-8");
+  const raw = import_node_fs21.readFileSync(filePath, "utf-8");
   const parsed = JSON.parse(raw);
   if (isPackageJson) {
     return parsed.np ?? {};
@@ -39035,14 +39313,14 @@ var npAdapter = {
     const configFiles = [];
     for (const filename of STANDALONE_CONFIG_FILES) {
       const filePath = import_node_path34.default.join(cwd, filename);
-      if (import_node_fs20.existsSync(filePath)) {
+      if (import_node_fs21.existsSync(filePath)) {
         configFiles.push(filePath);
       }
     }
     const pkgJsonPath = import_node_path34.default.join(cwd, PACKAGE_JSON);
-    if (import_node_fs20.existsSync(pkgJsonPath)) {
+    if (import_node_fs21.existsSync(pkgJsonPath)) {
       try {
-        const raw = import_node_fs20.readFileSync(pkgJsonPath, "utf-8");
+        const raw = import_node_fs21.readFileSync(pkgJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
         if ("np" in parsed) {
           configFiles.push(pkgJsonPath);
@@ -39080,7 +39358,7 @@ var npAdapter = {
   }
 };
 // src/migrate/adapters/release-it.ts
-var import_node_fs21 = require("node:fs");
+var import_node_fs22 = require("node:fs");
 var import_node_path35 = __toESM(require("node:path"));
 var import_node_url3 = require("node:url");
 var import_yaml4 = __toESM(require_dist(), 1);
@@ -39103,7 +39381,7 @@ async function loadConfigFile(filePath) {
       return null;
     }
   }
-  const raw = import_node_fs21.readFileSync(filePath, "utf-8");
+  const raw = import_node_fs22.readFileSync(filePath, "utf-8");
   if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
     return import_yaml4.default.parse(raw);
   }
@@ -39223,14 +39501,14 @@ var releaseItAdapter = {
     const configFiles = [];
     for (const filename of STANDALONE_CONFIG_FILES2) {
       const filePath = import_node_path35.default.join(cwd, filename);
-      if (import_node_fs21.existsSync(filePath)) {
+      if (import_node_fs22.existsSync(filePath)) {
         configFiles.push(filePath);
       }
     }
     const pkgJsonPath = import_node_path35.default.join(cwd, PACKAGE_JSON2);
-    if (import_node_fs21.existsSync(pkgJsonPath)) {
+    if (import_node_fs22.existsSync(pkgJsonPath)) {
       try {
-        const raw = import_node_fs21.readFileSync(pkgJsonPath, "utf-8");
+        const raw = import_node_fs22.readFileSync(pkgJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
         if ("release-it" in parsed) {
           configFiles.push(pkgJsonPath);
@@ -39279,7 +39557,7 @@ var releaseItAdapter = {
   }
 };
 // src/migrate/adapters/semantic-release.ts
-var import_node_fs22 = require("node:fs");
+var import_node_fs23 = require("node:fs");
 var import_node_path36 = __toESM(require("node:path"));
 var import_node_url4 = require("node:url");
 var import_yaml5 = __toESM(require_dist(), 1);
@@ -39367,7 +39645,7 @@ async function loadConfigFile2(filePath) {
       return {};
     }
   }
-  const raw = import_node_fs22.readFileSync(filePath, "utf-8");
+  const raw = import_node_fs23.readFileSync(filePath, "utf-8");
   if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
     return import_yaml5.default.parse(raw);
   }
@@ -39486,14 +39764,14 @@ var semanticReleaseAdapter = {
     const configFiles = [];
     for (const filename of STANDALONE_CONFIG_FILES3) {
       const filePath = import_node_path36.default.join(cwd, filename);
-      if (import_node_fs22.existsSync(filePath)) {
+      if (import_node_fs23.existsSync(filePath)) {
         configFiles.push(filePath);
       }
     }
     const pkgJsonPath = import_node_path36.default.join(cwd, PACKAGE_JSON3);
-    if (import_node_fs22.existsSync(pkgJsonPath)) {
+    if (import_node_fs23.existsSync(pkgJsonPath)) {
       try {
-        const raw = import_node_fs22.readFileSync(pkgJsonPath, "utf-8");
+        const raw = import_node_fs23.readFileSync(pkgJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
         if ("release" in parsed) {
           configFiles.push(pkgJsonPath);
@@ -39530,7 +39808,7 @@ var semanticReleaseAdapter = {
   }
 };
 // src/migrate/ci-advisor.ts
-var import_node_fs23 = require("node:fs");
+var import_node_fs24 = require("node:fs");
 var import_node_path37 = require("node:path");
 var CI_PATTERNS = {
   "semantic-release": [
@@ -39552,16 +39830,16 @@ var CI_PATTERNS = {
 };
 function scanCiWorkflows(cwd, source) {
   const workflowsDir = import_node_path37.join(cwd, ".github", "workflows");
-  if (!import_node_fs23.existsSync(workflowsDir))
+  if (!import_node_fs24.existsSync(workflowsDir))
     return [];
   const patterns = CI_PATTERNS[source];
   const advice = [];
-  const files = import_node_fs23.readdirSync(workflowsDir, { encoding: "utf-8" });
+  const files = import_node_fs24.readdirSync(workflowsDir, { encoding: "utf-8" });
   for (const filename of files) {
     if (!filename.endsWith(".yml") && !filename.endsWith(".yaml"))
       continue;
     const filePath = import_node_path37.join(workflowsDir, filename);
-    const content = import_node_fs23.readFileSync(filePath, "utf-8");
+    const content = import_node_fs24.readFileSync(filePath, "utf-8");
     for (const line of content.split(`
 `)) {
       const trimmed = line.trim();
@@ -39583,15 +39861,15 @@ function scanCiWorkflows(cwd, source) {
   return advice;
 }
 // src/migrate/cleanup.ts
-var import_node_fs24 = require("node:fs");
+var import_node_fs25 = require("node:fs");
 function removeFiles(targets) {
   const removed = [];
   for (const target of targets) {
     try {
-      if (import_node_fs24.statSync(target).isDirectory()) {
-        import_node_fs24.rmSync(target, { recursive: true });
+      if (import_node_fs25.statSync(target).isDirectory()) {
+        import_node_fs25.rmSync(target, { recursive: true });
       } else {
-        import_node_fs24.unlinkSync(target);
+        import_node_fs25.unlinkSync(target);
       }
       removed.push(target);
     } catch (error4) {
@@ -39802,7 +40080,7 @@ async function detectMigrationSources(cwd, adapters, from) {
   return results.filter((r2) => r2 != null && r2.result.found);
 }
 // src/migrate/pipeline.ts
-var import_node_fs25 = require("node:fs");
+var import_node_fs26 = require("node:fs");
 var import_node_path38 = require("node:path");
 async function executeMigration(options) {
   const { adapter, detected, cwd, dryRun, clean } = options;
@@ -39813,10 +40091,10 @@ async function executeMigration(options) {
   const ciAdvice = scanCiWorkflows(cwd, adapter.name);
   if (!dryRun) {
     const outFile = import_node_path38.join(cwd, "pubm.config.ts");
-    if (import_node_fs25.existsSync(outFile)) {
+    if (import_node_fs26.existsSync(outFile)) {
       throw new Error("pubm.config.ts already exists. Remove or rename it before migrating.");
     }
-    import_node_fs25.writeFileSync(outFile, configString, "utf-8");
+    import_node_fs26.writeFileSync(outFile, configString, "utf-8");
   }
   if (!dryRun && adapter.name === "changesets") {
     migrateFromChangesets(cwd);
@@ -40635,6 +40913,7 @@ var requiredMissingInformationTasks = (options) => createListr({
   ])
 });
 // src/tasks/snapshot-runner.ts
+var import_node_process25 = __toESM(require("node:process"));
 init_error4();
 init_git();
 init_i18n();
@@ -40658,7 +40937,8 @@ function generateSnapshotVersion(options) {
   const now2 = new Date;
   const timestamp = formatTimestamp(now2);
   if (options.template) {
-    return options.template.replace(/\{base\}/g, base2).replace(/\{tag\}/g, tag).replace(/\{timestamp\}/g, timestamp).replace(/\{commit\}/g, options.commit ?? "");
+    const suffix = options.template.replace(/\{tag\}/g, tag).replace(/\{timestamp\}/g, timestamp).replace(/\{commit\}/g, options.commit ?? "");
+    return `${base2}-${suffix}`;
   }
   return `${base2}-${tag}-${timestamp}`;
 }
@@ -40719,6 +40999,7 @@ function buildSnapshotVersionPlan(packages, versioning, tag, template) {
 }
 async function runSnapshotPipeline(ctx, options) {
   const { tag, filter, dryRun = false } = options;
+  ctx.runtime.promptEnabled = !m && !!import_node_process25.default.stdin.isTTY;
   const targetPackages = applySnapshotFilter(ctx.config.packages, filter);
   const versioning = ctx.config.versioning ?? "fixed";
   const plan = buildSnapshotVersionPlan(targetPackages, versioning, tag, ctx.config.snapshotTemplate);
@@ -40729,88 +41010,90 @@ async function runSnapshotPipeline(ctx, options) {
   const pipelineListrOptions = m ? createCiListrOptions() : undefined;
   const snapshotVersions = plan.mode === "single" ? new Map([[plan.packagePath, plan.version]]) : plan.packages;
   const originalVersions = new Map(targetPackages.map((p2) => [p2.path, p2.version || "0.0.0"]));
-  await createListr([
-    {
-      skip: options.skipTests,
-      title: t("task.test.title"),
-      task: async (ctx2, task) => {
-        const packageManager = await getPackageManager();
-        const command = `${packageManager} run ${ctx2.options.testScript}`;
-        task.title = t("task.test.titleWithCommand", { command });
-        task.output = `Executing \`${command}\``;
-        try {
-          await exec3(packageManager, ["run", ctx2.options.testScript], {
-            throwOnError: true
-          });
-        } catch (error4) {
-          throw new AbstractError(t("error.test.failed", { script: ctx2.options.testScript }), { cause: error4 });
+  try {
+    await createListr([
+      {
+        skip: options.skipTests,
+        title: t("task.test.title"),
+        task: async (ctx2, task) => {
+          const packageManager = await getPackageManager();
+          const command = `${packageManager} run ${ctx2.options.testScript}`;
+          task.title = t("task.test.titleWithCommand", { command });
+          task.output = `Executing \`${command}\``;
+          try {
+            await exec3(packageManager, ["run", ctx2.options.testScript], {
+              throwOnError: true
+            });
+          } catch (error4) {
+            throw new AbstractError(t("error.test.failed", { script: ctx2.options.testScript }), { cause: error4 });
+          }
         }
-      }
-    },
-    {
-      skip: options.skipBuild,
-      title: t("task.build.title"),
-      task: async (ctx2, task) => {
-        const packageManager = await getPackageManager();
-        const command = `${packageManager} run ${ctx2.options.buildScript}`;
-        task.title = t("task.build.titleWithCommand", { command });
-        task.output = `Executing \`${command}\``;
-        try {
-          await exec3(packageManager, ["run", ctx2.options.buildScript], {
-            throwOnError: true
-          });
-        } catch (error4) {
-          throw new AbstractError(t("error.build.failed", { script: ctx2.options.buildScript }), { cause: error4 });
+      },
+      {
+        skip: options.skipBuild,
+        title: t("task.build.title"),
+        task: async (ctx2, task) => {
+          const packageManager = await getPackageManager();
+          const command = `${packageManager} run ${ctx2.options.buildScript}`;
+          task.title = t("task.build.titleWithCommand", { command });
+          task.output = `Executing \`${command}\``;
+          try {
+            await exec3(packageManager, ["run", ctx2.options.buildScript], {
+              throwOnError: true
+            });
+          } catch (error4) {
+            throw new AbstractError(t("error.build.failed", { script: ctx2.options.buildScript }), { cause: error4 });
+          }
         }
-      }
-    },
-    {
-      title: t("task.snapshot.title"),
-      task: async (ctx2, task) => {
-        const versionLabel = plan.mode !== "independent" ? plan.version : `${snapshotVersions.size} packages`;
-        task.title = t("task.snapshot.titleWithVersion", {
-          version: versionLabel
-        });
-        await writeVersions(ctx2, snapshotVersions);
-        try {
+      },
+      {
+        title: t("task.snapshot.title"),
+        task: async (ctx2, task) => {
+          const versionLabel = plan.mode !== "independent" ? plan.version : `${snapshotVersions.size} packages`;
+          task.title = t("task.snapshot.titleWithVersion", {
+            version: versionLabel
+          });
+          await writeVersions(ctx2, snapshotVersions);
+          await resolveWorkspaceProtocols(ctx2);
           task.output = t("task.snapshot.publishing", { tag });
           const publishTasks = await collectPublishTasks(ctx2);
-          await createListr(publishTasks, {
+          return task.newListr(publishTasks, {
             concurrent: true
-          }).run(ctx2);
-        } finally {
-          await writeVersions(ctx2, originalVersions);
+          });
         }
-        task.output = t("task.snapshot.published", {
-          version: versionLabel
-        });
-      }
-    },
-    {
-      title: t("task.snapshot.createTag"),
-      enabled: !dryRun,
-      task: async (ctx2, task) => {
-        const git = new Git;
-        const headCommit = await git.latestCommit();
-        if (plan.mode === "independent") {
-          for (const [pkgPath, pkgVersion] of plan.packages) {
-            const pkgName = ctx2.config.packages.find((p2) => p2.path === pkgPath)?.name ?? pkgPath;
-            const tagName = `${pkgName}@${pkgVersion}`;
+      },
+      {
+        title: t("task.snapshot.createTag"),
+        enabled: !dryRun,
+        task: async (ctx2, task) => {
+          const git = new Git;
+          const headCommit = await git.latestCommit();
+          if (plan.mode === "independent") {
+            for (const [pkgPath, pkgVersion] of plan.packages) {
+              const pkgName = ctx2.config.packages.find((p2) => p2.path === pkgPath)?.name ?? pkgPath;
+              const tagName = `${pkgName}@${pkgVersion}`;
+              task.output = t("task.snapshot.creatingTag", { tag: tagName });
+              await git.createTag(tagName, headCommit);
+            }
+          } else {
+            const version = plan.version;
+            const tagName = `v${version}`;
             task.output = t("task.snapshot.creatingTag", { tag: tagName });
             await git.createTag(tagName, headCommit);
           }
-        } else {
-          const version = plan.version;
-          const tagName = `v${version}`;
-          task.output = t("task.snapshot.creatingTag", { tag: tagName });
-          await git.createTag(tagName, headCommit);
+          task.output = t("task.snapshot.pushingTag", { tag: "tags" });
+          await git.push("--tags");
+          task.output = t("task.snapshot.tagPushed", { tag: "tags" });
         }
-        task.output = t("task.snapshot.pushingTag", { tag: "tags" });
-        await git.push("--tags");
-        task.output = t("task.snapshot.tagPushed", { tag: "tags" });
       }
+    ], pipelineListrOptions).run(ctx);
+  } finally {
+    if (ctx.runtime.workspaceBackups?.size) {
+      restoreManifests(ctx.runtime.workspaceBackups);
+      ctx.runtime.workspaceBackups = undefined;
     }
-  ], pipelineListrOptions).run(ctx);
+    await writeVersions(ctx, originalVersions);
+  }
   const registries = collectRegistries(ctx.config);
   const parts = [];
   for (const registryKey of registries) {
@@ -40822,7 +41105,7 @@ async function runSnapshotPipeline(ctx, options) {
       parts.push(`${ui.chalk.bold(name)} on ${descriptor.label}`);
     }
   }
-  const versionDisplay = plan.mode !== "independent" ? ui.chalk.blueBright(plan.version) : "";
+  const versionDisplay = ui.chalk.blueBright(formatVersionSummary(ctx));
   console.log(`
 
 \uD83D\uDCF8 ${t("task.snapshot.success", { parts: parts.join(", "), version: versionDisplay })} \uD83D\uDCF8
@@ -42851,11 +43134,11 @@ function isBun2() {
 init_ui();
 
 // src/validate/entry-points.ts
-var import_node_fs26 = require("node:fs");
+var import_node_fs27 = require("node:fs");
 var import_node_path40 = __toESM(require("node:path"));
 var SIMPLE_FIELDS = ["main", "module", "types", "typings"];
 function checkPath(filePath, cwd) {
-  return import_node_fs26.existsSync(import_node_path40.default.resolve(cwd, filePath));
+  return import_node_fs27.existsSync(import_node_path40.default.resolve(cwd, filePath));
 }
 function validateExports(exports2, cwd, prefix = "exports") {
   const errors = [];