@solutiondesk/help 0.0.0 → 1.0.0-1a0b98f

package/dist/fumadocs.js

@@ -0,0 +1,981 @@
+import { directiveFromMarkdown } from 'mdast-util-directive';
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { gfmFromMarkdown } from 'mdast-util-gfm';
+import { directive } from 'micromark-extension-directive';
+import { gfm } from 'micromark-extension-gfm';
+import { Callout } from 'fumadocs-ui/components/callout';
+import { Card, Cards } from 'fumadocs-ui/components/card';
+import { CodeBlock, Pre } from 'fumadocs-ui/components/codeblock';
+import { Heading } from 'fumadocs-ui/components/heading';
+import { Step, Steps } from 'fumadocs-ui/components/steps';
+import { Tab, Tabs } from 'fumadocs-ui/components/tabs';
+import { Fragment as Fragment$1, createElement } from 'react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+// src/fumadocs/markdown.ts
+var HELP_BLOCKS = ["callout", "steps", "step", "tabs", "tab", "cards", "card"];
+var HELP_CALLOUT_TYPES = ["info", "warn", "error", "success", "idea"];
+var isHelpBlock = (name) => HELP_BLOCKS.includes(name);
+var CODE_FENCE = /^[ \t]*(`{3,}|~{3,})(.*)$/;
+var CLOSING_FENCE = /^([ \t]*):(:{2,}[ \t]*)$/;
+var MASK = "\uE000";
+function maskCodeFences(markdown) {
+  if (markdown.includes(MASK)) return markdown;
+  let open = null;
+  return markdown.split("\n").map((line) => {
+    const fence = CODE_FENCE.exec(line);
+    if (open) {
+      if (fence?.[1]?.[0] === open.char && fence[1].length >= open.length && !fence[2]?.trim()) {
+        open = null;
+        return line;
+      }
+      return line.replace(CLOSING_FENCE, `$1${MASK}$2`);
+    }
+    if (fence?.[1] && !(fence[1][0] === "`" && fence[2]?.includes("`"))) {
+      open = { char: fence[1][0] ?? "`", length: fence[1].length };
+    }
+    return line;
+  }).join("\n");
+}
+function unmask(node) {
+  if ("value" in node && typeof node.value === "string" && node.value.includes(MASK)) {
+    node.value = node.value.replaceAll(MASK, ":");
+  }
+  if ("children" in node) for (const child of node.children) unmask(child);
+}
+function parseHelpMarkdown(markdown) {
+  const source = markdown ?? "";
+  const masked = maskCodeFences(source);
+  const root = fromMarkdown(masked, {
+    extensions: [gfm(), directive()],
+    mdastExtensions: [gfmFromMarkdown(), directiveFromMarkdown()]
+  });
+  if (masked !== source) unmask(root);
+  return root;
+}
+var CONTROL = /[\u0000-\u001f\u007f]/;
+var PROTOCOL_RELATIVE = /^[\\/]{2}/;
+function safeHelpHref(raw) {
+  const href = (raw ?? "").trim();
+  if (CONTROL.test(href) || PROTOCOL_RELATIVE.test(href)) return null;
+  if (/^https?:\/\/[^\s]+$/i.test(href)) return href;
+  if (/^mailto:[^\s]+$/i.test(href)) return href;
+  if (/^\/[^\s]*$/.test(href)) return href;
+  if (/^#[^\s]*$/.test(href)) return href;
+  return null;
+}
+function safeHelpImageSrc(raw) {
+  const src = (raw ?? "").trim();
+  if (CONTROL.test(src) || PROTOCOL_RELATIVE.test(src)) return null;
+  if (/^https?:\/\/[^\s]+$/i.test(src)) return src;
+  if (/^\/[^\s]*$/.test(src)) return src;
+  return null;
+}
+function plainText(node, override) {
+  const own = override?.(node);
+  if (own !== void 0) return own;
+  if ("value" in node && typeof node.value === "string") return node.value;
+  if (node.type === "image") return node.alt ?? "";
+  if ("children" in node) {
+    return node.children.map((child) => plainText(child, override)).join("");
+  }
+  return "";
+}
+function sourceOf(node, markdown) {
+  const start = node.position?.start.offset;
+  const end = node.position?.end.offset;
+  return start === void 0 || end === void 0 ? plainText(node) : markdown.slice(start, end);
+}
+function labelOf(node) {
+  const first = node.children[0];
+  return first?.type === "paragraph" && first.data?.directiveLabel ? first : void 0;
+}
+function contentOf(node) {
+  return labelOf(node) ? node.children.slice(1) : node.children;
+}
+function directiveTitle(node) {
+  const attribute = node.attributes?.title?.trim();
+  if (attribute) return attribute;
+  const label = labelOf(node);
+  const text = label ? plainText(label).trim() : "";
+  return text || void 0;
+}
+function calloutType(node) {
+  const raw = node.attributes?.type?.trim().toLowerCase() ?? "";
+  return HELP_CALLOUT_TYPES.includes(raw) ? raw : "info";
+}
+function codeInfo(lang, meta) {
+  const info = [lang ?? "", meta ?? ""].join(" ").trim();
+  const first = info.match(/^\S*/)?.[0] ?? "";
+  const language = first.includes("=") ? void 0 : first || void 0;
+  const match = /(?:^|\s)title=(?:"([^"]*)"|'([^']*)'|(\S+))/.exec(info);
+  const title = (match ? match[1] ?? match[2] ?? match[3] : void 0)?.trim() || void 0;
+  return { language, title };
+}
+var GITHUB_SLUG_DROP = /[^\p{L}\p{M}\p{N}\p{Pc} -]/gu;
+function headingId(text, used) {
+  const base = text.toLowerCase().replace(GITHUB_SLUG_DROP, "").replace(/ /g, "-") || "section";
+  let id = base;
+  while (used.has(id)) {
+    const count = (used.get(base) ?? 0) + 1;
+    used.set(base, count);
+    id = `${base}-${count}`;
+  }
+  used.set(id, 0);
+  return id;
+}
+function isTitledStep(node) {
+  return node.type === "containerDirective" && node.name === "step" && !!directiveTitle(node);
+}
+function collectHeadings(root) {
+  const out = [];
+  const walk = (node) => {
+    if (node.type === "heading" || isTitledStep(node)) out.push(node);
+    if ("children" in node) for (const child of node.children) walk(child);
+  };
+  walk(root);
+  return out;
+}
+function headingIds(root, known, override) {
+  const headings = collectHeadings(root);
+  const ids = /* @__PURE__ */ new Map();
+  if (known && known.length === headings.length) {
+    headings.forEach((heading, index) => {
+      ids.set(heading, known[index]?.id ?? "");
+    });
+    return ids;
+  }
+  const used = /* @__PURE__ */ new Map();
+  const withoutBlocks = override ? (node) => {
+    if (override(node) === void 0) return void 0;
+    if (node.type !== "textDirective") return "";
+    return node.children.map((child) => plainText(child)).join("").trim();
+  } : void 0;
+  for (const heading of headings) {
+    const text = heading.type === "heading" ? plainText(heading, withoutBlocks) : (directiveTitle(heading) ?? "").replace(/\s+/g, " ").trim();
+    ids.set(heading, headingId(text, used));
+  }
+  return ids;
+}
+
+// src/fumadocs/blocks.ts
+var TEXT_VALUE_MAX = 300;
+var LONG_VALUE_MAX = 2e3;
+var ICON = /^[A-Za-z][A-Za-z0-9]{0,47}$/;
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: "\xA0"
+};
+function decodeEntities(value) {
+  return value.replace(/&(#x[0-9a-f]{1,6}|#[0-9]{1,7}|[a-z]+);/gi, (match, ref) => {
+    if (ref[0] === "#") {
+      const code = ref[1] === "x" || ref[1] === "X" ? parseInt(ref.slice(2), 16) : Number(ref.slice(1));
+      return Number.isFinite(code) && code > 0 && code <= 1114111 ? String.fromCodePoint(code) : match;
+    }
+    return NAMED_ENTITIES[ref.toLowerCase()] ?? match;
+  });
+}
+var ATTRIBUTE = /^(?:#([^\s"'<>=`}#.]+)|\.([^\s"'<>=`}#.]+)|([A-Za-z_:][A-Za-z0-9_.:-]*)(?:[ \t]*=[ \t]*(?:"([^"\n]*)"|'([^'\n]*)'|([^\s"'<>=`}]+)))?)/;
+function parseAttributes(src) {
+  const attributes = {};
+  let pos = 1;
+  for (; ; ) {
+    while (src[pos] === " " || src[pos] === "	") pos++;
+    if (src[pos] === "}") return { attributes, length: pos + 1 };
+    const match = ATTRIBUTE.exec(src.slice(pos));
+    if (!match) return null;
+    const [whole, id, cls, key, dq, sq, bare] = match;
+    if (id !== void 0) attributes.id = decodeEntities(id);
+    else if (cls !== void 0)
+      attributes.class = attributes.class ? `${attributes.class} ${cls}` : cls;
+    else if (key !== void 0) attributes[key] = decodeEntities(dq ?? sq ?? bare ?? "");
+    pos += whole.length;
+    if (src[pos] !== " " && src[pos] !== "	" && src[pos] !== "}") return null;
+  }
+}
+function parseLabel(src) {
+  let depth = 0;
+  for (let pos = 0; pos < src.length; pos++) {
+    const char = src[pos];
+    if (char === "\n") return null;
+    if (char === "\\") {
+      pos++;
+      continue;
+    }
+    if (char === "[") depth++;
+    else if (char === "]") {
+      depth--;
+      if (depth === 0) return { label: src.slice(1, pos), length: pos + 1 };
+    }
+  }
+  return null;
+}
+function parseDirectiveTail(src) {
+  let rest = src;
+  let label;
+  let attributes = {};
+  if (rest.startsWith("[")) {
+    const parsed = parseLabel(rest);
+    if (!parsed) return null;
+    label = parsed.label;
+    rest = rest.slice(parsed.length);
+  }
+  if (rest.startsWith("{")) {
+    const parsed = parseAttributes(rest);
+    if (!parsed) return null;
+    attributes = parsed.attributes;
+    rest = rest.slice(parsed.length);
+  }
+  return { ...label !== void 0 ? { label } : {}, attributes, rest };
+}
+function plainLabel(label) {
+  if (label === void 0) return void 0;
+  const text = label.replace(/\\(.)/g, "$1").replace(/[*_`~]/g, "").trim();
+  return text || void 0;
+}
+var isVideoAddress = (value) => safeHelpHref(value) === value && (/^https:\/\//i.test(value) || value.startsWith("/"));
+function fieldValue(field, raw) {
+  if (field.type === "boolean") {
+    const flag = raw.trim().toLowerCase();
+    if (flag === "" || flag === "true") return true;
+    if (flag === "false") return false;
+    return void 0;
+  }
+  const value = raw.trim();
+  switch (field.type) {
+    case "text":
+      return !/[\r\n]/.test(value) && value.length <= TEXT_VALUE_MAX ? value : void 0;
+    case "longText":
+      return value.length <= LONG_VALUE_MAX ? value : void 0;
+    case "icon":
+      return ICON.test(value) ? value : void 0;
+    case "url":
+      return value.length <= LONG_VALUE_MAX && safeHelpHref(value) === value ? value : void 0;
+    case "choice":
+      return field.options?.includes(value) ? value : void 0;
+    case "image":
+      return value.length <= LONG_VALUE_MAX && safeHelpImageSrc(value) === value ? value : void 0;
+    case "video":
+      return value.length <= LONG_VALUE_MAX && isVideoAddress(value) ? value : void 0;
+    default:
+      return void 0;
+  }
+}
+function helpBlockValues(block, attributes) {
+  const values = {};
+  for (const field of block.fields) {
+    const raw = Object.hasOwn(attributes, field.key) ? attributes[field.key] : void 0;
+    if (field.type === "boolean") {
+      if (raw === void 0) {
+        values[field.key] = false;
+        continue;
+      }
+    } else if (raw === void 0 || raw.trim() === "") {
+      continue;
+    }
+    const value = fieldValue(field, raw);
+    if (value !== void 0) values[field.key] = value;
+  }
+  return values;
+}
+function isTemplate(template) {
+  for (let i = 0; i < template.length; i++) {
+    const char = template[i];
+    if ((char === "{" || char === "}") && template[i + 1] === char) {
+      i++;
+      continue;
+    }
+    if (char === "}") return false;
+    if (char !== "{") continue;
+    const end = template.indexOf("}", i + 1);
+    if (end === -1) return false;
+    const key = template.slice(i + 1, end).trim();
+    if (!key || key.includes("{")) return false;
+    i = end;
+  }
+  return true;
+}
+function helpBlockText(block, values, label) {
+  const template = block.text ?? "";
+  const fields = new Map(block.fields.map((f) => [f.key, f]));
+  let text = "";
+  if (isTemplate(template)) {
+    for (let i = 0; i < template.length; i++) {
+      const char = template[i] ?? "";
+      if ((char === "{" || char === "}") && template[i + 1] === char) {
+        text += char;
+        i++;
+        continue;
+      }
+      if (char !== "{") {
+        text += char;
+        continue;
+      }
+      const end = template.indexOf("}", i + 1);
+      const key = template.slice(i + 1, end).trim();
+      const value = values[key];
+      if (value === true) text += fields.get(key)?.label ?? "";
+      else if (typeof value === "string") text += value;
+      i = end;
+    }
+  }
+  return `${text} ${label ?? ""}`.replace(/\s+/g, " ").trim();
+}
+var FORMS = {
+  textDirective: "inline",
+  leafDirective: "block",
+  containerDirective: "container"
+};
+function helpBlockMatcher(blocks, markdown) {
+  const defined = new Map((blocks ?? []).map((block) => [block.name, block]));
+  const cache = /* @__PURE__ */ new Map();
+  const find = (node) => {
+    if (defined.size === 0) return null;
+    if (node.type !== "textDirective" && node.type !== "leafDirective" && node.type !== "containerDirective") {
+      return null;
+    }
+    const block = defined.get(node.name);
+    if (!block || block.kind !== FORMS[node.type]) return null;
+    const start = node.position?.start.offset;
+    const end = node.position?.end.offset;
+    if (start === void 0 || end === void 0) return null;
+    const lineEnd = markdown.indexOf("\n", start);
+    const line = markdown.slice(start, lineEnd === -1 ? void 0 : lineEnd);
+    const head = /^(:+)([A-Za-z][A-Za-z0-9_-]*)/.exec(line);
+    const colons = head?.[1]?.length ?? 0;
+    const form = colons === 1 ? "textDirective" : colons === 2 ? "leafDirective" : "containerDirective";
+    if (!head || form !== node.type || head[2] !== node.name) return null;
+    const tail = parseDirectiveTail(line.slice(head[0].length));
+    if (!tail) return null;
+    if (node.type === "textDirective") {
+      if (line.length - tail.rest.length !== end - start) return null;
+    } else if (tail.rest.trim() !== "") return null;
+    const values = helpBlockValues(block, tail.attributes);
+    const label = node.type === "containerDirective" ? void 0 : plainLabel(tail.label);
+    return { block, node, values, text: helpBlockText(block, values, label) };
+  };
+  const use = (node) => {
+    if (!cache.has(node)) cache.set(node, find(node));
+    return cache.get(node) ?? null;
+  };
+  const text = (node) => {
+    const found = use(node);
+    if (!found) return void 0;
+    if (found.node.type !== "containerDirective") return found.text;
+    const inner = contentOf(found.node).map((child) => plainText(child, text)).join(" ");
+    return `${found.text} ${inner}`.trim();
+  };
+  return { use, text };
+}
+var PLAIN_CODE_COLORS = {
+  "--shiki-light": "var(--color-fd-foreground)",
+  "--shiki-dark": "var(--color-fd-foreground)"
+};
+var helpBodyComponents = {
+  Callout: ({ type, title, children }) => /* @__PURE__ */ jsx(Callout, { type, title, children }),
+  Steps: ({ children }) => /* @__PURE__ */ jsx(Steps, { children }),
+  Step: ({ title, id, children }) => /* @__PURE__ */ jsxs(Step, { children: [
+    title ? /* @__PURE__ */ jsx(Heading, { as: "h3", id, children: title }) : null,
+    children
+  ] }),
+  Tabs: ({ items, children }) => /* @__PURE__ */ jsx(Tabs, { items, children }),
+  Tab: ({ value, children }) => /* @__PURE__ */ jsx(Tab, { value, children }),
+  Cards: ({ children }) => /* @__PURE__ */ jsx(Cards, { children }),
+  Card: ({ title, href, icon, children }) => /* @__PURE__ */ jsx(Card, { title, href, icon, children }),
+  Code: ({ code, lang, title }) => /* @__PURE__ */ jsx(CodeBlock, { title, children: /* @__PURE__ */ jsx(Pre, { children: /* @__PURE__ */ jsx("code", { className: lang ? `language-${lang}` : void 0, style: PLAIN_CODE_COLORS, children: code.split("\n").map((line, index) => (
+    // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+    /* @__PURE__ */ jsxs("span", { className: "line", children: [
+      line,
+      "\n"
+    ] }, index)
+  )) }) }) }),
+  Heading: ({ level, id, children }) => {
+    const as = `h${level}`;
+    return /* @__PURE__ */ jsx(Heading, { as, id, children });
+  },
+  Link: ({ href, title, children }) => /* @__PURE__ */ jsx("a", { href, title, children }),
+  Image: ({ src, alt, title }) => /* @__PURE__ */ jsx("img", { src, alt, title, loading: "lazy" })
+};
+var BUILT_IN_KEYS = Object.keys(helpBodyComponents);
+function pickBuiltIns(components) {
+  const out = {};
+  for (const key of BUILT_IN_KEYS) {
+    const component = components[key];
+    if (component) out[key] = component;
+  }
+  return out;
+}
+var normalizeId = (id) => id.trim().replace(/\s+/g, " ").toLowerCase();
+function collectDefinitions(root) {
+  const out = /* @__PURE__ */ new Map();
+  const walk = (node) => {
+    if (node.type === "definition") {
+      const key = normalizeId(node.identifier);
+      if (!out.has(key)) out.set(key, node);
+    }
+    if ("children" in node) for (const child of node.children) walk(child);
+  };
+  walk(root);
+  return out;
+}
+function renderAll(nodes, ctx) {
+  return nodes.map((node, index) => (
+    // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+    /* @__PURE__ */ jsx(Fragment$1, { children: renderNode(node, ctx) }, index)
+  ));
+}
+var literalBlock = (text) => /* @__PURE__ */ jsx("p", { children: text });
+function renderImage(node, ctx) {
+  const src = safeHelpImageSrc(node.url);
+  if (!src) return node.alt ?? "";
+  return /* @__PURE__ */ jsx(ctx.c.Image, { src, alt: node.alt ?? "", title: node.title ?? void 0 });
+}
+function renderLink(href, title, children, ctx) {
+  const safe = safeHelpHref(href);
+  if (ctx.linkless || !safe) return children;
+  return /* @__PURE__ */ jsx(ctx.c.Link, { href: safe, title: title ?? void 0, children });
+}
+function renderParagraph(node, ctx) {
+  const parts = node.children.filter((child) => !(child.type === "text" && !child.value.trim()));
+  const only = parts.length === 1 ? parts[0] : void 0;
+  if (only?.type === "image" && only.title && safeHelpImageSrc(only.url)) {
+    return /* @__PURE__ */ jsxs("figure", { children: [
+      renderImage(only, ctx),
+      /* @__PURE__ */ jsx("figcaption", { children: only.title })
+    ] });
+  }
+  const inner = renderAll(node.children, { ...ctx, inline: true });
+  return ctx.tight ? inner : /* @__PURE__ */ jsx("p", { children: inner });
+}
+function renderList(node, ctx) {
+  const tight = !node.spread && node.children.every((item) => !item.spread);
+  const items = node.children.map((item, index) => (
+    // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+    /* @__PURE__ */ jsxs("li", { children: [
+      typeof item.checked === "boolean" ? /* @__PURE__ */ jsx("input", { type: "checkbox", checked: item.checked, disabled: true, readOnly: true }) : null,
+      renderAll(item.children, { ...ctx, tight })
+    ] }, index)
+  ));
+  if (node.ordered) {
+    return /* @__PURE__ */ jsx("ol", { start: node.start != null && node.start !== 1 ? node.start : void 0, children: items });
+  }
+  return /* @__PURE__ */ jsx("ul", { children: items });
+}
+function renderTable(node, ctx) {
+  const [head, ...body] = node.children;
+  const align = (index) => node.align?.[index] ?? void 0;
+  const cells = (row, Tag) => row.children.map((cell, index) => (
+    // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+    /* @__PURE__ */ jsx(Tag, { style: align(index) ? { textAlign: align(index) ?? void 0 } : void 0, children: renderAll(cell.children, { ...ctx, inline: true }) }, index)
+  ));
+  return /* @__PURE__ */ jsxs("table", { children: [
+    head ? /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsx("tr", { children: cells(head, "th") }) }) : null,
+    body.length ? /* @__PURE__ */ jsx("tbody", { children: body.map((row, index) => (
+      // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+      /* @__PURE__ */ jsx("tr", { children: cells(row, "td") }, index)
+    )) }) : null
+  ] });
+}
+function tabItems(titles) {
+  const seen = /* @__PURE__ */ new Map();
+  return titles.map((title, index) => {
+    const base = title || String(index + 1);
+    const count = (seen.get(base) ?? 0) + 1;
+    seen.set(base, count);
+    return count === 1 ? base : `${base} (${count})`;
+  });
+}
+var isDirective = (node, name) => node.type === "containerDirective" && node.name === name;
+function renderCard(node, ctx) {
+  const href = node.attributes?.href ? safeHelpHref(node.attributes.href) : null;
+  const iconName = node.attributes?.icon?.trim();
+  const icon = iconName && /^[A-Za-z][A-Za-z0-9]{0,47}$/.test(iconName) && ctx.icon ? ctx.icon(iconName) : void 0;
+  return /* @__PURE__ */ jsx(ctx.c.Card, { title: directiveTitle(node) ?? "", href: href ?? void 0, icon, children: renderAll(contentOf(node), { ...ctx, linkless: ctx.linkless || !!href }) });
+}
+function renderTabs(children, ctx) {
+  const tabs = children.filter((child) => isDirective(child, "tab"));
+  const items = tabItems(tabs.map(directiveTitle));
+  let index = 0;
+  return /* @__PURE__ */ jsx(ctx.c.Tabs, { items, children: children.map((child, i) => {
+    if (!isDirective(child, "tab")) {
+      return /* @__PURE__ */ jsx(Fragment$1, { children: renderNode(child, ctx) }, i);
+    }
+    const value = items[index++] ?? "";
+    return (
+      // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+      /* @__PURE__ */ jsx(ctx.c.Tab, { value, children: renderAll(contentOf(child), ctx) }, i)
+    );
+  }) });
+}
+function renderCustomBlock(use, ctx) {
+  const { block, node, values, text } = use;
+  const isContainer = node.type === "containerDirective";
+  const children = node.type === "containerDirective" ? renderAll(contentOf(node), { ...ctx, tight: false }) : node.children.length ? renderAll(node.children, { ...ctx, inline: true }) : void 0;
+  const Component = Object.hasOwn(ctx.custom, block.name) ? ctx.custom[block.name] : void 0;
+  if (Component) {
+    return createElement(Component, { ...values, block: block.name, lang: ctx.lang }, children);
+  }
+  const attributes = {
+    className: "sd-block",
+    "data-block": block.name,
+    "data-props": JSON.stringify(values)
+  };
+  if (block.kind === "inline") return /* @__PURE__ */ jsx("span", { ...attributes, children: text });
+  if (!isContainer) return /* @__PURE__ */ jsx("div", { ...attributes, children: text });
+  return /* @__PURE__ */ jsxs("div", { ...attributes, children: [
+    text ? /* @__PURE__ */ jsx("p", { className: "sd-block-text", children: text }) : null,
+    /* @__PURE__ */ jsx("div", { className: "sd-block-body", children })
+  ] });
+}
+function renderDirective(node, ctx) {
+  const { c } = ctx;
+  const custom = ctx.blocks.use(node);
+  if (custom) return renderCustomBlock(custom, ctx);
+  if (!isHelpBlock(node.name)) {
+    const source = sourceOf(node, ctx.markdown);
+    const lines = source.split("\n");
+    const closing = lines.length > 1 && /^\s*:{3,}\s*$/.test(lines.at(-1) ?? "");
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      literalBlock(lines[0] ?? ""),
+      renderAll(contentOf(node), ctx),
+      closing ? literalBlock(lines.at(-1)?.trim() ?? "") : null
+    ] });
+  }
+  const content = contentOf(node);
+  const title = directiveTitle(node);
+  switch (node.name) {
+    case "callout":
+      return /* @__PURE__ */ jsx(c.Callout, { type: calloutType(node), title, children: renderAll(content, ctx) });
+    case "steps":
+      return /* @__PURE__ */ jsx(c.Steps, { children: content.map(
+        (child, i) => isDirective(child, "step") ? (
+          // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+          /* @__PURE__ */ jsx(c.Step, { title: directiveTitle(child), id: ctx.ids.get(child), children: renderAll(contentOf(child), ctx) }, i)
+        ) : (
+          // A loose block between steps becomes a step of its own.
+          // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+          /* @__PURE__ */ jsx(c.Step, { children: renderNode(child, ctx) }, i)
+        )
+      ) });
+    case "step":
+      return /* @__PURE__ */ jsx(c.Steps, { children: /* @__PURE__ */ jsx(c.Step, { title, id: ctx.ids.get(node), children: renderAll(content, ctx) }) });
+    case "tabs":
+      return renderTabs(content, ctx);
+    case "tab":
+      return renderTabs([node], ctx);
+    case "cards":
+      return /* @__PURE__ */ jsx(c.Cards, { children: content.map(
+        (child, i) => isDirective(child, "card") ? (
+          // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+          /* @__PURE__ */ jsx(Fragment$1, { children: renderCard(child, ctx) }, i)
+        ) : (
+          // biome-ignore lint/suspicious/noArrayIndexKey: static content, never reordered.
+          /* @__PURE__ */ jsx(Fragment$1, { children: renderNode(child, ctx) }, i)
+        )
+      ) });
+    case "card":
+      return /* @__PURE__ */ jsx(c.Cards, { children: renderCard(node, ctx) });
+  }
+}
+function renderNode(node, ctx) {
+  const { c } = ctx;
+  switch (node.type) {
+    case "root":
+      return renderAll(node.children, ctx);
+    case "paragraph":
+      return renderParagraph(node, ctx);
+    case "heading":
+      return /* @__PURE__ */ jsx(c.Heading, { level: node.depth, id: ctx.ids.get(node) ?? "", children: renderAll(node.children, { ...ctx, inline: true }) });
+    case "text":
+      return node.value;
+    case "emphasis":
+      return /* @__PURE__ */ jsx("em", { children: renderAll(node.children, ctx) });
+    case "strong":
+      return /* @__PURE__ */ jsx("strong", { children: renderAll(node.children, ctx) });
+    case "delete":
+      return /* @__PURE__ */ jsx("del", { children: renderAll(node.children, ctx) });
+    case "inlineCode":
+      return /* @__PURE__ */ jsx("code", { children: node.value });
+    case "break":
+      return /* @__PURE__ */ jsx("br", {});
+    case "thematicBreak":
+      return /* @__PURE__ */ jsx("hr", {});
+    case "blockquote":
+      return /* @__PURE__ */ jsx("blockquote", { children: renderAll(node.children, { ...ctx, tight: false }) });
+    case "list":
+      return renderList(node, ctx);
+    case "listItem":
+      return /* @__PURE__ */ jsx("li", { children: renderAll(node.children, ctx) });
+    case "table":
+      return renderTable(node, ctx);
+    case "code": {
+      const { language, title } = codeInfo(node.lang, node.meta);
+      return /* @__PURE__ */ jsx(c.Code, { code: node.value, lang: language, title });
+    }
+    // Raw HTML is shown as text, never as markup.
+    case "html":
+      return ctx.inline ? node.value : literalBlock(node.value.trim());
+    case "link":
+      return renderLink(node.url, node.title, renderAll(node.children, ctx), ctx);
+    case "image":
+      return renderImage(node, ctx);
+    case "linkReference": {
+      const definition = ctx.definitions.get(normalizeId(node.identifier));
+      if (!definition) return sourceOf(node, ctx.markdown);
+      return renderLink(definition.url, definition.title, renderAll(node.children, ctx), ctx);
+    }
+    case "imageReference": {
+      const definition = ctx.definitions.get(normalizeId(node.identifier));
+      if (!definition) return sourceOf(node, ctx.markdown);
+      return renderImage({ url: definition.url, alt: node.alt, title: definition.title }, ctx);
+    }
+    case "definition":
+      return null;
+    case "containerDirective":
+      return renderDirective(node, { ...ctx, tight: false });
+    case "leafDirective":
+    case "textDirective": {
+      const custom = ctx.blocks.use(node);
+      if (custom) return renderCustomBlock(custom, ctx);
+      return node.type === "leafDirective" ? literalBlock(sourceOf(node, ctx.markdown)) : sourceOf(node, ctx.markdown);
+    }
+    // Not ours: printed back as written.
+    case "footnoteDefinition":
+      return literalBlock(sourceOf(node, ctx.markdown));
+    case "footnoteReference":
+      return sourceOf(node, ctx.markdown);
+    default:
+      return "children" in node ? renderAll(node.children, ctx) : "value" in node ? String(node.value) : plainText(node);
+  }
+}
+function HelpBody(props) {
+  const { page, components = {}, icon } = props;
+  const source = props.markdown ?? page?.markdown ?? "";
+  const headings = props.headings ?? page?.headings;
+  const root = parseHelpMarkdown(source);
+  const blocks = helpBlockMatcher(props.blocks, source);
+  const ctx = {
+    markdown: source,
+    blocks,
+    custom: components,
+    lang: props.lang ?? page?.locale ?? "",
+    ids: headingIds(root, headings, blocks.text),
+    c: { ...helpBodyComponents, ...pickBuiltIns(components) },
+    icon,
+    definitions: collectDefinitions(root),
+    linkless: false,
+    tight: false,
+    inline: false
+  };
+  return /* @__PURE__ */ jsx(Fragment, { children: renderNode(root, ctx) });
+}
+
+// ../sdk-core/src/webhook.ts
+function encoder() {
+  const Encoder = globalThis.TextEncoder;
+  if (!Encoder) throw new Error("TextEncoder is not available in this runtime.");
+  return new Encoder();
+}
+function bytesOf(body) {
+  if (typeof body === "string") return encoder().encode(body);
+  return body instanceof Uint8Array ? body : new Uint8Array(body);
+}
+function hex(buffer) {
+  let out = "";
+  for (const byte of new Uint8Array(buffer)) out += byte.toString(16).padStart(2, "0");
+  return out;
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+function parseHeader(header) {
+  let t = Number.NaN;
+  const signatures = [];
+  for (const part of header.split(",")) {
+    const index = part.indexOf("=");
+    if (index < 0) continue;
+    const key = part.slice(0, index).trim();
+    const value = part.slice(index + 1).trim();
+    if (key === "t" && /^\d{1,12}$/.test(value)) t = Number(value);
+    else if (key === "v1" && /^[0-9a-f]{64}$/i.test(value)) signatures.push(value.toLowerCase());
+  }
+  return Number.isFinite(t) && signatures.length > 0 ? { t, signatures } : null;
+}
+async function verifyWebhookSignature(secret, rawBody, header, options = {}) {
+  if (!secret || !header || header.length > 1e3) return false;
+  const parsed = parseHeader(header);
+  if (!parsed) return false;
+  const now = options.now instanceof Date ? options.now.getTime() : options.now ?? Date.now();
+  const tolerance = options.toleranceSeconds ?? 300;
+  if (Math.abs(now / 1e3 - parsed.t) > tolerance) return false;
+  const subtle = options.crypto?.subtle ?? globalThis.crypto?.subtle;
+  if (!subtle) {
+    throw new Error(
+      "Web Crypto is not available: pass `crypto` (on Node 18: require('node:crypto').webcrypto)."
+    );
+  }
+  const text = encoder();
+  const key = await subtle.importKey(
+    "raw",
+    text.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const prefix = text.encode(`${parsed.t}.`);
+  const body = bytesOf(rawBody);
+  const signed = new Uint8Array(prefix.length + body.length);
+  signed.set(prefix, 0);
+  signed.set(body, prefix.length);
+  const expected = hex(await subtle.sign("HMAC", key, signed));
+  let ok = false;
+  for (const signature of parsed.signatures) ok = constantTimeEqual(expected, signature) || ok;
+  return ok;
+}
+
+// src/fumadocs/revalidate.ts
+function createHelpRevalidateHandler(options) {
+  return async (request) => {
+    if (!options.secret) {
+      return new Response("Webhook secret is not configured", { status: 500 });
+    }
+    const raw = await request.text();
+    const signature = request.headers.get("x-solutiondesk-signature");
+    if (!await verifyWebhookSignature(options.secret, raw, signature, options.verifyOptions)) {
+      return new Response("Invalid signature", { status: 401 });
+    }
+    const body = parseBody(raw);
+    if (!body) return new Response("Malformed body", { status: 400 });
+    if (body.event !== "ping" || options.includePing) await options.revalidate(body);
+    return new Response(null, { status: 204 });
+  };
+}
+function parseBody(raw) {
+  let body;
+  try {
+    body = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof body !== "object" || body === null) return null;
+  const { event, path, previousPaths } = body;
+  if (typeof event !== "string") return null;
+  if (path !== null && path !== void 0 && typeof path !== "string") return null;
+  if (previousPaths !== void 0 && !Array.isArray(previousPaths)) return null;
+  return body;
+}
+
+// src/fumadocs/structured.ts
+function helpStructuredData(markdown, headings, blocks) {
+  const source = markdown ?? "";
+  const root = parseHelpMarkdown(source);
+  const matcher = helpBlockMatcher(blocks, source);
+  const ids = headingIds(root, headings, matcher.text);
+  const out = { headings: [], contents: [] };
+  let current;
+  const text = (node) => plainText(node, matcher.text).replace(/\s+/g, " ").trim();
+  const add = (content) => {
+    if (content) out.contents.push({ heading: current, content });
+  };
+  const walk = (node) => {
+    if (node.type === "heading") {
+      current = ids.get(node);
+      const content = text(node);
+      if (current && content) out.headings.push({ id: current, content });
+      return;
+    }
+    if (isTitledStep(node)) {
+      current = ids.get(node);
+      const content = directiveTitle(node) ?? "";
+      if (current) out.headings.push({ id: current, content });
+      for (const child of contentOf(node)) walk(child);
+      return;
+    }
+    const use = matcher.use(node);
+    if (use) {
+      add(use.text);
+      if (use.node.type === "containerDirective")
+        for (const child of contentOf(use.node)) walk(child);
+      return;
+    }
+    if (node.type === "paragraph" || node.type === "tableCell") {
+      add(text(node));
+      return;
+    }
+    if (node.type === "code" || node.type === "html" || node.type === "definition") return;
+    if ("children" in node) for (const child of node.children) walk(child);
+  };
+  walk(root);
+  return out;
+}
+
+// src/fumadocs/source.ts
+var linkTitle = (title) => title.replace(/[[\]]/g, "").trim() || "Link";
+var linkUrl = (url) => url.replace(/\)/g, "%29").replace(/\s/g, "%20");
+var lastSegment = (path) => path.split("/").at(-1) ?? path;
+var slugsOf = (path) => path ? path.split("/") : [];
+var pageFileName = (page) => {
+  if (!page.path) return "index";
+  const name = lastSegment(page.path);
+  return name === "index" ? "index_" : name;
+};
+var folderDirName = (folder) => folder.group ? `(${folder.slug})` : folder.slug;
+function helpMetaEntry(node) {
+  switch (node.type) {
+    case "page":
+      return pageFileName(node);
+    case "folder":
+      return folderDirName(node);
+    case "separator": {
+      const title = node.title?.replace(/---/g, "\u2013").trim();
+      if (!title) return "---";
+      return `---${node.icon ? `[${node.icon}]` : ""}${title}---`;
+    }
+    case "link":
+      return `${node.external ? "external:" : ""}${node.icon ? `[${node.icon}]` : ""}[${linkTitle(node.title)}](${linkUrl(node.url)})`;
+  }
+}
+function helpTreeToFiles(payload, options) {
+  const files = [];
+  const ext = (name, extension) => `${name}${options.suffix ? `.${options.suffix}` : ""}.${extension}`;
+  const join = (dir, name) => dir ? `${dir}/${name}` : name;
+  const seen = /* @__PURE__ */ new Set();
+  const blocks = payload.site.blocks ?? [];
+  const addPage = (page, file) => {
+    if (seen.has(file)) return;
+    seen.add(file);
+    const isPrefetched = options.prefetched?.has(page.path) ?? false;
+    const prefetched = options.prefetched?.get(page.path) ?? null;
+    const load = isPrefetched ? async () => prefetched : () => options.load(page.path);
+    const data = {
+      title: page.title,
+      ...page.description ? { description: page.description } : {},
+      ...page.icon ? { icon: page.icon } : {},
+      path: page.path,
+      lang: options.lang,
+      blocks,
+      load,
+      structuredData: async () => {
+        const full = await load();
+        return full ? helpStructuredData(full.markdown, full.headings, blocks) : { headings: [], contents: [] };
+      },
+      ...prefetched ? { page: prefetched } : {}
+    };
+    files.push({ type: "page", path: file, slugs: slugsOf(page.path), data });
+  };
+  const folderPages = (folder) => {
+    const pages = folder.children.map(helpMetaEntry);
+    if (!folder.index || !folder.listIndex) return pages;
+    const at = folder.children[0]?.type === "separator" ? 1 : 0;
+    return [...pages.slice(0, at), "index", ...pages.slice(at)];
+  };
+  const addFolder = (folder, dir) => {
+    if (folder.index) addPage(folder.index, join(dir, ext("index", "mdx")));
+    const data = {
+      title: folder.title,
+      ...folder.description ? { description: folder.description } : {},
+      ...folder.icon ? { icon: folder.icon } : {},
+      ...folder.root ? { root: true } : {},
+      defaultOpen: folder.defaultOpen,
+      collapsible: folder.collapsible,
+      ...folder.index && !folder.listIndex ? { pagesIndex: "index" } : {},
+      pages: folderPages(folder)
+    };
+    files.push({ type: "meta", path: join(dir, ext("meta", "json")), data });
+    addChildren(folder.children, dir);
+  };
+  const addChildren = (nodes, dir) => {
+    for (const node of nodes) {
+      if (node.type === "page") {
+        addPage(node, join(dir, ext(pageFileName(node), "mdx")));
+      } else if (node.type === "folder") {
+        addFolder(node, join(dir, folderDirName(node)));
+      }
+    }
+  };
+  files.push({
+    type: "meta",
+    path: ext("meta", "json"),
+    data: { title: payload.site.name, pages: payload.tree.map(helpMetaEntry) }
+  });
+  addChildren(payload.tree, "");
+  return files;
+}
+function helpTreePaths(tree) {
+  const out = [];
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (node.type === "page") out.push(node.path);
+      else if (node.type === "folder") {
+        if (node.index) out.push(node.index.path);
+        walk(node.children);
+      }
+    }
+  };
+  walk(tree);
+  return out;
+}
+var isNotFoundError = (error) => error instanceof Error && error.name === "SolutionDeskError" && error.status === 404;
+async function mapLimit(items, limit, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const index = next++;
+      out[index] = await fn(items[index]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, worker));
+  return out;
+}
+async function createHelpSource(client, options = {}) {
+  const { requestOptions } = options;
+  const languages = options.languages?.length ? [...options.languages] : [void 0];
+  const files = await Promise.all(
+    languages.map(async (lang) => {
+      const payload = await client.site(lang ? { lang } : {}, requestOptions);
+      const forLang = lang ?? payload.locale;
+      const load = async (path) => {
+        try {
+          return (await client.page(path, { lang: forLang }, requestOptions)).page;
+        } catch (error) {
+          if (isNotFoundError(error)) return null;
+          throw error;
+        }
+      };
+      let prefetched;
+      if (options.pages === "eager") {
+        const paths = helpTreePaths(payload.tree);
+        const pages = await mapLimit(paths, options.concurrency ?? 6, load);
+        prefetched = new Map(paths.map((path, index) => [path, pages[index] ?? null]));
+      }
+      return helpTreeToFiles(payload, {
+        lang: forLang,
+        load,
+        ...lang ? { suffix: lang } : {},
+        ...prefetched ? { prefetched } : {}
+      });
+    })
+  );
+  return { files: files.flat() };
+}
+function helpDynamicSource(client, options = {}) {
+  return { files: async () => (await createHelpSource(client, options)).files };
+}
+
+// src/fumadocs/toc.ts
+function getHelpToc(headings, options = {}) {
+  const list = "headings" in headings ? headings.headings : headings;
+  const min = options.minLevel ?? 1;
+  const max = options.maxLevel ?? 6;
+  return list.filter((heading) => heading.level >= min && heading.level <= max && heading.id).map((heading) => ({ title: heading.text, url: `#${heading.id}`, depth: heading.level }));
+}
+
+export { HELP_BLOCKS, HELP_CALLOUT_TYPES, HelpBody, createHelpRevalidateHandler, createHelpSource, getHelpToc, helpBlockText, helpBlockValues, helpBodyComponents, helpDynamicSource, helpMetaEntry, helpStructuredData, helpTreePaths, helpTreeToFiles, safeHelpHref };