relizy 1.8.0 → 1.9.0

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

@@ -15,6 +15,9 @@ import fastGlob from 'fast-glob';
 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("'", "'\\''")}'`;
@@ -2713,7 +2716,7 @@ function getDefaultConfig() {
       slack: {
         enabled: false,
         onlyStable: true,
-        postMaxLength: 2500,
+        changelogFormat: "summary",
         noAuthors: false,
         noPackages: false
       }
@@ -3462,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}
@@ -3679,29 +3686,35 @@ ${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}
@@ -3834,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",
@@ -3844,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) {
@@ -4788,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 "";
@@ -4838,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) {
@@ -4855,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 = [];
@@ -4952,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.";
@@ -5036,6 +5741,7 @@ async function postReleaseToSlack({
   contributors,
   packages,
   postMaxLength,
+  changelogFormat,
   dryRun = false
 }) {
   const useWebhook = Boolean(webhookUrl);
@@ -5056,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})
 
@@ -6648,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);
@@ -6679,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) {
@@ -6837,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);
@@ -7221,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)");
@@ -7267,4 +7982,4 @@ async function release(options = {}) {
   }
 }
 
-export { getCurrentGitRef as $, expandPackagesToBumpWithDependents as A, extractChangelogSummary as B, extractVersionFromPackageTag$1 as C, extractVersionFromRepoTag as D, extractVersionFromTag as E, fetchGitTags as F, filterOutPrivatePackages as G, filterPrivatePackagesUnlessIncluded as H, findGitHubPR as I, findGitLabMR as J, findReachableCommitBySubject as K, formatChangelogForSlack as L, formatPackagesForSlack as M, NEW_PACKAGE_MARKER as N, formatSlackMessage as O, PR_COMMENT_MARKER as P, formatTweetMessage as Q, generateChangelog as R, generateMarkDown as S, getAuthCommand as T, getBumpedIndependentPackages as U, getBumpedPackageIndependently as V, getCIName as W, getCanaryVersion as X, getCommitChangedFiles as Y, getCommitSubject as Z, getCurrentGitBranch as _, assertBranchUpToDateWithRemote as a, readPackages as a$, getDefaultConfig as a0, getDependentsOf as a1, getFirstCommit as a2, getGitDiff as a3, getGitStatus as a4, getGitUpstream as a5, getIndependentTag as a6, getLastPackageTag as a7, getLastRepoTag as a8, getLastStableTag as a9, isCommitOnlyInIgnoredPackages as aA, isGraduating as aB, isGraduatingToStableBetweenVersion as aC, isInCI as aD, isPrerelease as aE, isPrereleaseReleaseType as aF, isStableReleaseType as aG, isTagVersionCompatibleWithCurrent as aH, isVersionAlreadyPublishedError as aI, isVersionPublished as aJ, listTags as aK, loadRelizyConfig as aL, mergeTypes as aM, parseChangelogMarkdown as aN, parseGitRemoteUrl as aO, postPrComment as aP, postReleaseToSlack as aQ, postReleaseToTwitter as aR, prComment as aS, providerRelease as aT, providerReleaseSafetyCheck as aU, publish as aV, publishPackage as aW, publishSafetyCheck as aX, pushCommitAndTags as aY, pushTagForce as aZ, readPackageJson as a_, getLastTag as aa, getModifiedReleaseFilePatterns as ab, getNewPackageCompareBase as ac, getNpmRegistry as ad, getPackageCommits as ae, getPackageDependencies as af, getPackageNewVersion as ag, getPackages as ah, getPackagesOrBumpedPackages as ai, getPackagesToPublishInIndependentMode as aj, getPackagesToPublishInSelectiveMode as ak, getPreid as al, getReleaseTagNames as am, getReleaseUrl as an, getRootPackage as ao, getShortCommitSha as ap, getSlackToken as aq, getSlackWebhookUrl as ar, getTwitterCredentials as as, github as at, gitlab as au, globDirsAbsolute as av, hasLernaJson as aw, isAncestor as ax, isBumpedPackage as ay, isChangedPreid as az, assertReleaseTagsAvailable as b, reconcileFromTag as b0, redactSecrets as b1, release as b2, resetRewrittenTagCache as b3, resolveAllConfiguredRegistryTargets as b4, resolveIgnoredPackagePaths as b5, resolveRegistryTargetsForPackage as b6, resolveRegistryTargetsForPackages as b7, resolveTags as b8, retagAnnotatedLocal as b9, rollbackModifiedFiles as ba, shouldFilterPrereleaseTags as bb, social as bc, socialSafetyCheck as bd, tagExists as be, topologicalSort as bf, tryPostPrComment as bg, updateLernaVersion as bh, withRegistryNpmrc as bi, writeChangelogToFile as bj, writeVersion as bk, 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 };