relizy 1.7.0 → 1.9.0

package/dist/shared/{relizy.uCxVVpbQ.mjs → relizy.CN-7XcP7.mjs}

@@ -1,4 +1,4 @@
-import { logger, execPromise } from '@maz-ui/node';
+import { execPromise, logger } from '@maz-ui/node';
 import { execSync, spawnSync } from 'node:child_process';
 import process$1 from 'node:process';
 import { formatJson } from '@maz-ui/utils/helpers/formatJson';
@@ -9,12 +9,120 @@ import { existsSync, readFileSync, statSync, writeFileSync, rmSync } from 'node:
 import path, { join, relative, sep } from 'node:path';
 import { select, confirm, input } from '@inquirer/prompts';
 import micromatch from 'micromatch';
+import * as semver from 'semver';
 import { getErrorMessage } from '@maz-ui/utils/helpers/getErrorMessage';
 import fastGlob from 'fast-glob';
-import * as semver from 'semver';
 import { upperFirst } from '@maz-ui/utils/helpers/upperFirst';
 import { convert } from 'convert-gitmoji';
 import { fetch as fetch$1 } from 'node-fetch-native';
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { gfmFromMarkdown } from 'mdast-util-gfm';
+import { gfm } from 'micromark-extension-gfm';
+
+function shellSingleQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+async function isAncestor(ancestor, descendant, cwd) {
+  try {
+    await execPromise(
+      `git merge-base --is-ancestor ${shellSingleQuote(ancestor)} ${shellSingleQuote(descendant)}`,
+      { cwd, noStderr: true, noStdout: true, noSuccess: true, noError: true }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getCommitSubject(ref, cwd) {
+  try {
+    const { stdout } = await execPromise(
+      `git log -1 --format=%s ${shellSingleQuote(ref)}`,
+      { cwd, noStderr: true, noStdout: true, noSuccess: true, noError: true }
+    );
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function findReachableCommitBySubject(subject, to, cwd) {
+  try {
+    const { stdout } = await execPromise(
+      `git log ${shellSingleQuote(to)} --grep=${shellSingleQuote(subject)} --fixed-strings --format=%H -n 1`,
+      { cwd, noStderr: true, noStdout: true, noSuccess: true, noError: true }
+    );
+    return stdout.trim().split("\n")[0]?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function tagExists(tag, cwd) {
+  try {
+    const tagRef = `refs/tags/${tag}`;
+    await execPromise(
+      `git rev-parse --verify --quiet ${shellSingleQuote(tagRef)}`,
+      { cwd, noStderr: true, noStdout: true, noSuccess: true, noError: true }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+const LIST_TAGS_MAX_BUFFER = 64 * 1024 * 1024;
+async function listTags({
+  pattern,
+  cwd,
+  logLevel
+} = {}) {
+  const list = pattern ? ` --list ${shellSingleQuote(pattern)}` : "";
+  try {
+    const { stdout } = await execPromise(
+      `git tag${list} --sort=-creatordate`,
+      { cwd, logLevel, noStderr: true, noStdout: true, noSuccess: true, maxBuffer: LIST_TAGS_MAX_BUFFER }
+    );
+    return stdout.trim().split("\n").filter((tag) => tag.length > 0);
+  } catch {
+    return [];
+  }
+}
+async function retagAnnotatedLocal({
+  tag,
+  commit,
+  message,
+  signed,
+  cwd,
+  logLevel
+}) {
+  const sign = signed ? "-s " : "";
+  await execPromise(
+    `git tag -f ${sign}-a ${shellSingleQuote(tag)} ${shellSingleQuote(commit)} -m ${shellSingleQuote(message)}`,
+    { cwd, logLevel, noStderr: true, noStdout: true }
+  );
+}
+async function pushTagForce(tag, cwd, logLevel) {
+  await execPromise(
+    `git push origin ${shellSingleQuote(tag)} --force`,
+    { cwd, logLevel, noStderr: true, noStdout: true }
+  );
+}
+const COMMIT_SEPARATOR = "";
+const FIELD_SEPARATOR = "";
+function getGitDiff(from, to = "HEAD", cwd) {
+  const range = from ? `${from}...${to}` : to;
+  const output = execSync(
+    `git --no-pager log "${range}" --pretty="%x1E%s%x1F%h%x1F%an%x1F%ae%n%b" --name-status`,
+    { cwd, encoding: "utf8" }
+  ).trim();
+  return output.split(COMMIT_SEPARATOR).slice(1).map((record) => {
+    const [firstLine = "", ...body] = record.split("\n");
+    const [message = "", shortHash = "", authorName = "", authorEmail = ""] = firstLine.split(FIELD_SEPARATOR);
+    return {
+      message,
+      shortHash,
+      author: { name: authorName, email: authorEmail },
+      body: body.join("\n")
+    };
+  });
+}
 
 function getPackageDependencies({
   packagePath,
@@ -134,94 +242,6 @@ function topologicalSort(packages) {
   return sorted;
 }
 
-function shellSingleQuote(value) {
-  return `'${value.replaceAll("'", "'\\''")}'`;
-}
-async function isAncestor(ancestor, descendant, cwd) {
-  try {
-    await execPromise(
-      `git merge-base --is-ancestor ${shellSingleQuote(ancestor)} ${shellSingleQuote(descendant)}`,
-      { cwd, noStderr: true, noStdout: true, noSuccess: true, noError: true }
-    );
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function getCommitSubject(ref, cwd) {
-  try {
-    const { stdout } = await execPromise(
-      `git log -1 --format=%s ${shellSingleQuote(ref)}`,
-      { cwd, noStderr: true, noStdout: true, noSuccess: true, noError: true }
-    );
-    return stdout.trim() || null;
-  } catch {
-    return null;
-  }
-}
-async function findReachableCommitBySubject(subject, to, cwd) {
-  try {
-    const { stdout } = await execPromise(
-      `git log ${shellSingleQuote(to)} --grep=${shellSingleQuote(subject)} --fixed-strings --format=%H -n 1`,
-      { cwd, noStderr: true, noStdout: true, noSuccess: true, noError: true }
-    );
-    return stdout.trim().split("\n")[0]?.trim() || null;
-  } catch {
-    return null;
-  }
-}
-async function tagExists(tag, cwd) {
-  try {
-    const tagRef = `refs/tags/${tag}`;
-    await execPromise(
-      `git rev-parse --verify --quiet ${shellSingleQuote(tagRef)}`,
-      { cwd, noStderr: true, noStdout: true, noSuccess: true, noError: true }
-    );
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function retagAnnotatedLocal({
-  tag,
-  commit,
-  message,
-  signed,
-  cwd,
-  logLevel
-}) {
-  const sign = signed ? "-s " : "";
-  await execPromise(
-    `git tag -f ${sign}-a ${shellSingleQuote(tag)} ${shellSingleQuote(commit)} -m ${shellSingleQuote(message)}`,
-    { cwd, logLevel, noStderr: true, noStdout: true }
-  );
-}
-async function pushTagForce(tag, cwd, logLevel) {
-  await execPromise(
-    `git push origin ${shellSingleQuote(tag)} --force`,
-    { cwd, logLevel, noStderr: true, noStdout: true }
-  );
-}
-const COMMIT_SEPARATOR = "";
-const FIELD_SEPARATOR = "";
-function getGitDiff(from, to = "HEAD", cwd) {
-  const range = from ? `${from}...${to}` : to;
-  const output = execSync(
-    `git --no-pager log "${range}" --pretty="%x1E%s%x1F%h%x1F%an%x1F%ae%n%b" --name-status`,
-    { cwd, encoding: "utf8" }
-  ).trim();
-  return output.split(COMMIT_SEPARATOR).slice(1).map((record) => {
-    const [firstLine = "", ...body] = record.split("\n");
-    const [message = "", shortHash = "", authorName = "", authorEmail = ""] = firstLine.split(FIELD_SEPARATOR);
-    return {
-      message,
-      shortHash,
-      author: { name: authorName, email: authorEmail },
-      body: body.join("\n")
-    };
-  });
-}
-
 const sessionCache = /* @__PURE__ */ new Map();
 function resetRewrittenTagCache() {
   sessionCache.clear();
@@ -1104,7 +1124,7 @@ function updateLernaVersion({
     logger.fail(`Unable to update lerna.json: ${error}`);
   }
 }
-function extractVersionFromPackageTag(tag) {
+function extractVersionFromPackageTag$1(tag) {
   const atIndex = tag.lastIndexOf("@");
   if (atIndex === -1) {
     return null;
@@ -1399,7 +1419,7 @@ function getIndependentTag({ version, name }) {
 }
 async function getLastStableTag({ logLevel, cwd }) {
   const { stdout } = await execPromise(
-    `git tag --sort=-creatordate | grep -E '^[^0-9]*[0-9]+\\.[0-9]+\\.[0-9]+$' | head -n 1`,
+    `git tag --sort=-creatordate | grep -E '^[^0-9@]*[0-9]+\\.[0-9]+\\.[0-9]+$' | head -n 1`,
     {
       logLevel,
       noStderr: true,
@@ -1424,81 +1444,132 @@ async function getLastTag({ logLevel, cwd }) {
   logger.debug("Last tag:", lastTag || "No tags found");
   return lastTag;
 }
-async function getAllRecentRepoTags(options) {
-  const limit = options?.limit;
-  try {
-    const { stdout } = await execPromise(
-      `git tag --sort=-creatordate | head -n ${limit}`,
-      {
-        logLevel: options?.logLevel,
-        noStderr: true,
-        noStdout: true,
-        noSuccess: true,
-        cwd: options?.cwd
-      }
-    );
-    const tags = stdout.trim().split("\n").filter((tag) => tag.length > 0);
-    logger.debug(`Retrieved ${tags.length} recent repo tags`);
-    return tags;
-  } catch {
-    return [];
+const NEW_VERSION_PLACEHOLDER = "{{newVersion}}";
+function parseTagVersion(value) {
+  return /^\d/.test(value) ? semver.valid(value) : null;
+}
+function splitTagBody(tagBody) {
+  const index = tagBody.indexOf(NEW_VERSION_PLACEHOLDER);
+  if (index === -1) {
+    return null;
+  }
+  return {
+    prefix: tagBody.slice(0, index),
+    suffix: tagBody.slice(index + NEW_VERSION_PLACEHOLDER.length)
+  };
+}
+function extractVersionFromRepoTag(tag, tagBody) {
+  const parts = splitTagBody(tagBody);
+  if (!parts || !tag.startsWith(parts.prefix) || !tag.endsWith(parts.suffix)) {
+    return null;
+  }
+  return parseTagVersion(tag.slice(parts.prefix.length, tag.length - parts.suffix.length));
+}
+function extractVersionFromLegacyRepoTag(tag) {
+  return parseTagVersion(tag.startsWith("v") ? tag.slice(1) : tag);
+}
+function extractVersionFromPackageTag(tag, packageName) {
+  const prefix = `${packageName}@`;
+  return tag.startsWith(prefix) ? parseTagVersion(tag.slice(prefix.length)) : null;
+}
+async function getRepoTags({
+  tagBody,
+  logLevel,
+  cwd
+}) {
+  const templateTags = [];
+  const legacyTags = [];
+  const unrecognizedTags = [];
+  for (const tag of await listTags({ logLevel, cwd })) {
+    const templateVersion = tagBody ? extractVersionFromRepoTag(tag, tagBody) : null;
+    if (templateVersion) {
+      templateTags.push({ tag, version: templateVersion });
+      continue;
+    }
+    const legacyVersion = extractVersionFromLegacyRepoTag(tag);
+    if (legacyVersion) {
+      legacyTags.push({ tag, version: legacyVersion });
+    } else if (!tag.includes("@") && tag.split(/[^\d.]/).some((part) => semver.valid(part))) {
+      unrecognizedTags.push(tag);
+    }
   }
+  logger.debug(`Retrieved ${templateTags.length} repo tags following "${tagBody}" and ${legacyTags.length} in the v1.2.3 or 1.2.3 format`);
+  return { tags: [...templateTags, ...legacyTags], unrecognizedTags };
 }
-async function getAllRecentPackageTags({
+async function getPackageTags({
   packageName,
-  limit = 50,
   logLevel,
   cwd
 }) {
-  try {
-    const escapedPackageName = packageName.replace(/[@/]/g, "\\$&");
-    const { stdout } = await execPromise(
-      `git tag --sort=-creatordate | grep -E '^${escapedPackageName}@' | head -n ${limit}`,
-      {
-        logLevel,
-        noStderr: true,
-        noStdout: true,
-        noSuccess: true,
-        cwd
-      }
-    );
-    const tags = stdout.trim().split("\n").filter((tag) => tag.length > 0);
-    logger.debug(`Retrieved ${tags.length} recent tags for package ${packageName}`);
-    return tags;
-  } catch {
-    return [];
+  const tags = [];
+  for (const tag of await listTags({ pattern: `${packageName}@*`, logLevel, cwd })) {
+    const version = extractVersionFromPackageTag(tag, packageName);
+    if (version) {
+      tags.push({ tag, version });
+    }
   }
+  logger.debug(`Retrieved ${tags.length} tags for package ${packageName}`);
+  return tags;
 }
-function filterCompatibleTags({
+function selectPreviousTag({
   tags,
-  pkg,
-  onlyStable
+  currentVersion,
+  maxVersion,
+  onlyStable,
+  label
 }) {
-  const filtered = tags.filter((tag) => {
-    const tagVersion = extractVersionFromTag(tag, pkg.name);
-    if (!tagVersion) {
-      logger.debug(`Skipping tag ${tag}: cannot extract version`);
-      return false;
-    }
-    if (onlyStable && isPrerelease(tagVersion)) {
-      logger.debug(`Skipping tag ${tag}: prerelease version ${tagVersion} (onlyStable=${onlyStable})`);
+  const candidates = tags.filter(({ tag, version }) => {
+    if (!isTagVersionCompatibleWithCurrent(version, currentVersion)) {
+      logger.debug(`Skipping tag ${tag}: version ${version} has higher major than current ${currentVersion}`);
       return false;
     }
-    if (!isTagVersionCompatibleWithCurrent(tagVersion, pkg.version)) {
-      logger.debug(`Skipping tag ${tag}: version ${tagVersion} has higher major than current ${pkg.version}`);
+    if (semver.valid(maxVersion) && semver.gt(version, maxVersion)) {
+      logger.debug(`Skipping tag ${tag}: version ${version} is higher than ${maxVersion}`);
       return false;
     }
-    logger.debug(`Tag ${tag} with version ${tagVersion} is compatible`);
     return true;
   });
-  logger.debug(`Filtered ${tags.length} tags down to ${filtered.length} compatible tags`);
-  return filtered;
+  const highest = (list) => list.reduce(
+    (best, candidate) => !best || semver.gt(candidate.version, best.version) ? candidate : best,
+    null
+  );
+  if (onlyStable) {
+    const stable = highest(candidates.filter(({ version }) => !isPrerelease(version)));
+    if (stable) {
+      logger.debug(`Previous ${label} tag: ${stable.tag}`);
+      return stable.tag;
+    }
+  }
+  const previous = highest(candidates);
+  if (previous) {
+    if (onlyStable) {
+      logger.info(`No stable ${label} tag found for version ${currentVersion}, falling back to last prerelease tag: ${previous.tag}`);
+    } else {
+      logger.debug(`Previous ${label} tag: ${previous.tag}`);
+    }
+    return previous.tag;
+  }
+  logger.info(`No compatible ${label} tag found for version ${currentVersion}`);
+  return null;
+}
+const warnedUnrecognizedTags = /* @__PURE__ */ new Set();
+function warnUnrecognizedTags({ tags, tagBody, cwd }) {
+  const key = `${cwd}:${tagBody}`;
+  if (tags.length === 0 || warnedUnrecognizedTags.has(key)) {
+    return;
+  }
+  warnedUnrecognizedTags.add(key);
+  logger.warn(
+    `No previous release tag follows templates.tagBody "${tagBody}", but some tags look like one (${tags.slice(0, 3).join(", ")}). If the template was changed, pass the tag of the previous release with --from.`
+  );
 }
 function getLastRepoTag(options) {
   if (options?.pkg) {
     return getLastRepoTagWithFiltering({
       pkg: options.pkg,
       onlyStable: options.onlyStable ?? false,
+      tagBody: options.tagBody,
+      maxVersion: options.currentVersion ?? options.pkg.version,
       logLevel: options.logLevel,
       cwd: options.cwd
     });
@@ -1511,40 +1582,24 @@ function getLastRepoTag(options) {
 async function getLastRepoTagWithFiltering({
   pkg,
   onlyStable,
+  tagBody,
+  maxVersion,
   logLevel,
   cwd
 }) {
-  const recentTags = await getAllRecentRepoTags({ limit: 50, logLevel, cwd });
-  if (recentTags.length === 0) {
-    logger.info("No tags found in repository");
+  const { tags, unrecognizedTags } = await getRepoTags({ tagBody, logLevel, cwd });
+  if (tags.length === 0) {
+    logger.info("No release tags found in repository");
+    warnUnrecognizedTags({ tags: unrecognizedTags, tagBody, cwd });
     return null;
   }
-  const compatibleTags = filterCompatibleTags({
-    tags: recentTags,
-    pkg,
-    onlyStable
+  return selectPreviousTag({
+    tags,
+    currentVersion: pkg.version,
+    maxVersion,
+    onlyStable,
+    label: "repo"
   });
-  if (compatibleTags.length > 0) {
-    const lastTag = compatibleTags[0];
-    logger.debug(`Last compatible repo tag: ${lastTag}`);
-    return lastTag;
-  }
-  if (onlyStable) {
-    const prereleaseFallback = filterCompatibleTags({
-      tags: recentTags,
-      pkg,
-      onlyStable: false
-    });
-    if (prereleaseFallback.length > 0) {
-      const fallbackTag = prereleaseFallback[0];
-      logger.info(
-        `No stable repo tag found for version ${pkg.version}, falling back to last prerelease tag: ${fallbackTag}`
-      );
-      return fallbackTag;
-    }
-  }
-  logger.info(`No compatible tags found for version ${pkg.version}`);
-  return null;
 }
 async function getLastPackageTag({
   pkg,
@@ -1590,42 +1645,18 @@ async function getLastPackageTagWithFiltering({
   logLevel,
   cwd
 }) {
-  const recentTags = await getAllRecentPackageTags({
-    packageName: pkg.name,
-    limit: 50,
-    logLevel,
-    cwd
-  });
-  if (recentTags.length === 0) {
+  const tags = await getPackageTags({ packageName: pkg.name, logLevel, cwd });
+  if (tags.length === 0) {
     logger.info(`No tags found for package ${pkg.name}`);
     return null;
   }
-  const compatibleTags = filterCompatibleTags({
-    tags: recentTags,
-    pkg,
-    onlyStable
+  return selectPreviousTag({
+    tags,
+    currentVersion: pkg.version,
+    maxVersion: pkg.version,
+    onlyStable,
+    label: `${pkg.name} package`
   });
-  if (compatibleTags.length > 0) {
-    const lastTag = compatibleTags[0];
-    logger.debug(`Last compatible package tag for ${pkg.name}: ${lastTag}`);
-    return lastTag;
-  }
-  if (onlyStable) {
-    const prereleaseFallback = filterCompatibleTags({
-      tags: recentTags,
-      pkg,
-      onlyStable: false
-    });
-    if (prereleaseFallback.length > 0) {
-      const fallbackTag = prereleaseFallback[0];
-      logger.info(
-        `No stable tags found for package ${pkg.name} with version ${pkg.version}, falling back to last prerelease tag: ${fallbackTag}`
-      );
-      return fallbackTag;
-    }
-  }
-  logger.info(`No compatible tags found for package ${pkg.name} with version ${pkg.version}`);
-  return null;
 }
 const NEW_PACKAGE_MARKER = "__NEW_PACKAGE__";
 async function resolveFromTagIndependent({
@@ -1648,6 +1679,18 @@ async function resolveFromTagIndependent({
   }
   return lastPackageTag;
 }
+function getRepoCurrentVersion({ cwd, pkg }) {
+  let rootVersion = null;
+  try {
+    rootVersion = semver.valid(JSON.parse(readFileSync(join(cwd, "package.json"), "utf8")).version);
+  } catch {
+    logger.debug(`Cannot read the root version in ${cwd}, using the version of ${pkg.name}`);
+  }
+  if (!rootVersion || !semver.valid(pkg.version)) {
+    return rootVersion || pkg.version;
+  }
+  return semver.gt(rootVersion, pkg.version) ? rootVersion : pkg.version;
+}
 async function resolveFromTagUnified({
   config,
   pkg,
@@ -1659,6 +1702,8 @@ async function resolveFromTagUnified({
   const lastRepoTag = await getLastRepoTag({
     pkg,
     onlyStable,
+    tagBody: config.templates.tagBody,
+    currentVersion: getRepoCurrentVersion({ cwd: config.cwd, pkg }),
     logLevel,
     cwd: config.cwd
   });
@@ -2536,7 +2581,8 @@ const SENSITIVE_KEYS = /* @__PURE__ */ new Set([
   "_authtoken"
 ]);
 const SECRET_CONTAINER_KEYS = /* @__PURE__ */ new Set(["tokens"]);
-function redactValue(value, inSecretContainer, keyIsSensitive) {
+const CIRCULAR = "[Circular]";
+function redactValue(value, inSecretContainer, keyIsSensitive, ancestors) {
   if (typeof value === "string") {
     if (value === "") {
       return value;
@@ -2546,26 +2592,29 @@ function redactValue(value, inSecretContainer, keyIsSensitive) {
     }
     return value;
   }
-  if (Array.isArray(value)) {
-    return value.map((item) => redactValue(item, inSecretContainer, false));
+  if (!value || typeof value !== "object") {
+    return value;
   }
-  if (value && typeof value === "object") {
-    return redactObject(value, inSecretContainer);
+  if (ancestors.has(value)) {
+    return CIRCULAR;
   }
-  return value;
+  ancestors.add(value);
+  const result = Array.isArray(value) ? value.map((item) => redactValue(item, inSecretContainer, false, ancestors)) : redactObject(value, inSecretContainer, ancestors);
+  ancestors.delete(value);
+  return result;
 }
-function redactObject(obj, inSecretContainer) {
+function redactObject(obj, inSecretContainer, ancestors) {
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
     const lowerKey = key.toLowerCase();
     const childInContainer = inSecretContainer || SECRET_CONTAINER_KEYS.has(lowerKey);
     const keyIsSensitive = SENSITIVE_KEYS.has(lowerKey);
-    result[key] = redactValue(value, childInContainer, keyIsSensitive);
+    result[key] = redactValue(value, childInContainer, keyIsSensitive, ancestors);
   }
   return result;
 }
 function redactSecrets(value) {
-  return redactValue(value, false, false);
+  return redactValue(value, false, false, /* @__PURE__ */ new WeakSet());
 }
 
 function getDefaultConfig() {
@@ -2667,7 +2716,7 @@ function getDefaultConfig() {
       slack: {
         enabled: false,
         onlyStable: true,
-        postMaxLength: 2500,
+        changelogFormat: "summary",
         noAuthors: false,
         noPackages: false
       }
@@ -3416,15 +3465,19 @@ function getCommitBody(commit) {
   const contentLines = lines.filter((line) => {
     const trimmedLine = line.trim();
     if (!trimmedLine) {
-      return false;
+      return true;
     }
     const isFileLine = /^[AMDTUXB](?:\d{3})?\s+/.test(trimmedLine) || /^[RCM]\d{3}\s+/.test(trimmedLine);
     return !isFileLine;
   });
-  if (contentLines.length === 0) {
+  const paragraphLines = contentLines.filter((line, index) => line.trim() || contentLines[index - 1]?.trim());
+  while (paragraphLines.length > 0 && !paragraphLines.at(-1)?.trim()) {
+    paragraphLines.pop();
+  }
+  if (paragraphLines.length === 0) {
     return "";
   }
-  const indentedBody = contentLines.map((line) => `  ${line}`).join("\n");
+  const indentedBody = paragraphLines.map((line) => line.trim() ? `  ${line}` : "").join("\n");
   return `
 
 ${indentedBody}
@@ -3633,29 +3686,76 @@ ${existingChangelog}`;
 const BASE_PROMPT = `You are a release-notes rewriter.
 The user message contains a markdown changelog built from conventional commits, wrapped in a <changelog> tag. Your job: rewrite the content inside that tag.
 Never ask for clarification. Never reply with questions, greetings, or meta-commentary. Your only output is the rewritten changelog content.
-Never invent changes that are not in the input \u2014 if something is not mentioned, it does not exist.
-Never include compare links, contributor lists, or release metadata \u2014 only the content provided.
-Respond with the rewritten content only \u2014 no preamble, no explanation, no surrounding code fence, no <changelog> tag.
+Never invent changes: if something is not mentioned in the input, it does not exist.
+Text indented under a bullet is the body of that commit: use it to understand and describe the change, never treat it as a separate change.
+If the input has one section per package (headings such as "## my-package@1.2.0"), keep each change attributed to its package.
+Never include compare links, contributor lists, or release metadata: only the content provided.
+Respond with the rewritten content only: no preamble, no explanation, no surrounding code fence, no <changelog> tag.
 Output language: {{language}}.`;
 const PROVIDER_RELEASE_PROMPT = `Format the output as markdown with "### <Type>" sections matching the input (Features, Bug Fixes, etc.).
 Merge redundant items that describe the same change.
-Rewrite each bullet for end-user clarity \u2014 focus on what changed for the user, not internal details.
+Rewrite each bullet for end-user clarity: focus on what changed for the user, not internal details.
 Preserve exactly as given: PR and issue references like #123, commit hashes, commit scopes like **auth:**, and all markdown links.
 Preserve the \u26A0\uFE0F marker on breaking items and the "#### \u26A0\uFE0F Breaking Changes" section if present.
 Purely internal commits (chore, refactor with no user-visible impact) may be dropped unless they carry meaningful information.
 Tone: professional, concise, public-facing release notes.`;
-const TWITTER_PROMPT = `Output plain text \u2014 no markdown. A leading "#" becomes a hashtag on Twitter, so avoid it.
-Hard maximum: {{maxLength}} characters \u2014 never exceed it.
-Remove commit hashes (e.g. "aabf96b") and PR/issue references (e.g. "#123") \u2014 they are meaningless on Twitter.
-If the input has one change, write one substantive sentence about it (ground it in the input, never invent).
-If the input has multiple changes, surface 2 to 4 highlights.
-You produce ONLY the changelog content \u2014 the outer template will add the project name, version, and URLs around it.
-Tone: enthusiastic but not cringy. At most 1-2 emojis total.
-Do not add hashtags unless the user explicitly supplies them.`;
-const SLACK_PROMPT = `Format with Slack-compatible markdown: *bold*, _italic_, \`code\`, and "-" bullet lists.
-Keep it concise \u2014 3 to 8 bullets maximum.
-If any breaking changes are present, lead with them.
+const TWITTER_PROMPT = `Output plain text: no markdown syntax at all (no "**", "_", backticks, headings, bullets or links).
+Never start a word with "#": Twitter turns it into a hashtag. Only add hashtags when the extra guidelines ask for them.
+Remove commit hashes (e.g. "aabf96b"), PR and issue references (e.g. "#123") and scope markers (e.g. "**auth:**"): mention the scope in the sentence only when it helps.
+If breaking changes are present, mention them first.
+If the input has one change, write one substantive sentence about it.
+If the input has multiple changes, surface the 2 to 4 most user-visible ones.
+You produce ONLY the changelog content: the outer template adds the project name, version, and URLs around it.
+Tone: enthusiastic but not cringy. At most 1 or 2 emojis in total.`;
+const SLACK_PROMPT = `Format the output as standard markdown: "### <Type>" headings matching the input, "- " bullets, **bold**, _italic_ and \`code\`.
+Never use Slack mrkdwn syntax (single-asterisk bold, <url|text> links): the output is converted for Slack automatically.
+Keep PR and issue references as the markdown links given in the input (e.g. "([#123](https://...))").
+If the input has package headings, keep them as "## " headings.
+If breaking changes are present, lead with them.
+Keep it scannable: 3 to 8 bullets in total, one line each, focused on what changed for the team.
 Tone: factual, oriented toward an internal team audience.`;
+const MAX_LENGTH_PROMPT = `Hard maximum: {{maxLength}} characters. Never exceed it.`;
+function wrapChangelogPrompt(prompt) {
+  return `<changelog>
+${prompt}
+</changelog>
+
+Rewrite the content inside the <changelog> tag per the rules in the system prompt. Output ONLY the rewritten content, with no preamble, no explanation, no surrounding tags.`;
+}
+
+function getModel(config) {
+  const model = config.ai?.providers?.["ai-sdk"]?.model;
+  if (!model) {
+    throw new Error(
+      "No model configured for the ai-sdk provider. Set ai.providers['ai-sdk'].model, e.g. openai('gpt-5-mini') from @ai-sdk/openai."
+    );
+  }
+  return model;
+}
+const aiSdkProvider = {
+  name: "ai-sdk",
+  async safetyCheck(config) {
+    getModel(config);
+    try {
+      await import('ai');
+    } catch {
+      throw new Error("ai is not installed. Install it with: pnpm add -D ai");
+    }
+  },
+  async generate(config, request) {
+    const model = getModel(config);
+    const { generateText } = await import('ai');
+    const reasoning = config.ai?.providers?.["ai-sdk"]?.reasoning;
+    const result = await generateText({
+      model,
+      instructions: request.systemPrompt,
+      prompt: wrapChangelogPrompt(request.prompt),
+      ...reasoning && { reasoning }
+    });
+    logger.verbose("AI SDK steps:", result.steps?.flatMap((step) => step.content.map((part) => part.type)).join(", "));
+    return result.text.trim();
+  }
+};
 
 function claudeBinaryAvailable() {
   try {
@@ -3699,16 +3799,11 @@ const claudeCodeProvider = {
     const { claudeRun } = await import('@yoloship/claude-sdk');
     const auth = resolveAuth(config);
     const model = config.ai?.providers?.["claude-code"]?.model;
-    const wrappedPrompt = `<changelog>
-${request.prompt}
-</changelog>
-
-Rewrite the content inside the <changelog> tag per the rules in the system prompt. Output ONLY the rewritten content, with no preamble, no explanation, no surrounding tags.`;
     const hasAuth = !!(auth.apiKey || auth.oauthToken);
     const result = await claudeRun(
       {
         systemPrompt: request.systemPrompt,
-        prompt: wrappedPrompt,
+        prompt: wrapChangelogPrompt(request.prompt),
         maxTurns: 1,
         effort: "low",
         disableSlashCommands: true,
@@ -3725,7 +3820,8 @@ Rewrite the content inside the <changelog> tag per the rules in the system promp
 };
 
 const providers = {
-  "claude-code": claudeCodeProvider
+  "claude-code": claudeCodeProvider,
+  "ai-sdk": aiSdkProvider
 };
 function getAIProvider(config) {
   const name = config.ai?.provider ?? "claude-code";
@@ -3751,6 +3847,16 @@ function substitutePlaceholders(prompt, vars) {
   }
   return result;
 }
+function getExtraGuidelines(config, target) {
+  const guidelines = config.ai?.extraGuidelines;
+  if (!guidelines) {
+    return [];
+  }
+  if (typeof guidelines === "string") {
+    return [guidelines];
+  }
+  return [guidelines.global, guidelines[target]].filter((guideline) => !!guideline?.trim());
+}
 function assemblePrompt(config, target, maxLength) {
   const vars = {
     language: config.ai?.language ?? "en",
@@ -3761,9 +3867,10 @@ function assemblePrompt(config, target, maxLength) {
     return substitutePlaceholders(override, vars);
   }
   const parts = [BASE_PROMPT, PLATFORM_PROMPTS[target]];
-  if (config.ai?.extraGuidelines) {
-    parts.push(config.ai.extraGuidelines);
+  if (maxLength !== void 0) {
+    parts.push(MAX_LENGTH_PROMPT);
   }
+  parts.push(...getExtraGuidelines(config, target));
   return substitutePlaceholders(parts.join("\n\n"), vars);
 }
 function applyAIOverride(config, ai) {
@@ -4705,6 +4812,648 @@ async function postPrComment({
   }
 }
 
+const SLACK_MAX_BLOCKS = 50;
+const SLACK_SECTION_MAX_LENGTH = 3e3;
+const SLACK_RICH_TEXT_BLOCK_MAX_LENGTH = 3e3;
+const SLACK_RICH_TEXT_MESSAGE_MAX_LENGTH = 11e3;
+const SLACK_HEADER_MAX_LENGTH = 150;
+const ELLIPSIS = "\u2026";
+const SLACK_MAX_LIST_INDENT = 8;
+function parseMarkdown(markdown) {
+  return fromMarkdown(markdown, {
+    extensions: [gfm()],
+    mdastExtensions: [gfmFromMarkdown()]
+  });
+}
+function splitIntoUnits(root) {
+  const units = [];
+  for (const node of root.children) {
+    if (node.type === "heading") {
+      units.push({ type: "heading", node });
+    } else if (node.type === "list") {
+      node.children.forEach((item, index) => units.push({ type: "item", node: item, list: node, index }));
+    } else {
+      units.push({ type: "block", node });
+    }
+  }
+  return units;
+}
+function countOmittedChanges(units) {
+  const items = units.filter((unit) => unit.type === "item").length;
+  return items > 0 ? items : units.filter((unit) => unit.type !== "heading").length;
+}
+function formatOmittedChanges(count) {
+  return count > 0 ? `\u2026 and ${count} more change${count > 1 ? "s" : ""}` : "";
+}
+function sliceSlackText(text, length) {
+  const end = Math.max(0, length);
+  const lastCode = text.charCodeAt(end - 1);
+  return text.slice(0, lastCode >= 55296 && lastCode <= 56319 ? end - 1 : end);
+}
+function dropTrailingHeadings(rendered) {
+  let end = rendered.length;
+  while (end > 0 && rendered[end - 1]?.unit.type === "heading") {
+    end--;
+  }
+  return rendered.slice(0, end);
+}
+function getListItemParts(item) {
+  const [first, ...rest] = item.children;
+  if (first?.type === "paragraph") {
+    return { head: first.children, body: rest };
+  }
+  return { head: [], body: item.children };
+}
+function getCheckboxPrefix(item) {
+  if (item.checked === true) {
+    return "\u2611 ";
+  }
+  if (item.checked === false) {
+    return "\u2610 ";
+  }
+  return "";
+}
+function getListItemNumber(list, index) {
+  return (list.start ?? 1) + index;
+}
+function getAltText(node) {
+  return node.alt ?? "";
+}
+function toPlainText(node) {
+  if ("value" in node && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node.type === "image" || node.type === "imageReference") {
+    return getAltText(node);
+  }
+  if (node.type === "break") {
+    return " ";
+  }
+  if ("children" in node) {
+    return node.children.map(toPlainText).join("");
+  }
+  return "";
+}
+function isAbsoluteUrl(url) {
+  return /^(?:https?:\/\/|mailto:)/i.test(url);
+}
+function collapseSoftBreaks(text) {
+  const lines = text.split("\n");
+  return lines.map((line, index) => {
+    const withoutLeading = index > 0 ? line.trimStart() : line;
+    return index < lines.length - 1 ? withoutLeading.trimEnd() : withoutLeading;
+  }).join(" ");
+}
+function tableToPlainText(table) {
+  return table.children.map((row) => row.children.map((cell) => toPlainText(cell).trim()).join(" | ")).join("\n");
+}
+function escapeMrkdwn(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeMrkdwnUrl(url) {
+  return url.replaceAll("<", "%3C").replaceAll(">", "%3E").replaceAll("|", "%7C");
+}
+function formatMrkdwnLink(url, label) {
+  if (!isAbsoluteUrl(url)) {
+    return escapeMrkdwn(label);
+  }
+  const safeUrl = escapeMrkdwnUrl(url);
+  return label && label !== url ? `<${safeUrl}|${escapeMrkdwn(label)}>` : `<${safeUrl}>`;
+}
+function wrapMrkdwn(marker, children, active) {
+  const inner = renderInlineMrkdwn(children, /* @__PURE__ */ new Set([...active, marker]));
+  if (active.has(marker)) {
+    return inner;
+  }
+  const content = inner.trim();
+  if (!content) {
+    return inner;
+  }
+  const start = inner.indexOf(content);
+  return `${inner.slice(0, start)}${marker}${content}${marker}${inner.slice(start + content.length)}`;
+}
+function renderInlineNodeMrkdwn(node, active) {
+  switch (node.type) {
+    case "text":
+      return escapeMrkdwn(collapseSoftBreaks(node.value));
+    case "strong":
+      return wrapMrkdwn("*", node.children, active);
+    case "emphasis":
+      return wrapMrkdwn("_", node.children, active);
+    case "delete":
+      return wrapMrkdwn("~", node.children, active);
+    case "inlineCode":
+      return `\`${escapeMrkdwn(node.value)}\``;
+    case "break":
+      return "\n";
+    case "link":
+      return formatMrkdwnLink(node.url, toPlainText(node));
+    case "image":
+      return formatMrkdwnLink(node.url, getAltText(node));
+    case "linkReference":
+      return renderInlineMrkdwn(node.children, active);
+    case "imageReference":
+      return escapeMrkdwn(getAltText(node));
+    case "html":
+      return escapeMrkdwn(node.value);
+    case "footnoteReference":
+      return `[^${escapeMrkdwn(node.identifier)}]`;
+  }
+}
+function renderInlineMrkdwn(nodes, active = /* @__PURE__ */ new Set()) {
+  return nodes.map((node) => renderInlineNodeMrkdwn(node, active)).join("");
+}
+function quoteMrkdwn(text) {
+  return text.split("\n").map((line) => `> ${line}`).join("\n");
+}
+function renderListItemMrkdwn(item, list, index, depth) {
+  const indent = "    ".repeat(depth);
+  const bullet = depth === 0 ? "\u2022" : "\u25E6";
+  const marker = list.ordered ? `${getListItemNumber(list, index)}.` : bullet;
+  const { head, body } = getListItemParts(item);
+  const lines = [`${indent}${marker} ${getCheckboxPrefix(item)}${renderInlineMrkdwn(head)}`.trimEnd()];
+  for (const child of body) {
+    if (child.type === "list") {
+      child.children.forEach((subItem, subIndex) => lines.push(renderListItemMrkdwn(subItem, child, subIndex, depth + 1)));
+      continue;
+    }
+    const rendered = renderBlockMrkdwn(child);
+    if (rendered) {
+      lines.push(quoteMrkdwn(rendered));
+    }
+  }
+  return lines.join("\n");
+}
+function renderBlockMrkdwn(node) {
+  switch (node.type) {
+    case "heading": {
+      const text = renderInlineMrkdwn(node.children, /* @__PURE__ */ new Set(["*"])).trim();
+      return text ? `*${text}*` : "";
+    }
+    case "paragraph":
+      return renderInlineMrkdwn(node.children);
+    case "list":
+      return node.children.map((item, index) => renderListItemMrkdwn(item, node, index, 0)).join("\n");
+    case "blockquote":
+      return quoteMrkdwn(node.children.map(renderBlockMrkdwn).filter(Boolean).join("\n"));
+    case "code":
+      return `\`\`\`
+${escapeMrkdwn(node.value)}
+\`\`\``;
+    case "html":
+      return escapeMrkdwn(node.value);
+    case "table":
+      return escapeMrkdwn(tableToPlainText(node));
+    default:
+      return "";
+  }
+}
+function renderUnitMrkdwn(unit) {
+  if (unit.type === "item") {
+    return renderListItemMrkdwn(unit.node, unit.list, unit.index, 0);
+  }
+  return renderBlockMrkdwn(unit.node);
+}
+function joinMrkdwnUnits(rendered) {
+  let text = "";
+  rendered.forEach((current, index) => {
+    const previous = rendered[index - 1];
+    if (previous) {
+      const sameList = previous.unit.type === "item" && current.unit.type === "item" && previous.unit.list === current.unit.list;
+      text += previous.unit.type === "heading" || sameList ? "\n" : "\n\n";
+    }
+    text += current.output;
+  });
+  return text;
+}
+function markdownToSlackMrkdwn(markdown, { maxLength, cutCommits = false } = {}) {
+  if (!markdown.trim()) {
+    return "";
+  }
+  const rendered = splitIntoUnits(parseMarkdown(markdown)).map((unit) => ({ unit, output: renderUnitMrkdwn(unit), length: 0 })).filter(({ output }) => output !== "");
+  const full = joinMrkdwnUnits(rendered);
+  if (maxLength === void 0 || full.length <= maxLength) {
+    return full;
+  }
+  for (let count = rendered.length - 1; count >= 0; count--) {
+    const next = rendered[count];
+    if (cutCommits && next.unit.type !== "heading") {
+      const note2 = formatOmittedChanges(countOmittedChanges(rendered.slice(count + 1).map(({ unit }) => unit)));
+      const suffix = note2 ? `
+
+_${note2}_` : "";
+      const prefix = joinMrkdwnUnits([...rendered.slice(0, count), { ...next, output: "" }]);
+      const cut = cutMrkdwn(next.output, maxLength - prefix.length - suffix.length - ELLIPSIS.length);
+      if (cut) {
+        return `${prefix}${cut}${ELLIPSIS}${suffix}`;
+      }
+    }
+    const kept = dropTrailingHeadings(rendered.slice(0, count));
+    if (kept.length === 0) {
+      continue;
+    }
+    const note = formatOmittedChanges(countOmittedChanges(rendered.slice(kept.length).map(({ unit }) => unit)));
+    const candidate = note ? `${joinMrkdwnUnits(kept)}
+
+_${note}_` : joinMrkdwnUnits(kept);
+    if (candidate.length <= maxLength) {
+      return candidate;
+    }
+  }
+  return `${sliceSlackText(full, maxLength - 3)}...`;
+}
+function cutMrkdwn(text, budget) {
+  if (budget <= 0) {
+    return "";
+  }
+  let cut = sliceSlackText(text, budget);
+  const linkStart = cut.lastIndexOf("<");
+  if (linkStart > cut.lastIndexOf(">")) {
+    cut = cut.slice(0, linkStart);
+  }
+  const entityStart = cut.lastIndexOf("&");
+  if (entityStart > cut.lastIndexOf(";")) {
+    cut = cut.slice(0, entityStart);
+  }
+  cut = cut.trimEnd();
+  return /[^\s•◦>]/.test(cut) ? cut : "";
+}
+function hasStyle(style) {
+  return Object.values(style).some(Boolean);
+}
+function pushText(elements, text, style) {
+  if (!text) {
+    return;
+  }
+  const previous = elements.at(-1);
+  if (previous?.type === "text" && JSON.stringify(previous.style ?? {}) === JSON.stringify(style)) {
+    previous.text += text;
+    return;
+  }
+  elements.push(hasStyle(style) ? { type: "text", text, style: { ...style } } : { type: "text", text });
+}
+function pushLink(elements, url, text, style) {
+  if (!isAbsoluteUrl(url)) {
+    pushText(elements, text, style);
+    return;
+  }
+  const link = { type: "link", url };
+  if (text && text !== url) {
+    link.text = text;
+  }
+  if (hasStyle(style)) {
+    link.style = { ...style };
+  }
+  elements.push(link);
+}
+function appendInlineRichText(elements, node, style) {
+  switch (node.type) {
+    case "text":
+      pushText(elements, collapseSoftBreaks(node.value), style);
+      break;
+    case "strong":
+      node.children.forEach((child) => appendInlineRichText(elements, child, { ...style, bold: true }));
+      break;
+    case "emphasis":
+      node.children.forEach((child) => appendInlineRichText(elements, child, { ...style, italic: true }));
+      break;
+    case "delete":
+      node.children.forEach((child) => appendInlineRichText(elements, child, { ...style, strike: true }));
+      break;
+    case "inlineCode":
+      pushText(elements, node.value, { ...style, code: true });
+      break;
+    case "break":
+      pushText(elements, "\n", style);
+      break;
+    case "link":
+      pushLink(elements, node.url, toPlainText(node), style);
+      break;
+    case "image":
+      pushLink(elements, node.url, getAltText(node), style);
+      break;
+    case "linkReference":
+      node.children.forEach((child) => appendInlineRichText(elements, child, style));
+      break;
+    case "imageReference":
+      pushText(elements, getAltText(node), style);
+      break;
+    case "html":
+      pushText(elements, node.value, style);
+      break;
+    case "footnoteReference":
+      pushText(elements, `[^${node.identifier}]`, style);
+      break;
+  }
+}
+function renderInlineRichText(nodes, style = {}, prefix = "") {
+  const elements = [];
+  pushText(elements, prefix, style);
+  nodes.forEach((node) => appendInlineRichText(elements, node, style));
+  return elements;
+}
+function ensureNotEmpty(elements) {
+  return elements.length > 0 ? elements : [{ type: "text", text: " " }];
+}
+function preformatted(value) {
+  return value ? [{ type: "rich_text_preformatted", elements: [{ type: "text", text: value }] }] : [];
+}
+function quote(elements) {
+  return elements.length > 0 ? [{ type: "rich_text_quote", elements }] : [];
+}
+function blockquoteInline(nodes) {
+  const elements = [];
+  nodes.forEach((node, index) => {
+    if (index > 0) {
+      pushText(elements, "\n", {});
+    }
+    if (node.type === "paragraph" || node.type === "heading") {
+      node.children.forEach((child) => appendInlineRichText(elements, child, node.type === "heading" ? { bold: true } : {}));
+    } else {
+      pushText(elements, toPlainText(node), {});
+    }
+  });
+  return elements;
+}
+function renderBodyBlockRichText(node) {
+  switch (node.type) {
+    case "paragraph":
+      return quote(renderInlineRichText(node.children));
+    case "heading":
+      return [{ type: "rich_text_section", elements: ensureNotEmpty(renderInlineRichText(node.children, { bold: true })) }];
+    case "blockquote":
+      return quote(blockquoteInline(node.children));
+    case "code":
+      return preformatted(node.value);
+    case "html":
+      return quote(renderInlineRichText([], {}, node.value));
+    case "table":
+      return preformatted(tableToPlainText(node));
+    default:
+      return [];
+  }
+}
+function renderListItemRichText(item, list, index, indent) {
+  const { head, body } = getListItemParts(item);
+  const listElement = {
+    type: "rich_text_list",
+    style: list.ordered ? "ordered" : "bullet",
+    elements: [{ type: "rich_text_section", elements: ensureNotEmpty(renderInlineRichText(head, {}, getCheckboxPrefix(item))) }]
+  };
+  if (indent > 0) {
+    listElement.indent = Math.min(indent, SLACK_MAX_LIST_INDENT);
+  }
+  const offset = list.ordered ? getListItemNumber(list, index) - 1 : 0;
+  if (offset > 0) {
+    listElement.offset = offset;
+  }
+  const elements = [listElement];
+  for (const child of body) {
+    if (child.type === "list") {
+      child.children.forEach((subItem, subIndex) => elements.push(...renderListItemRichText(subItem, child, subIndex, indent + 1)));
+    } else {
+      elements.push(...renderBodyBlockRichText(child));
+    }
+  }
+  return elements;
+}
+function renderUnitRichText(unit) {
+  if (unit.type === "heading") {
+    const elements = renderInlineRichText(unit.node.children, { bold: true });
+    return elements.length > 0 ? [{ type: "rich_text_section", elements }] : [];
+  }
+  if (unit.type === "item") {
+    return renderListItemRichText(unit.node, unit.list, unit.index, 0);
+  }
+  const node = unit.node;
+  switch (node.type) {
+    case "paragraph":
+      return [{ type: "rich_text_section", elements: ensureNotEmpty(renderInlineRichText(node.children)) }];
+    case "blockquote":
+      return quote(blockquoteInline(node.children));
+    case "code":
+      return preformatted(node.value);
+    case "html":
+      return [{ type: "rich_text_section", elements: ensureNotEmpty(renderInlineRichText([], {}, node.value)) }];
+    case "table":
+      return preformatted(tableToPlainText(node));
+    default:
+      return [];
+  }
+}
+function inlineLength(elements) {
+  return elements.reduce((total, element) => total + (element.type === "text" ? element.text.length : (element.text ?? element.url).length), 0);
+}
+function elementLength(element) {
+  return richTextToPlainText({ elements: [element] }).length + 1;
+}
+function blocksLength(blocks) {
+  return blocks.map(richTextToPlainText).join("\n\n").length;
+}
+function isSameListLevel(previous, element) {
+  return previous?.type === "rich_text_list" && element.type === "rich_text_list" && previous.style === element.style && (previous.indent ?? 0) === (element.indent ?? 0);
+}
+function isSameInlineContainer(previous, element) {
+  return (element.type === "rich_text_section" || element.type === "rich_text_quote") && previous?.type === element.type;
+}
+function appendElement(elements, element) {
+  const previous = elements.at(-1);
+  if (isSameListLevel(previous, element) && element.type === "rich_text_list") {
+    previous.elements.push(...structuredClone(element.elements));
+    return;
+  }
+  if (isSameInlineContainer(previous, element) && element.type !== "rich_text_list") {
+    const last = previous.elements.at(-1);
+    const separatorStyle = last?.type === "text" ? last.style ?? {} : {};
+    pushText(previous.elements, element.type === "rich_text_quote" ? "\n\n" : "\n", separatorStyle);
+    for (const inline of structuredClone(element.elements)) {
+      if (inline.type === "text") {
+        pushText(previous.elements, inline.text, inline.style ?? {});
+      } else {
+        previous.elements.push(inline);
+      }
+    }
+    return;
+  }
+  elements.push(structuredClone(element));
+}
+function assembleRichTextBlocks(rendered, blockMaxLength) {
+  const blocks = [];
+  let current;
+  let currentLength = 0;
+  let currentHasContent = false;
+  for (const { unit, output, length } of rendered) {
+    const startsSection = unit.type === "heading" && currentHasContent;
+    const overflows = currentHasContent && currentLength + length > blockMaxLength;
+    if (!current || startsSection || overflows) {
+      current = { type: "rich_text", elements: [] };
+      blocks.push(current);
+      currentLength = 0;
+      currentHasContent = false;
+    }
+    output.forEach((element) => appendElement(current.elements, element));
+    currentLength += length;
+    currentHasContent ||= unit.type !== "heading";
+  }
+  return blocks;
+}
+function takeInlineCharacters(elements, count) {
+  const kept = [];
+  let remaining = count;
+  for (const element of elements) {
+    const length = inlineLength([element]);
+    if (length <= remaining) {
+      kept.push(structuredClone(element));
+      remaining -= length;
+      continue;
+    }
+    if (element.type === "text") {
+      pushText(kept, sliceSlackText(element.text, remaining), element.style ?? {});
+    }
+    break;
+  }
+  return kept;
+}
+function takeElementCharacters(element, count) {
+  const inlines = element.type === "rich_text_list" ? element.elements[0].elements : element.elements;
+  const elements = takeInlineCharacters(inlines, count);
+  if (elements.length === 0) {
+    return void 0;
+  }
+  return element.type === "rich_text_list" ? { ...element, elements: [{ type: "rich_text_section", elements }] } : { ...element, elements };
+}
+function withEllipsis(element) {
+  const result = structuredClone(element);
+  const inlines = result.type === "rich_text_list" ? result.elements.at(-1).elements : result.elements;
+  const last = inlines.at(-1);
+  if (last?.type === "text") {
+    last.text = last.text.trimEnd();
+    if (!last.text) {
+      inlines.pop();
+    }
+  }
+  pushText(inlines, ELLIPSIS, {});
+  return result;
+}
+function cutRichTextElement(element, budget) {
+  const characters = element.type === "rich_text_list" ? element.elements.reduce((total, section) => total + inlineLength(section.elements), 0) : inlineLength(element.elements);
+  let best;
+  let low = 1;
+  let high = characters - 1;
+  while (low <= high) {
+    const count = Math.floor((low + high) / 2);
+    const taken = takeElementCharacters(element, count);
+    const candidate = taken && withEllipsis(taken);
+    if (candidate && elementLength(candidate) <= budget) {
+      best = candidate;
+      low = count + 1;
+    } else {
+      high = count - 1;
+    }
+  }
+  return best;
+}
+function cutRichTextElements(elements, budget) {
+  const kept = [];
+  let remaining = budget;
+  for (const element of elements) {
+    const length = elementLength(element);
+    if (length + ELLIPSIS.length <= remaining) {
+      kept.push(structuredClone(element));
+      remaining -= length;
+      continue;
+    }
+    const cut = cutRichTextElement(element, remaining);
+    if (cut) {
+      return [...kept, cut];
+    }
+    break;
+  }
+  const last = kept.pop();
+  return last ? [...kept, withEllipsis(last)] : [];
+}
+function markdownToSlackRichText(markdown, {
+  maxLength,
+  maxBlocks = SLACK_MAX_BLOCKS,
+  maxPayloadLength,
+  blockMaxLength = SLACK_RICH_TEXT_BLOCK_MAX_LENGTH
+} = {}) {
+  if (!markdown.trim() || maxBlocks < 1) {
+    return [];
+  }
+  const rendered = splitIntoUnits(parseMarkdown(markdown)).map((unit) => {
+    const output = renderUnitRichText(unit);
+    return { unit, output, length: output.reduce((total, element) => total + elementLength(element), 0) };
+  }).filter(({ output }) => output.length > 0);
+  const totalLength = (units) => units.reduce((total, { length }) => total + length, 0);
+  const fits = (candidate) => candidate.length <= maxBlocks && (maxLength === void 0 || blocksLength(candidate) <= maxLength) && (maxPayloadLength === void 0 || JSON.stringify(candidate).length <= maxPayloadLength);
+  const blocks = assembleRichTextBlocks(rendered, blockMaxLength);
+  if (fits(blocks)) {
+    return blocks;
+  }
+  const truncate = (chars) => {
+    let remaining = chars;
+    let index = 0;
+    const kept = [];
+    for (; index < rendered.length && rendered[index].length <= remaining; index++) {
+      kept.push(rendered[index]);
+      remaining -= rendered[index].length;
+    }
+    const next = rendered[index];
+    const cut = next && next.unit.type !== "heading" ? cutRichTextElements(next.output, remaining) : [];
+    const visible = cut.length > 0 ? [...kept, { unit: next.unit, output: cut, length: cut.reduce((total, element) => total + elementLength(element), 0) }] : dropTrailingHeadings(kept);
+    const note = formatOmittedChanges(countOmittedChanges(rendered.slice(cut.length > 0 ? index + 1 : visible.length).map(({ unit }) => unit)));
+    const truncated = assembleRichTextBlocks(visible, blockMaxLength);
+    if (note) {
+      const noteSection = { type: "rich_text_section", elements: [{ type: "text", text: note, style: { italic: true } }] };
+      const last = truncated.at(-1);
+      if (last) {
+        last.elements.push(noteSection);
+      } else {
+        truncated.push({ type: "rich_text", elements: [noteSection] });
+      }
+    }
+    return truncated;
+  };
+  let best = truncate(0);
+  let low = 1;
+  let high = totalLength(rendered) - 1;
+  while (low <= high) {
+    const chars = Math.floor((low + high) / 2);
+    const candidate = truncate(chars);
+    if (fits(candidate)) {
+      best = candidate;
+      low = chars + 1;
+    } else {
+      high = chars - 1;
+    }
+  }
+  return best;
+}
+function inlineToPlainText(elements) {
+  return elements.map((element) => element.type === "text" ? element.text : element.text ?? element.url).join("");
+}
+function richTextToPlainText(block) {
+  return block.elements.map((element) => {
+    switch (element.type) {
+      case "rich_text_list":
+        return element.elements.map((section, index) => {
+          const indent = "    ".repeat(element.indent ?? 0);
+          const marker = element.style === "ordered" ? `${(element.offset ?? 0) + index + 1}.` : "\u2022";
+          return `${indent}${marker} ${inlineToPlainText(section.elements)}`;
+        }).join("\n");
+      case "rich_text_quote":
+        return quoteMrkdwn(inlineToPlainText(element.elements));
+      case "rich_text_preformatted":
+        return `\`\`\`
+${inlineToPlainText(element.elements)}
+\`\`\``;
+      default:
+        return inlineToPlainText(element.elements);
+    }
+  }).join("\n");
+}
+
 function extractChangelogSummary(changelog, { stripBoldMarkers = false, maxLength } = {}) {
   if (changelog.trim() === "") {
     return "";
@@ -4755,14 +5504,12 @@ function getSlackToken(options) {
 function getSlackWebhookUrl(options) {
   return options.socialWebhookUrl || process.env.RELIZY_SLACK_WEBHOOK_URL || process.env.SLACK_WEBHOOK_URL || null;
 }
-function formatChangelogForSlack(changelog, maxLength = 2500) {
-  let formatted = changelog.replace(/^### (.+)$/gm, "*$1*").replace(/^## (.+)$/gm, "*$1*").replace(/^# (.+)$/gm, "*$1*").replace(/\*\*(.+?)\*\*/g, "*$1*").replace(/^([ \t]*)-[ \t]+/gm, "$1\u2022 ");
-  const linkPattern = /\[([^\]]*)]\(([^)]*)\)/g;
-  formatted = formatted.replace(linkPattern, (_, text, url) => `<${url}|${text}>`);
-  if (formatted.length > maxLength) {
-    formatted = `${formatted.substring(0, maxLength - 3)}...`;
-  }
-  return formatted;
+const SLACK_SUMMARY_MAX_LENGTH = 2500;
+function resolveSlackPostMaxLength({ changelogFormat = "summary", postMaxLength }) {
+  return postMaxLength ?? (changelogFormat === "full" ? void 0 : SLACK_SUMMARY_MAX_LENGTH);
+}
+function formatChangelogForSlack(changelog, maxLength = SLACK_SUMMARY_MAX_LENGTH) {
+  return markdownToSlackMrkdwn(changelog, { maxLength });
 }
 function formatPackagesForSlack(packages) {
   if (packages.length === 0) {
@@ -4772,75 +5519,96 @@ function formatPackagesForSlack(packages) {
     (pkg) => pkg.hasTransition ? `\u2022 *${pkg.name}* : \`${pkg.oldVersion}\` \u2192 \`${pkg.newVersion}\`` : `\u2022 *${pkg.name}* : \`${pkg.version}\``
   ).join("\n");
 }
-function formatSlackMessage({ projectName, version, changelog, releaseUrl, changelogUrl, template, contributors = [], packages = [], postMaxLength = 2500 }) {
+function truncateSlackText(text, maxLength) {
+  return text.length > maxLength ? `${sliceSlackText(text, maxLength - 1)}\u2026` : text;
+}
+function formatListSection(title, lines, noun) {
+  const render = (count) => {
+    const omitted = lines.length - count;
+    const kept = lines.slice(0, count);
+    if (omitted > 0) {
+      kept.push(`_\u2026 and ${omitted} more ${noun}_`);
+    }
+    return `${title}
+
+${kept.join("\n")}`;
+  };
+  for (let count = lines.length; count > 0; count--) {
+    const text = render(count);
+    if (text.length <= SLACK_SECTION_MAX_LENGTH) {
+      return text;
+    }
+  }
+  return truncateSlackText(render(0), SLACK_SECTION_MAX_LENGTH);
+}
+function renderSlackTemplate({ template, projectName, version, changelog, contributorsLine, packagesLine, releaseUrl, changelogUrl }) {
+  let message = template.replace("{{projectName}}", projectName).replace("{{newVersion}}", version).replace("{{changelog}}", changelog).replace("{{contributors}}", contributorsLine).replace("{{packages}}", packagesLine);
+  if (releaseUrl) {
+    message = message.replace("{{releaseUrl}}", releaseUrl);
+  } else {
+    message = message.replace("{{releaseUrl}}", "").trim();
+  }
+  if (changelogUrl) {
+    message = message.replace("{{changelogUrl}}", changelogUrl);
+  } else {
+    message = message.replace("{{changelogUrl}}", "").trim();
+  }
+  return message;
+}
+function formatSlackMessage({ projectName, version, changelog, releaseUrl, changelogUrl, template, contributors = [], packages = [], postMaxLength, changelogFormat = "summary" }) {
   const contributorsLine = contributors.length > 0 ? contributors.map((n) => `\u2022 ${n}`).join("\n") : "";
   const packagesLine = formatPackagesForSlack(packages);
+  const maxLength = resolveSlackPostMaxLength({ changelogFormat, postMaxLength });
   if (template) {
-    const summary = extractChangelogSummary(changelog, { maxLength: postMaxLength });
-    let message = template.replace("{{projectName}}", projectName).replace("{{newVersion}}", version).replace("{{changelog}}", summary).replace("{{contributors}}", contributorsLine).replace("{{packages}}", packagesLine);
-    if (releaseUrl) {
-      message = message.replace("{{releaseUrl}}", releaseUrl);
-    } else {
-      message = message.replace("{{releaseUrl}}", "").trim();
-    }
-    if (changelogUrl) {
-      message = message.replace("{{changelogUrl}}", changelogUrl);
+    const templateContext = { template, projectName, version, contributorsLine, packagesLine, releaseUrl, changelogUrl };
+    let changelogText;
+    if (changelogFormat === "full") {
+      const overhead = renderSlackTemplate({ ...templateContext, changelog: "\0" }).length - 1;
+      changelogText = markdownToSlackMrkdwn(changelog, {
+        maxLength: Math.max(0, Math.min(maxLength ?? Infinity, SLACK_SECTION_MAX_LENGTH - overhead)),
+        cutCommits: true
+      });
     } else {
-      message = message.replace("{{changelogUrl}}", "").trim();
+      changelogText = extractChangelogSummary(changelog, { maxLength });
     }
     return [
       {
         type: "section",
         text: {
           type: "mrkdwn",
-          text: message
+          text: truncateSlackText(renderSlackTemplate({ ...templateContext, changelog: changelogText }), SLACK_SECTION_MAX_LENGTH)
         }
       }
     ];
   }
-  const blocks = [
-    {
-      type: "header",
-      text: {
-        type: "plain_text",
-        text: `\u{1F4E3} ${projectName} ${version} is out!`,
-        emoji: true
-      }
+  const headerBlock = {
+    type: "header",
+    text: {
+      type: "plain_text",
+      text: truncateSlackText(`\u{1F4E3} ${projectName} ${version} is out!`, SLACK_HEADER_MAX_LENGTH),
+      emoji: true
     }
-  ];
-  const formattedChangelog = formatChangelogForSlack(changelog, postMaxLength);
-  if (formattedChangelog) {
-    blocks.push({
-      type: "section",
-      text: {
-        type: "mrkdwn",
-        text: formattedChangelog
-      }
-    });
-  }
+  };
+  const trailingBlocks = [];
   if (packages.length > 0) {
-    blocks.push({
+    trailingBlocks.push({
       type: "section",
       text: {
         type: "mrkdwn",
-        text: `*\u{1F4E6} Packages*
-
-${packagesLine}`
+        text: formatListSection("*\u{1F4E6} Packages*", packagesLine.split("\n"), "packages")
       }
     });
   }
   if (contributors.length > 0) {
-    blocks.push({
+    trailingBlocks.push({
       type: "section",
       text: {
         type: "mrkdwn",
-        text: `*\u2764\uFE0F Contributors*
-
-${contributorsLine}`
+        text: formatListSection("*\u2764\uFE0F Contributors*", contributorsLine.split("\n"), "contributors")
       }
     });
   }
-  blocks.push({
+  trailingBlocks.push({
     type: "divider"
   });
   const elements = [];
@@ -4869,19 +5637,39 @@ ${contributorsLine}`
     });
   }
   if (elements.length > 0) {
-    blocks.push({
+    trailingBlocks.push({
       type: "actions",
       elements
     });
   }
-  return blocks;
+  const changelogBlocks = [];
+  if (changelogFormat === "full") {
+    const surroundingBlocks = [headerBlock, ...trailingBlocks];
+    changelogBlocks.push(...markdownToSlackRichText(changelog, {
+      maxLength,
+      maxBlocks: SLACK_MAX_BLOCKS - surroundingBlocks.length,
+      maxPayloadLength: SLACK_RICH_TEXT_MESSAGE_MAX_LENGTH - JSON.stringify(surroundingBlocks).length
+    }));
+  } else {
+    const formattedChangelog = formatChangelogForSlack(changelog, Math.min(postMaxLength ?? SLACK_SUMMARY_MAX_LENGTH, SLACK_SECTION_MAX_LENGTH));
+    if (formattedChangelog) {
+      changelogBlocks.push({
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: formattedChangelog
+        }
+      });
+    }
+  }
+  return [headerBlock, ...changelogBlocks, ...trailingBlocks];
 }
 function mapWebhookError(status, body) {
   if (status === 404 || body.includes("no_service")) {
     return "The webhook URL is invalid or has been deactivated. Regenerate it in your Slack app settings.";
   }
   if (body.includes("invalid_payload")) {
-    return "The message payload was rejected by Slack (likely exceeds 3000 chars per block). Lower social.slack.postMaxLength.";
+    return 'The message payload was rejected by Slack (likely exceeds its block limits). Lower social.slack.postMaxLength or switch social.slack.changelogFormat to "summary".';
   }
   if (body.includes("channel_not_found")) {
     return "The channel bound to this webhook was archived or removed. Create a new webhook.";
@@ -4953,6 +5741,7 @@ async function postReleaseToSlack({
   contributors,
   packages,
   postMaxLength,
+  changelogFormat,
   dryRun = false
 }) {
   const useWebhook = Boolean(webhookUrl);
@@ -4973,12 +5762,13 @@ async function postReleaseToSlack({
     changelogUrl,
     contributors,
     packages,
-    postMaxLength
+    postMaxLength,
+    changelogFormat
   });
   const fallbackText = `${projectName} ${version} is out!`;
   logger.debug(`Message blocks (${blocks.length} blocks)`);
   if (dryRun) {
-    const preview = blocks.filter((b) => b.type === "header" || b.type === "section").map((b) => b.text?.text ?? "").filter(Boolean).join("\n\n");
+    const preview = blocks.map((b) => b.type === "rich_text" ? richTextToPlainText(b) : b.text?.text ?? "").filter(Boolean).join("\n\n");
     const target = useWebhook ? "webhook" : `channel: ${channel}`;
     logger.box(`[dry-run] Slack Post Preview (${target})
 
@@ -6565,7 +7355,8 @@ async function handleSlackPost({
         template,
         contributors,
         packages,
-        postMaxLength: slackConfig.postMaxLength ?? 2500,
+        postMaxLength: slackConfig.postMaxLength,
+        changelogFormat: slackConfig.changelogFormat ?? "summary",
         dryRun
       });
       await executeHook("success:slack", config, dryRun);
@@ -6596,6 +7387,9 @@ async function social(options = {}) {
       }
     });
     applyAIOverride(config, options.ai);
+    if (options.slackFormat) {
+      config.social.slack = { ...config.social.slack, changelogFormat: options.slackFormat };
+    }
     logger.debug(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
     await socialSafetyCheck({ config });
     if (!config.release.social && !config.social?.twitter?.enabled && !config.social?.slack?.enabled) {
@@ -6754,13 +7548,16 @@ async function social(options = {}) {
 ${twitterChangelog}`);
       }
     }
-    let slackChangelog = minifiedBody;
+    const slackChangelogFormat = config.social?.slack?.changelogFormat ?? "summary";
+    const slackBody = slackChangelogFormat === "full" ? richBody : minifiedBody;
+    let slackChangelog = slackBody;
     if (hasContent && slackWillPost && isAISocialEnabled(config, "slack")) {
       slackChangelog = await generateAISocialChangelog({
         config,
         rawBody: richBody,
-        fallbackBody: minifiedBody,
-        platform: "slack"
+        fallbackBody: slackBody,
+        platform: "slack",
+        maxLength: resolveSlackPostMaxLength({ changelogFormat: slackChangelogFormat, postMaxLength: config.social.slack.postMaxLength })
       });
       if (dryRun) {
         logger.box("[dry-run] AI Slack preview", slackChangelog);
@@ -7138,8 +7935,9 @@ async function release(options = {}) {
         bumpResult,
         dryRun,
         logLevel: config.logLevel,
-        safetyCheck: false
+        safetyCheck: false,
         // Already checked in releaseSafetyCheck
+        slackFormat: options.slackFormat
       });
     } else {
       logger.info("Skipping social media posts (--no-social or no social media enabled)");
@@ -7184,4 +7982,4 @@ async function release(options = {}) {
   }
 }
 
-export { getDefaultConfig as $, expandPackagesToBumpWithDependents as A, extractChangelogSummary as B, extractVersionFromPackageTag as C, extractVersionFromTag as D, fetchGitTags as E, filterOutPrivatePackages as F, filterPrivatePackagesUnlessIncluded as G, findGitHubPR as H, findGitLabMR as I, findReachableCommitBySubject as J, formatChangelogForSlack as K, formatPackagesForSlack as L, formatSlackMessage as M, NEW_PACKAGE_MARKER as N, formatTweetMessage as O, PR_COMMENT_MARKER as P, generateChangelog as Q, generateMarkDown as R, getAuthCommand as S, getBumpedIndependentPackages as T, getBumpedPackageIndependently as U, getCIName as V, getCanaryVersion as W, getCommitChangedFiles as X, getCommitSubject as Y, getCurrentGitBranch as Z, getCurrentGitRef as _, assertBranchUpToDateWithRemote as a, redactSecrets as a$, getDependentsOf as a0, getFirstCommit as a1, getGitDiff as a2, getGitStatus as a3, getGitUpstream as a4, getIndependentTag as a5, getLastPackageTag as a6, getLastRepoTag as a7, getLastStableTag as a8, getLastTag as a9, isGraduating as aA, isGraduatingToStableBetweenVersion as aB, isInCI as aC, isPrerelease as aD, isPrereleaseReleaseType as aE, isStableReleaseType as aF, isTagVersionCompatibleWithCurrent as aG, isVersionAlreadyPublishedError as aH, isVersionPublished as aI, loadRelizyConfig as aJ, mergeTypes as aK, parseChangelogMarkdown as aL, parseGitRemoteUrl as aM, postPrComment as aN, postReleaseToSlack as aO, postReleaseToTwitter as aP, prComment as aQ, providerRelease as aR, providerReleaseSafetyCheck as aS, publish as aT, publishPackage as aU, publishSafetyCheck as aV, pushCommitAndTags as aW, pushTagForce as aX, readPackageJson as aY, readPackages as aZ, reconcileFromTag as a_, getModifiedReleaseFilePatterns as aa, getNewPackageCompareBase as ab, getNpmRegistry as ac, getPackageCommits as ad, getPackageDependencies as ae, getPackageNewVersion as af, getPackages as ag, getPackagesOrBumpedPackages as ah, getPackagesToPublishInIndependentMode as ai, getPackagesToPublishInSelectiveMode as aj, getPreid as ak, getReleaseTagNames as al, getReleaseUrl as am, getRootPackage as an, getShortCommitSha as ao, getSlackToken as ap, getSlackWebhookUrl as aq, getTwitterCredentials as ar, github as as, gitlab as at, globDirsAbsolute as au, hasLernaJson as av, isAncestor as aw, isBumpedPackage as ax, isChangedPreid as ay, isCommitOnlyInIgnoredPackages as az, assertReleaseTagsAvailable as b, release as b0, resetRewrittenTagCache as b1, resolveAllConfiguredRegistryTargets as b2, resolveIgnoredPackagePaths as b3, resolveRegistryTargetsForPackage as b4, resolveRegistryTargetsForPackages as b5, resolveTags as b6, retagAnnotatedLocal as b7, rollbackModifiedFiles as b8, shouldFilterPrereleaseTags as b9, social as ba, socialSafetyCheck as bb, tagExists as bc, topologicalSort as bd, tryPostPrComment as be, updateLernaVersion as bf, withRegistryNpmrc as bg, writeChangelogToFile as bh, writeVersion as bi, buildChangelogBody as c, buildCommentBody as d, buildCompareLink as e, buildContributors as f, buildReleaseSummary as g, bump as h, capReleaseTypeForZeroMajor as i, changelog as j, checkGitStatusIfDirty as k, collectContributorNames as l, collectPackageBumps as m, confirmBump as n, createCommitAndTags as o, createGitlabRelease as p, defineConfig as q, detectGitProvider as r, detectPackageManager as s, detectPullRequest as t, determinePublishTag as u, determineReleaseType as v, determineSemverChange as w, executeBuildCmd as x, executeFormatCmd as y, executeHook as z };
+export { getBumpedPackageIndependently as $, determineReleaseType as A, determineSemverChange as B, executeBuildCmd as C, executeFormatCmd as D, executeHook as E, expandPackagesToBumpWithDependents as F, extractChangelogSummary as G, extractVersionFromPackageTag$1 as H, extractVersionFromRepoTag as I, extractVersionFromTag as J, fetchGitTags as K, filterOutPrivatePackages as L, filterPrivatePackagesUnlessIncluded as M, NEW_PACKAGE_MARKER as N, findGitHubPR as O, PR_COMMENT_MARKER as P, findGitLabMR as Q, findReachableCommitBySubject as R, SLACK_HEADER_MAX_LENGTH as S, formatChangelogForSlack as T, formatPackagesForSlack as U, formatSlackMessage as V, formatTweetMessage as W, generateChangelog as X, generateMarkDown as Y, getAuthCommand as Z, getBumpedIndependentPackages as _, SLACK_MAX_BLOCKS as a, providerRelease as a$, getCIName as a0, getCanaryVersion as a1, getCommitChangedFiles as a2, getCommitSubject as a3, getCurrentGitBranch as a4, getCurrentGitRef as a5, getDefaultConfig as a6, getDependentsOf as a7, getFirstCommit as a8, getGitDiff as a9, gitlab as aA, globDirsAbsolute as aB, hasLernaJson as aC, isAncestor as aD, isBumpedPackage as aE, isChangedPreid as aF, isCommitOnlyInIgnoredPackages as aG, isGraduating as aH, isGraduatingToStableBetweenVersion as aI, isInCI as aJ, isPrerelease as aK, isPrereleaseReleaseType as aL, isStableReleaseType as aM, isTagVersionCompatibleWithCurrent as aN, isVersionAlreadyPublishedError as aO, isVersionPublished as aP, listTags as aQ, loadRelizyConfig as aR, markdownToSlackMrkdwn as aS, markdownToSlackRichText as aT, mergeTypes as aU, parseChangelogMarkdown as aV, parseGitRemoteUrl as aW, postPrComment as aX, postReleaseToSlack as aY, postReleaseToTwitter as aZ, prComment as a_, getGitStatus as aa, getGitUpstream as ab, getIndependentTag as ac, getLastPackageTag as ad, getLastRepoTag as ae, getLastStableTag as af, getLastTag as ag, getModifiedReleaseFilePatterns as ah, getNewPackageCompareBase as ai, getNpmRegistry as aj, getPackageCommits as ak, getPackageDependencies as al, getPackageNewVersion as am, getPackages as an, getPackagesOrBumpedPackages as ao, getPackagesToPublishInIndependentMode as ap, getPackagesToPublishInSelectiveMode as aq, getPreid as ar, getReleaseTagNames as as, getReleaseUrl as at, getRootPackage as au, getShortCommitSha as av, getSlackToken as aw, getSlackWebhookUrl as ax, getTwitterCredentials as ay, github as az, SLACK_RICH_TEXT_BLOCK_MAX_LENGTH as b, providerReleaseSafetyCheck as b0, publish as b1, publishPackage as b2, publishSafetyCheck as b3, pushCommitAndTags as b4, pushTagForce as b5, readPackageJson as b6, readPackages as b7, reconcileFromTag as b8, redactSecrets as b9, release as ba, resetRewrittenTagCache as bb, resolveAllConfiguredRegistryTargets as bc, resolveIgnoredPackagePaths as bd, resolveRegistryTargetsForPackage as be, resolveRegistryTargetsForPackages as bf, resolveSlackPostMaxLength as bg, resolveTags as bh, retagAnnotatedLocal as bi, richTextToPlainText as bj, rollbackModifiedFiles as bk, shouldFilterPrereleaseTags as bl, sliceSlackText as bm, social as bn, socialSafetyCheck as bo, tagExists as bp, topologicalSort as bq, tryPostPrComment as br, updateLernaVersion as bs, withRegistryNpmrc as bt, writeChangelogToFile as bu, writeVersion as bv, SLACK_RICH_TEXT_MESSAGE_MAX_LENGTH as c, SLACK_SECTION_MAX_LENGTH as d, SLACK_SUMMARY_MAX_LENGTH as e, assertBranchUpToDateWithRemote as f, assertReleaseTagsAvailable as g, buildChangelogBody as h, buildCommentBody as i, buildCompareLink as j, buildContributors as k, buildReleaseSummary as l, bump as m, capReleaseTypeForZeroMajor as n, changelog as o, checkGitStatusIfDirty as p, collectContributorNames as q, collectPackageBumps as r, confirmBump as s, createCommitAndTags as t, createGitlabRelease as u, defineConfig as v, detectGitProvider as w, detectPackageManager as x, detectPullRequest as y, determinePublishTag as z };