@pubm/core 0.5.2 → 0.5.3

package/dist/index.js

@@ -14330,6 +14330,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.",
@@ -14499,6 +14501,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",
@@ -14755,6 +14758,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.",
@@ -14924,6 +14929,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",
@@ -15180,6 +15186,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.",
@@ -15349,6 +15357,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",
@@ -15605,6 +15614,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.",
@@ -15774,6 +15785,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",
@@ -16030,6 +16042,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가 배포를 처리합니다.",
@@ -16199,6 +16213,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 내용 표시",
@@ -16455,6 +16470,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 应处理发布。",
@@ -16624,6 +16641,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 内容",
@@ -17614,7 +17632,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@pubm/core",
-    version: "0.5.2",
+    version: "0.5.3",
     type: "module",
     description: "Core SDK for pubm - publish manager for multiple registries",
     types: "./dist/index.d.ts",
@@ -17693,7 +17711,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.3", package_default.version);
   PUBM_ENGINES = {
     node: resolveDefine(">=24", coreEngines.node ?? ">=18"),
     git: resolveDefine(">=2.11.0", coreEngines.git ?? ">=2.11.0"),
@@ -22352,9 +22370,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;
@@ -22368,7 +22388,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", {
@@ -22384,8 +22404,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 {
@@ -22393,7 +22413,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 }));
           }
@@ -22520,7 +22540,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);
       });
     }
   };
@@ -23121,6 +23141,43 @@ import { readFile as readFile4 } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join as join3 } from "node:path";
 import process14 from "node:process";
+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,
@@ -23135,7 +23192,7 @@ async function npmPackageRegistry(packagePath) {
   const manifest = await NpmPackageRegistry.reader.read(packagePath);
   return new NpmPackageRegistry(manifest.name, packagePath);
 }
-var NpmError, NpmConnector, NpmPackageRegistry;
+var NpmError, NPM_OFFICIAL_REGISTRY = "https://registry.npmjs.org", NpmConnector, NpmPackageRegistry;
 var init_npm2 = __esm(() => {
   init_dist();
   init_error4();
@@ -23323,8 +23380,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;
@@ -23335,16 +23395,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);
       }
@@ -23355,9 +23419,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,
@@ -23389,44 +23457,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.");
@@ -23456,6 +23501,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;
@@ -23481,6 +23531,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();
+      }
+    }
   };
 });
 
@@ -33518,7 +33672,7 @@ var require_dist = __commonJS((exports) => {
 init_runner();
 
 // src/tasks/runner.ts
-import process21 from "node:process";
+import process22 from "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);
@@ -35861,29 +36015,11 @@ function createPublishTasks(hasPublish, dryRun, skipPublish) {
 
 // src/tasks/phases/push-release.ts
 init_dist2();
-var import_semver4 = __toESM(require_semver2(), 1);
-import { existsSync as existsSync6, readFileSync as readFileSync9, rmSync } from "node:fs";
-import { join as join9 } from "node:path";
-import process19 from "node:process";
-
-// 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_semver4 = __toESM(require_semver2(), 1);
+import { rmSync } from "node:fs";
+import process20 from "node:process";
 
 // src/utils/github-token.ts
 init_secure_store();
@@ -35920,13 +36056,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) {
@@ -35934,16 +36063,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: {
@@ -35954,7 +36074,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)
     })
@@ -36036,67 +36156,448 @@ async function deleteGitHubRelease(releaseId) {
   }
 }
 
-// src/tasks/runner-utils/version-pr.ts
+// src/tasks/release-notes.ts
 import { existsSync as existsSync5, readFileSync as readFileSync8 } from "node:fs";
-import path13 from "node:path";
-import process18 from "node:process";
-init_error4();
-init_git();
-init_i18n();
+import { join as join9 } from "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
+import { execFileSync } from "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"
-    },
-    body: JSON.stringify({
+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 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
+import path13 from "node:path";
+function resolveCommitPackages(commit, packagePaths) {
+  const matched = new Set;
+  if (commit.scope) {
+    for (const pkgPath of packagePaths) {
+      const dirName = path13.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
+import process18 from "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 (process18.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 ? join9(ctx.cwd, pkgPath, "CHANGELOG.md") : join9(ctx.cwd, "CHANGELOG.md");
+  if (!existsSync5(changelogPath))
+    return null;
+  return parseChangelogSection(readFileSync8(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
+import { existsSync as existsSync6, readFileSync as readFileSync9 } from "node:fs";
+import path14 from "node:path";
+import process19 from "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,
       body: options.body,
       head: options.branch,
@@ -36191,7 +36692,7 @@ async function pushViaPr(ctx, git, task) {
   const prBody = buildPrBodyFromContext(ctx, plan);
   const remoteUrl = await git.repository();
   const { owner, repo } = parseOwnerRepo(remoteUrl);
-  const token = process18.env.GITHUB_TOKEN;
+  const token = process19.env.GITHUB_TOKEN;
   if (!token) {
     throw new AbstractError(t("error.githubRelease.tokenRequired"));
   }
@@ -36223,10 +36724,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 ? path13.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
-      const changelogPath = path13.join(changelogDir, "CHANGELOG.md");
-      if (existsSync5(changelogPath)) {
-        const section = parseChangelogSection(readFileSync8(changelogPath, "utf-8"), pkgVersion);
+      const changelogDir = pkgConfig ? path14.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
+      const changelogPath = path14.join(changelogDir, "CHANGELOG.md");
+      if (existsSync6(changelogPath)) {
+        const section = parseChangelogSection(readFileSync9(changelogPath, "utf-8"), pkgVersion);
         if (section)
           changelogs.set(name, section);
       }
@@ -36237,17 +36738,17 @@ function buildPrBodyFromContext(ctx, plan) {
       packages.push({ name: pkg.name, version, bump: "" });
     }
     if (plan.mode === "single") {
-      const changelogPath = path13.join(ctx.cwd, "CHANGELOG.md");
-      if (existsSync5(changelogPath)) {
-        const section = parseChangelogSection(readFileSync8(changelogPath, "utf-8"), version);
+      const changelogPath = path14.join(ctx.cwd, "CHANGELOG.md");
+      if (existsSync6(changelogPath)) {
+        const section = parseChangelogSection(readFileSync9(changelogPath, "utf-8"), version);
         if (section)
           changelogs.set(packages[0]?.name ?? "", section);
       }
     } else {
       for (const pkg of ctx.config.packages) {
-        const changelogPath = path13.join(ctx.cwd, pkg.path, "CHANGELOG.md");
-        if (existsSync5(changelogPath)) {
-          const section = parseChangelogSection(readFileSync8(changelogPath, "utf-8"), version);
+        const changelogPath = path14.join(ctx.cwd, pkg.path, "CHANGELOG.md");
+        if (existsSync6(changelogPath)) {
+          const section = parseChangelogSection(readFileSync9(changelogPath, "utf-8"), version);
           if (section)
             changelogs.set(pkg.name, section);
         }
@@ -36305,7 +36806,7 @@ function createReleaseTask(hasPublish, dryRun, mode, skipReleaseDraft) {
       const tokenResult = resolveGitHubToken();
       let hasToken = !!tokenResult;
       if (tokenResult) {
-        process19.env.GITHUB_TOKEN = tokenResult.token;
+        process20.env.GITHUB_TOKEN = tokenResult.token;
       } else if (mode !== "ci") {
         const answer = await task.prompt(ListrEnquirerPromptAdapter).run({
           type: "select",
@@ -36325,7 +36826,7 @@ function createReleaseTask(hasPublish, dryRun, mode, skipReleaseDraft) {
             message: t("task.release.tokenPrompt")
           });
           if (token) {
-            process19.env.GITHUB_TOKEN = token;
+            process20.env.GITHUB_TOKEN = token;
             saveGitHubToken(token);
             hasToken = true;
           }
@@ -36345,22 +36846,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 = join9(ctx.cwd, pkgConfig.path, "CHANGELOG.md");
-              if (existsSync6(changelogPath)) {
-                const section = parseChangelogSection(readFileSync9(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
             });
@@ -36398,39 +36897,14 @@ function createReleaseTask(hasPublish, dryRun, mode, skipReleaseDraft) {
           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 = join9(ctx.cwd, pkgConfig.path, "CHANGELOG.md");
-              if (existsSync6(changelogPath)) {
-                const section = parseChangelogSection(readFileSync9(changelogPath, "utf-8"), pkgVersion);
-                if (section) {
-                  sections.push(`## ${pkgName} v${pkgVersion}
-
-${section}`);
-                }
-              }
-            }
-            if (sections.length > 0) {
-              changelogBody = sections.join(`
-
----
-
-`);
-            }
-          } else {
-            const changelogPath = join9(ctx.cwd, "CHANGELOG.md");
-            if (existsSync6(changelogPath)) {
-              const section = parseChangelogSection(readFileSync9(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);
@@ -36438,7 +36912,7 @@ ${section}`);
             displayLabel: packageName,
             version,
             tag,
-            changelogBody,
+            body,
             assets: preparedAssets,
             draft: !!ctx.options.releaseDraft
           });
@@ -36484,21 +36958,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;
             }
@@ -36506,24 +36990,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());
         }
       }
@@ -36535,7 +37025,7 @@ ${repositoryUrl}/compare/${lastRev}...${tag}`;
 init_catalog2();
 init_error4();
 init_i18n();
-import path14 from "node:path";
+import path15 from "node:path";
 init_exec();
 var JS_WORKSPACE_TYPES = new Set(["pnpm", "npm", "yarn", "bun", "deno"]);
 var ECOSYSTEM_DEFAULTS = {
@@ -36620,7 +37110,7 @@ async function resolveExecutions(ctx, type) {
           });
         } else {
           for (const pkg of group.groupPackages) {
-            const pkgCwd = path14.resolve(ctx.cwd, pkg.path);
+            const pkgCwd = path15.resolve(ctx.cwd, pkg.path);
             executions.push({
               label: `${resolved.command} (${pkg.path})`,
               cmd: "sh",
@@ -36641,7 +37131,7 @@ async function resolveExecutions(ctx, type) {
           });
         } else {
           for (const pkg of group.groupPackages) {
-            const pkgCwd = path14.resolve(ctx.cwd, pkg.path);
+            const pkgCwd = path15.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({
@@ -36655,7 +37145,7 @@ async function resolveExecutions(ctx, type) {
       }
     }
     for (const pkg of group.individualPackages) {
-      const pkgCwd = path14.resolve(ctx.cwd, pkg.path);
+      const pkgCwd = path15.resolve(ctx.cwd, pkg.path);
       const resolved = resolveScript(pkg, group.ecosystemKey, ctx, type);
       if (resolved.command) {
         executions.push({
@@ -36753,13 +37243,13 @@ function createBuildTask(hasPrepare, skipBuild) {
 
 // src/tasks/phases/version.ts
 init_dist2();
-import path17 from "node:path";
+import path18 from "node:path";
 
 // src/changelog/file.ts
 import { existsSync as existsSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 function writeChangelogToFile(cwd, newContent) {
-  const changelogPath = path15.join(cwd, "CHANGELOG.md");
+  const changelogPath = path16.join(cwd, "CHANGELOG.md");
   let existing = "";
   if (existsSync7(changelogPath)) {
     existing = readFileSync10(changelogPath, "utf-8");
@@ -36806,6 +37296,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) {
@@ -36824,8 +37329,8 @@ function buildChangelogEntries(changesets, packagePath) {
 
 // src/changeset/reader.ts
 import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync11, rmSync as rmSync2 } from "node:fs";
-import path16 from "node:path";
-import process20 from "node:process";
+import path17 from "node:path";
+import process21 from "node:process";
 
 // src/changeset/parser.ts
 var import_yaml2 = __toESM(require_dist(), 1);
@@ -36845,8 +37350,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$/, "");
@@ -36858,8 +37363,8 @@ function parseChangeset(content, fileName, resolveKey) {
 }
 
 // src/changeset/reader.ts
-function readChangesets(cwd = process20.cwd(), resolveKey) {
-  const changesetsDir = path16.join(cwd, ".pubm", "changesets");
+function readChangesets(cwd = process21.cwd(), resolveKey) {
+  const changesetsDir = path17.join(cwd, ".pubm", "changesets");
   if (!existsSync8(changesetsDir)) {
     return [];
   }
@@ -36869,16 +37374,16 @@ function readChangesets(cwd = process20.cwd(), resolveKey) {
     if (!file.endsWith(".md") || file === "README.md") {
       continue;
     }
-    const filePath = path16.join(changesetsDir, file);
+    const filePath = path17.join(changesetsDir, file);
     const content = readFileSync11(filePath, "utf-8");
     changesets.push(parseChangeset(content, file, resolveKey));
   }
   return changesets;
 }
 function deleteChangesetFiles(cwd, changesets) {
-  const changesetsDir = path16.join(cwd, ".pubm", "changesets");
+  const changesetsDir = path17.join(cwd, ".pubm", "changesets");
   for (const changeset of changesets) {
-    const filePath = path16.join(changesetsDir, `${changeset.id}.md`);
+    const filePath = path17.join(changesetsDir, `${changeset.id}.md`);
     if (existsSync8(filePath)) {
       rmSync2(filePath);
     }
@@ -36935,7 +37440,7 @@ function createVersionTask(hasPrepare, dryRun) {
           const changesets = readChangesets(ctx.cwd, resolver);
           if (changesets.length > 0) {
             registerChangesetBackups(ctx, changesets);
-            const changelogPath = path17.join(ctx.cwd, "CHANGELOG.md");
+            const changelogPath = path18.join(ctx.cwd, "CHANGELOG.md");
             registerChangelogBackup(ctx, changelogPath);
             const pkgPath = ctx.config.packages[0]?.path ?? "";
             const entries = buildChangelogEntries(changesets, pkgPath);
@@ -36992,9 +37497,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 = path17.join(ctx.cwd, "CHANGELOG.md");
+            const changelogPath = path18.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);
@@ -37052,15 +37557,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 ? path17.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
-              const changelogPath = path17.join(changelogDir, "CHANGELOG.md");
+              const changelogDir = pkgConfig ? path18.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
+              const changelogPath = path18.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 ? path17.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
+                const changelogDir = pkgConfig ? path18.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
                 writeChangelogToFile(changelogDir, generateChangelog(pkgVersion, entries));
               }
             }
@@ -37123,7 +37628,7 @@ function chainCleanup(existing, next) {
   };
 }
 async function run(ctx) {
-  ctx.runtime.promptEnabled = !m && process21.stdin.isTTY;
+  ctx.runtime.promptEnabled = !m && process22.stdin.isTTY;
   const mode = ctx.options.mode ?? "local";
   const phases = resolvePhases(ctx.options);
   const dryRun = !!ctx.options.dryRun;
@@ -37138,12 +37643,12 @@ async function run(ctx) {
       interactive: false,
       sigint: true
     });
-    process21.exit(130);
+    process22.exit(130);
   };
-  process21.on("SIGINT", onSigint);
+  process22.on("SIGINT", onSigint);
   try {
     if (ctx.options.contents)
-      process21.chdir(ctx.options.contents);
+      process22.chdir(ctx.options.contents);
     if (mode === "ci" && hasPrepare)
       await runCiPreparePreflight(ctx, chainCleanup, cleanupRef);
     if (mode === "local" && hasPrepare)
@@ -37171,7 +37676,7 @@ async function run(ctx) {
         parts.push(`${ui.chalk.bold(name)} on ${descriptor.label}`);
       }
     }
-    process21.removeListener("SIGINT", onSigint);
+    process22.removeListener("SIGINT", onSigint);
     if (mode === "ci" && hasPrepare && !hasPublish) {
       cleanupRef.current?.();
       console.log(`
@@ -37191,83 +37696,27 @@ async function run(ctx) {
     }
     await ctx.runtime.pluginRunner.runHook("onSuccess", ctx);
   } catch (e3) {
-    process21.removeListener("SIGINT", onSigint);
+    process22.removeListener("SIGINT", onSigint);
     cleanupRef.current?.();
     await ctx.runtime.pluginRunner.runErrorHook(ctx, e3);
     consoleError(e3);
     await ctx.runtime.rollback.execute(ctx, {
-      interactive: ctx.runtime.promptEnabled
-    });
-    process21.exit(1);
-  }
-}
-
-// src/index.ts
-init_dist();
-// src/changelog/changeset-writer.ts
-class ChangesetChangelogWriter {
-  formatEntries(entries) {
-    if (entries.length === 0)
-      return [];
-    return [
-      { category: undefined, items: entries.map((e3) => `- ${e3.summary}`) }
-    ];
-  }
-}
-// 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;
+      interactive: ctx.runtime.promptEnabled
+    });
+    process22.exit(1);
+  }
+}
+
+// src/index.ts
+init_dist();
+// src/changelog/changeset-writer.ts
+class ChangesetChangelogWriter {
+  formatEntries(entries) {
+    if (entries.length === 0)
+      return [];
+    return [
+      { category: undefined, items: entries.map((e3) => `- ${e3.summary}`) }
+    ];
   }
 }
 // src/changelog/renderer.ts
@@ -37312,11 +37761,11 @@ function maxBump(a3, b2) {
 }
 // src/changeset/migrate.ts
 import { copyFileSync, existsSync as existsSync9, mkdirSync as mkdirSync3, readdirSync as readdirSync4 } from "node:fs";
-import path18 from "node:path";
-import process22 from "node:process";
+import path19 from "node:path";
+import process23 from "node:process";
 var SKIPPED_FILES = new Set(["config.json", "README.md"]);
-function migrateFromChangesets(cwd = process22.cwd()) {
-  const changesetDir = path18.join(cwd, ".changeset");
+function migrateFromChangesets(cwd = process23.cwd()) {
+  const changesetDir = path19.join(cwd, ".changeset");
   if (!existsSync9(changesetDir)) {
     return {
       success: false,
@@ -37325,7 +37774,7 @@ function migrateFromChangesets(cwd = process22.cwd()) {
       configMigrated: false
     };
   }
-  const pubmDir = path18.join(cwd, ".pubm", "changesets");
+  const pubmDir = path19.join(cwd, ".pubm", "changesets");
   mkdirSync3(pubmDir, { recursive: true });
   const files = readdirSync4(changesetDir);
   const migratedFiles = [];
@@ -37339,13 +37788,13 @@ function migrateFromChangesets(cwd = process22.cwd()) {
       continue;
     }
     if (file === "pre.json") {
-      copyFileSync(path18.join(changesetDir, file), path18.resolve(cwd, ".pubm", "pre.json"));
+      copyFileSync(path19.join(changesetDir, file), path19.resolve(cwd, ".pubm", "pre.json"));
       migratedFiles.push(file);
       continue;
     }
     if (file.endsWith(".md")) {
-      const src = path18.join(changesetDir, file);
-      const dest = path18.join(pubmDir, file);
+      const src = path19.join(changesetDir, file);
+      const dest = path19.join(pubmDir, file);
       copyFileSync(src, dest);
       migratedFiles.push(file);
     }
@@ -37357,8 +37806,8 @@ function migrateFromChangesets(cwd = process22.cwd()) {
   };
 }
 // src/changeset/status.ts
-import process23 from "node:process";
-function getStatus(cwd = process23.cwd(), resolveKey) {
+import process24 from "node:process";
+function getStatus(cwd = process24.cwd(), resolveKey) {
   const changesets = readChangesets(cwd, resolveKey);
   const packages = new Map;
   for (const changeset of changesets) {
@@ -37385,8 +37834,8 @@ function getStatus(cwd = process23.cwd(), resolveKey) {
 }
 // src/changeset/version.ts
 var import_semver5 = __toESM(require_semver2(), 1);
-import process24 from "node:process";
-function calculateVersionBumps(currentVersions, cwd = process24.cwd(), resolveKey) {
+import process25 from "node:process";
+function calculateVersionBumps(currentVersions, cwd = process25.cwd(), resolveKey) {
   const changesets = readChangesets(cwd, resolveKey);
   const bumpTypes = new Map;
   for (const changeset of changesets) {
@@ -37420,8 +37869,8 @@ function calculateVersionBumps(currentVersions, cwd = process24.cwd(), resolveKe
 // src/changeset/writer.ts
 var import_yaml3 = __toESM(require_dist(), 1);
 import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync9 } from "node:fs";
-import path19 from "node:path";
-import process25 from "node:process";
+import path20 from "node:path";
+import process26 from "node:process";
 var adjectives = [
   "brave",
   "calm",
@@ -37515,12 +37964,12 @@ ${summary}
   }
   return content;
 }
-function writeChangeset(releases, summary, cwd = process25.cwd()) {
-  const changesetsDir = path19.join(cwd, ".pubm", "changesets");
+function writeChangeset(releases, summary, cwd = process26.cwd()) {
+  const changesetsDir = path20.join(cwd, ".pubm", "changesets");
   mkdirSync4(changesetsDir, { recursive: true });
   const id = generateChangesetId();
   const fileName = `${id}.md`;
-  const filePath = path19.join(changesetsDir, fileName);
+  const filePath = path20.join(changesetsDir, fileName);
   const content = generateChangesetContent(releases, summary);
   writeFileSync9(filePath, content, "utf-8");
   return filePath;
@@ -37529,7 +37978,7 @@ function writeChangeset(releases, summary, cwd = process25.cwd()) {
 init_catalog2();
 init_i18n();
 var import_micromatch4 = __toESM(require_micromatch(), 1);
-import path20 from "node:path";
+import path21 from "node:path";
 init_catalog();
 var defaultValidate = {
   cleanInstall: true,
@@ -37613,7 +38062,7 @@ async function resolveConfig(config, cwd) {
         if (import_micromatch4.default.scan(normalized).isGlob) {
           return import_micromatch4.default.isMatch(pkgPathForward, normalized);
         }
-        return path20.normalize(cp.path) === pkg.path;
+        return path21.normalize(cp.path) === pkg.path;
       });
       return {
         path: pkg.path,
@@ -37673,7 +38122,7 @@ import {
 } from "node:fs/promises";
 import { createRequire as createRequire2 } from "node:module";
 import { tmpdir as tmpdir3 } from "node:os";
-import path21 from "node:path";
+import path22 from "node:path";
 import { pathToFileURL } from "node:url";
 import vm from "node:vm";
 var CONFIG_FILES = [
@@ -37726,7 +38175,7 @@ var CONFIG_MODULE_SHIMS = {
 };
 async function findConfigFile(cwd) {
   for (const file of CONFIG_FILES) {
-    const filePath = path21.join(cwd, file);
+    const filePath = path22.join(cwd, file);
     try {
       if ((await stat6(filePath)).isFile()) {
         return filePath;
@@ -37747,15 +38196,15 @@ function isBareSpecifier(specifier) {
   return !specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.startsWith("file:") && !specifier.startsWith("node:");
 }
 async function findClosestPackageManifest(filePath) {
-  let current = path21.dirname(filePath);
+  let current = path22.dirname(filePath);
   while (true) {
-    const manifestPath = path21.join(current, "package.json");
+    const manifestPath = path22.join(current, "package.json");
     try {
       if ((await stat6(manifestPath)).isFile()) {
         return manifestPath;
       }
     } catch {}
-    const parent = path21.dirname(current);
+    const parent = path22.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -37857,13 +38306,13 @@ async function collectOptionalDependenciesForInputs(inputPaths) {
 async function findInstalledPackagePath(startDir, dependency) {
   let current = startDir;
   while (true) {
-    const packageDir = path21.join(current, "node_modules", dependency);
+    const packageDir = path22.join(current, "node_modules", dependency);
     try {
       if ((await stat6(packageDir)).isDirectory()) {
         return packageDir;
       }
     } catch {}
-    const parent = path21.dirname(current);
+    const parent = path22.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -37871,19 +38320,19 @@ async function findInstalledPackagePath(startDir, dependency) {
   }
 }
 async function writeOptionalDependencyStubs(moduleDir, resolveFromDir, optionalDependencies) {
-  const nodeModulesDir = path21.join(moduleDir, "node_modules");
+  const nodeModulesDir = path22.join(moduleDir, "node_modules");
   for (const dependency of optionalDependencies) {
     if (await findInstalledPackagePath(resolveFromDir, dependency)) {
       continue;
     }
-    const packageDir = path21.join(nodeModulesDir, dependency);
+    const packageDir = path22.join(nodeModulesDir, dependency);
     await mkdir(packageDir, { recursive: true });
-    await writeFile3(path21.join(packageDir, "package.json"), JSON.stringify({
+    await writeFile3(path22.join(packageDir, "package.json"), JSON.stringify({
       name: dependency,
       private: true,
       main: "./index.js"
     }, null, 2), "utf8");
-    await writeFile3(path21.join(packageDir, "index.js"), createOptionalDependencyProxyPackage(dependency), "utf8");
+    await writeFile3(path22.join(packageDir, "index.js"), createOptionalDependencyProxyPackage(dependency), "utf8");
   }
 }
 function createOptionalDependencyPlugin(specifiers) {
@@ -37995,10 +38444,10 @@ async function buildConfigWithFormat(entrypoint, format3) {
 }
 async function buildConfigWithChildProcess(entrypoint, format3 = "esm") {
   const extension = format3 === "esm" ? "mjs" : "cjs";
-  const tempDir = await mkdtemp(path21.join(tmpdir3(), "pubm-config-"));
-  const buildScript = path21.join(tempDir, "build-config.mjs");
-  const outfile = path21.join(tempDir, `pubm.config.${extension}`);
-  const resultFile = path21.join(tempDir, "build-result.json");
+  const tempDir = await mkdtemp(path22.join(tmpdir3(), "pubm-config-"));
+  const buildScript = path22.join(tempDir, "build-config.mjs");
+  const outfile = path22.join(tempDir, `pubm.config.${extension}`);
+  const resultFile = path22.join(tempDir, "build-result.json");
   try {
     await writeFile3(buildScript, [
       'import { readFile, stat, writeFile } from "node:fs/promises";',
@@ -38274,11 +38723,11 @@ async function buildConfigWithChildProcess(entrypoint, format3 = "esm") {
 }
 function rewriteImportMeta(source, configPath) {
   const replacements = [
-    ["import.meta.dirname", JSON.stringify(path21.dirname(configPath))],
+    ["import.meta.dirname", JSON.stringify(path22.dirname(configPath))],
     ["import.meta.filename", JSON.stringify(configPath)],
     ["import.meta.path", JSON.stringify(configPath)],
     ["import.meta.url", JSON.stringify(pathToFileURL(configPath).href)],
-    ["import.meta.dir", JSON.stringify(path21.dirname(configPath))]
+    ["import.meta.dir", JSON.stringify(path22.dirname(configPath))]
   ];
   let rewritten = source;
   for (const [pattern, value] of replacements) {
@@ -38294,10 +38743,10 @@ async function importConfigModule(configPath) {
   return normalizeConfigNamespace(namespace);
 }
 async function importBundledConfig(source, configPath, optionalDependencies) {
-  const tempDir = await mkdtemp(path21.join(path21.dirname(configPath), ".pubm-config-module-"));
-  const tempFile = path21.join(tempDir, "pubm.config.mjs");
+  const tempDir = await mkdtemp(path22.join(path22.dirname(configPath), ".pubm-config-module-"));
+  const tempFile = path22.join(tempDir, "pubm.config.mjs");
   try {
-    await writeOptionalDependencyStubs(tempDir, path21.dirname(configPath), optionalDependencies);
+    await writeOptionalDependencyStubs(tempDir, path22.dirname(configPath), optionalDependencies);
     await writeFile3(tempFile, source, "utf8");
     return importConfigModule(tempFile);
   } finally {
@@ -38312,7 +38761,7 @@ async function executeBundledConfigInVm(source, configPath) {
     exports: module.exports,
     require: require2,
     __filename: configPath,
-    __dirname: path21.dirname(configPath),
+    __dirname: path22.dirname(configPath),
     console,
     process,
     Buffer,
@@ -38343,7 +38792,7 @@ function formatStageError(stage, error4) {
 async function loadConfig(cwd = process.cwd(), configPath) {
   let resolvedConfigPath;
   if (configPath) {
-    resolvedConfigPath = path21.resolve(cwd, configPath);
+    resolvedConfigPath = path22.resolve(cwd, configPath);
     try {
       if (!(await stat6(resolvedConfigPath)).isFile()) {
         throw new Error(`Config path is not a file: ${resolvedConfigPath}`);
@@ -38422,36 +38871,6 @@ function defineConfig(config) {
 // src/index.ts
 init_context();
 
-// src/conventional-commit/scope-resolver.ts
-import path22 from "node:path";
-function resolveCommitPackages(commit, packagePaths) {
-  const matched = new Set;
-  if (commit.scope) {
-    for (const pkgPath of packagePaths) {
-      const dirName = path22.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 = {
@@ -38492,147 +38911,6 @@ function resolveBumpType(commit, typeMap) {
     return null;
   return mapped;
 }
-// src/conventional-commit/git-log.ts
-import { execFileSync } from "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 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();
@@ -40504,6 +40782,7 @@ var requiredMissingInformationTasks = (options) => createListr({
   ])
 });
 // src/tasks/snapshot-runner.ts
+import process27 from "node:process";
 init_error4();
 init_git();
 init_i18n();
@@ -40527,7 +40806,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}`;
 }
@@ -40588,6 +40868,7 @@ function buildSnapshotVersionPlan(packages, versioning, tag, template) {
 }
 async function runSnapshotPipeline(ctx, options) {
   const { tag, filter, dryRun = false } = options;
+  ctx.runtime.promptEnabled = !m && !!process27.stdin.isTTY;
   const targetPackages = applySnapshotFilter(ctx.config.packages, filter);
   const versioning = ctx.config.versioning ?? "fixed";
   const plan = buildSnapshotVersionPlan(targetPackages, versioning, tag, ctx.config.snapshotTemplate);
@@ -40598,88 +40879,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) {
@@ -40691,7 +40974,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