deepspace 0.10.1 → 0.10.2

package/dist/documentation.js

@@ -0,0 +1,3953 @@
+// src/documentation/build.ts
+import { buildSync as buildSync3 } from "esbuild";
+import { readFileSync as readFileSync6 } from "fs";
+import { resolve as resolve7 } from "path";
+
+// src/documentation/markdown.ts
+import hljs from "highlight.js/lib/core";
+import bash from "highlight.js/lib/languages/bash";
+import css from "highlight.js/lib/languages/css";
+import javascript from "highlight.js/lib/languages/javascript";
+import json from "highlight.js/lib/languages/json";
+import markdown from "highlight.js/lib/languages/markdown";
+import typescript from "highlight.js/lib/languages/typescript";
+import xml from "highlight.js/lib/languages/xml";
+import yaml from "highlight.js/lib/languages/yaml";
+import { Marked } from "marked";
+import sanitizeHtml from "sanitize-html";
+import { parse as parseYaml } from "yaml";
+
+// src/documentation/text.ts
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function escapeXml(value) {
+  return escapeHtml(value).replace(/&#39;/g, "&apos;");
+}
+function slugify(value) {
+  return value.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function documentationSubject(name) {
+  const normalized = name.trim();
+  if (!normalized || /^documentation$/i.test(normalized)) return "documentation";
+  return /(?:\bdocs?|documentation)$/i.test(normalized) ? normalized : `${normalized} documentation`;
+}
+function createSlugger(fallback = "section") {
+  const seen = /* @__PURE__ */ new Map();
+  return (value) => {
+    const base = slugify(value) || fallback;
+    const count = seen.get(base) ?? 0;
+    seen.set(base, count + 1);
+    return count === 0 ? base : `${base}-${count + 1}`;
+  };
+}
+
+// src/documentation/types.ts
+var DOCUMENTATION_CONFIG_FILE = "documentation.json";
+var DOCUMENTATION_MANIFEST_VERSION = 2;
+var DOCUMENTATION_CONTEXTUAL_ACTIONS = [
+  "copy",
+  "view",
+  "assistant",
+  "chatgpt",
+  "claude",
+  "mcp",
+  "add-mcp",
+  "cursor",
+  "vscode"
+];
+var DEFAULT_DOCUMENTATION_CONTEXTUAL_ACTIONS = DOCUMENTATION_CONTEXTUAL_ACTIONS;
+var DOCUMENTATION_OPENAPI_SAMPLE_LANGUAGES = ["curl", "javascript", "python", "go"];
+var DEFAULT_DOCUMENTATION_OPENAPI_EXAMPLES = {
+  languages: ["curl", "python", "javascript", "go"],
+  defaults: "all",
+  autogenerate: true
+};
+var DocumentationError = class extends Error {
+  code;
+  diagnostics;
+  constructor(message, code, diagnostics = []) {
+    super(message);
+    this.name = "DocumentationError";
+    this.code = code;
+    this.diagnostics = diagnostics;
+  }
+};
+
+// src/documentation/markdown.ts
+var COMPONENT_NAMES = [
+  "Note",
+  "Tip",
+  "Warning",
+  "Info",
+  "Card",
+  "Accordion",
+  "AccordionGroup",
+  "Step",
+  "Tab",
+  "CodeGroup",
+  "Steps",
+  "Tabs"
+];
+var LEAF_COMPONENTS = [
+  "Note",
+  "Tip",
+  "Warning",
+  "Info",
+  "Card",
+  "Accordion",
+  "Step",
+  "Tab",
+  "CodeGroup"
+];
+var WRAPPER_COMPONENTS = ["AccordionGroup", "Steps", "Tabs"];
+for (const [name, language] of Object.entries({
+  bash,
+  css,
+  html: xml,
+  javascript,
+  json,
+  jsx: javascript,
+  markdown,
+  md: markdown,
+  shell: bash,
+  sh: bash,
+  ts: typescript,
+  tsx: typescript,
+  typescript,
+  xml,
+  yaml,
+  yml: yaml
+})) {
+  hljs.registerLanguage(name, language);
+}
+var markdownRenderer = new Marked({
+  renderer: {
+    code({ text, lang }) {
+      const { language, title } = parseCodeFenceInfo(lang);
+      const highlighted = language && hljs.getLanguage(language) ? hljs.highlight(text, { language, ignoreIllegals: true }).value : escapeHtml(text);
+      const className = language ? ` class="language-${escapeHtml(language)} hljs"` : ' class="hljs"';
+      return `<pre${title ? ` data-code-title="${escapeHtml(title)}"` : ""}><code${className}>${highlighted}</code></pre>
+`;
+    }
+  }
+});
+function stripFirstMarkdownH1(source) {
+  const lines = [...source.matchAll(/.*(?:\r?\n|$)/g)].filter((match) => match[0]);
+  let inFrontmatter = false;
+  let frontmatterSeen = false;
+  let fence;
+  for (const [index, match] of lines.entries()) {
+    const raw = match[0];
+    const line = raw.replace(/\r?\n$/, "");
+    const content = index === 0 ? line.replace(/^\uFEFF/, "") : line;
+    if (index === 0 && content === "---") {
+      inFrontmatter = true;
+      frontmatterSeen = true;
+      continue;
+    }
+    if (inFrontmatter) {
+      if (frontmatterSeen && /^(?:---|\.\.\.)\s*$/.test(content)) inFrontmatter = false;
+      continue;
+    }
+    const fenceMatch = content.match(/^ {0,3}(`{3,}|~{3,})/);
+    if (fenceMatch?.[1]) {
+      const marker = fenceMatch[1][0];
+      if (!fence) fence = { marker, length: fenceMatch[1].length };
+      else if (fence.marker === marker && fenceMatch[1].length >= fence.length) fence = void 0;
+      continue;
+    }
+    if (fence || !/^ {0,3}#(?:[\t ]+|$)/.test(content)) continue;
+    const start = match.index ?? 0;
+    const newline = raw.endsWith("\r\n") ? "\r\n" : raw.endsWith("\n") ? "\n" : "";
+    return `${source.slice(0, start)}${newline}${source.slice(start + raw.length)}`;
+  }
+  return source;
+}
+function parseMarkdown(source, file) {
+  const { frontmatter, body } = parseFrontmatter(source, file);
+  validateExecutableMdx(body, file);
+  const placeholders = [];
+  let prepared = protectCode(body.replace(/^\uFEFF/, ""), placeholders);
+  for (const name of [...LEAF_COMPONENTS, ...WRAPPER_COMPONENTS]) {
+    prepared = replaceComponentBlocks(prepared, name, placeholders);
+  }
+  const rendered = String(markdownRenderer.parse(prepared, { gfm: true, breaks: false }));
+  let restored = rendered;
+  for (let pass = 0; pass < placeholders.length + 1; pass++) {
+    let changed = false;
+    restored = restored.replace(
+      /(?:<p>)?@@DEEPSPACE_COMPONENT_(\d+)@@(?:<\/p>)?/g,
+      (_match, indexRaw) => {
+        const replacement = placeholders[Number(indexRaw)];
+        if (replacement === void 0) return "";
+        changed = true;
+        return replacement;
+      }
+    );
+    if (!changed) break;
+  }
+  restored = restored.replace(
+    /<div class="documentation-code-group" data-code-group-pending data-code-group-title="([^"]*)">([\s\S]*?)<\/div>/g,
+    (_match, title, innerHtml) => renderCodeGroup(innerHtml, title)
+  );
+  const safe = sanitizeHtml(restored, {
+    allowedTags: [
+      ...sanitizeHtml.defaults.allowedTags,
+      "article",
+      "aside",
+      "button",
+      "details",
+      "div",
+      "figure",
+      "figcaption",
+      "h1",
+      "h2",
+      "h3",
+      "h4",
+      "h5",
+      "h6",
+      "input",
+      "label",
+      "section",
+      "span",
+      "summary",
+      "table",
+      "thead",
+      "tbody",
+      "tr",
+      "th",
+      "td"
+    ],
+    allowedAttributes: {
+      a: ["href", "title", "target", "rel", "class"],
+      aside: ["class"],
+      button: ["type", "class", "data-copy-code"],
+      code: ["class"],
+      details: ["class", "open"],
+      div: ["class", "data-tab-group", "data-tab-persist"],
+      img: ["src", "alt", "title", "width", "height", "loading"],
+      input: ["type", "checked", "disabled"],
+      pre: ["class", "data-code-title"],
+      section: ["class", "data-tab", "data-tab-title"],
+      span: ["class"],
+      summary: ["class"],
+      table: ["class"],
+      "*": ["id", "aria-label", "aria-hidden", "role"]
+    },
+    allowedSchemes: ["http", "https", "mailto"],
+    allowProtocolRelative: false,
+    disallowedTagsMode: "escape",
+    transformTags: {
+      a: (_tagName, attributes) => {
+        const external = /^https?:\/\//i.test(attributes.href ?? "");
+        return {
+          tagName: "a",
+          attribs: external ? { ...attributes, target: "_blank", rel: "noopener noreferrer" } : attributes
+        };
+      },
+      img: (_tagName, attributes) => ({
+        tagName: "img",
+        attribs: { ...attributes, loading: attributes.loading ?? "lazy" }
+      })
+    }
+  });
+  const { html, headings } = addHeadingIds(safe);
+  return {
+    frontmatter,
+    markdown: body.trim(),
+    html,
+    text: htmlToText(html),
+    headings
+  };
+}
+function parseFrontmatter(source, file) {
+  if (!source.startsWith("---\n") && !source.startsWith("---\r\n")) {
+    return { frontmatter: {}, body: source };
+  }
+  const normalized = source.replace(/\r\n/g, "\n");
+  const end = normalized.indexOf("\n---\n", 4);
+  if (end === -1) {
+    throw new DocumentationError(
+      `Unclosed front matter in ${file}`,
+      "documentation_frontmatter_invalid",
+      [{ code: "frontmatter_unclosed", message: "Expected a closing --- line", file, line: 1 }]
+    );
+  }
+  let value;
+  try {
+    value = parseYaml(normalized.slice(4, end), { maxAliasCount: 20 });
+  } catch (error) {
+    throw new DocumentationError(
+      `Invalid front matter in ${file}: ${errorMessage(error)}`,
+      "documentation_frontmatter_invalid",
+      [{ code: "frontmatter_yaml", message: errorMessage(error), file, line: 1 }]
+    );
+  }
+  if (value === null) value = {};
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new DocumentationError(
+      `Front matter must be a mapping in ${file}`,
+      "documentation_frontmatter_invalid",
+      [{ code: "frontmatter_shape", message: "Expected key/value front matter", file, line: 1 }]
+    );
+  }
+  const raw = value;
+  const frontmatter = {};
+  for (const key of ["title", "description", "slug"]) {
+    if (raw[key] !== void 0 && typeof raw[key] !== "string") {
+      throw frontmatterTypeError(file, key, "string");
+    }
+    if (typeof raw[key] === "string") frontmatter[key] = raw[key];
+  }
+  for (const key of ["hidden", "noindex"]) {
+    if (raw[key] !== void 0 && typeof raw[key] !== "boolean") {
+      throw frontmatterTypeError(file, key, "boolean");
+    }
+    if (typeof raw[key] === "boolean") frontmatter[key] = raw[key];
+  }
+  return { frontmatter, body: normalized.slice(end + 5) };
+}
+function replaceComponentBlocks(source, name, placeholders) {
+  const pattern = new RegExp(`<${name}(\\s[^>]*)?>([\\s\\S]*?)<\\/${name}>`, "g");
+  return source.replace(pattern, (_match, attributesRaw, inner) => {
+    const attributes = parseAttributes(attributesRaw ?? "");
+    const innerHtml = String(markdownRenderer.parse(inner.trim(), { gfm: true, breaks: false }));
+    const html = renderComponent(name, attributes, innerHtml);
+    const index = placeholders.push(html) - 1;
+    return `
+
+@@DEEPSPACE_COMPONENT_${index}@@
+
+`;
+  });
+}
+function renderComponent(name, attributes, innerHtml) {
+  const title = escapeHtml(attributes.title ?? attributes.label ?? "");
+  switch (name) {
+    case "Note":
+    case "Tip":
+    case "Warning":
+    case "Info":
+      return `<aside class="documentation-callout documentation-callout-${name.toLowerCase()}">${title ? `<strong>${title}</strong>` : `<strong>${name}</strong>`}${innerHtml}</aside>`;
+    case "Card": {
+      const href = safeHref(attributes.href);
+      const content = `${title ? `<strong>${title}</strong>` : ""}${innerHtml}`;
+      return href ? `<a class="documentation-card" href="${escapeHtml(href)}">${content}<span aria-hidden="true">\u2192</span></a>` : `<div class="documentation-card">${content}</div>`;
+    }
+    case "Accordion":
+      return `<details class="documentation-accordion"><summary>${title || "Details"}</summary>${innerHtml}</details>`;
+    case "AccordionGroup":
+      return `<div class="documentation-accordion-group">${innerHtml}</div>`;
+    case "Step":
+      return `<section class="documentation-step">${title ? `<h3>${title}</h3>` : ""}${innerHtml}</section>`;
+    case "Steps":
+      return `<div class="documentation-steps">${innerHtml}</div>`;
+    case "Tab":
+      return `<section class="documentation-tab" data-tab data-tab-title="${title || "Tab"}">${innerHtml}</section>`;
+    case "Tabs":
+      return `<div class="documentation-tabs" data-tab-group>${innerHtml}</div>`;
+    case "CodeGroup":
+      return `<div class="documentation-code-group" data-code-group-pending data-code-group-title="${title}">${innerHtml}</div>`;
+  }
+}
+function renderCodeGroup(innerHtml, title) {
+  const blocks = [...innerHtml.matchAll(/<pre([^>]*)>([\s\S]*?)<\/pre>/g)];
+  if (blocks.length === 0) {
+    return `<div class="documentation-code-group">${title ? `<div class="documentation-code-group-title">${title}</div>` : ""}${innerHtml}</div>`;
+  }
+  const tabs = blocks.map((match, index) => {
+    const attributes = match[1] ?? "";
+    const explicit = attributes.match(/\sdata-code-title="([^"]+)"/)?.[1];
+    const language = match[2]?.match(/class="language-([^\s"]+)/)?.[1];
+    const label = explicit ?? codeLanguageLabel(language) ?? `Example ${index + 1}`;
+    return `<section class="documentation-code-tab" data-tab data-tab-title="${escapeHtml(label)}"><pre${attributes}>${match[2]}</pre></section>`;
+  }).join("");
+  return `<div class="documentation-code-group" data-tab-group data-tab-persist="code">${title ? `<div class="documentation-code-group-title">${title}</div>` : ""}${tabs}</div>`;
+}
+function parseCodeFenceInfo(value) {
+  const raw = value?.trim() ?? "";
+  if (!raw) return {};
+  const language = raw.split(/\s+/, 1)[0]?.toLowerCase();
+  const metadata = raw.slice(language?.length ?? 0).trim();
+  const quotedTitle = metadata.match(/(?:^|\s)title=(?:"([^"]+)"|'([^']+)')/i);
+  const title = quotedTitle?.[1] ?? quotedTitle?.[2] ?? (metadata && !metadata.includes("=") ? metadata : void 0);
+  return {
+    ...language ? { language } : {},
+    ...title ? { title: title.trim() } : {}
+  };
+}
+function codeLanguageLabel(language) {
+  if (!language) return void 0;
+  const names = {
+    bash: "Shell",
+    javascript: "JavaScript",
+    js: "JavaScript",
+    jsx: "React",
+    shell: "Shell",
+    sh: "Shell",
+    ts: "TypeScript",
+    tsx: "React",
+    typescript: "TypeScript"
+  };
+  return names[language] ?? language.toUpperCase();
+}
+function parseAttributes(raw) {
+  const attributes = {};
+  const pattern = /([A-Za-z][A-Za-z0-9_-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+  for (const match of raw.matchAll(pattern)) {
+    attributes[match[1]] = match[2] ?? match[3] ?? "";
+  }
+  return attributes;
+}
+function validateExecutableMdx(body, file) {
+  const validationBody = stripCodeForValidation(body);
+  const lines = validationBody.split("\n");
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    if (/^\s*(?:import|export)\s/.test(line)) {
+      throw new DocumentationError(
+        `Executable MDX is not supported in ${file}:${index + 1}`,
+        "documentation_mdx_unsafe",
+        [{
+          code: "mdx_module_syntax",
+          message: "Use the built-in documentation component vocabulary instead of import/export",
+          file,
+          line: index + 1
+        }]
+      );
+    }
+    if (/<[A-Za-z][^>]*\son[A-Za-z]+\s*=/.test(line) || /<script\b/i.test(line)) {
+      throw new DocumentationError(
+        `Active HTML is not supported in ${file}:${index + 1}`,
+        "documentation_mdx_unsafe",
+        [{
+          code: "active_html",
+          message: "Scripts and inline event handlers are prohibited",
+          file,
+          line: index + 1
+        }]
+      );
+    }
+    if (/<[A-Z][A-Za-z0-9]*[^>]*=\s*\{/.test(line)) {
+      throw new DocumentationError(
+        `JSX expressions are not supported in ${file}:${index + 1}`,
+        "documentation_mdx_unsafe",
+        [{
+          code: "jsx_expression",
+          message: "Component attributes must use quoted string values",
+          file,
+          line: index + 1
+        }]
+      );
+    }
+  }
+  const componentPattern = /<\/?([A-Z][A-Za-z0-9]*)\b/g;
+  for (const match of validationBody.matchAll(componentPattern)) {
+    if (!COMPONENT_NAMES.includes(match[1])) {
+      const line = validationBody.slice(0, match.index).split("\n").length;
+      throw new DocumentationError(
+        `Unknown documentation component <${match[1]}> in ${file}:${line}`,
+        "documentation_mdx_component_unknown",
+        [{
+          code: "unknown_component",
+          message: `Supported components: ${COMPONENT_NAMES.join(", ")}`,
+          file,
+          line
+        }]
+      );
+    }
+  }
+}
+function protectCode(source, placeholders) {
+  const fenced = source.replace(
+    /^([ \t]*)(`{3,}|~{3,})[^\n]*\n[\s\S]*?^\1\2[ \t]*(?=\n|$)/gm,
+    (block, indentation) => {
+      const normalized = indentation ? block.split("\n").map((line) => line.startsWith(indentation) ? line.slice(indentation.length) : line).join("\n") : block;
+      const html = String(markdownRenderer.parse(normalized, { gfm: true, breaks: false }));
+      const index = placeholders.push(html) - 1;
+      return `
+
+@@DEEPSPACE_COMPONENT_${index}@@
+
+`;
+    }
+  );
+  return fenced.replace(/`([^`\n]+)`/g, (_match, code) => {
+    const index = placeholders.push(`<code>${escapeHtml(code)}</code>`) - 1;
+    return `@@DEEPSPACE_COMPONENT_${index}@@`;
+  });
+}
+function stripCodeForValidation(source) {
+  return source.replace(
+    /^([ \t]*)(`{3,}|~{3,})[^\n]*\n[\s\S]*?^\1\2[ \t]*(?=\n|$)/gm,
+    (block) => block.replace(/[^\n]/g, " ")
+  ).replace(/`[^`\n]+`/g, (code) => " ".repeat(code.length));
+}
+function addHeadingIds(html) {
+  const headings = [];
+  const slug = createSlugger();
+  const output = html.replace(/<h([1-6])>([\s\S]*?)<\/h\1>/g, (_match, depthRaw, content) => {
+    const text = htmlToText(content);
+    const id = slug(text);
+    const depth = Number(depthRaw);
+    headings.push({ depth, id, text });
+    return `<h${depth} id="${id}">${content}<a class="documentation-heading-anchor" href="#${id}" aria-label="Link to ${escapeHtml(text)}">#</a></h${depth}>`;
+  });
+  return { html: output, headings };
+}
+function htmlToText(html) {
+  return decodeEntities(
+    html.replace(/<pre[\s\S]*?<\/pre>/g, " ").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim()
+  );
+}
+function decodeEntities(value) {
+  return value.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+}
+function safeHref(value) {
+  if (!value) return "";
+  if (/^(?:https?:|mailto:|\/|#)/i.test(value)) return value;
+  return "";
+}
+function frontmatterTypeError(file, key, type) {
+  return new DocumentationError(
+    `Front matter ${key} must be a ${type} in ${file}`,
+    "documentation_frontmatter_invalid",
+    [{ code: "frontmatter_type", message: `${key} must be a ${type}`, file, line: 1 }]
+  );
+}
+
+// src/documentation/routing.ts
+function collapseRoute(value) {
+  let route = `/${value}`.replace(/\/{2,}/g, "/");
+  if (route.length > 1) route = route.replace(/\/$/, "");
+  return route;
+}
+function normalizeRoute(value) {
+  assertSafeRoute(value);
+  let route = collapseRoute(value);
+  route = route.replace(/\.(?:md|mdx)$/i, "");
+  route = route.replace(/\/index$/i, "");
+  return route || "/";
+}
+function routeFromRelativePath(relativePath) {
+  let path = relativePath.replace(/\.(?:md|mdx)$/i, "");
+  if (path === "index") path = "";
+  else path = path.replace(/\/index$/i, "");
+  return normalizeRoute(path);
+}
+function normalizeDocumentationBasePath(value) {
+  if (!value || value === "/") return "";
+  const normalized = normalizeRoute(value);
+  if (normalized === "/_documentation") {
+    throw new DocumentationError("The internal /_documentation namespace cannot be a public documentation base", "documentation_base_invalid");
+  }
+  return normalized;
+}
+function documentationPublicPath(basePath, path) {
+  const base = normalizeDocumentationBasePath(basePath);
+  const suffix = path.startsWith("/") ? path : `/${path}`;
+  if (suffix === "/") return base || "/";
+  return `${base}${suffix}`;
+}
+function publicDocumentationReferences(source, basePath) {
+  const base = normalizeDocumentationBasePath(basePath);
+  if (!base) return source;
+  const publicPath = (value) => value === base || value.startsWith(`${base}/`) ? value : `${base}${value}`;
+  return source.replace(
+    /(\]\()(\/(?!\/)[^)\s]*)/g,
+    (_match, prefix, value) => `${prefix}${publicPath(value)}`
+  ).replace(
+    /^(\s*\[[^\]]+\]:\s*)(\/(?!\/)\S*)/gm,
+    (_match, prefix, value) => `${prefix}${publicPath(value)}`
+  ).replace(
+    /(\b(?:href|src)=["'])(\/(?!\/)[^"']*)/g,
+    (_match, prefix, value) => `${prefix}${publicPath(value)}`
+  );
+}
+function markdownUrlForRoute(route, basePath = "") {
+  const logical = route === "/" ? "/index.md" : `${normalizeRoute(route)}.md`;
+  return documentationPublicPath(basePath, logical);
+}
+function artifactPathsForRoute(route) {
+  const clean = normalizeRoute(route).replace(/^\//, "");
+  return clean ? {
+    data: `data/${clean}.json`,
+    html: `${clean}/index.html`,
+    markdown: `${clean}.md`
+  } : {
+    data: "data/index.json",
+    html: "index.html",
+    markdown: "index.md"
+  };
+}
+function routeArtifactId(route) {
+  return route === "/" ? "index" : normalizeRoute(route).replace(/^\//, "").replace(/[^a-z0-9]+/gi, "-");
+}
+function joinSiteUrl(base, route) {
+  const path = route.startsWith("/") ? route : `/${route}`;
+  return `${base.replace(/\/$/, "")}${path}`;
+}
+function assertSafeRoute(value) {
+  if (value.includes("\\") || value.includes("\0")) throw unsafeRoute(value);
+  let decoded = value;
+  for (let pass = 0; pass < 5; pass++) {
+    let next;
+    try {
+      next = decodeURIComponent(decoded);
+    } catch {
+      throw unsafeRoute(value);
+    }
+    if (next === decoded) break;
+    decoded = next;
+  }
+  if (decoded.includes("\\") || decoded.includes("\0") || decoded.split("/").some((segment) => segment === "." || segment === "..")) throw unsafeRoute(value);
+}
+function unsafeRoute(value) {
+  return new DocumentationError(
+    `Documentation route contains an unsafe path segment: ${value}`,
+    "documentation_route_invalid",
+    [{ code: "route_path_escape", message: value }]
+  );
+}
+
+// src/documentation/artifacts.ts
+function pageMarkdown(page, basePath = "/docs") {
+  const title = `# ${page.title}`;
+  const body = publicDocumentationReferences(page.markdown, basePath).trim();
+  return `${title}
+${page.description ? `
+${page.description}
+` : ""}${body ? `
+${body}
+` : "\n"}`;
+}
+function createSearchEntries(pages) {
+  return pages.filter((page) => !page.hidden).map((page) => ({
+    route: page.route,
+    title: page.title,
+    ...page.description ? { description: page.description } : {},
+    headings: page.headings.filter((heading) => heading.depth > 1).map((heading) => heading.text),
+    text: page.text.slice(0, 12e3)
+  }));
+}
+function createAssistantChunks(pages) {
+  return pages.flatMap((page) => {
+    if (page.hidden) return [];
+    const chunks = [];
+    let index = 0;
+    const sections = page.html.split(/(?=<h[23]\b)/);
+    for (const section of sections) {
+      const headingMatch = section.match(/^<h[23] id="([^"]+)">/);
+      const heading = headingMatch ? page.headings.find((candidate) => candidate.id === headingMatch[1]) : void 0;
+      const route = heading ? `${page.route}#${heading.id}` : page.route;
+      const paragraphs = htmlToText(section).split(/(?<=[.!?])\s+(?=[A-Z0-9])/);
+      let current = "";
+      const flush = () => {
+        const text = current.trim();
+        if (!text) return;
+        chunks.push({
+          id: `${routeArtifactId(page.route)}:${index++}`,
+          route,
+          title: page.title,
+          ...heading ? { heading: heading.text } : {},
+          text
+        });
+        current = "";
+      };
+      for (const paragraph of paragraphs) {
+        if (current.length + paragraph.length > 1800) flush();
+        current += `${current ? " " : ""}${paragraph}`;
+      }
+      flush();
+    }
+    return chunks;
+  });
+}
+function pagesInNavigationOrder(pages, navigation) {
+  const byRoute = new Map(pages.map((page) => [page.route, page]));
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit2 = (nodes) => {
+    for (const node of nodes) {
+      if (node.kind === "group") {
+        visit2(node.items);
+        continue;
+      }
+      if (node.kind !== "page" || seen.has(node.route)) continue;
+      const page = byRoute.get(node.route);
+      if (page) ordered.push(page);
+      seen.add(node.route);
+    }
+  };
+  visit2(navigation);
+  for (const page of pages) {
+    if (!seen.has(page.route)) ordered.push(page);
+  }
+  return ordered;
+}
+function renderLlmsIndex(pages, name, basePath = "/docs") {
+  const lines = [`# ${name}`, "", "> Documentation index generated by DeepSpace Documentation.", ""];
+  for (const page of pages.filter((candidate) => !candidate.hidden)) {
+    lines.push(
+      `- [${page.title}](${markdownUrlForRoute(page.route, basePath)})${page.description ? `: ${page.description}` : ""}`
+    );
+  }
+  return `${lines.join("\n")}
+`;
+}
+function renderLlmsFull(pages, name, basePath = "/docs") {
+  return `# ${name}
+
+${pages.filter((page) => !page.hidden).map(
+    (page) => `${pageMarkdown(page, basePath).trim()}
+
+Source: ${markdownUrlForRoute(page.route, basePath)}`
+  ).join("\n\n---\n\n")}
+`;
+}
+function renderSitemap(pages, baseUrl) {
+  const urls = baseUrl ? pages.filter((page) => !page.hidden && !page.noindex).map((page) => `  <url><loc>${escapeXml(joinSiteUrl(baseUrl, page.route))}</loc></url>`).join("\n") : "";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urls}${urls ? "\n" : ""}</urlset>
+`;
+}
+function renderRobots(baseUrl, noindex) {
+  if (noindex) return "User-agent: *\nDisallow: /\n";
+  return `User-agent: *
+Allow: /
+${baseUrl ? `Sitemap: ${joinSiteUrl(baseUrl, "/sitemap.xml")}
+` : ""}`;
+}
+function stableJson(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+
+// src/documentation/graph.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync3 } from "fs";
+import { basename as basename2, dirname, extname as extname2, join, posix, relative as relative3, resolve as resolve4, sep as sep2 } from "path";
+
+// src/documentation/config.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/shared/ai-models.ts
+var MULTI_STEP_AGENT_PROFILES = ["application", "documentation"];
+function createMultiStepModelFactory(provider) {
+  return (model) => ({
+    ...model,
+    ...provider,
+    agentSupport: "multi-step",
+    agentProfiles: MULTI_STEP_AGENT_PROFILES
+  });
+}
+var anthropicModel = createMultiStepModelFactory({
+  provider: "anthropic",
+  providerLabel: "Anthropic",
+  transport: "messages"
+});
+var openAIModel = createMultiStepModelFactory({
+  provider: "openai",
+  providerLabel: "OpenAI",
+  transport: "chat-completions"
+});
+var DEEPSPACE_AI_MODELS = [
+  anthropicModel({
+    id: "claude-fable-5",
+    label: "Claude Fable 5",
+    family: "Claude 5",
+    recommendation: "frontier"
+  }),
+  anthropicModel({
+    id: "claude-opus-5",
+    label: "Claude Opus 5",
+    family: "Claude 5",
+    recommendation: "frontier"
+  }),
+  anthropicModel({
+    id: "claude-sonnet-5",
+    label: "Claude Sonnet 5",
+    family: "Claude 5",
+    recommendation: "balanced"
+  }),
+  anthropicModel({
+    id: "claude-haiku-4-5",
+    label: "Claude Haiku 4.5",
+    family: "Claude 4.5",
+    recommendation: "fast"
+  }),
+  openAIModel({
+    id: "gpt-5.6-sol",
+    label: "GPT-5.6 Sol",
+    family: "GPT-5.6",
+    recommendation: "frontier"
+  }),
+  openAIModel({
+    id: "gpt-5.6-terra",
+    label: "GPT-5.6 Terra",
+    family: "GPT-5.6",
+    recommendation: "balanced"
+  }),
+  openAIModel({
+    id: "gpt-5.6-luna",
+    label: "GPT-5.6 Luna",
+    family: "GPT-5.6",
+    recommendation: "fast"
+  }),
+  {
+    id: "gpt-oss-120b",
+    label: "GPT-OSS 120B",
+    provider: "cerebras",
+    providerLabel: "Cerebras",
+    family: "GPT-OSS",
+    agentSupport: "single-step",
+    agentProfiles: [],
+    transport: "chat-completions",
+    recommendation: "limited",
+    note: "Available for direct generation; the current proxy adapter has not passed multi-step tool-result continuation."
+  }
+];
+var DEEPSPACE_AI_DEFAULTS = {
+  agent: "claude-sonnet-5",
+  directGeneration: "claude-sonnet-5",
+  summarization: "claude-haiku-4-5"
+};
+var DEEPSPACE_AGENT_PROFILES = {
+  application: {
+    id: "application",
+    defaultModel: DEEPSPACE_AI_DEFAULTS.agent,
+    maxSteps: 21,
+    maxToolCalls: 20,
+    allowedTools: "application-defined"
+  },
+  documentation: {
+    id: "documentation",
+    defaultModel: DEEPSPACE_AI_DEFAULTS.agent,
+    // Permit up to twenty completed read-only tools plus one final synthesis
+    // step. The runner disables tools once the tool-call budget is exhausted.
+    maxSteps: 21,
+    maxToolCalls: 20,
+    allowedTools: ["documentation_search", "documentation_read"]
+  }
+};
+function getDeepSpaceAIModel(modelId) {
+  if (typeof modelId !== "string") return null;
+  return DEEPSPACE_AI_MODELS.find((model) => model.id === modelId) ?? null;
+}
+function listDeepSpaceAgentModels(profileId = "application") {
+  const defaultModel = DEEPSPACE_AGENT_PROFILES[profileId].defaultModel;
+  return DEEPSPACE_AI_MODELS.filter(
+    (model) => model.agentProfiles.includes(profileId)
+  ).sort((left, right) => Number(right.id === defaultModel) - Number(left.id === defaultModel));
+}
+function resolveDeepSpaceAgentModel(modelId, profileId = "application") {
+  const profile = DEEPSPACE_AGENT_PROFILES[profileId];
+  const resolvedId = modelId === void 0 ? profile.defaultModel : modelId;
+  const model = getDeepSpaceAIModel(resolvedId);
+  if (!model || !model.agentProfiles.includes(profileId)) return null;
+  return { modelId: model.id, provider: model.provider, model, profile };
+}
+
+// src/documentation/config/schema.ts
+import { z } from "zod";
+var linkSchema = z.object({
+  label: z.string().trim().min(1),
+  href: z.string().trim().min(1)
+});
+var navigationSchema = z.lazy(
+  () => z.union([
+    z.string().trim().min(1),
+    linkSchema,
+    z.object({
+      group: z.string().trim().min(1),
+      pages: z.array(navigationSchema).min(1)
+    })
+  ])
+);
+var openApiExamplesSchema = z.object({
+  languages: z.array(z.enum(DOCUMENTATION_OPENAPI_SAMPLE_LANGUAGES)).min(1).optional(),
+  defaults: z.enum(["required", "all"]).optional(),
+  autogenerate: z.boolean().optional()
+});
+var openapiItemSchema = z.union([
+  z.string().trim().min(1).transform((source) => ({ source })),
+  z.object({
+    source: z.string().trim().min(1),
+    route: z.string().trim().optional(),
+    label: z.string().trim().min(1).optional(),
+    playground: z.boolean().optional(),
+    baseUrl: z.string().url().optional(),
+    examples: openApiExamplesSchema.optional()
+  })
+]);
+var themeObjectSchema = z.object({
+  preset: z.string().trim().min(1).optional(),
+  accent: z.string().trim().optional(),
+  background: z.string().trim().optional(),
+  logo: z.string().trim().optional(),
+  logoDark: z.string().trim().optional(),
+  favicon: z.string().trim().optional(),
+  defaultMode: z.enum(["light", "dark", "system"]).optional()
+});
+var fontSpecSchema = z.union([
+  z.string().trim().min(1).transform((family) => ({ family })),
+  z.object({
+    family: z.string().trim().min(1),
+    weight: z.union([z.number().int().min(100).max(900), z.string().trim().min(1)]).optional(),
+    source: z.string().trim().min(1).optional(),
+    format: z.string().trim().min(1).optional()
+  })
+]);
+var colorPairSchema = z.union([
+  z.string().trim().min(1).transform((color) => ({ light: color })),
+  z.object({
+    light: z.string().trim().min(1).optional(),
+    dark: z.string().trim().min(1).optional()
+  })
+]);
+var navigationRootSchema = z.union([
+  z.array(navigationSchema),
+  z.object({
+    groups: z.array(
+      z.object({
+        group: z.string().trim().min(1),
+        pages: z.array(navigationSchema).min(1)
+      })
+    ),
+    global: z.record(z.string(), z.unknown()).optional()
+  })
+]);
+var navbarSchema = z.object({
+  links: z.array(linkSchema).optional(),
+  primary: z.object({
+    type: z.string().optional(),
+    label: z.string().trim().min(1),
+    href: z.string().trim().min(1)
+  }).optional()
+}).optional();
+var footerSchema = z.union([
+  z.array(linkSchema),
+  z.object({ socials: z.record(z.string(), z.string().trim().min(1)).optional() })
+]);
+var logoSchema = z.union([
+  z.string().trim().min(1),
+  z.object({
+    light: z.string().trim().min(1),
+    dark: z.string().trim().min(1).optional(),
+    href: z.string().trim().min(1).optional()
+  })
+]).optional();
+var contextualActionsSchema = z.array(z.enum(DOCUMENTATION_CONTEXTUAL_ACTIONS)).min(1).max(DOCUMENTATION_CONTEXTUAL_ACTIONS.length).refine((actions) => new Set(actions).size === actions.length, {
+  message: "actions must not contain duplicates"
+});
+var hostnameSchema = z.hostname("must be a hostname such as docs.example.com").trim().toLowerCase().refine((value) => value.includes("."), "must include a public suffix");
+var rawConfigSchema = z.object({
+  $schema: z.string().optional(),
+  name: z.string().trim().min(1),
+  description: z.string().trim().optional(),
+  source: z.string().trim().min(1).default("documentation"),
+  output: z.string().trim().min(1).default("dist/_documentation"),
+  url: z.string().url().optional(),
+  domains: z.array(hostnameSchema).max(1, "one compiled documentation surface has one canonical custom domain").default([]),
+  theme: z.union([z.string().trim().min(1), themeObjectSchema]).default({}),
+  colors: z.object({
+    primary: z.string().trim().optional(),
+    light: z.string().trim().optional(),
+    dark: z.string().trim().optional()
+  }).optional(),
+  logo: logoSchema,
+  favicon: z.string().trim().min(1).optional(),
+  appearance: z.object({
+    default: z.enum(["light", "dark", "system"]).optional(),
+    strict: z.boolean().optional()
+  }).optional(),
+  background: z.object({
+    color: colorPairSchema.optional(),
+    decoration: z.enum(["none", "gradient", "grid"]).optional()
+  }).optional(),
+  fonts: z.object({
+    family: z.string().trim().min(1).optional(),
+    body: fontSpecSchema.optional(),
+    heading: fontSpecSchema.optional(),
+    mono: fontSpecSchema.optional()
+  }).optional(),
+  styling: z.object({
+    codeblocks: z.enum(["dark", "system"]).optional(),
+    eyebrows: z.enum(["section", "breadcrumbs", "none"]).optional()
+  }).optional(),
+  navigation: navigationRootSchema.optional(),
+  navbar: navbarSchema,
+  links: z.array(linkSchema).default([]),
+  footer: footerSchema.default([]),
+  redirects: z.record(z.string(), z.string()).default({}),
+  api: z.object({
+    playground: z.object({
+      display: z.enum(["interactive", "simple", "none"]).optional()
+    }).optional(),
+    examples: openApiExamplesSchema.optional()
+  }).optional(),
+  openapi: z.union([openapiItemSchema, z.array(openapiItemSchema)]).optional(),
+  assistant: z.object({
+    access: z.enum(["disabled", "public", "authenticated"]).default("disabled"),
+    model: z.string().trim().min(1).optional(),
+    suggestions: z.array(z.string().trim().min(1)).max(6).optional()
+  }).default({ access: "disabled" }),
+  mcp: z.object({
+    access: z.enum(["disabled", "public"]).default("public")
+  }).default({ access: "public" }),
+  contextual: z.object({
+    actions: contextualActionsSchema.default([...DEFAULT_DOCUMENTATION_CONTEXTUAL_ACTIONS])
+  }).default({ actions: [...DEFAULT_DOCUMENTATION_CONTEXTUAL_ACTIONS] }),
+  seo: z.object({
+    noindex: z.boolean().optional(),
+    ogImage: z.string().trim().optional(),
+    metaTags: z.record(z.string(), z.string()).optional(),
+    metatags: z.record(z.string(), z.string()).optional()
+  }).default({})
+});
+var RAW_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "$schema",
+  "name",
+  "description",
+  "source",
+  "output",
+  "url",
+  "domains",
+  "theme",
+  "colors",
+  "logo",
+  "favicon",
+  "appearance",
+  "background",
+  "fonts",
+  "styling",
+  "navigation",
+  "navbar",
+  "links",
+  "footer",
+  "redirects",
+  "api",
+  "openapi",
+  "assistant",
+  "mcp",
+  "contextual",
+  "seo"
+]);
+
+// src/documentation/config/validation.ts
+import { existsSync, realpathSync } from "fs";
+import { isAbsolute, relative, resolve } from "path";
+function validateLinks(links, field, configPath) {
+  for (const link of links) {
+    if (!/^(?:https?:\/\/|mailto:|\/|#)/i.test(link.href)) {
+      throw new DocumentationError(
+        `Unsafe ${field} link: ${link.href}`,
+        "documentation_config_invalid",
+        [{ code: "unsafe_link", message: `${field}: ${link.href}`, file: configPath }]
+      );
+    }
+  }
+}
+function safeChildPath(appDir, configured, field, configPath) {
+  if (isAbsolute(configured)) {
+    throw new DocumentationError(
+      `documentation.json ${field} must be relative to the app directory`,
+      "documentation_path_invalid",
+      [{ code: "absolute_path", message: `${field}: ${configured}`, file: configPath }]
+    );
+  }
+  const path = resolve(appDir, configured);
+  const rel = relative(appDir, path);
+  if (rel === ".." || rel.startsWith(`..${pathSeparator()}`)) {
+    throw new DocumentationError(
+      `documentation.json ${field} escapes the app directory`,
+      "documentation_path_invalid",
+      [{ code: "path_escape", message: `${field}: ${configured}`, file: configPath }]
+    );
+  }
+  if (existsSync(path)) {
+    const realRoot = realpathSync(appDir);
+    const realPath = realpathSync(path);
+    const realRelative = relative(realRoot, realPath);
+    if (realRelative === ".." || realRelative.startsWith(`..${pathSeparator()}`)) {
+      throw new DocumentationError(
+        `documentation.json ${field} resolves outside the app directory`,
+        "documentation_path_invalid",
+        [{ code: "path_symlink_escape", message: `${field}: ${configured}`, file: configPath }]
+      );
+    }
+  }
+  return path;
+}
+function pathSeparator() {
+  return process.platform === "win32" ? "\\" : "/";
+}
+function isWithin(parent, child) {
+  const rel = relative(parent, child);
+  return rel !== "" && rel !== ".." && !rel.startsWith(`..${pathSeparator()}`);
+}
+function validateRedirects(redirects, configPath) {
+  for (const [from, to] of Object.entries(redirects)) {
+    if (!from.startsWith("/") || !to.startsWith("/")) {
+      throw new DocumentationError(
+        `Redirects must use absolute site paths: ${from} -> ${to}`,
+        "documentation_redirect_invalid",
+        [{ code: "redirect_path", message: `${from} -> ${to}`, file: configPath }]
+      );
+    }
+    if (from === to) {
+      throw new DocumentationError(
+        `Redirect points to itself: ${from}`,
+        "documentation_redirect_invalid",
+        [{ code: "redirect_loop", message: from, file: configPath }]
+      );
+    }
+    const seen = /* @__PURE__ */ new Set([from]);
+    let cursor = to;
+    while (cursor && redirects[cursor]) {
+      if (seen.has(cursor)) {
+        throw new DocumentationError(
+          `Redirect loop includes ${cursor}`,
+          "documentation_redirect_invalid",
+          [{ code: "redirect_loop", message: [...seen, cursor].join(" -> "), file: configPath }]
+        );
+      }
+      seen.add(cursor);
+      cursor = redirects[cursor];
+    }
+  }
+}
+function humanize(value) {
+  return value.split(/[-_]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+
+// src/documentation/config.ts
+function loadDocumentationConfig(appDir) {
+  const resolvedAppDir = resolve2(appDir);
+  const configPath = resolve2(resolvedAppDir, DOCUMENTATION_CONFIG_FILE);
+  if (!existsSync2(configPath)) {
+    throw new DocumentationError(
+      `No ${DOCUMENTATION_CONFIG_FILE} found in ${resolvedAppDir}`,
+      "documentation_config_missing",
+      [{ code: "documentation_config_missing", message: `Create ${DOCUMENTATION_CONFIG_FILE}`, file: configPath }]
+    );
+  }
+  const raw = readFileSync(configPath, "utf8");
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch (error) {
+    throw new DocumentationError(
+      `${DOCUMENTATION_CONFIG_FILE} is not valid JSON: ${errorMessage(error)}`,
+      "documentation_config_invalid",
+      [{ code: "invalid_json", message: errorMessage(error), file: configPath }]
+    );
+  }
+  const parsed = rawConfigSchema.safeParse(input);
+  if (!parsed.success) {
+    const diagnostics = parsed.error.issues.map((issue) => ({
+      code: "invalid_config_value",
+      message: `${issue.path.join(".") || "<root>"}: ${issue.message}`,
+      file: configPath
+    }));
+    throw new DocumentationError(
+      `${DOCUMENTATION_CONFIG_FILE} has ${diagnostics.length} validation error(s)`,
+      "documentation_config_invalid",
+      diagnostics
+    );
+  }
+  const data = parsed.data;
+  if (data.assistant.model !== void 0 && !resolveDeepSpaceAgentModel(data.assistant.model, "documentation")) {
+    const catalogModel = getDeepSpaceAIModel(data.assistant.model);
+    const reason = catalogModel ? `does not support the multi-step documentation agent (${catalogModel.note ?? "incompatible runtime contract"})` : "is not in the DeepSpace model catalog";
+    const supported = listDeepSpaceAgentModels("documentation").map((model) => model.id).join(", ");
+    throw new DocumentationError(
+      `${DOCUMENTATION_CONFIG_FILE} has an unsupported assistant model`,
+      "documentation_config_invalid",
+      [
+        {
+          code: "unsupported_assistant_model",
+          message: `assistant.model '${data.assistant.model}' ${reason}. Supported models: ${supported}`,
+          file: configPath
+        }
+      ]
+    );
+  }
+  const warnings = [];
+  if (input && typeof input === "object" && !Array.isArray(input)) {
+    for (const key of Object.keys(input)) {
+      if (!RAW_CONFIG_KEYS.has(key)) {
+        warnings.push({
+          code: "unsupported_config_key",
+          message: `Unsupported Mintlify configuration key '${key}' was ignored`,
+          file: configPath
+        });
+      }
+    }
+  }
+  const themeInput = typeof data.theme === "string" ? { preset: data.theme } : data.theme;
+  if (typeof data.theme === "string") {
+    warnings.push({
+      code: "mintlify_theme_normalized",
+      message: `Mintlify theme '${data.theme}' is mapped to the native Orbit surface`,
+      file: configPath
+    });
+  }
+  const logo = typeof data.logo === "string" ? { light: data.logo } : data.logo;
+  const background = data.background?.color;
+  const bodyFont = data.fonts?.body ?? (data.fonts?.family ? { family: data.fonts.family } : void 0);
+  const headingFont = data.fonts?.heading ?? bodyFont;
+  const monoFont = data.fonts?.mono;
+  const navigation = Array.isArray(data.navigation) ? data.navigation : data.navigation?.groups;
+  if (data.navigation && !Array.isArray(data.navigation)) {
+    warnings.push({
+      code: "mintlify_navigation_normalized",
+      message: "Mintlify navigation.groups was normalized to native navigation",
+      file: configPath
+    });
+  }
+  const navbarLinks = [
+    ...data.navbar?.links ?? [],
+    ...data.navbar?.primary ? [{ label: data.navbar.primary.label, href: data.navbar.primary.href }] : []
+  ];
+  const footer = Array.isArray(data.footer) ? data.footer : Object.entries(data.footer.socials ?? {}).map(([label, href]) => ({
+    label: humanize(label),
+    href
+  }));
+  const config = {
+    $schema: data.$schema,
+    name: data.name,
+    description: data.description,
+    source: data.source,
+    output: data.output,
+    url: data.url,
+    domains: [...new Set(data.domains)],
+    theme: {
+      ...themeInput,
+      accent: themeInput.accent ?? data.colors?.primary ?? data.colors?.light ?? data.colors?.dark,
+      background: background?.light ?? themeInput.background,
+      backgroundDark: background && "dark" in background ? background.dark : void 0,
+      backgroundDecoration: data.background?.decoration,
+      bodyFont,
+      headingFont,
+      monoFont,
+      codeBlockMode: data.styling?.codeblocks,
+      eyebrowStyle: data.styling?.eyebrows,
+      logo: themeInput.logo ?? logo?.light,
+      logoDark: themeInput.logoDark ?? logo?.dark,
+      logoHref: logo?.href,
+      favicon: themeInput.favicon ?? data.favicon,
+      defaultMode: data.appearance?.default ?? themeInput.defaultMode,
+      strictMode: data.appearance?.strict
+    },
+    navigation,
+    links: data.links.length > 0 ? data.links : navbarLinks,
+    footer,
+    redirects: data.redirects,
+    openapi: normalizeOpenApi(data.openapi, data.api),
+    assistant: data.assistant,
+    mcp: data.mcp,
+    contextual: data.contextual,
+    seo: {
+      ...data.seo.noindex === void 0 ? {} : { noindex: data.seo.noindex },
+      ...data.seo.ogImage ? { ogImage: data.seo.ogImage } : {},
+      ...data.seo.metaTags ?? data.seo.metatags ? { metaTags: data.seo.metaTags ?? data.seo.metatags } : {}
+    }
+  };
+  validateRedirects(config.redirects, configPath);
+  validateLinks(config.links, "links", configPath);
+  validateLinks(config.footer, "footer", configPath);
+  if (config.theme.logoHref) {
+    validateLinks([{ label: "logo", href: config.theme.logoHref }], "logo.href", configPath);
+  }
+  const sourceDir = safeChildPath(resolvedAppDir, config.source, "source", configPath);
+  const outputDir = safeChildPath(resolvedAppDir, config.output, "output", configPath);
+  if (sourceDir === outputDir || isWithin(sourceDir, outputDir)) {
+    throw new DocumentationError(
+      "documentation.json output must not contain the documentation source directory",
+      "documentation_path_collision",
+      [
+        {
+          code: "documentation_path_collision",
+          message: `source=${config.source}, output=${config.output}`,
+          file: configPath
+        }
+      ]
+    );
+  }
+  config.theme = {
+    ...config.theme,
+    ...config.theme.logo ? { logo: normalizeLocalAsset(config.theme.logo, sourceDir) } : {},
+    ...config.theme.logoDark ? { logoDark: normalizeLocalAsset(config.theme.logoDark, sourceDir) } : {},
+    ...config.theme.favicon ? { favicon: normalizeLocalAsset(config.theme.favicon, sourceDir) } : {},
+    ...config.theme.bodyFont?.source ? {
+      bodyFont: {
+        ...config.theme.bodyFont,
+        source: normalizeLocalAsset(config.theme.bodyFont.source, sourceDir)
+      }
+    } : {},
+    ...config.theme.headingFont?.source ? {
+      headingFont: {
+        ...config.theme.headingFont,
+        source: normalizeLocalAsset(config.theme.headingFont.source, sourceDir)
+      }
+    } : {},
+    ...config.theme.monoFont?.source ? {
+      monoFont: {
+        ...config.theme.monoFont,
+        source: normalizeLocalAsset(config.theme.monoFont.source, sourceDir)
+      }
+    } : {}
+  };
+  if (config.seo.ogImage) {
+    config.seo = {
+      ...config.seo,
+      ogImage: normalizeLocalAsset(config.seo.ogImage, sourceDir)
+    };
+  }
+  return { config, configPath, sourceDir, outputDir, raw, warnings };
+}
+function normalizeLocalAsset(value, sourceDir) {
+  if (/^(?:https?:|data:|\/media\/)/i.test(value)) return value;
+  const relativePath = value.replace(/^\.\//, "").replace(/^\/+/, "");
+  if (!relativePath || !existsSync2(resolve2(sourceDir, relativePath))) return value;
+  return `/media/${relativePath.split("\\").join("/")}`;
+}
+function normalizeOpenApi(value, api) {
+  if (!value) return [];
+  const items = Array.isArray(value) ? value : [value];
+  return items.map((item) => {
+    const localExamples = "examples" in item ? item.examples : void 0;
+    const display = api?.playground?.display;
+    return {
+      ...item,
+      ..."playground" in item && item.playground !== void 0 ? { playground: item.playground } : display ? { playground: display === "interactive" } : {},
+      examples: {
+        languages: localExamples?.languages ?? api?.examples?.languages ?? [...DEFAULT_DOCUMENTATION_OPENAPI_EXAMPLES.languages],
+        defaults: localExamples?.defaults ?? api?.examples?.defaults ?? DEFAULT_DOCUMENTATION_OPENAPI_EXAMPLES.defaults,
+        autogenerate: localExamples?.autogenerate ?? api?.examples?.autogenerate ?? DEFAULT_DOCUMENTATION_OPENAPI_EXAMPLES.autogenerate
+      }
+    };
+  });
+}
+
+// src/documentation/mdx.ts
+import { createProcessor } from "@mdx-js/mdx";
+import { gfmToMarkdown } from "mdast-util-gfm";
+import { toMarkdown } from "mdast-util-to-markdown";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import rehypeHighlight from "rehype-highlight";
+var EXECUTABLE_NODE_TYPES = /* @__PURE__ */ new Set([
+  "mdxjsEsm",
+  "mdxFlowExpression",
+  "mdxTextExpression"
+]);
+function parseMdx(source, file) {
+  const { frontmatter, body } = parseFrontmatter(source, file);
+  try {
+    const processor = createProcessor({ remarkPlugins: [remarkGfm] });
+    const tree = processor.parse(body);
+    const staticTree = projectStaticMarkdown(tree);
+    const markdown2 = toMarkdown(staticTree, {
+      extensions: [gfmToMarkdown()]
+    });
+    return { ...parseMarkdown(markdown2, file), frontmatter };
+  } catch (error) {
+    if (error instanceof DocumentationError) throw error;
+    const line = diagnosticLine(error);
+    throw new DocumentationError(
+      `Invalid MDX in ${file}: ${errorMessage(error)}`,
+      "documentation_mdx_invalid",
+      [{ code: "mdx_syntax", message: errorMessage(error), file, ...line ? { line } : {} }]
+    );
+  }
+}
+function mdxCompileOptions() {
+  return {
+    jsx: false,
+    outputFormat: "program",
+    remarkPlugins: [remarkGfm, remarkFrontmatter, removeFrontmatter, addRuntimeMetadata],
+    rehypePlugins: [rehypeHighlight]
+  };
+}
+function projectStaticMarkdown(node) {
+  const projected = { ...node };
+  delete projected.attributes;
+  delete projected.name;
+  projected.children = (node.children ?? []).flatMap(projectStaticNode);
+  return projected;
+}
+function projectStaticNode(node) {
+  if (EXECUTABLE_NODE_TYPES.has(node.type)) return [];
+  if (node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") {
+    const title = jsxTitle(node);
+    const titleNode = title ? [{
+      type: "paragraph",
+      children: [{ type: "text", value: title }]
+    }] : [];
+    return [...titleNode, ...(node.children ?? []).flatMap(projectStaticNode)];
+  }
+  return [projectStaticMarkdown(node)];
+}
+function jsxTitle(node) {
+  const attribute = node.attributes?.find(
+    (candidate) => candidate.type === "mdxJsxAttribute" && (candidate.name === "title" || candidate.name === "label")
+  );
+  return typeof attribute?.value === "string" ? attribute.value : void 0;
+}
+function removeFrontmatter() {
+  return (tree) => {
+    tree.children = tree.children?.filter((node) => node.type !== "yaml");
+  };
+}
+function addRuntimeMetadata() {
+  return (tree) => {
+    const slug = createSlugger();
+    visit(tree, (node) => {
+      if (node.type === "heading") {
+        const text = staticText(node);
+        const id = slug(text);
+        node.data = {
+          ...node.data,
+          hProperties: {
+            ...asRecord(node.data?.hProperties),
+            id
+          }
+        };
+      }
+      if (node.type === "code" && typeof node.meta === "string" && node.meta.trim()) {
+        node.data = {
+          ...node.data,
+          hProperties: {
+            ...asRecord(node.data?.hProperties),
+            "data-code-title": node.meta.trim()
+          }
+        };
+      }
+    });
+  };
+}
+function staticText(node) {
+  if (node.type === "text" || node.type === "inlineCode") return node.value ?? "";
+  if (EXECUTABLE_NODE_TYPES.has(node.type)) return "";
+  return (node.children ?? []).map(staticText).join("");
+}
+function visit(node, visitor) {
+  visitor(node);
+  for (const child of node.children ?? []) visit(child, visitor);
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function diagnosticLine(error) {
+  if (!error || typeof error !== "object" || !("line" in error)) return void 0;
+  return typeof error.line === "number" ? error.line : void 0;
+}
+
+// src/documentation/openapi.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, realpathSync as realpathSync2 } from "fs";
+import { basename, extname, relative as relative2, resolve as resolve3, sep } from "path";
+import { parse as parseYaml2 } from "yaml";
+
+// src/documentation/openapi-object.ts
+function asOpenApiObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function resolveOpenApiObject(value, document2, seen = /* @__PURE__ */ new Set()) {
+  const object = asOpenApiObject(value);
+  if (!object || typeof object.$ref !== "string") return object;
+  const reference = object.$ref;
+  if (!reference.startsWith("#/") || seen.has(reference)) return void 0;
+  seen.add(reference);
+  let resolved = document2;
+  for (const segment of reference.slice(2).split("/")) {
+    resolved = asOpenApiObject(resolved)?.[segment.replace(/~1/g, "/").replace(/~0/g, "~")];
+  }
+  const target = asOpenApiObject(resolved);
+  if (!target) return void 0;
+  const siblings = Object.fromEntries(Object.entries(object).filter(([key]) => key !== "$ref"));
+  return { ...target, ...siblings };
+}
+
+// src/documentation/openapi-samples.ts
+var LANGUAGE_METADATA = {
+  curl: { label: "cURL", syntax: "bash" },
+  javascript: { label: "JavaScript", syntax: "javascript" },
+  python: { label: "Python", syntax: "python" },
+  go: { label: "Go", syntax: "go" }
+};
+function createOpenApiCodeSamples(operation, document2, examples, customSamples) {
+  const custom = normalizeCustomSamples(customSamples);
+  if (examples?.autogenerate === false || !operation.baseUrl) return custom;
+  const languages = examples?.languages ?? DEFAULT_DOCUMENTATION_OPENAPI_EXAMPLES.languages;
+  const defaults = examples?.defaults ?? DEFAULT_DOCUMENTATION_OPENAPI_EXAMPLES.defaults;
+  const request = buildSampleRequest(operation, document2, defaults === "all");
+  const customLanguages = new Set(custom.map((sample) => knownLanguage(sample.language)));
+  const generated = languages.filter((language) => !customLanguages.has(language)).map(
+    (language) => ({
+      language,
+      label: LANGUAGE_METADATA[language].label,
+      syntax: LANGUAGE_METADATA[language].syntax,
+      code: renderSample(language, request),
+      generated: true
+    })
+  );
+  return [...custom, ...generated];
+}
+function buildSampleRequest(operation, document2, includeOptional) {
+  let path = operation.path;
+  const query = new URLSearchParams();
+  const headers = { Accept: "application/json" };
+  const cookies = [];
+  const parameters = operation.parameters.filter(
+    (parameter) => parameter.required || includeOptional
+  );
+  for (const parameter of parameters) {
+    const value = sampleParameterValue(parameter, document2);
+    if (parameter.in === "path") {
+      path = path.replaceAll(`{${parameter.name}}`, encodeURIComponent(String(value)));
+    } else if (parameter.in === "query") {
+      query.set(parameter.name, String(value));
+    } else if (parameter.in === "header") {
+      headers[parameter.name] = String(value);
+    } else if (parameter.in === "cookie") {
+      cookies.push(`${parameter.name}=${String(value)}`);
+    }
+  }
+  path = path.replace(
+    /\{([^}]+)\}/g,
+    (_match, name) => encodeURIComponent(`example-${slugPart(name)}`)
+  );
+  applySecurity(operation.security ?? document2.security, document2, headers, query, cookies);
+  if (cookies.length > 0) headers.Cookie = cookies.join("; ");
+  const body = requestBodyExample(operation.requestBody, document2, includeOptional);
+  if (body !== void 0) headers["Content-Type"] = "application/json";
+  const separator = path.includes("?") ? "&" : "?";
+  const search = query.toString();
+  const url = `${operation.baseUrl?.replace(/\/$/, "") ?? ""}${path}${search ? `${separator}${search}` : ""}`;
+  return { method: operation.method, url, headers, ...body === void 0 ? {} : { body } };
+}
+function sampleParameterValue(parameter, document2) {
+  if (parameter.example !== void 0) return parameter.example;
+  const schema = resolveOpenApiObject(parameter.schema, document2);
+  if (schema) {
+    if (schema.example !== void 0) return schema.example;
+    if (schema.default !== void 0) return schema.default;
+    if (Array.isArray(schema.enum) && schema.enum.length > 0) return schema.enum[0];
+    if (schema.type === "boolean") return true;
+    if (schema.type === "integer" || schema.type === "number") return 1;
+  }
+  return `example-${slugPart(parameter.name)}`;
+}
+function requestBodyExample(value, document2, includeOptional) {
+  const requestBody = resolveOpenApiObject(value, document2);
+  if (!requestBody) return void 0;
+  const content = asOpenApiObject(requestBody.content);
+  if (!content) return void 0;
+  const jsonMedia = Object.entries(content).find(([contentType]) => contentType.endsWith("+json"));
+  const media = asOpenApiObject(content["application/json"]) ?? asOpenApiObject(jsonMedia?.[1]);
+  if (!media) return void 0;
+  if (media.example !== void 0) return media.example;
+  const namedExamples = asOpenApiObject(media.examples);
+  if (namedExamples) {
+    for (const example of Object.values(namedExamples)) {
+      const resolved = resolveOpenApiObject(example, document2);
+      if (resolved && resolved.value !== void 0) return resolved.value;
+    }
+  }
+  return schemaExample(media.schema, document2, includeOptional, /* @__PURE__ */ new Set(), 0);
+}
+function schemaExample(value, document2, includeOptional, seen, depth) {
+  if (depth > 8) return void 0;
+  const schema = resolveOpenApiObject(value, document2, seen);
+  if (!schema) return void 0;
+  if (schema.example !== void 0) return schema.example;
+  if (schema.default !== void 0) return schema.default;
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) return schema.enum[0];
+  const alternatives = Array.isArray(schema.oneOf) ? schema.oneOf : Array.isArray(schema.anyOf) ? schema.anyOf : void 0;
+  if (alternatives?.[0] !== void 0) {
+    return schemaExample(alternatives[0], document2, includeOptional, seen, depth + 1);
+  }
+  if (Array.isArray(schema.allOf)) {
+    return Object.assign(
+      {},
+      ...schema.allOf.map((part) => {
+        const example = schemaExample(part, document2, includeOptional, seen, depth + 1);
+        return asOpenApiObject(example) ?? {};
+      })
+    );
+  }
+  const properties = asOpenApiObject(schema.properties);
+  if (schema.type === "object" || properties) {
+    const required = new Set(
+      Array.isArray(schema.required) ? schema.required.filter((name) => typeof name === "string") : []
+    );
+    return Object.fromEntries(
+      Object.entries(properties ?? {}).filter(([name]) => includeOptional || required.has(name)).map(([name, property]) => [
+        name,
+        schemaExample(property, document2, includeOptional, new Set(seen), depth + 1)
+      ]).filter((entry) => entry[1] !== void 0)
+    );
+  }
+  if (schema.type === "array" || schema.items !== void 0) {
+    const item = schemaExample(schema.items, document2, includeOptional, seen, depth + 1);
+    return item === void 0 ? [] : [item];
+  }
+  if (schema.type === "boolean") return true;
+  if (schema.type === "integer" || schema.type === "number") return 1;
+  if (schema.type === "string") return stringExample(schema.format);
+  return void 0;
+}
+function stringExample(format) {
+  switch (format) {
+    case "date-time":
+      return "2026-01-01T00:00:00Z";
+    case "date":
+      return "2026-01-01";
+    case "email":
+      return "user@example.com";
+    case "uuid":
+      return "00000000-0000-4000-8000-000000000000";
+    case "uri":
+    case "url":
+      return "https://example.com";
+    default:
+      return "string";
+  }
+}
+function applySecurity(value, document2, headers, query, cookies) {
+  if (!Array.isArray(value)) return;
+  const requirement = value.map(asOpenApiObject).find(Boolean);
+  if (!requirement) return;
+  const schemes = asOpenApiObject(asOpenApiObject(document2.components)?.securitySchemes);
+  for (const name of Object.keys(requirement)) {
+    const scheme = resolveOpenApiObject(schemes?.[name], document2);
+    if (!scheme) continue;
+    if (scheme.type === "http" && scheme.scheme === "bearer") {
+      headers.Authorization = "Bearer <token>";
+    } else if (scheme.type === "http" && scheme.scheme === "basic") {
+      headers.Authorization = "Basic <credentials>";
+    } else if (scheme.type === "apiKey" && typeof scheme.name === "string") {
+      if (scheme.in === "query") query.set(scheme.name, "<api-key>");
+      else if (scheme.in === "cookie") cookies.push(`${scheme.name}=<api-key>`);
+      else headers[scheme.name] = "<api-key>";
+    }
+  }
+}
+function renderSample(language, request) {
+  switch (language) {
+    case "curl":
+      return renderCurl(request);
+    case "javascript":
+      return renderJavaScript(request);
+    case "python":
+      return renderPython(request);
+    case "go":
+      return renderGo(request);
+  }
+}
+function renderCurl(request) {
+  const lines = [`curl --request ${request.method} \\`, `  --url '${escapeShell(request.url)}'`];
+  for (const [name, value] of Object.entries(request.headers)) {
+    lines[lines.length - 1] += " \\";
+    lines.push(`  --header '${escapeShell(`${name}: ${value}`)}'`);
+  }
+  if (request.body !== void 0) {
+    lines[lines.length - 1] += " \\";
+    lines.push(`  --data '${escapeShell(prettyJson(request.body))}'`);
+  }
+  return lines.join("\n");
+}
+function renderJavaScript(request) {
+  const options = [
+    `method: ${JSON.stringify(request.method)}`,
+    `headers: ${indent(prettyJson(request.headers), 2).trimStart()}`,
+    ...request.body === void 0 ? [] : [`body: JSON.stringify(${indent(prettyJson(request.body), 2).trimStart()})`]
+  ];
+  return [
+    `const response = await fetch(${JSON.stringify(request.url)}, {`,
+    options.map((option) => `  ${option},`).join("\n"),
+    "})",
+    "",
+    "if (!response.ok) throw new Error(`Request failed: ${response.status}`)",
+    "const data = await response.json()",
+    "console.log(data)"
+  ].join("\n");
+}
+function renderPython(request) {
+  const arguments_ = [
+    JSON.stringify(request.method),
+    JSON.stringify(request.url),
+    `headers=${pythonValue(request.headers)}`,
+    ...request.body === void 0 ? [] : [`json=${pythonValue(request.body)}`]
+  ];
+  return [
+    "import requests",
+    "",
+    "response = requests.request(",
+    arguments_.map((argument) => `    ${argument},`).join("\n"),
+    ")",
+    "response.raise_for_status()",
+    "print(response.json())"
+  ].join("\n");
+}
+function renderGo(request) {
+  const requestBody = request.body === void 0 ? "nil" : `strings.NewReader(${JSON.stringify(prettyJson(request.body))})`;
+  const imports = ['"fmt"', '"io"', '"net/http"'];
+  if (request.body !== void 0) imports.push('"strings"');
+  return [
+    "package main",
+    "",
+    "import (",
+    ...imports.map((value) => `	${value}`),
+    ")",
+    "",
+    "func main() {",
+    `	req, err := http.NewRequest(${JSON.stringify(request.method)}, ${JSON.stringify(request.url)}, ${requestBody})`,
+    "	if err != nil { panic(err) }",
+    ...Object.entries(request.headers).map(
+      ([name, value]) => `	req.Header.Set(${JSON.stringify(name)}, ${JSON.stringify(value)})`
+    ),
+    "",
+    "	res, err := http.DefaultClient.Do(req)",
+    "	if err != nil { panic(err) }",
+    "	defer res.Body.Close()",
+    "",
+    "	body, err := io.ReadAll(res.Body)",
+    "	if err != nil { panic(err) }",
+    "	fmt.Println(string(body))",
+    "}"
+  ].join("\n");
+}
+function normalizeCustomSamples(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => {
+    const sample = asOpenApiObject(entry);
+    const language = typeof sample?.lang === "string" ? sample.lang.trim().toLowerCase() : "";
+    const source = typeof sample?.source === "string" ? sample.source.trim() : "";
+    if (!language || !source) return [];
+    const normalizedLanguage = knownLanguage(language);
+    const label = typeof sample?.label === "string" && sample.label.trim() ? sample.label.trim() : normalizedLanguage ? LANGUAGE_METADATA[normalizedLanguage].label : language;
+    return [
+      {
+        language,
+        label,
+        syntax: syntaxForLanguage(language),
+        code: source,
+        generated: false
+      }
+    ];
+  });
+}
+function knownLanguage(value) {
+  if (["curl", "bash", "shell", "sh"].includes(value)) return "curl";
+  if (["javascript", "js", "node", "nodejs"].includes(value)) return "javascript";
+  if (["python", "py"].includes(value)) return "python";
+  if (["go", "golang"].includes(value)) return "go";
+  return void 0;
+}
+function syntaxForLanguage(value) {
+  const known = knownLanguage(value);
+  return known ? LANGUAGE_METADATA[known].syntax : value.replace(/[^a-z0-9_+#.-]/g, "") || "text";
+}
+function prettyJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+function pythonValue(value) {
+  return prettyJson(value).replace(/\btrue\b/g, "True").replace(/\bfalse\b/g, "False").replace(/\bnull\b/g, "None");
+}
+function escapeShell(value) {
+  return value.replace(/'/g, `'"'"'`);
+}
+function indent(value, spaces) {
+  const prefix = " ".repeat(spaces);
+  return value.split("\n").map((line) => `${prefix}${line}`).join("\n");
+}
+function slugPart(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "value";
+}
+
+// src/documentation/openapi.ts
+var HTTP_METHODS = ["get", "post", "put", "patch", "delete", "options", "head", "trace"];
+function parseOpenApi(appDir, config) {
+  const sourcePath = resolve3(appDir, config.source);
+  assertOpenApiSourcePath(appDir, sourcePath, config.source);
+  if (!existsSync3(sourcePath)) {
+    throw new DocumentationError(`OpenAPI source not found: ${config.source}`, "documentation_openapi_missing", [
+      { code: "openapi_missing", message: config.source, file: sourcePath }
+    ]);
+  }
+  assertOpenApiSourcePath(appDir, realpathSync2(sourcePath), config.source);
+  const raw = readFileSync2(sourcePath, "utf8");
+  let parsed;
+  try {
+    parsed = [".yaml", ".yml"].includes(extname(sourcePath).toLowerCase()) ? parseYaml2(raw, { maxAliasCount: 50 }) : JSON.parse(raw);
+  } catch (error) {
+    throw new DocumentationError(
+      `Invalid OpenAPI document ${config.source}: ${errorMessage(error)}`,
+      "documentation_openapi_invalid",
+      [{ code: "openapi_parse", message: errorMessage(error), file: sourcePath }]
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw invalidOpenApi(sourcePath, "Document root must be an object");
+  }
+  const document2 = parsed;
+  if (typeof document2.openapi !== "string" && typeof document2.swagger !== "string") {
+    throw invalidOpenApi(sourcePath, "Expected an openapi or swagger version field");
+  }
+  if (!document2.paths || typeof document2.paths !== "object") {
+    throw invalidOpenApi(sourcePath, "Expected a paths object");
+  }
+  const documentServer = firstServerUrl(document2.servers) ?? swaggerServerUrl(document2);
+  const operations = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const [path, pathItem] of Object.entries(document2.paths)) {
+    const normalizedPathItem = resolveOpenApiObject(pathItem, document2);
+    if (!normalizedPathItem) continue;
+    for (const method of HTTP_METHODS) {
+      const operation = resolveOpenApiObject(
+        normalizedPathItem[method],
+        document2
+      );
+      if (!operation) continue;
+      const baseUrl = config.baseUrl ?? firstServerUrl(operation.servers) ?? firstServerUrl(normalizedPathItem.servers) ?? documentServer;
+      const fallbackId = `${method}-${path}`;
+      const operationId = slugify(
+        typeof operation.operationId === "string" ? operation.operationId : fallbackId
+      );
+      if (!operationId)
+        throw invalidOpenApi(sourcePath, `Could not derive id for ${method} ${path}`);
+      if (ids.has(operationId)) {
+        throw invalidOpenApi(sourcePath, `Duplicate operation id: ${operationId}`);
+      }
+      ids.add(operationId);
+      const summary = typeof operation.summary === "string" ? operation.summary : `${method.toUpperCase()} ${path}`;
+      const parameters = mergeParameters(
+        normalizedPathItem.parameters,
+        operation.parameters,
+        document2
+      );
+      const security = "security" in operation ? operation.security : document2.security;
+      const normalized = {
+        method: method.toUpperCase(),
+        path,
+        operationId,
+        summary,
+        ...typeof operation.description === "string" ? { description: operation.description } : {},
+        tags: Array.isArray(operation.tags) ? operation.tags.filter((tag) => typeof tag === "string") : [],
+        parameters,
+        ..."requestBody" in operation ? { requestBody: operation.requestBody } : {},
+        responses: normalizeResponses(operation.responses, document2),
+        ...security === void 0 ? {} : { security },
+        ...baseUrl ? { baseUrl } : {},
+        playground: config.playground === true && Boolean(baseUrl)
+      };
+      operations.push({
+        ...normalized,
+        codeSamples: createOpenApiCodeSamples(
+          normalized,
+          document2,
+          config.examples,
+          operation["x-codeSamples"] ?? operation["x-code-samples"]
+        )
+      });
+    }
+  }
+  if (operations.length === 0) {
+    throw invalidOpenApi(sourcePath, "No HTTP operations found");
+  }
+  const route = normalizeRoute(config.route ?? "/api-reference");
+  const title = config.label ?? (typeof document2.info?.title === "string" ? document2.info.title : basename(config.source, extname(config.source)));
+  return { sourcePath, title, route, raw, operations };
+}
+function assertOpenApiSourcePath(appDir, sourcePath, configured) {
+  const sourceIsReal = existsSync3(sourcePath);
+  const root = sourceIsReal && existsSync3(appDir) && sourcePath === realpathSync2(sourcePath) ? realpathSync2(appDir) : resolve3(appDir);
+  const rel = relative2(root, sourcePath);
+  if (rel === ".." || rel.startsWith(`..${sep}`) || rel === "") {
+    throw new DocumentationError(
+      `OpenAPI source must be a file inside the app directory: ${configured}`,
+      "documentation_openapi_path_invalid",
+      [{ code: "openapi_path_escape", message: configured, file: sourcePath }]
+    );
+  }
+}
+function operationMarkdown(operation) {
+  const lines = [
+    `<div class="documentation-api-badge"><span class="method method-${operation.method.toLowerCase()}">${operation.method}</span><code>${operation.path}</code></div>`,
+    ""
+  ];
+  if (operation.description) lines.push(operation.description, "");
+  if (operation.parameters.length > 0) {
+    lines.push(
+      "## Parameters",
+      "",
+      "| Name | In | Required | Description |",
+      "| --- | --- | --- | --- |"
+    );
+    for (const parameter of operation.parameters) {
+      lines.push(
+        `| \`${escapeTable(parameter.name)}\` | ${escapeTable(parameter.in)} | ${parameter.required ? "yes" : "no"} | ${escapeTable(parameter.description ?? "")} |`
+      );
+    }
+    lines.push("");
+  }
+  if (operation.requestBody !== void 0) {
+    lines.push("## Request body", "", "```json", prettyJson2(operation.requestBody), "```", "");
+  }
+  if (operation.security !== void 0) {
+    lines.push("## Security", "", "```json", prettyJson2(operation.security), "```", "");
+  }
+  lines.push("## Responses", "");
+  if (operation.responses.length === 0) {
+    lines.push("No response schema is declared.", "");
+  } else {
+    for (const response of operation.responses) {
+      lines.push(`### ${response.status}`, "", response.description || "Response", "");
+      if (response.schema !== void 0) {
+        lines.push("```json", prettyJson2(response.schema), "```", "");
+      }
+    }
+  }
+  if (operation.codeSamples.length > 0) {
+    lines.push("## Request examples", "", '<CodeGroup title="Request">', "");
+    for (const sample of operation.codeSamples) {
+      const fence = codeFence(sample.code);
+      const label = sample.label.replace(/["\r\n]/g, "'");
+      lines.push(`${fence}${sample.syntax} title="${label}"`, sample.code, fence, "");
+    }
+    lines.push("</CodeGroup>", "");
+  }
+  return lines.join("\n");
+}
+function mergeParameters(pathParameters, operationParameters, document2) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const values of [pathParameters, operationParameters]) {
+    if (!Array.isArray(values)) continue;
+    for (const value of values) {
+      for (const parameter of normalizeParameter(value, document2)) {
+        merged.set(`${parameter.in}\0${parameter.name}`, parameter);
+      }
+    }
+  }
+  return [...merged.values()];
+}
+function normalizeParameter(value, document2) {
+  const parameter = resolveOpenApiObject(value, document2);
+  if (!parameter) return [];
+  if (typeof parameter.name !== "string" || typeof parameter.in !== "string") return [];
+  return [
+    {
+      name: parameter.name,
+      in: parameter.in,
+      required: parameter.required === true,
+      ...typeof parameter.description === "string" ? { description: parameter.description } : {},
+      ..."schema" in parameter ? { schema: parameter.schema } : {},
+      ..."example" in parameter ? { example: parameter.example } : {}
+    }
+  ];
+}
+function normalizeResponses(value, document2) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+  return Object.entries(value).map(([status, response]) => {
+    const data = resolveOpenApiObject(response, document2);
+    if (!data) {
+      return { status, description: "" };
+    }
+    return {
+      status,
+      description: typeof data.description === "string" ? data.description : "",
+      ..."content" in data ? { schema: data.content } : {}
+    };
+  });
+}
+function invalidOpenApi(file, message) {
+  return new DocumentationError(`Invalid OpenAPI document: ${message}`, "documentation_openapi_invalid", [
+    { code: "openapi_shape", message, file }
+  ]);
+}
+function prettyJson2(value) {
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+function escapeTable(value) {
+  return value.replace(/\|/g, "\\|").replace(/\n/g, " ");
+}
+function codeFence(source) {
+  const longest = Math.max(0, ...[...source.matchAll(/`+/g)].map((match) => match[0].length));
+  return "`".repeat(Math.max(3, longest + 1));
+}
+function firstServerUrl(value) {
+  if (!Array.isArray(value)) return void 0;
+  for (const server of value) {
+    const object = asOpenApiObject(server);
+    if (typeof object?.url === "string") return object.url;
+  }
+  return void 0;
+}
+function swaggerServerUrl(document2) {
+  if (typeof document2.host !== "string" || !document2.host) return void 0;
+  const scheme = Array.isArray(document2.schemes) ? document2.schemes.find((value) => typeof value === "string") : void 0;
+  const basePath = typeof document2.basePath === "string" ? document2.basePath : "";
+  return `${scheme ?? "https"}://${document2.host}${basePath}`;
+}
+
+// src/documentation/graph.ts
+function validateDocumentation(appDir) {
+  const loaded = loadDocumentationConfig(appDir);
+  if (!existsSync4(loaded.sourceDir)) {
+    throw new DocumentationError(
+      `Documentation source directory not found: ${loaded.config.source}`,
+      "documentation_source_missing",
+      [{ code: "source_missing", message: loaded.config.source, file: loaded.sourceDir }]
+    );
+  }
+  const warnings = [...loaded.warnings];
+  const contentFiles = collectContentFiles(loaded.sourceDir);
+  const sourceFiles = contentFiles.filter((path) => [".md", ".mdx"].includes(extname2(path).toLowerCase()));
+  if (sourceFiles.length === 0 && loaded.config.openapi.length === 0) {
+    throw new DocumentationError(
+      `No .md or .mdx pages found in ${loaded.config.source}`,
+      "documentation_pages_missing",
+      [{ code: "pages_missing", message: loaded.config.source, file: loaded.sourceDir }]
+    );
+  }
+  const pages = sourceFiles.map((sourcePath) => pageFromSource(loaded, sourcePath));
+  const openApiHashes = [];
+  const openApiGroups = [];
+  for (const openapiConfig of loaded.config.openapi) {
+    const api = parseOpenApi(resolve4(appDir), openapiConfig);
+    openApiHashes.push(api.raw);
+    const apiPages = api.operations.map((operation) => {
+      const markdown2 = operationMarkdown(operation);
+      const parsed = parseMarkdown(markdown2, `${api.sourcePath}#${operation.operationId}`);
+      return {
+        sourcePath: api.sourcePath,
+        relativePath: `${relative3(resolve4(appDir), api.sourcePath)}#${operation.operationId}`,
+        route: joinRoute(api.route, operation.operationId),
+        title: operation.summary,
+        description: operation.description,
+        hidden: false,
+        noindex: loaded.config.seo.noindex === true,
+        markdown: markdown2,
+        html: parsed.html,
+        text: parsed.text,
+        headings: parsed.headings,
+        sourceFormat: "generated",
+        kind: "openapi",
+        openapi: operation
+      };
+    });
+    pages.push(...apiPages);
+    openApiGroups.push({
+      kind: "group",
+      label: api.title,
+      items: apiPages.map((page) => ({ kind: "page", route: page.route, label: page.title }))
+    });
+  }
+  assertUniqueRoutes(pages);
+  const byRoute = new Map(pages.map((page) => [page.route, page]));
+  const navigation = loaded.config.navigation ? normalizeNavigation(loaded.config.navigation, byRoute, loaded.config) : automaticNavigation(pages.filter((page) => page.kind === "page"));
+  navigation.push(...openApiGroups);
+  assertNavigationCoverage(navigation, pages, loaded.config);
+  validatePageLinks(pages, byRoute, loaded.config.redirects);
+  validateRedirectTargets(loaded.config, byRoute);
+  const hash = createHash("sha256");
+  hash.update(loaded.raw);
+  for (const contentPath of contentFiles) {
+    hash.update(relative3(resolve4(appDir), contentPath).split(sep2).join("/"));
+    hash.update(readFileSync3(contentPath));
+  }
+  for (const raw of openApiHashes) hash.update(raw);
+  const graph = {
+    config: loaded.config,
+    pages: pages.sort((a, b) => a.route.localeCompare(b.route)),
+    navigation,
+    sourceHash: hash.digest("hex")
+  };
+  return {
+    appDir: resolve4(appDir),
+    configPath: loaded.configPath,
+    sourceDir: loaded.sourceDir,
+    outputDir: loaded.outputDir,
+    graph,
+    warnings
+  };
+}
+function pageFromSource(loaded, sourcePath) {
+  const source = readFileSync3(sourcePath, "utf8");
+  const relativePath = relative3(loaded.sourceDir, sourcePath).split(sep2).join("/");
+  const rewritten = rewriteLocalReferences(source, relativePath, loaded.sourceDir, sourcePath);
+  const sourceFormat = extname2(sourcePath).toLowerCase() === ".mdx" ? "mdx" : "markdown";
+  const authored = sourceFormat === "mdx" ? parseMdx(rewritten, sourcePath) : parseMarkdown(rewritten, sourcePath);
+  const route = authored.frontmatter.slug ? normalizeRoute(authored.frontmatter.slug) : routeFromRelativePath(relativePath);
+  const title = authored.frontmatter.title ?? authored.headings.find((heading) => heading.depth === 1)?.text ?? titleFromFile(relativePath);
+  const normalizedSource = stripFirstMarkdownH1(rewritten);
+  const parsed = sourceFormat === "mdx" ? parseMdx(normalizedSource, sourcePath) : parseMarkdown(normalizedSource, sourcePath);
+  return {
+    sourcePath,
+    relativePath,
+    route,
+    title,
+    description: parsed.frontmatter.description,
+    hidden: parsed.frontmatter.hidden === true,
+    noindex: loaded.config.seo.noindex === true || parsed.frontmatter.noindex === true,
+    markdown: parsed.markdown,
+    html: parsed.html,
+    text: parsed.text,
+    headings: parsed.headings,
+    sourceFormat,
+    kind: "page"
+  };
+}
+function collectContentFiles(sourceDir) {
+  const files = [];
+  const walk = (directory) => {
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const path = join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        throw new DocumentationError(
+          `Documentation content may not contain symbolic links: ${path}`,
+          "documentation_source_unsafe",
+          [{ code: "source_symlink", message: path, file: path }]
+        );
+      }
+      if (entry.isDirectory()) walk(path);
+      else if (entry.isFile()) files.push(path);
+    }
+  };
+  walk(sourceDir);
+  return files.sort();
+}
+function normalizeNavigation(items, pages, config) {
+  return items.map((item) => {
+    if (typeof item === "string") {
+      const route = navigationReferenceToRoute(item);
+      const page = pages.get(route);
+      if (!page) {
+        throw new DocumentationError(
+          `Navigation references a missing page: ${item}`,
+          "documentation_navigation_invalid",
+          [{ code: "navigation_missing_page", message: item }]
+        );
+      }
+      return { kind: "page", route, label: page.title };
+    }
+    if ("group" in item) {
+      return {
+        kind: "group",
+        label: item.group,
+        items: normalizeNavigation(item.pages, pages, config)
+      };
+    }
+    if (!isSafeLink(item.href)) {
+      throw new DocumentationError(
+        `Unsafe navigation link: ${item.href}`,
+        "documentation_navigation_invalid",
+        [{ code: "navigation_unsafe_link", message: item.href }]
+      );
+    }
+    if (item.href.startsWith("/")) {
+      const route = normalizeRoute(item.href);
+      if (!pages.has(route) && !config.redirects[route]) {
+        throw new DocumentationError(
+          `Navigation link points to an unknown internal route: ${item.href}`,
+          "documentation_navigation_invalid",
+          [{ code: "navigation_missing_route", message: item.href }]
+        );
+      }
+      return { kind: "link", href: route, label: item.label };
+    }
+    return { kind: "link", href: item.href, label: item.label };
+  });
+}
+function automaticNavigation(pages) {
+  return pages.filter((page) => !page.hidden).sort((a, b) => a.route.localeCompare(b.route)).map((page) => ({ kind: "page", route: page.route, label: page.title }));
+}
+function assertNavigationCoverage(navigation, pages, config) {
+  if (!config.navigation) return;
+  const routes = /* @__PURE__ */ new Set();
+  const visit2 = (nodes) => {
+    for (const node of nodes) {
+      if (node.kind === "page") routes.add(node.route);
+      else if (node.kind === "group") visit2(node.items);
+    }
+  };
+  visit2(navigation);
+  const orphaned = pages.filter((page) => page.kind === "page" && !page.hidden && !routes.has(page.route));
+  if (orphaned.length > 0) {
+    throw new DocumentationError(
+      `${orphaned.length} public page(s) are missing from navigation`,
+      "documentation_navigation_incomplete",
+      orphaned.map((page) => ({
+        code: "navigation_orphan",
+        message: page.route,
+        file: page.sourcePath
+      }))
+    );
+  }
+}
+function validatePageLinks(pages, byRoute, redirects) {
+  const diagnostics = [];
+  for (const page of pages) {
+    if (page.kind !== "page") continue;
+    const pattern = /(!?)\[[^\]]*\]\(([^)\s]+)(?:\s+["'][^"']*["'])?\)/g;
+    for (const match of page.markdown.matchAll(pattern)) {
+      const isImage = match[1] === "!";
+      const href = match[2];
+      if (isImage || href.startsWith("/media/")) continue;
+      if (/^(?:https?:|mailto:|#|data:)/i.test(href)) continue;
+      const routePart = href.split("#")[0].split("?")[0];
+      if (!routePart) continue;
+      const target = routePart.startsWith("/") ? normalizeRoute(routePart) : normalizeRoute(posix.join(dirname(page.route), routePart));
+      const normalized = navigationReferenceToRoute(target);
+      if (!byRoute.has(normalized) && !redirects[normalized]) {
+        diagnostics.push({
+          code: "broken_internal_link",
+          message: `${href} resolves to ${normalized}`,
+          file: page.sourcePath,
+          line: page.markdown.slice(0, match.index).split("\n").length
+        });
+      }
+    }
+  }
+  if (diagnostics.length > 0) {
+    throw new DocumentationError(
+      `${diagnostics.length} broken internal documentation link(s)`,
+      "documentation_links_invalid",
+      diagnostics
+    );
+  }
+}
+function rewriteLocalReferences(source, relativePath, sourceDir, sourcePath) {
+  const pageDirectory = posix.dirname(relativePath);
+  return source.replace(
+    /(!?)\[([^\]]*)\]\(([^)\s]+)((?:\s+["'][^"']*["'])?)\)/g,
+    (match, imageMarker, label, href, title) => {
+      if (/^(?:https?:|mailto:|data:|#)/i.test(href)) return match;
+      const [pathPart, suffix = ""] = href.split(/(?=[?#])/);
+      if (!pathPart) return match;
+      const relativeTarget = pathPart.startsWith("/") ? pathPart.replace(/^\//, "") : posix.normalize(posix.join(pageDirectory, pathPart));
+      if (relativeTarget === ".." || relativeTarget.startsWith("../")) {
+        throw new DocumentationError(
+          `Documentation reference escapes the source directory: ${href}`,
+          "documentation_link_unsafe",
+          [{ code: "link_path_escape", message: href, file: sourcePath }]
+        );
+      }
+      const absoluteTarget = resolve4(sourceDir, relativeTarget);
+      if (imageMarker === "!") {
+        if (!existsSync4(absoluteTarget)) {
+          throw new DocumentationError(
+            `Documentation image not found: ${href}`,
+            "documentation_asset_missing",
+            [{ code: "asset_missing", message: href, file: sourcePath }]
+          );
+        }
+        return `![${label}](/media/${relativeTarget}${suffix}${title})`;
+      }
+      if (/\.(?:md|mdx)$/i.test(relativeTarget)) {
+        return `[${label}](${routeFromRelativePath(relativeTarget)}${suffix}${title})`;
+      }
+      const markdownTarget = [
+        `${absoluteTarget}.mdx`,
+        `${absoluteTarget}.md`,
+        join(absoluteTarget, "index.mdx"),
+        join(absoluteTarget, "index.md")
+      ].find(existsSync4);
+      if (markdownTarget) {
+        const targetRelative = relative3(sourceDir, markdownTarget).split(sep2).join("/");
+        return `[${label}](${routeFromRelativePath(targetRelative)}${suffix}${title})`;
+      }
+      if (existsSync4(absoluteTarget)) {
+        return `[${label}](/media/${relativeTarget}${suffix}${title})`;
+      }
+      return match;
+    }
+  );
+}
+function validateRedirectTargets(config, byRoute) {
+  for (const [from, to] of Object.entries(config.redirects)) {
+    const normalizedFrom = normalizeRoute(from);
+    if (byRoute.has(normalizedFrom)) {
+      throw new DocumentationError(
+        `Redirect source collides with a page: ${from}`,
+        "documentation_redirect_invalid",
+        [{ code: "redirect_page_collision", message: from }]
+      );
+    }
+    const finalTarget = followRedirects(to, config.redirects);
+    if (!byRoute.has(normalizeRoute(finalTarget))) {
+      throw new DocumentationError(
+        `Redirect target does not exist: ${from} -> ${to}`,
+        "documentation_redirect_invalid",
+        [{ code: "redirect_missing_target", message: `${from} -> ${to}` }]
+      );
+    }
+  }
+}
+function followRedirects(route, redirects) {
+  let cursor = route;
+  const seen = /* @__PURE__ */ new Set();
+  while (redirects[cursor] && !seen.has(cursor)) {
+    seen.add(cursor);
+    cursor = redirects[cursor];
+  }
+  return cursor;
+}
+function assertUniqueRoutes(pages) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const existing = seen.get(page.route);
+    if (existing) {
+      throw new DocumentationError(
+        `Multiple documentation pages resolve to ${page.route}`,
+        "documentation_route_collision",
+        [existing, page].map((candidate) => ({
+          code: "route_collision",
+          message: candidate.route,
+          file: candidate.sourcePath
+        }))
+      );
+    }
+    if (["/api", "/assets", "/data", "/media", "/mcp", "/.well-known"].some(
+      (reserved) => page.route === reserved || page.route.startsWith(`${reserved}/`)
+    )) {
+      throw new DocumentationError(
+        `Documentation route uses a reserved prefix: ${page.route}`,
+        "documentation_route_reserved",
+        [{ code: "reserved_route", message: page.route, file: page.sourcePath }]
+      );
+    }
+    seen.set(page.route, page);
+  }
+}
+function navigationReferenceToRoute(value) {
+  return normalizeRoute(value);
+}
+function titleFromFile(relativePath) {
+  const stem = basename2(relativePath, extname2(relativePath));
+  const candidate = stem.toLowerCase() === "index" ? basename2(dirname(relativePath)) : stem;
+  if (!candidate || candidate === ".") return "Overview";
+  return candidate.split(/[-_]/).filter(Boolean).map(capitalize).join(" ");
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function joinRoute(left, right) {
+  return normalizeRoute(`${left}/${slugify(right)}`);
+}
+function isSafeLink(value) {
+  return /^(?:https?:\/\/|mailto:|\/|#)/i.test(value);
+}
+
+// src/documentation/custom-runtime.ts
+import { compileSync } from "@mdx-js/mdx";
+import { parse as parseJavaScript } from "acorn";
+import { buildSync } from "esbuild";
+import { createRequire } from "module";
+import { existsSync as existsSync5, mkdtempSync, readFileSync as readFileSync4, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname2, extname as extname3, join as join2, relative as relative4, resolve as resolve5, sep as sep3 } from "path";
+import { fileURLToPath } from "url";
+function buildCustomDocumentationRuntime(validation, basePath) {
+  const sitePath = resolve5(validation.appDir, "documentation.tsx");
+  const mdxPages = validation.graph.pages.filter((page) => page.sourceFormat === "mdx");
+  if (!existsSync5(sitePath) && mdxPages.length === 0) return null;
+  const temporaryDir = mkdtempSync(join2(tmpdir(), "deepspace-documentation-runtime-"));
+  try {
+    const compiledPages = mdxPages.map((page, index) => {
+      const source = readFileSync4(page.sourcePath, "utf8");
+      const rewritten = rewriteLocalReferences(
+        source,
+        page.relativePath,
+        validation.sourceDir,
+        page.sourcePath
+      );
+      const compiled = compileSync(
+        publicDocumentationReferences(stripFirstMarkdownH1(rewritten), basePath),
+        mdxCompileOptions()
+      );
+      const path = join2(temporaryDir, `page-${index}.mjs`);
+      writeFileSync(path, resolveCompiledImports(String(compiled), page.sourcePath, validation.appDir));
+      return { path, route: page.route };
+    });
+    const clientEntry = runtimeEntry("documentation-client-core.js", "runtime/client.tsx");
+    const publicEntry = runtimeEntry("documentation-react.js", "runtime/public.tsx");
+    const serverEntry = runtimeEntry("documentation-server-core.js", "runtime/server.tsx");
+    const browserEntry = join2(temporaryDir, "browser-entry.ts");
+    const serverBundleEntry = join2(temporaryDir, "server-entry.ts");
+    writeFileSync(browserEntry, generatedBrowserEntry(clientEntry, publicEntry, sitePath, compiledPages));
+    writeFileSync(serverBundleEntry, generatedServerEntry(serverEntry, sitePath, compiledPages));
+    const reactAliases = runtimeDependencyAliases(validation.appDir);
+    const alias = { ...reactAliases, "deepspace/documentation/react": publicEntry };
+    const browserOutDir = join2(temporaryDir, "browser");
+    const sharedBuildOptions = {
+      absWorkingDir: temporaryDir,
+      bundle: true,
+      define: { "process.env.NODE_ENV": '"production"' },
+      jsx: "automatic",
+      target: ["es2022"],
+      ...existsSync5(resolve5(validation.appDir, "tsconfig.json")) ? { tsconfig: resolve5(validation.appDir, "tsconfig.json") } : {},
+      write: false
+    };
+    const browser = buildSync({
+      ...sharedBuildOptions,
+      alias,
+      entryPoints: ["browser-entry.ts"],
+      chunkNames: "documentation-page-[hash]",
+      entryNames: "documentation-custom-runtime",
+      format: "esm",
+      loader: assetLoaders("dataurl"),
+      minify: true,
+      outdir: browserOutDir,
+      platform: "browser",
+      splitting: true
+    });
+    const server = buildSync({
+      ...sharedBuildOptions,
+      alias: { ...reactAliases, "deepspace/documentation/react": serverEntry },
+      entryPoints: ["server-entry.ts"],
+      format: "cjs",
+      loader: { ...assetLoaders("dataurl"), ".css": "text" },
+      logLevel: "silent",
+      minify: false,
+      outdir: join2(temporaryDir, "server"),
+      platform: "node",
+      target: ["node22"]
+    });
+    const browserAssets = (browser.outputFiles ?? []).map((output) => ({
+      path: relative4(browserOutDir, output.path).split(sep3).join("/"),
+      content: output.text
+    }));
+    if (!browserAssets.some((asset) => asset.path === "documentation-custom-runtime.js")) {
+      throw new Error("Executable documentation build did not emit documentation-custom-runtime.js");
+    }
+    const stylesheets = browserAssets.filter((asset) => extname3(asset.path) === ".css").map((asset) => documentationPublicPath(basePath, `/assets/${asset.path}`));
+    const serverJavaScript = outputWithExtension(server, ".js").text;
+    const module = { exports: {} };
+    const evaluate = new Function("require", "module", "exports", serverJavaScript);
+    evaluate(createRequire(join2(validation.appDir, "package.json")), module, module.exports);
+    if (typeof module.exports.render !== "function") {
+      throw new Error("The generated documentation server renderer did not export render()");
+    }
+    return {
+      browserAssets,
+      stylesheets,
+      render: (data, route) => module.exports.render?.(route, data) ?? ""
+    };
+  } catch (error) {
+    if (error instanceof DocumentationError) throw error;
+    throw new DocumentationError(
+      `Unable to compile executable documentation: ${errorMessage(error)}`,
+      "documentation_runtime_build_failed",
+      [{ code: "runtime_compile", message: errorMessage(error), file: existsSync5(sitePath) ? sitePath : void 0 }]
+    );
+  } finally {
+    rmSync(temporaryDir, { recursive: true, force: true });
+  }
+}
+function generatedBrowserEntry(clientEntry, publicEntry, sitePath, pages) {
+  const siteImport = existsSync5(sitePath) ? `import Site from ${quote(sitePath)}` : `import { DefaultDocumentation as Site } from ${quote(publicEntry)}`;
+  const pageLoaders = pages.map((page) => `${quote(page.route)}: () => import(${quote(page.path)})`).join(",\n");
+  return `import { hydrateDocumentation } from ${quote(clientEntry)}
+${siteImport}
+const loaders = { ${pageLoaders} }
+const pages = {}
+async function loadPage(route) {
+  const loader = loaders[route]
+  if (loader && !pages[route]) pages[route] = (await loader()).default
+}
+const payload = document.getElementById('deepspace-documentation-data')
+if (payload?.textContent) await loadPage(JSON.parse(payload.textContent).page.route)
+hydrateDocumentation({ Site, pages, loadPage })
+`;
+}
+function generatedServerEntry(serverEntry, sitePath, pages) {
+  const imports = pages.map((page, index) => `import Page${index} from ${quote(page.path)}`).join("\n");
+  const siteImport = existsSync5(sitePath) ? `import Site from ${quote(sitePath)}` : `import { DefaultDocumentation as Site } from ${quote(serverEntry)}`;
+  const pageMap = pages.map((page, index) => `${quote(page.route)}: Page${index}`).join(",\n");
+  return `import { renderDocumentation } from ${quote(serverEntry)}
+${siteImport}
+${imports}
+const pages = { ${pageMap} }
+export function render(route, data) {
+  return renderDocumentation({ data, Page: pages[route], Site })
+}
+`;
+}
+function resolveCompiledImports(code, sourcePath, appDir) {
+  const tree = parseJavaScript(code, { ecmaVersion: "latest", sourceType: "module" });
+  const replacements = [];
+  const appRequire = createRequire(join2(appDir, "package.json"));
+  visitJavaScript(tree, (node) => {
+    const source = importSource(node);
+    if (!source || typeof source.value !== "string" || source.start === void 0 || source.end === void 0) {
+      return;
+    }
+    const specifier = source.value;
+    if (/^(?:data:|https?:|node:)/.test(specifier)) return;
+    const resolved = specifier.startsWith(".") ? resolve5(dirname2(sourcePath), specifier) : specifier === "deepspace/documentation/react" || specifier === "react" || specifier.startsWith("react/") ? specifier : appRequire.resolve(specifier);
+    replacements.push({ start: source.start, end: source.end, value: quote(resolved.split(sep3).join("/")) });
+  });
+  return replacements.sort((left, right) => right.start - left.start).reduce(
+    (output, replacement) => `${output.slice(0, replacement.start)}${replacement.value}${output.slice(replacement.end)}`,
+    code
+  );
+}
+function importSource(node) {
+  if (node.type === "ImportDeclaration" || node.type === "ExportAllDeclaration" || node.type === "ExportNamedDeclaration" || node.type === "ImportExpression") return node.source;
+  return void 0;
+}
+function visitJavaScript(node, visitor) {
+  visitor(node);
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) {
+      for (const child of value) {
+        if (isJavaScriptNode(child)) visitJavaScript(child, visitor);
+      }
+    } else if (isJavaScriptNode(value)) {
+      visitJavaScript(value, visitor);
+    }
+  }
+}
+function isJavaScriptNode(value) {
+  return Boolean(value && typeof value === "object" && "type" in value && typeof value.type === "string");
+}
+function runtimeEntry(builtName, sourceRelativePath) {
+  const built = fileURLToPath(new URL(`./${builtName}`, import.meta.url));
+  if (existsSync5(built)) return built;
+  const source = fileURLToPath(new URL(`./${sourceRelativePath}`, import.meta.url));
+  if (!existsSync5(source)) {
+    throw new Error(`${builtName} is missing from this deepspace installation; reinstall the package`);
+  }
+  return source;
+}
+function runtimeDependencyAliases(appDir) {
+  const require2 = createRequire(join2(appDir, "package.json"));
+  return Object.fromEntries(
+    ["react", "react/jsx-runtime", "react-dom", "react-dom/client", "react-dom/server"].map((specifier) => [specifier, require2.resolve(specifier)])
+  );
+}
+function outputWithExtension(result, extension) {
+  const output = optionalOutputWithExtension(result, extension);
+  if (!output) throw new Error(`Executable documentation build did not emit a ${extension} file`);
+  return output;
+}
+function optionalOutputWithExtension(result, extension) {
+  return result.outputFiles?.find((output) => extname3(output.path) === extension);
+}
+function assetLoaders(imageLoader) {
+  return {
+    ".avif": imageLoader,
+    ".css": "css",
+    ".gif": imageLoader,
+    ".jpeg": imageLoader,
+    ".jpg": imageLoader,
+    ".png": imageLoader,
+    ".svg": imageLoader,
+    ".webp": imageLoader,
+    ".woff": imageLoader,
+    ".woff2": imageLoader
+  };
+}
+function quote(value) {
+  return JSON.stringify(value);
+}
+
+// src/documentation/output.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  existsSync as existsSync6,
+  mkdirSync,
+  readFileSync as readFileSync5,
+  readdirSync as readdirSync2,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { dirname as dirname3, extname as extname4, join as join3, relative as relative5, resolve as resolve6, sep as sep4 } from "path";
+import sanitizeHtml2 from "sanitize-html";
+var MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".avif",
+  ".gif",
+  ".ico",
+  ".jpeg",
+  ".jpg",
+  ".png",
+  ".svg",
+  ".webp",
+  ".woff",
+  ".woff2"
+]);
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".js", ".jsx", ".md", ".mdx", ".ts", ".tsx"]);
+var DocumentationOutput = class {
+  constructor(outputDir, appDir, sourceDir) {
+    this.outputDir = outputDir;
+    assertSafeOutput(appDir, sourceDir, outputDir);
+    if (existsSync6(outputDir)) rmSync2(outputDir, { recursive: true, force: true });
+    mkdirSync(outputDir, { recursive: true });
+  }
+  files = /* @__PURE__ */ new Set();
+  write(relativePath, content) {
+    const path = this.safePath(relativePath);
+    mkdirSync(dirname3(path), { recursive: true });
+    writeFileSync2(path, content);
+    this.files.add(normalizeRelativePath(relativePath));
+  }
+  copyMedia(sourceDir, auxiliarySources) {
+    const walk = (directory) => {
+      for (const entry of readdirSync2(directory, { withFileTypes: true })) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+        const sourcePath = join3(directory, entry.name);
+        if (entry.isDirectory()) {
+          walk(sourcePath);
+          continue;
+        }
+        const extension = extname4(entry.name).toLowerCase();
+        if (SOURCE_EXTENSIONS.has(extension) || auxiliarySources.has(resolve6(sourcePath))) continue;
+        if (!MEDIA_EXTENSIONS.has(extension)) {
+          throw new DocumentationError(
+            `Unsupported documentation media type: ${relative5(sourceDir, sourcePath)}`,
+            "documentation_media_unsupported",
+            [{
+              code: "media_type_unsupported",
+              message: extension || "(no extension)",
+              file: sourcePath
+            }]
+          );
+        }
+        const mediaPath = `media/${normalizeRelativePath(relative5(sourceDir, sourcePath))}`;
+        const content = extension === ".svg" ? sanitizeSvg(readFileSync5(sourcePath, "utf8"), sourcePath) : readFileSync5(sourcePath);
+        this.write(mediaPath, content);
+      }
+    };
+    walk(sourceDir);
+  }
+  hash() {
+    const hash = createHash2("sha256");
+    for (const file of [...this.files].sort()) {
+      hash.update(file);
+      hash.update(readFileSync5(join3(this.outputDir, file)));
+    }
+    return hash.digest("hex");
+  }
+  safePath(relativePath) {
+    const path = resolve6(this.outputDir, relativePath);
+    const rel = relative5(this.outputDir, path);
+    if (rel === ".." || rel.startsWith(`..${sep4}`) || rel === "") {
+      throw new DocumentationError(
+        `Refusing documentation artifact outside the output directory: ${relativePath}`,
+        "documentation_output_unsafe",
+        [{ code: "artifact_path_escape", message: relativePath }]
+      );
+    }
+    return path;
+  }
+};
+function assertSafeOutput(appDir, sourceDir, outputDir) {
+  const appRelative = relative5(appDir, outputDir);
+  const sourceRelative = relative5(sourceDir, outputDir);
+  if (outputDir === appDir || outputDir === sourceDir || appRelative === ".." || appRelative.startsWith(`..${sep4}`) || sourceRelative === "" || !sourceRelative.startsWith("..") && sourceRelative !== "") {
+    throw new DocumentationError(
+      `Refusing unsafe documentation output directory: ${outputDir}`,
+      "documentation_output_unsafe",
+      [{ code: "unsafe_output", message: outputDir }]
+    );
+  }
+}
+function sanitizeSvg(source, sourcePath) {
+  const safe = sanitizeHtml2(source, {
+    allowedTags: [
+      "svg",
+      "g",
+      "path",
+      "circle",
+      "ellipse",
+      "line",
+      "polyline",
+      "polygon",
+      "rect",
+      "image",
+      "defs",
+      "linearGradient",
+      "radialGradient",
+      "stop",
+      "clipPath",
+      "mask",
+      "title",
+      "desc",
+      "text",
+      "tspan"
+    ],
+    allowedAttributes: {
+      svg: [
+        "xmlns",
+        "xmlns:xlink",
+        "viewBox",
+        "width",
+        "height",
+        "fill",
+        "stroke",
+        "role",
+        "aria-label"
+      ],
+      image: ["href", "xlink:href", "x", "y", "width", "height", "preserveAspectRatio"],
+      "*": [
+        "id",
+        "class",
+        "d",
+        "x",
+        "y",
+        "x1",
+        "x2",
+        "y1",
+        "y2",
+        "cx",
+        "cy",
+        "r",
+        "rx",
+        "ry",
+        "points",
+        "width",
+        "height",
+        "viewBox",
+        "fill",
+        "fill-rule",
+        "fill-opacity",
+        "stroke",
+        "stroke-width",
+        "stroke-linecap",
+        "stroke-linejoin",
+        "stroke-opacity",
+        "opacity",
+        "transform",
+        "offset",
+        "stop-color",
+        "stop-opacity",
+        "clip-path",
+        "mask",
+        "role",
+        "aria-label",
+        "aria-hidden",
+        "font-family",
+        "font-size",
+        "font-style",
+        "font-weight",
+        "letter-spacing",
+        "text-anchor",
+        "dominant-baseline"
+      ]
+    },
+    allowedSchemes: ["data"],
+    allowProtocolRelative: false,
+    disallowedTagsMode: "discard",
+    parser: { lowerCaseTags: false, lowerCaseAttributeNames: false }
+  });
+  if (!/<svg\b/i.test(safe)) {
+    throw new DocumentationError(
+      `Invalid documentation SVG: ${relative5(process.cwd(), sourcePath)}`,
+      "documentation_media_invalid",
+      [{ code: "svg_invalid", message: "Expected an SVG root element", file: sourcePath }]
+    );
+  }
+  return safe;
+}
+function normalizeRelativePath(path) {
+  return path.split(sep4).join("/");
+}
+
+// src/documentation/resource-path.ts
+var RESOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "7z",
+  "avif",
+  "css",
+  "csv",
+  "gif",
+  "gz",
+  "ico",
+  "jpeg",
+  "jpg",
+  "js",
+  "json",
+  "map",
+  "md",
+  "mjs",
+  "mp3",
+  "mp4",
+  "pdf",
+  "png",
+  "svg",
+  "tar",
+  "txt",
+  "wasm",
+  "webm",
+  "webp",
+  "woff",
+  "woff2",
+  "xml",
+  "yaml",
+  "yml",
+  "zip"
+]);
+function isNativeDocumentationResourcePath(pathname) {
+  const leaf = pathname.slice(pathname.lastIndexOf("/") + 1);
+  const extension = leaf.includes(".") ? leaf.slice(leaf.lastIndexOf(".") + 1).toLowerCase() : "";
+  return extension !== "" && RESOURCE_EXTENSIONS.has(extension);
+}
+function encodeNativeDocumentationPath(pathname) {
+  return pathname.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+}
+
+// src/documentation/skill.ts
+import { createHash as createHash3 } from "crypto";
+var AGENT_SKILLS_SCHEMA = "https://schemas.agentskills.io/discovery/0.2.0/schema.json";
+function createDocumentationSkillArtifacts(graph, baseUrl, basePath = "/docs") {
+  const name = documentationSkillName(graph.config.name);
+  const description = documentationSkillDescription(graph.config.name, graph.config.description);
+  const root = baseUrl?.replace(/\/$/, "") ?? "";
+  const markdown2 = renderDocumentationSkill(graph, name, description, root);
+  const digest = createHash3("sha256").update(markdown2).digest("hex");
+  return {
+    name,
+    description,
+    markdown: markdown2,
+    legacyIndex: {
+      skills: [{ name, description, files: ["SKILL.md"] }]
+    },
+    discoveryIndex: {
+      $schema: AGENT_SKILLS_SCHEMA,
+      skills: [
+        {
+          name,
+          type: "skill-md",
+          description,
+          url: documentationPublicPath(basePath, `/.well-known/agent-skills/${name}/skill.md`),
+          digest: `sha256:${digest}`
+        }
+      ]
+    }
+  };
+}
+function documentationSkillName(value) {
+  const normalized = value.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+  return normalized.slice(0, 64).replace(/-+$/g, "") || "documentation";
+}
+function documentationSkillDescription(name, description) {
+  const detail = description?.replace(/\s+/g, " ").trim();
+  const value = detail ? `Use when answering questions, integrating, or implementing work with ${name}. ${detail}` : `Use when answering questions, integrating, or implementing work with ${name}.`;
+  return value.slice(0, 1024).trim();
+}
+function renderDocumentationSkill(graph, name, description, root) {
+  const lines = [
+    "---",
+    `name: ${JSON.stringify(name)}`,
+    `description: ${JSON.stringify(description)}`,
+    "metadata:",
+    '  version: "1.0"',
+    `  source-hash: ${JSON.stringify(graph.sourceHash)}`,
+    "---",
+    "",
+    `# ${graph.config.name}`,
+    "",
+    graph.config.description ?? `Use the published ${documentationSubject(graph.config.name)} as the source of truth.`,
+    "",
+    "## Grounding workflow",
+    "",
+    `1. Read [the documentation index](${root}/llms.txt) to discover the available pages.`,
+    graph.config.mcp.access === "public" ? `2. Prefer the read-only MCP server at \`${root}/mcp\` for ranked search and exact page reads.` : `2. Search the index, then open the relevant page Markdown directly.`,
+    `3. Read a page's canonical Markdown before making implementation claims or quoting commands.`,
+    `4. Treat this release as authoritative; do not mix instructions from another version or hostname.`,
+    "",
+    "## Documentation map",
+    "",
+    ...renderNavigation(graph.navigation, graph.pages, root),
+    "## Constraints",
+    "",
+    "- Do not invent APIs, commands, configuration keys, or supported behavior.",
+    "- Preserve security, authentication, billing, and deployment boundaries stated in the documentation.",
+    "- When pages disagree, prefer the more specific page and report the conflict.",
+    "- Link the exact source page in the final answer when the client supports citations.",
+    ""
+  ];
+  return lines.join("\n");
+}
+function renderNavigation(navigation, pages, root) {
+  const byRoute = new Map(pages.map((page) => [page.route, page]));
+  const lines = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit2 = (nodes, depth) => {
+    for (const node of nodes) {
+      if (node.kind === "group") {
+        lines.push(`${"#".repeat(Math.min(depth + 2, 6))} ${node.label}`, "");
+        visit2(node.items, depth + 1);
+        continue;
+      }
+      if (node.kind !== "page" || seen.has(node.route)) continue;
+      const page = byRoute.get(node.route);
+      if (!page || page.hidden) continue;
+      seen.add(page.route);
+      const markdownRoute = markdownUrlForRoute(page.route);
+      lines.push(renderPageLink(page, root, markdownRoute));
+    }
+  };
+  visit2(navigation, 1);
+  const remaining = pages.filter((page) => !page.hidden && !seen.has(page.route));
+  if (remaining.length > 0) {
+    lines.push("### More", "");
+    for (const page of remaining) {
+      const markdownRoute = markdownUrlForRoute(page.route);
+      lines.push(renderPageLink(page, root, markdownRoute));
+    }
+  }
+  lines.push("");
+  return lines;
+}
+function renderPageLink(page, root, markdownRoute) {
+  return `- [${page.title}](${root}${markdownRoute})${page.description ? ` \u2014 ${page.description}` : ""}`;
+}
+
+// src/documentation/renderer.ts
+import { buildSync as buildSync2 } from "esbuild";
+import { createRequire as createRequire2 } from "module";
+var cachedRenderer;
+function renderDefaultDocumentation(data) {
+  cachedRenderer ??= loadDefaultRenderer();
+  return cachedRenderer.renderDefaultDocumentation(data);
+}
+function loadDefaultRenderer() {
+  const entry = runtimeEntry("documentation-default-renderer.cjs", "runtime/default-renderer.tsx");
+  if (entry.endsWith(".cjs")) {
+    return createRequire2(import.meta.url)(entry);
+  }
+  const result = buildSync2({
+    entryPoints: [entry],
+    bundle: true,
+    write: false,
+    minify: false,
+    platform: "node",
+    format: "cjs",
+    target: ["node22"],
+    jsx: "automatic",
+    define: { "process.env.NODE_ENV": '"production"' }
+  });
+  const source = result.outputFiles?.[0]?.text;
+  if (!source) throw new Error("Default documentation renderer did not emit JavaScript");
+  const module = { exports: {} };
+  const evaluate = new Function("require", "module", "exports", source);
+  evaluate(createRequire2(import.meta.url), module, module.exports);
+  return module.exports;
+}
+
+// src/documentation/runtime/styles/base.ts
+var DOCUMENTATION_BASE_CSS = String.raw`
+:root {
+  --documentation-accent: #635bff;
+  --documentation-accent-2: #24c8ff;
+  --documentation-brand-bg: #f8fafc;
+  --documentation-brand-bg-dark: #0c0e14;
+  --documentation-font-body: Inter, ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  --documentation-font-heading: Inter, ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  --documentation-font-mono: "Geist Mono", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  --documentation-bg: #fbfcfe;
+  --documentation-surface: #ffffff;
+  --documentation-surface-raised: #ffffff;
+  --documentation-panel: #f4f6fa;
+  --documentation-panel-strong: #edf0f6;
+  --documentation-text: #11131a;
+  --documentation-text-soft: #353a47;
+  --documentation-muted: #5c6270;
+  --documentation-faint: #646a78;
+  --documentation-border: #e4e7ed;
+  --documentation-border-strong: #d7dbe4;
+  --documentation-code-bg: #11131a;
+  --documentation-code-panel: #171a23;
+  --documentation-code-text: #e8ebf5;
+  --documentation-shadow-sm: 0 1px 2px rgba(15, 18, 28, .04), 0 2px 8px rgba(15, 18, 28, .03);
+  --documentation-shadow-lg: 0 24px 80px rgba(15, 18, 28, .18), 0 6px 24px rgba(15, 18, 28, .08);
+  --documentation-header-height: 66px;
+  --documentation-sidebar-width: 292px;
+  color-scheme: light;
+  font-family: var(--documentation-font-body);
+}
+
+:root[data-theme="dark"] {
+  --documentation-brand-bg: var(--documentation-brand-bg-dark);
+  --documentation-bg: var(--documentation-brand-bg-dark);
+  --documentation-surface: #10131b;
+  --documentation-surface-raised: #151923;
+  --documentation-panel: #171b25;
+  --documentation-panel-strong: #1e2330;
+  --documentation-text: #f2f4fa;
+  --documentation-text-soft: #cbd0dc;
+  --documentation-muted: #999fad;
+  --documentation-faint: #808797;
+  --documentation-border: #252a36;
+  --documentation-border-strong: #343a49;
+  --documentation-code-bg: #080a0f;
+  --documentation-code-panel: #10131a;
+  --documentation-code-text: #eef0f7;
+  --documentation-shadow-sm: 0 1px 2px rgba(0, 0, 0, .24);
+  --documentation-shadow-lg: 0 28px 90px rgba(0, 0, 0, .55), 0 8px 24px rgba(0, 0, 0, .35);
+  color-scheme: dark;
+}
+
+* { box-sizing: border-box; }
+html { scroll-behavior: smooth; scroll-padding-top: 92px; }
+body { margin: 0; background: var(--documentation-brand-bg); color: var(--documentation-text); font-family: var(--documentation-font-body); font-size: 15.5px; line-height: 1.7; text-rendering: optimizeLegibility; -webkit-font-smoothing: antialiased; -moz-osx-font-smoothing: grayscale; }
+:root[data-background-decoration="gradient"] body { background-image: radial-gradient(circle at 58% 7%, color-mix(in srgb, var(--documentation-accent) 7%, transparent), transparent 32%); background-attachment: fixed; }
+:root[data-background-decoration="grid"] body { background-image: linear-gradient(color-mix(in srgb, var(--documentation-border) 26%, transparent) 1px, transparent 1px), linear-gradient(90deg, color-mix(in srgb, var(--documentation-border) 26%, transparent) 1px, transparent 1px); background-attachment: fixed; background-size: 32px 32px; }
+body:has(.documentation-modal-layer), body:has(.documentation-mobile-nav) { overflow: hidden; }
+button, input, textarea { font: inherit; }
+button, a { -webkit-tap-highlight-color: transparent; }
+a { color: inherit; }
+button:focus-visible, a:focus-visible, input:focus-visible, textarea:focus-visible, summary:focus-visible { outline: 2px solid color-mix(in srgb, var(--documentation-accent) 74%, white); outline-offset: 3px; }
+::selection { background: color-mix(in srgb, var(--documentation-accent) 24%, transparent); }
+
+.documentation-skip-link { position: fixed; z-index: 200; top: -64px; left: 16px; padding: 9px 13px; border-radius: 8px; background: var(--documentation-text); color: var(--documentation-bg); font-weight: 650; text-decoration: none; }
+.documentation-skip-link:focus { top: 12px; }
+.documentation-app.is-navigating::before { content: ""; position: fixed; z-index: 240; inset: 0 auto auto 0; width: 42%; height: 2px; background: linear-gradient(90deg, var(--documentation-accent), var(--documentation-accent-2)); box-shadow: 0 0 14px color-mix(in srgb, var(--documentation-accent-2) 48%, transparent); animation: documentation-navigation-progress .8s ease-in-out infinite alternate; }
+::view-transition-old(documentation-article) { animation: documentation-page-out .11s ease-in both; }
+::view-transition-new(documentation-article) { animation: documentation-page-in .16s ease-out both; }
+
+`;
+
+// src/documentation/runtime/styles/content.ts
+var DOCUMENTATION_CONTENT_CSS = String.raw`
+.documentation-main { min-width: 0; margin-left: var(--documentation-sidebar-width); transition: margin-right .24s ease; }
+.documentation-reader-grid { display: grid; grid-template-columns: minmax(0, 670px) 212px; justify-content: center; gap: 70px; width: 100%; padding: 62px 52px 156px; }
+.documentation-article { display: flex; min-width: 0; min-height: calc(100vh - var(--documentation-header-height) - 158px); flex-direction: column; view-transition-name: documentation-article; }
+.documentation-breadcrumbs { display: none; align-items: center; gap: 5px; margin-bottom: 24px; color: var(--documentation-muted); font-size: 12px; }
+.documentation-breadcrumbs span { display: inline-flex; align-items: center; gap: 5px; }
+.documentation-breadcrumbs svg { width: 12px; height: 12px; }
+.documentation-article-header { margin-bottom: 38px; }
+.documentation-article-meta { display: flex; align-items: center; justify-content: space-between; gap: 18px; min-height: 32px; margin-bottom: 7px; }
+.documentation-eyebrow { color: color-mix(in srgb, var(--documentation-accent) 76%, var(--documentation-text)); font-size: 12px; font-weight: 700; letter-spacing: .035em; }
+.documentation-contextual-actions { position: relative; display: inline-flex; flex: 0 0 auto; align-items: stretch; height: 30px; border: 1px solid var(--documentation-border); border-radius: 8px; background: color-mix(in srgb, var(--documentation-surface) 92%, transparent); box-shadow: var(--documentation-shadow-sm); }
+.documentation-contextual-actions button, .documentation-contextual-actions a, .documentation-contextual-actions summary { display: inline-flex; align-items: center; gap: 6px; min-width: 0; height: 28px; padding: 0 9px; border: 0; background: transparent; color: var(--documentation-muted); cursor: pointer; font: 590 11px/1 var(--documentation-font-body); text-decoration: none; white-space: nowrap; }
+.documentation-contextual-actions button:hover, .documentation-contextual-actions a:hover, .documentation-contextual-actions summary:hover { color: var(--documentation-text); }
+.documentation-contextual-actions svg { flex: 0 0 auto; width: 13px; height: 13px; }
+.documentation-contextual-actions details { position: relative; border-left: 1px solid var(--documentation-border); }
+.documentation-contextual-actions summary { width: 29px; padding: 0; justify-content: center; list-style: none; }
+.documentation-contextual-actions summary::-webkit-details-marker { display: none; }
+.documentation-contextual-actions details[open] summary { background: var(--documentation-panel); color: var(--documentation-text); }
+.documentation-contextual-actions details[open] summary svg { transform: rotate(180deg); }
+.documentation-contextual-menu { position: absolute; z-index: 35; top: calc(100% + 7px); right: -1px; display: grid; width: min(316px, calc(100vw - 32px)); max-height: min(510px, calc(100vh - 120px)); overflow: auto; padding: 6px; border: 1px solid var(--documentation-border-strong); border-radius: 12px; background: var(--documentation-surface-raised); box-shadow: var(--documentation-shadow-lg); }
+.documentation-contextual-menu button, .documentation-contextual-menu a { display: grid; grid-template-columns: 30px minmax(0, 1fr) auto; align-items: center; gap: 9px; width: 100%; height: auto; min-height: 50px; padding: 6px 8px; border-radius: 8px; text-align: left; }
+.documentation-contextual-menu button:hover, .documentation-contextual-menu a:hover { background: var(--documentation-panel); }
+.documentation-contextual-action-icon { display: grid; place-items: center; width: 30px; height: 30px; border: 1px solid var(--documentation-border); border-radius: 7px; background: var(--documentation-surface); color: var(--documentation-text-soft); }
+.documentation-contextual-action-icon svg { width: 15px; height: 15px; }
+.documentation-contextual-action-copy { display: grid; min-width: 0; gap: 2px; }
+.documentation-contextual-action-copy strong { overflow: hidden; color: var(--documentation-text); font-size: 12px; font-weight: 640; line-height: 1.2; text-overflow: ellipsis; white-space: nowrap; }
+.documentation-contextual-action-copy small { overflow: hidden; color: var(--documentation-muted); font-size: 10.5px; font-weight: 450; line-height: 1.25; text-overflow: ellipsis; white-space: nowrap; }
+.documentation-contextual-menu .documentation-contextual-action-external { width: 12px; height: 12px; color: var(--documentation-faint); }
+.documentation-article-header h1 { margin: 0; color: var(--documentation-text); font-family: var(--documentation-font-heading); font-size: clamp(34px, 3vw, 41px); font-weight: 650; letter-spacing: -.038em; line-height: 1.09; overflow-wrap: anywhere; }
+.documentation-article-header h1:focus { outline: none; }
+.documentation-lede { max-width: 650px; margin: 13px 0 0; color: var(--documentation-text-soft); font-size: 17.5px; letter-spacing: -.01em; line-height: 1.56; }
+
+.documentation-prose { color: var(--documentation-text-soft); }
+.documentation-prose > :first-child { margin-top: 0; }
+.documentation-prose h1, .documentation-prose h2, .documentation-prose h3, .documentation-prose h4, .documentation-prose h5, .documentation-prose h6 { color: var(--documentation-text); font-family: var(--documentation-font-heading); scroll-margin-top: 92px; }
+.documentation-prose h1 { margin: 46px 0 17px; font-size: 30px; letter-spacing: -.03em; line-height: 1.2; }
+.documentation-prose h2 { margin: 49px 0 16px; padding-top: 5px; font-size: 25px; font-weight: 625; letter-spacing: -.03em; line-height: 1.25; }
+.documentation-prose h3 { margin: 33px 0 12px; font-size: 19px; font-weight: 620; letter-spacing: -.018em; line-height: 1.35; }
+.documentation-prose h4 { margin: 27px 0 10px; font-size: 16px; font-weight: 620; }
+.documentation-heading-anchor { margin-left: 8px; color: transparent; font-size: .72em; font-weight: 500; text-decoration: none; }
+.documentation-prose h2:hover .documentation-heading-anchor, .documentation-prose h3:hover .documentation-heading-anchor, .documentation-heading-anchor:focus-visible { color: var(--documentation-faint); }
+.documentation-prose p { margin: 0 0 19px; }
+.documentation-prose ul, .documentation-prose ol { margin: 0 0 21px; padding-left: 25px; }
+.documentation-prose li { margin: 5px 0; padding-left: 3px; }
+.documentation-prose li::marker { color: var(--documentation-faint); }
+.documentation-prose strong { color: var(--documentation-text); font-weight: 610; }
+.documentation-prose a { color: color-mix(in srgb, var(--documentation-accent) 78%, var(--documentation-text)); font-weight: 560; text-decoration-color: color-mix(in srgb, var(--documentation-accent) 38%, transparent); text-decoration-thickness: 1px; text-underline-offset: 3px; }
+.documentation-prose a:hover { text-decoration-color: currentColor; }
+.documentation-prose img { display: block; max-width: 100%; height: auto; margin: 26px 0; border: 1px solid var(--documentation-border); border-radius: 12px; background: var(--documentation-surface); box-shadow: var(--documentation-shadow-sm); }
+.documentation-prose blockquote { margin: 25px 0; padding: 4px 0 4px 18px; border-left: 2px solid color-mix(in srgb, var(--documentation-accent) 45%, var(--documentation-border)); color: var(--documentation-muted); }
+.documentation-prose blockquote p:last-child { margin-bottom: 0; }
+.documentation-prose hr { margin: 44px 0; border: 0; border-top: 1px solid var(--documentation-border); }
+.documentation-prose :not(pre) > code, .documentation-assistant-message code { padding: 2px 5px; border: 1px solid var(--documentation-border); border-radius: 5px; background: var(--documentation-panel); color: var(--documentation-text); font: 520 .88em/1.4 var(--documentation-font-mono); overflow-wrap: anywhere; }
+.documentation-prose pre { position: relative; overflow: auto; margin: 23px 0; padding: 20px 20px 19px; border: 1px solid color-mix(in srgb, var(--documentation-border-strong) 50%, #000); border-radius: 12px; background: linear-gradient(145deg, var(--documentation-code-panel), var(--documentation-code-bg)); color: var(--documentation-code-text); box-shadow: 0 12px 34px rgba(7, 9, 14, .12); font: 13px/1.66 var(--documentation-font-mono); tab-size: 2; }
+.documentation-prose pre code { display: block; min-width: max-content; padding-right: 76px; background: transparent; }
+:root[data-code-mode="system"][data-theme="light"] .documentation-prose pre { border-color: var(--documentation-border); background: linear-gradient(145deg, #f7f8fb, #f1f3f7); color: #252936; box-shadow: 0 8px 26px rgba(15, 18, 28, .06); }
+:root[data-code-mode="system"][data-theme="light"] .documentation-code-actions button { border-color: rgba(17, 19, 26, .1); background: rgba(255, 255, 255, .72); color: #606675; }
+:root[data-code-mode="system"][data-theme="light"] .documentation-code-actions button:hover { background: #fff; color: #11131a; }
+:root[data-code-mode="system"][data-theme="light"] .hljs-keyword, :root[data-code-mode="system"][data-theme="light"] .hljs-selector-tag, :root[data-code-mode="system"][data-theme="light"] .hljs-literal { color: #6f42c1; }
+:root[data-code-mode="system"][data-theme="light"] .hljs-string, :root[data-code-mode="system"][data-theme="light"] .hljs-title, :root[data-code-mode="system"][data-theme="light"] .hljs-name, :root[data-code-mode="system"][data-theme="light"] .hljs-type { color: #087f5b; }
+:root[data-code-mode="system"][data-theme="light"] .hljs-number, :root[data-code-mode="system"][data-theme="light"] .hljs-meta, :root[data-code-mode="system"][data-theme="light"] .hljs-built_in { color: #a15c00; }
+:root[data-code-mode="system"][data-theme="light"] .hljs-comment, :root[data-code-mode="system"][data-theme="light"] .hljs-quote { color: #7b8190; }
+.documentation-code-actions { position: sticky; float: right; top: 0; right: 0; display: inline-flex; gap: 4px; margin: -12px -12px 0 10px; }
+.documentation-code-actions button { height: 28px; padding: 0 8px; border: 1px solid rgba(255, 255, 255, .12); border-radius: 7px; background: rgba(255, 255, 255, .07); color: #aeb5c6; cursor: pointer; font-size: 10.5px; font-weight: 650; }
+.documentation-code-actions button:hover { background: rgba(255, 255, 255, .12); color: #fff; }
+.hljs-keyword, .hljs-selector-tag, .hljs-literal, .hljs-section, .hljs-link { color: #b7a7ff; }
+.hljs-string, .hljs-title, .hljs-name, .hljs-type, .hljs-attribute, .hljs-symbol, .hljs-bullet, .hljs-addition { color: #73dfb4; }
+.hljs-number, .hljs-meta, .hljs-built_in, .hljs-builtin-name, .hljs-params { color: #f0b96b; }
+.hljs-comment, .hljs-quote, .hljs-deletion { color: #767f93; font-style: italic; }
+.hljs-variable, .hljs-template-variable, .hljs-regexp { color: #ff95b4; }
+
+.documentation-prose table { display: block; width: 100%; overflow: auto; margin: 25px 0 29px; border: 1px solid var(--documentation-border); border-radius: 10px; border-collapse: separate; border-spacing: 0; background: var(--documentation-surface); font-size: 14px; }
+.documentation-prose thead { background: var(--documentation-panel); }
+.documentation-prose th, .documentation-prose td { min-width: 130px; padding: 10px 13px; border-right: 1px solid var(--documentation-border); border-bottom: 1px solid var(--documentation-border); text-align: left; vertical-align: top; }
+.documentation-prose th:last-child, .documentation-prose td:last-child { border-right: 0; }
+.documentation-prose tr:last-child td { border-bottom: 0; }
+.documentation-prose th { color: var(--documentation-text); font-size: 12px; font-weight: 700; letter-spacing: .02em; }
+
+.documentation-callout { --callout-accent: var(--documentation-accent); position: relative; margin: 24px 0; padding: 16px 18px 16px 20px; overflow: hidden; border: 1px solid color-mix(in srgb, var(--callout-accent) 25%, var(--documentation-border)); border-radius: 11px; background: linear-gradient(105deg, color-mix(in srgb, var(--callout-accent) 7%, var(--documentation-surface)), var(--documentation-surface)); }
+.documentation-callout::before { content: ""; position: absolute; inset: 0 auto 0 0; width: 2px; background: var(--callout-accent); }
+.documentation-callout > strong { display: block; margin-bottom: 3px; color: color-mix(in srgb, var(--callout-accent) 72%, var(--documentation-text)); font-size: 13px; }
+.documentation-callout > :last-child { margin-bottom: 0; }
+.documentation-callout-warning { --callout-accent: #e58a21; }
+.documentation-callout-tip { --callout-accent: #17a673; }
+.documentation-callout-info { --callout-accent: #278fdb; }
+.documentation-callout-note { --callout-accent: var(--documentation-accent); }
+.documentation-card { display: grid; grid-template-columns: 1fr auto; align-items: center; gap: 12px; margin: 14px 0; padding: 16px 17px; border: 1px solid var(--documentation-border); border-radius: 11px; background: var(--documentation-surface); box-shadow: var(--documentation-shadow-sm); text-decoration: none !important; transition: border-color .16s, box-shadow .16s, transform .16s; }
+.documentation-card:hover { border-color: color-mix(in srgb, var(--documentation-accent) 42%, var(--documentation-border)); box-shadow: 0 7px 24px rgba(15, 18, 28, .07); transform: translateY(-1px); }
+.documentation-card strong { display: block; margin-bottom: 2px; }
+.documentation-accordion-group { margin: 21px 0; border: 1px solid var(--documentation-border); border-radius: 11px; overflow: hidden; }
+.documentation-accordion-group .documentation-accordion { margin: 0; border: 0; border-bottom: 1px solid var(--documentation-border); border-radius: 0; }
+.documentation-accordion-group .documentation-accordion:last-child { border-bottom: 0; }
+.documentation-accordion { margin: 14px 0; padding: 0 16px; border: 1px solid var(--documentation-border); border-radius: 10px; background: var(--documentation-surface); }
+.documentation-accordion summary { padding: 14px 25px 14px 0; color: var(--documentation-text); cursor: pointer; font-weight: 650; list-style: none; }
+.documentation-accordion summary::-webkit-details-marker { display: none; }
+.documentation-accordion summary::after { content: "+"; float: right; margin-right: -20px; color: var(--documentation-faint); font-size: 18px; font-weight: 400; line-height: 1; }
+.documentation-accordion[open] summary::after { content: "−"; }
+.documentation-accordion > :last-child { margin-bottom: 15px; }
+.documentation-steps { margin: 25px 0; counter-reset: documentation-step; }
+.documentation-step { position: relative; margin-left: 13px; padding: 0 0 29px 34px; border-left: 1px solid var(--documentation-border-strong); counter-increment: documentation-step; }
+.documentation-step:last-child { padding-bottom: 3px; border-color: transparent; }
+.documentation-step::before { content: counter(documentation-step); position: absolute; left: -14px; top: -1px; display: grid; place-items: center; width: 27px; height: 27px; border: 1px solid color-mix(in srgb, var(--documentation-accent) 46%, var(--documentation-border)); border-radius: 50%; background: var(--documentation-surface); color: color-mix(in srgb, var(--documentation-accent) 78%, var(--documentation-text)); box-shadow: 0 0 0 5px var(--documentation-bg); font-size: 11px; font-weight: 740; }
+.documentation-step h3 { margin-top: 0; }
+.documentation-tabs { margin: 23px 0; overflow: hidden; border: 1px solid var(--documentation-border); border-radius: 11px; background: var(--documentation-surface); }
+.documentation-tab-buttons { display: flex; gap: 2px; overflow-x: auto; padding: 6px; border-bottom: 1px solid var(--documentation-border); background: var(--documentation-panel); }
+.documentation-tab-buttons button { flex: 0 0 auto; padding: 6px 10px; border: 0; border-radius: 7px; background: transparent; color: var(--documentation-muted); cursor: pointer; font-size: 12.5px; font-weight: 620; }
+.documentation-tab-buttons button[aria-selected="true"] { background: var(--documentation-surface); color: var(--documentation-text); box-shadow: var(--documentation-shadow-sm); }
+.documentation-tab { padding: 16px 18px 2px; }
+.documentation-tab > :first-child { margin-top: 0; }
+.documentation-code-group { margin: 23px 0; overflow: hidden; border: 1px solid var(--documentation-border-strong); border-radius: 12px; background: var(--documentation-surface); }
+.documentation-code-group-title { padding: 8px 13px; border-bottom: 1px solid var(--documentation-border); background: var(--documentation-panel); color: var(--documentation-muted); font-size: 11px; font-weight: 650; }
+.documentation-code-group .documentation-tab-buttons { border-color: color-mix(in srgb, var(--documentation-border) 72%, transparent); background: var(--documentation-panel); }
+.documentation-code-tab { padding: 0; }
+.documentation-code-group pre { margin: 0; border: 0; border-radius: 0; box-shadow: none; }
+
+.documentation-api-badge { display: flex; align-items: center; gap: 9px; margin: 0 0 25px; padding: 11px 13px; border: 1px solid var(--documentation-border); border-radius: 10px; background: var(--documentation-panel); }
+.method { display: inline-grid; place-items: center; min-width: 52px; padding: 4px 7px; border-radius: 6px; background: #3178e8; color: white; font: 750 10px/1.3 var(--documentation-font-mono); letter-spacing: .035em; }
+.method-post { background: #138b5b; }
+.method-put, .method-patch { background: #bd7215; }
+.method-delete { background: #cd464d; }
+.documentation-playground { margin: 48px 0 30px; padding: 20px; border: 1px solid var(--documentation-border); border-radius: 12px; background: var(--documentation-panel); }
+.documentation-playground-title { display: flex; align-items: center; justify-content: space-between; gap: 16px; }
+.documentation-playground-title > div { display: flex; align-items: center; gap: 9px; }
+.documentation-playground-title code { overflow: hidden; color: var(--documentation-muted); font: 11px var(--documentation-font-mono); text-overflow: ellipsis; white-space: nowrap; }
+.documentation-playground > p { color: var(--documentation-muted); font-size: 12px; }
+.documentation-playground label { display: grid; gap: 5px; margin: 13px 0; color: var(--documentation-muted); font-size: 11px; font-weight: 650; }
+.documentation-playground input, .documentation-playground textarea { width: 100%; padding: 10px; border: 1px solid var(--documentation-border-strong); border-radius: 8px; background: var(--documentation-surface); color: var(--documentation-text); font: 12.5px/1.55 var(--documentation-font-mono); resize: vertical; }
+.documentation-playground > button { padding: 9px 13px; border: 0; border-radius: 8px; background: var(--documentation-accent); color: white; cursor: pointer; font-size: 12px; font-weight: 680; }
+.documentation-playground > button:disabled { opacity: .58; cursor: wait; }
+.documentation-playground > pre { max-height: 320px; overflow: auto; margin: 14px 0 0; padding: 13px; border-radius: 8px; background: var(--documentation-code-bg); color: var(--documentation-code-text); font: 11.5px/1.55 var(--documentation-font-mono); white-space: pre-wrap; }
+
+.documentation-context-rail { position: sticky; top: 92px; align-self: start; max-height: calc(100vh - 116px); overflow: auto; padding-left: 18px; }
+.documentation-outline { display: grid; gap: 2px; }
+.documentation-outline h2 { margin: 0 0 7px; color: var(--documentation-text); font-size: 11.5px; font-weight: 700; }
+.documentation-outline a { padding: 3px 0; color: var(--documentation-muted); font-size: 11.5px; line-height: 1.42; text-decoration: none; transition: color .12s; }
+.documentation-outline a:hover, .documentation-outline a.is-active { color: var(--documentation-text); }
+.documentation-outline a.is-active { font-weight: 640; }
+.documentation-outline a.depth-3 { padding-left: 11px; }
+.documentation-feedback { display: flex; align-items: center; gap: 7px; min-height: 47px; margin-top: 58px; padding: 11px 13px; border: 1px solid var(--documentation-border); border-radius: 10px; background: var(--documentation-panel); color: var(--documentation-muted); font-size: 12px; }
+.documentation-feedback > span { margin-right: auto; }
+.documentation-feedback button { padding: 5px 9px; border: 1px solid var(--documentation-border); border-radius: 7px; background: var(--documentation-surface); color: var(--documentation-muted); cursor: pointer; font-size: 11px; }
+.documentation-feedback button:hover { color: var(--documentation-text); }
+.documentation-feedback p { display: flex; align-items: center; gap: 7px; margin: 0; }
+.documentation-feedback svg { width: 15px; color: #17a673; }
+.documentation-pagination { display: grid; grid-template-columns: 1fr 1fr; gap: 13px; margin-top: auto; padding-top: 28px; }
+.documentation-app.has-assistant .documentation-pagination { margin-bottom: 76px; transform: translateY(76px); }
+.documentation-pagination a { display: flex; flex-direction: column; min-height: 86px; padding: 14px 15px; border: 1px solid var(--documentation-border); border-radius: 10px; background: var(--documentation-surface); text-decoration: none; transition: border-color .15s, transform .15s; }
+.documentation-pagination a:hover { border-color: color-mix(in srgb, var(--documentation-accent) 38%, var(--documentation-border)); transform: translateY(-1px); }
+.documentation-pagination a:last-child { text-align: right; }
+.documentation-pagination small { margin-bottom: 7px; color: var(--documentation-faint); font-size: 10.5px; font-weight: 650; text-transform: uppercase; letter-spacing: .05em; }
+.documentation-pagination span { display: flex; align-items: center; justify-content: space-between; gap: 8px; color: var(--documentation-text); font-size: 13px; font-weight: 650; }
+.documentation-pagination a:last-child span { justify-content: flex-end; }
+.documentation-pagination svg { flex: 0 0 auto; width: 15px; }
+.documentation-pagination svg.is-back { transform: rotate(180deg); }
+
+`;
+
+// src/documentation/runtime/styles/navigation.ts
+var DOCUMENTATION_NAVIGATION_CSS = String.raw`
+.documentation-header { position: fixed; z-index: 50; inset: 0 0 auto; display: grid; grid-template-columns: var(--documentation-sidebar-width) minmax(300px, 1fr) auto; align-items: center; height: var(--documentation-header-height); border-bottom: 1px solid color-mix(in srgb, var(--documentation-border) 84%, transparent); background: color-mix(in srgb, var(--documentation-bg) 91%, transparent); backdrop-filter: blur(18px) saturate(1.15); transition: right .24s ease; }
+.documentation-brand { display: flex; align-items: center; gap: 10px; min-width: 0; height: 100%; padding: 0 23px; color: var(--documentation-text); text-decoration: none; }
+.documentation-brand-mark { position: relative; display: grid; place-items: center; width: 27px; height: 27px; color: var(--documentation-accent); }
+.documentation-brand-mark::before { content: ""; position: absolute; inset: -7px; border-radius: 50%; background: radial-gradient(circle, color-mix(in srgb, var(--documentation-accent-2) 15%, transparent), transparent 68%); }
+.documentation-brand-mark svg { position: relative; width: 27px; height: 27px; }
+.documentation-brand-name { overflow: hidden; font-size: 16px; font-weight: 720; letter-spacing: -.025em; text-overflow: ellipsis; white-space: nowrap; }
+.documentation-brand-product { padding-left: 10px; border-left: 1px solid var(--documentation-border-strong); color: var(--documentation-muted); font-size: 12px; font-weight: 600; letter-spacing: .04em; }
+.documentation-brand-logo { max-width: 145px; max-height: 26px; object-fit: contain; object-position: left center; }
+.documentation-brand-logo-dark { display: none; }
+:root[data-theme="dark"] .documentation-brand-logo-light { display: none; }
+:root[data-theme="dark"] .documentation-brand-logo-dark { display: block; }
+
+.documentation-header-center { display: flex; align-items: center; justify-content: center; padding: 0 20px; }
+.documentation-search-trigger { display: flex; align-items: center; width: min(380px, 38vw); height: 38px; gap: 9px; padding: 0 10px 0 12px; border: 1px solid var(--documentation-border); border-radius: 10px; background: color-mix(in srgb, var(--documentation-surface) 88%, transparent); color: var(--documentation-muted); box-shadow: var(--documentation-shadow-sm); cursor: pointer; text-align: left; transition: border-color .15s, color .15s, transform .15s; }
+.documentation-search-trigger:hover { border-color: var(--documentation-border-strong); color: var(--documentation-text); transform: translateY(-1px); }
+.documentation-search-trigger > span { min-width: 0; flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.documentation-search-trigger svg { width: 16px; }
+.documentation-search-trigger kbd { padding: 2px 5px; border: 1px solid var(--documentation-border); border-radius: 5px; background: var(--documentation-panel); color: var(--documentation-faint); font: 600 10px/1.3 var(--documentation-font-mono); }
+
+.documentation-top-links { display: flex; align-items: center; gap: 18px; height: 100%; padding: 0 24px 0 10px; }
+.documentation-top-links a { display: inline-flex; align-items: center; gap: 4px; color: var(--documentation-muted); font-size: 13px; font-weight: 560; text-decoration: none; white-space: nowrap; }
+.documentation-top-links a:hover { color: var(--documentation-text); }
+.documentation-top-links svg { width: 12px; height: 12px; }
+.documentation-mobile-actions { display: none; align-items: center; gap: 3px; padding-right: 12px; }
+.documentation-icon-button { display: grid; place-items: center; width: 38px; height: 38px; padding: 0; border: 0; border-radius: 9px; background: transparent; color: var(--documentation-muted); cursor: pointer; }
+.documentation-icon-button:hover { background: var(--documentation-panel); color: var(--documentation-text); }
+
+.documentation-frame { min-height: 100vh; padding-top: var(--documentation-header-height); }
+.documentation-sidebar { position: fixed; z-index: 30; inset: var(--documentation-header-height) auto 0 0; display: flex; flex-direction: column; width: var(--documentation-sidebar-width); border-right: 1px solid var(--documentation-border); background: var(--documentation-bg); }
+.documentation-page-tree { flex: 1; overflow: auto; padding: 26px 18px 36px 22px; overscroll-behavior: contain; scrollbar-width: thin; scrollbar-color: var(--documentation-border-strong) transparent; }
+.documentation-nav-section { margin: 0 0 25px; }
+.documentation-nav-section > h2 { margin: 0 0 7px; padding: 0 9px; color: var(--documentation-text-soft); font-size: 11.5px; font-weight: 720; letter-spacing: .025em; }
+.documentation-nav-link { display: flex; align-items: center; justify-content: space-between; gap: 8px; min-height: 33px; margin: 1px 0; padding: 6px 9px; border-radius: 8px; color: var(--documentation-muted); font-size: 13.25px; line-height: 1.38; text-decoration: none; transition: background .12s, color .12s; }
+.documentation-nav-link > span { min-width: 0; overflow-wrap: anywhere; }
+.documentation-nav-link > svg { flex: 0 0 auto; width: 12px; height: 12px; }
+.documentation-nav-link:hover { background: var(--documentation-panel); color: var(--documentation-text); }
+.documentation-nav-link.is-active { position: relative; background: linear-gradient(90deg, color-mix(in srgb, var(--documentation-accent) 11%, transparent), color-mix(in srgb, var(--documentation-accent-2) 5%, transparent)); color: color-mix(in srgb, var(--documentation-accent) 77%, var(--documentation-text)); font-weight: 650; }
+.documentation-nav-link.is-active::before { content: ""; position: absolute; inset: 8px auto 8px -5px; width: 2px; border-radius: 4px; background: linear-gradient(var(--documentation-accent), var(--documentation-accent-2)); box-shadow: 0 0 10px color-mix(in srgb, var(--documentation-accent-2) 52%, transparent); }
+.documentation-nav-folder { margin: 2px 0; }
+.documentation-nav-folder > summary { display: flex; align-items: center; justify-content: space-between; min-height: 34px; padding: 6px 9px; border-radius: 8px; color: var(--documentation-muted); cursor: pointer; font-size: 13.25px; font-weight: 620; list-style: none; }
+.documentation-nav-folder > summary::-webkit-details-marker { display: none; }
+.documentation-nav-folder > summary:hover { background: var(--documentation-panel); color: var(--documentation-text); }
+.documentation-nav-folder > summary svg { width: 13px; transition: transform .16s; }
+.documentation-nav-folder:not([open]) > summary svg { transform: rotate(-90deg); }
+.documentation-nav-folder > div { margin-left: 8px; padding-left: 9px; border-left: 1px solid var(--documentation-border); }
+
+.documentation-sidebar-footer { flex: 0 0 auto; display: grid; gap: 11px; padding: 13px 20px 16px 22px; border-top: 1px solid var(--documentation-border); background: color-mix(in srgb, var(--documentation-panel) 46%, var(--documentation-bg)); }
+.documentation-sidebar-footer > nav { display: flex; flex-wrap: wrap; gap: 8px 13px; }
+.documentation-sidebar-footer a, .documentation-sidebar-footer > span { color: var(--documentation-faint); font-size: 10.5px; text-decoration: none; }
+.documentation-sidebar-footer a:hover { color: var(--documentation-text); }
+.documentation-theme-controls { display: inline-flex; width: max-content; padding: 2px; border: 1px solid var(--documentation-border); border-radius: 9px; background: var(--documentation-surface); box-shadow: var(--documentation-shadow-sm); }
+.documentation-theme-controls button { display: grid; place-items: center; width: 28px; height: 25px; padding: 0; border: 0; border-radius: 6px; background: transparent; color: var(--documentation-faint); cursor: pointer; }
+.documentation-theme-controls button:hover { color: var(--documentation-text); }
+.documentation-theme-controls button[aria-pressed="true"] { background: var(--documentation-panel-strong); color: var(--documentation-text); }
+.documentation-theme-controls svg { width: 14px; height: 14px; }
+
+`;
+
+// src/documentation/runtime/styles/overlays.ts
+var DOCUMENTATION_OVERLAYS_CSS = String.raw`
+.documentation-modal-layer { position: fixed; z-index: 100; inset: 0; display: flex; background: rgba(9, 11, 17, .48); backdrop-filter: blur(5px); animation: documentation-fade-in .14s ease-out; }
+.documentation-search-layer { align-items: flex-start; justify-content: center; padding: min(12vh, 100px) 16px 16px; }
+.documentation-search-dialog { width: min(680px, 100%); overflow: hidden; border: 1px solid var(--documentation-border-strong); border-radius: 14px; background: var(--documentation-surface-raised); box-shadow: var(--documentation-shadow-lg); animation: documentation-dialog-in .18s ease-out; }
+.documentation-search-input { display: flex; align-items: center; gap: 11px; height: 56px; padding: 0 15px; border-bottom: 1px solid var(--documentation-border); }
+.documentation-search-input > svg { flex: 0 0 auto; width: 18px; color: var(--documentation-muted); }
+.documentation-search-input input { min-width: 0; flex: 1; border: 0; outline: 0; background: transparent; color: var(--documentation-text); font-size: 16px; }
+.documentation-search-input input::placeholder { color: var(--documentation-faint); }
+.documentation-search-input kbd, .documentation-search-dialog footer kbd { padding: 2px 5px; border: 1px solid var(--documentation-border); border-radius: 5px; background: var(--documentation-panel); color: var(--documentation-faint); font: 600 9px/1.4 var(--documentation-font-mono); }
+.documentation-search-results { min-height: 180px; max-height: min(56vh, 500px); overflow: auto; padding: 7px; }
+.documentation-search-empty { display: grid; place-items: center; min-height: 180px; padding: 25px; color: var(--documentation-muted); text-align: center; }
+.documentation-search-empty svg { width: 29px; height: 29px; margin-bottom: 8px; color: var(--documentation-accent); }
+.documentation-search-empty strong { color: var(--documentation-text); font-size: 14px; }
+.documentation-search-empty span { font-size: 12px; }
+.documentation-search-state { padding: 28px 16px; color: var(--documentation-muted); font-size: 13px; text-align: center; }
+.documentation-search-result, .documentation-search-assistant { display: flex; align-items: center; justify-content: space-between; gap: 14px; width: 100%; min-height: 64px; padding: 10px 11px; border: 0; border-radius: 9px; background: transparent; color: var(--documentation-text); cursor: pointer; text-align: left; text-decoration: none; }
+.documentation-search-result.is-active, .documentation-search-assistant.is-active { background: var(--documentation-panel); }
+.documentation-search-result > span, .documentation-search-assistant > span { min-width: 0; flex: 1; display: grid; }
+.documentation-search-result strong, .documentation-search-assistant strong { overflow: hidden; font-size: 13px; font-weight: 670; text-overflow: ellipsis; white-space: nowrap; }
+.documentation-search-result small, .documentation-search-assistant small { overflow: hidden; color: var(--documentation-muted); font-size: 11.5px; line-height: 1.5; text-overflow: ellipsis; white-space: nowrap; }
+.documentation-search-result > svg, .documentation-search-assistant > svg:last-child { flex: 0 0 auto; width: 14px; color: var(--documentation-faint); }
+.documentation-search-assistant { border-top: 1px solid var(--documentation-border); border-radius: 0 0 9px 9px; color: color-mix(in srgb, var(--documentation-accent) 76%, var(--documentation-text)); }
+.documentation-search-assistant > svg:first-child { flex: 0 0 auto; width: 19px; }
+.documentation-search-result mark { border-radius: 3px; background: color-mix(in srgb, var(--documentation-accent) 18%, transparent); color: inherit; }
+.documentation-search-dialog > footer { display: flex; gap: 17px; padding: 8px 13px; border-top: 1px solid var(--documentation-border); background: var(--documentation-panel); color: var(--documentation-faint); font-size: 9.5px; }
+.documentation-search-dialog > footer span { display: flex; align-items: center; gap: 3px; }
+
+.documentation-mobile-nav { display: flex; flex-direction: column; width: min(342px, 88vw); height: 100%; border-right: 1px solid var(--documentation-border); background: var(--documentation-bg); box-shadow: var(--documentation-shadow-lg); animation: documentation-drawer-in .2s ease-out; }
+.documentation-mobile-nav > header { display: flex; align-items: center; justify-content: space-between; min-height: 64px; border-bottom: 1px solid var(--documentation-border); }
+.documentation-mobile-nav > header .documentation-brand { border: 0; padding-left: 20px; }
+.documentation-mobile-nav > header .documentation-icon-button { margin-right: 12px; }
+.documentation-mobile-nav > .documentation-page-tree { padding-top: 22px; }
+.documentation-mobile-nav > footer { display: flex; align-items: center; flex-wrap: wrap; gap: 8px 13px; padding: 13px 18px; border-top: 1px solid var(--documentation-border); }
+.documentation-mobile-nav > footer a { color: var(--documentation-muted); font-size: 11px; text-decoration: none; }
+
+.documentation-assistant-launcher { position: fixed; z-index: 70; left: 50%; bottom: 20px; display: grid; grid-template-columns: auto minmax(0, 1fr) auto; align-items: center; gap: 0; width: min(452px, calc(100vw - 36px)); min-height: 48px; padding: 5px; border: 1px solid color-mix(in srgb, var(--documentation-border-strong) 92%, var(--documentation-accent)); border-radius: 13px; background: color-mix(in srgb, var(--documentation-surface-raised) 96%, transparent); color: var(--documentation-text); box-shadow: 0 18px 45px rgba(15, 18, 28, .11), 0 2px 8px rgba(15, 18, 28, .05); transform: translateX(-50%); backdrop-filter: blur(18px) saturate(1.1); transition: border-color .16s, box-shadow .16s, transform .16s; }
+.documentation-assistant-launcher:hover { border-color: color-mix(in srgb, var(--documentation-accent) 32%, var(--documentation-border-strong)); box-shadow: 0 20px 48px rgba(15, 18, 28, .14), 0 2px 8px rgba(15, 18, 28, .06); transform: translateX(-50%) translateY(-1px); }
+.documentation-assistant-launcher input { min-width: 0; height: 36px; padding: 0 12px; border: 0; outline: 0; background: transparent; color: var(--documentation-text); font-size: 13px; }
+.documentation-assistant-launcher input::placeholder { color: var(--documentation-muted); }
+.documentation-launcher-agent, .documentation-launcher-send { display: grid; place-items: center; height: 36px; border: 0; border-radius: 9px; cursor: pointer; }
+.documentation-launcher-agent { width: auto; padding: 0 13px 0 9px; border-right: 1px solid var(--documentation-border); border-radius: 0; background: transparent; color: var(--documentation-text-soft); font-size: 11.5px; font-weight: 650; white-space: nowrap; }
+.documentation-launcher-agent:hover { color: var(--documentation-accent); }
+.documentation-launcher-send { width: 36px; padding: 0; }
+.documentation-launcher-send { background: var(--documentation-accent); color: #fff; }
+.documentation-launcher-send:disabled { background: var(--documentation-panel); color: var(--documentation-faint); cursor: default; }
+.documentation-launcher-send svg { width: 15px; }
+.documentation-assistant { position: fixed; z-index: 90; left: 50%; bottom: 18px; display: grid; grid-template-rows: auto minmax(0, 1fr) auto auto; width: min(620px, calc(100vw - 36px)); height: min(570px, calc(100vh - 94px)); overflow: hidden; border: 1px solid var(--documentation-border-strong); border-radius: 16px; background: var(--documentation-surface); box-shadow: 0 28px 80px rgba(15, 18, 28, .18), 0 6px 22px rgba(15, 18, 28, .08); animation: documentation-assistant-in .2s ease-out; transform: translateX(-50%); }
+.documentation-assistant > header { display: flex; align-items: center; justify-content: space-between; min-height: 54px; padding: 0 11px 0 18px; border-bottom: 1px solid var(--documentation-border); }
+.documentation-assistant > header > div { display: flex; align-items: center; }
+.documentation-assistant > header > div > span { display: grid; gap: 1px; }
+.documentation-assistant > header strong { font-size: 13px; font-weight: 620; letter-spacing: -.01em; }
+.documentation-assistant > header small { color: var(--documentation-muted); font-size: 10.5px; }
+.documentation-assistant > header button { display: grid; place-items: center; width: 32px; height: 32px; padding: 0; border: 0; border-radius: 8px; background: transparent; color: var(--documentation-muted); cursor: pointer; }
+.documentation-assistant > header button:hover { background: var(--documentation-panel); color: var(--documentation-text); }
+.documentation-assistant > header button:focus-visible { outline-width: 1px; outline-offset: 1px; }
+.documentation-assistant > header button svg { width: 15px; height: 15px; }
+.documentation-assistant-messages { overflow: auto; padding: 20px 20px 14px; overscroll-behavior: contain; }
+.documentation-assistant-message { display: flex; align-items: flex-start; margin: 0 0 20px; color: var(--documentation-text-soft); font-size: 13px; line-height: 1.64; }
+.documentation-assistant-message > div { min-width: 0; max-width: 590px; }
+.documentation-assistant-message.is-user { justify-content: flex-end; margin-left: 54px; }
+.documentation-assistant-message.is-user > div { padding: 8px 11px; border: 1px solid var(--documentation-border); border-radius: 10px; background: var(--documentation-panel); color: var(--documentation-text); }
+.documentation-assistant-message.is-error > div { color: #c64b50; }
+.documentation-assistant-message a { color: color-mix(in srgb, var(--documentation-accent) 79%, var(--documentation-text)); font-weight: 580; text-underline-offset: 3px; }
+.documentation-assistant-markdown > :first-child { margin-top: 0; }
+.documentation-assistant-markdown > :last-child { margin-bottom: 0; }
+.documentation-assistant-markdown p { margin: 0 0 11px; }
+.documentation-assistant-markdown ul, .documentation-assistant-markdown ol { margin: 0 0 12px; padding-left: 20px; }
+.documentation-assistant-markdown li { margin: 3px 0; }
+.documentation-assistant-heading { display: block; margin: 15px 0 6px; color: var(--documentation-text); font-family: var(--documentation-font-heading); font-size: 13px; }
+.documentation-assistant-code { overflow: hidden; margin: 12px 0; border: 1px solid var(--documentation-border-strong); border-radius: 10px; background: var(--documentation-code-bg); color: var(--documentation-code-text); }
+.documentation-assistant-code figcaption { display: flex; align-items: center; justify-content: space-between; min-height: 34px; padding: 0 8px 0 12px; border-bottom: 1px solid rgba(255,255,255,.09); background: var(--documentation-code-panel); color: #aeb5c6; font: 600 10.5px/1.3 var(--documentation-font-mono); }
+.documentation-assistant-code button { padding: 4px 7px; border: 1px solid rgba(255,255,255,.1); border-radius: 6px; background: rgba(255,255,255,.06); color: inherit; cursor: pointer; font-size: 10px; }
+.documentation-assistant-code pre { overflow: auto; margin: 0; padding: 13px; font: 11.5px/1.58 var(--documentation-font-mono); }
+.documentation-assistant-code code { padding: 0; border: 0; background: transparent; color: inherit; font: inherit; white-space: pre; }
+.documentation-assistant-activity { display: inline-flex; align-items: center; gap: 8px; color: var(--documentation-muted); font-size: 12px; }
+.documentation-assistant-activity > span { width: 6px; height: 6px; border-radius: 50%; background: var(--documentation-accent); box-shadow: 0 0 0 3px color-mix(in srgb, var(--documentation-accent) 10%, transparent); animation: documentation-activity 1.25s ease-in-out infinite; }
+.documentation-assistant-suggestions { display: grid; gap: 7px; margin-top: 26px; }
+.documentation-assistant-suggestions p { margin: 0 0 1px; color: var(--documentation-faint); font-size: 10px; font-weight: 650; letter-spacing: .035em; text-transform: uppercase; }
+.documentation-assistant-suggestions button { min-height: 38px; padding: 8px 11px; border: 1px solid var(--documentation-border); border-radius: 9px; background: var(--documentation-bg); color: var(--documentation-muted); cursor: pointer; font-size: 12px; text-align: left; transition: border-color .14s, background .14s, color .14s; }
+.documentation-assistant-suggestions button:hover { border-color: var(--documentation-border-strong); background: var(--documentation-panel); color: var(--documentation-text); }
+.documentation-assistant-composer { display: flex; align-items: flex-end; gap: 7px; margin: 0 16px 9px; padding: 7px; border: 1px solid var(--documentation-border-strong); border-radius: 11px; background: var(--documentation-bg); box-shadow: 0 3px 12px rgba(15, 18, 28, .045); }
+.documentation-assistant-composer:focus-within { border-color: color-mix(in srgb, var(--documentation-accent) 52%, var(--documentation-border)); box-shadow: 0 0 0 3px color-mix(in srgb, var(--documentation-accent) 9%, transparent); }
+.documentation-assistant-composer textarea { min-height: 41px; max-height: 160px; flex: 1; padding: 4px 5px; resize: none; border: 0; outline: 0; background: transparent; color: var(--documentation-text); font-size: 12.5px; line-height: 1.5; }
+.documentation-assistant-composer button { display: grid; place-items: center; width: 32px; height: 32px; padding: 0; border: 0; border-radius: 8px; background: var(--documentation-accent); color: white; cursor: pointer; }
+.documentation-assistant-composer button:disabled { background: var(--documentation-panel-strong); color: var(--documentation-faint); cursor: default; }
+.documentation-assistant > footer { padding: 0 18px 10px; color: var(--documentation-faint); font-size: 9.5px; text-align: center; }
+@keyframes documentation-fade-in { from { opacity: 0; } }
+@keyframes documentation-dialog-in { from { opacity: 0; transform: translateY(-8px) scale(.99); } }
+@keyframes documentation-drawer-in { from { transform: translateX(-24px); } }
+@keyframes documentation-assistant-in { from { transform: translateX(-50%) translateY(18px) scale(.985); opacity: .7; } }
+@keyframes documentation-page-out { to { opacity: 0; transform: translateY(-3px); } }
+@keyframes documentation-page-in { from { opacity: 0; transform: translateY(4px); } }
+@keyframes documentation-activity { 50% { opacity: .42; transform: scale(.82); } }
+@keyframes documentation-navigation-progress { from { transform: translateX(-20%); } to { transform: translateX(155%); } }
+
+`;
+
+// src/documentation/runtime/styles/responsive.ts
+var DOCUMENTATION_RESPONSIVE_CSS = String.raw`
+@media (max-width: 1320px) {
+  .documentation-reader-grid { grid-template-columns: minmax(0, 640px) 190px; gap: 48px; padding-inline: 70px; }
+  .documentation-top-links { gap: 13px; padding-right: 16px; }
+  .documentation-top-links a { font-size: 12px; }
+}
+
+@media (max-width: 1140px) {
+  .documentation-reader-grid { grid-template-columns: minmax(0, 760px); }
+  .documentation-context-rail { display: none; }
+  .documentation-header { grid-template-columns: var(--documentation-sidebar-width) 1fr auto; }
+  .documentation-top-links { display: none; }
+  .documentation-breadcrumbs { display: flex; }
+}
+
+@media (max-width: 900px) {
+  :root { --documentation-sidebar-width: 0px; }
+  .documentation-header { grid-template-columns: minmax(0, 1fr) auto; }
+  .documentation-header > .documentation-brand { padding-left: 17px; border-right: 0; }
+  .documentation-header-center, .documentation-sidebar { display: none; }
+  .documentation-mobile-actions { display: flex; }
+  .documentation-main { margin-left: 0; }
+  .documentation-reader-grid { padding: 44px 30px 90px; }
+  .documentation-assistant { width: min(660px, calc(100vw - 24px)); }
+}
+
+@media (max-width: 600px) {
+  body { font-size: 15px; }
+  .documentation-brand { padding-right: 8px; }
+  .documentation-brand-product { display: none; }
+  .documentation-mobile-actions { padding-right: 8px; }
+  .documentation-icon-button { width: 34px; }
+  .documentation-reader-grid { padding: 31px 19px 72px; }
+  .documentation-breadcrumbs { margin-bottom: 19px; overflow: hidden; white-space: nowrap; }
+  .documentation-breadcrumbs span { flex: 0 0 auto; }
+  .documentation-article-header { margin-bottom: 30px; }
+  .documentation-article-meta { align-items: flex-start; }
+  .documentation-eyebrow { padding-top: 8px; }
+  .documentation-contextual-primary button, .documentation-contextual-primary a { max-width: 112px; overflow: hidden; text-overflow: ellipsis; }
+  .documentation-article-header h1 { font-size: 32px; line-height: 1.13; }
+  .documentation-lede { font-size: 17px; line-height: 1.52; }
+  .documentation-prose h2 { margin-top: 42px; font-size: 23px; }
+  .documentation-prose h3 { font-size: 18px; }
+  .documentation-prose pre { margin-inline: -5px; padding: 17px; border-radius: 10px; font-size: 12px; }
+  .documentation-code-actions { margin-right: -9px; margin-top: -9px; }
+  .documentation-pagination { grid-template-columns: 1fr; }
+  .documentation-app.has-assistant .documentation-pagination { margin-bottom: 124px; transform: translateY(124px); }
+  .documentation-feedback { align-items: flex-start; flex-wrap: wrap; }
+  .documentation-feedback > span { width: 100%; margin-bottom: 2px; }
+  .documentation-search-layer { padding: 8px; align-items: stretch; }
+  .documentation-search-dialog { display: grid; grid-template-rows: auto minmax(0, 1fr) auto; height: 100%; border-radius: 12px; }
+  .documentation-search-results { max-height: none; }
+  .documentation-search-dialog > footer { justify-content: center; }
+  .documentation-assistant-launcher { bottom: 12px; width: calc(100vw - 20px); }
+  .documentation-assistant-launcher kbd { display: none; }
+  .documentation-assistant { bottom: 0; width: 100%; height: calc(100vh - 8px); border-width: 1px 0 0; border-radius: 18px 18px 0 0; }
+  .documentation-assistant-suggestions { grid-template-columns: 1fr; }
+  .documentation-playground-title { align-items: flex-start; flex-direction: column; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  html { scroll-behavior: auto; }
+  *, *::before, *::after { animation-duration: .001ms !important; animation-iteration-count: 1 !important; scroll-behavior: auto !important; transition-duration: .001ms !important; }
+}
+`;
+
+// src/documentation/runtime/styles.ts
+var DOCUMENTATION_CSS = DOCUMENTATION_BASE_CSS + DOCUMENTATION_NAVIGATION_CSS + DOCUMENTATION_CONTENT_CSS + DOCUMENTATION_OVERLAYS_CSS + DOCUMENTATION_RESPONSIVE_CSS;
+
+// src/documentation/template.ts
+function renderPage(options, assets = {}, runtime = createPageRuntime(options)) {
+  const { config, page } = options;
+  const { data: runtimeData, document: runtimeDocument } = runtime;
+  const theme = runtimeData.config.theme;
+  const accent = validCssColor(theme.accent) ? theme.accent : "#635bff";
+  const background = validCssColor(theme.background) ? theme.background : "#fbfcfe";
+  const backgroundDark = validCssColor(theme.backgroundDark) ? theme.backgroundDark : "#0c0e14";
+  const defaultMode = theme.defaultMode ?? "system";
+  const bodyFont = cssFontStack(theme.bodyFont?.family);
+  const headingFont = cssFontStack(theme.headingFont?.family ?? theme.bodyFont?.family);
+  const monoFont = cssMonoFontStack(theme.monoFont?.family);
+  const fontFaces = renderFontFaces(theme);
+  const fontPreloads = renderFontPreloads(theme);
+  const markup = assets.markup ?? renderDefaultDocumentation(runtimeData);
+  const assetRoot = documentationPublicPath(options.basePath, "/assets");
+  return `<!doctype html>
+<html lang="en" data-theme-mode="${defaultMode}" data-theme-strict="${theme.strictMode ? "true" : "false"}" data-code-mode="${theme.codeBlockMode ?? "dark"}" data-background-decoration="${theme.backgroundDecoration ?? "none"}" data-eyebrow-style="${theme.eyebrowStyle ?? "section"}">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${escapeHtml(runtimeDocument.title)}</title>
+  <meta name="description" content="${escapeHtml(runtimeDocument.description ?? "")}">
+  <meta name="generator" content="DeepSpace Documentation Orbit">
+  <meta name="color-scheme" content="light dark">
+  ${runtimeDocument.robots ? `<meta name="robots" content="${escapeHtml(runtimeDocument.robots)}">` : ""}
+  ${runtimeDocument.canonical ? `<link rel="canonical" href="${escapeHtml(runtimeDocument.canonical)}">` : ""}
+  <meta property="og:type" content="article">
+  <meta property="og:title" content="${escapeHtml(runtimeDocument.openGraph["og:title"] ?? "")}">
+  <meta property="og:description" content="${escapeHtml(runtimeDocument.openGraph["og:description"] ?? "")}">
+  ${runtimeDocument.openGraph["og:url"] ? `<meta property="og:url" content="${escapeHtml(runtimeDocument.openGraph["og:url"])}">` : ""}
+  ${config.seo.ogImage ? `<meta property="og:image" content="${escapeHtml(config.seo.ogImage)}">` : ""}
+  ${renderCustomMeta(config.seo.metaTags)}
+  ${theme.favicon ? `<link rel="icon" href="${escapeHtml(theme.favicon)}">` : ""}
+  ${fontPreloads}
+  <link rel="stylesheet" href="${assetRoot}/documentation.css">
+  ${(assets.customStylesheets ?? []).map((href) => `<link rel="stylesheet" href="${escapeHtml(href)}">`).join("\n  ")}
+  <style>${fontFaces}:root{--documentation-accent:${accent};--documentation-brand-bg:${background};--documentation-brand-bg-dark:${backgroundDark};--documentation-font-body:${bodyFont};--documentation-font-heading:${headingFont};--documentation-font-mono:${monoFont}}</style>
+  <script src="${assetRoot}/documentation-theme.js"></script>
+</head>
+<body data-route="${escapeHtml(page.route)}">
+  <div id="deepspace-documentation-root">${markup}</div>
+  <script id="deepspace-documentation-data" type="application/json">${serializeBootstrap(runtimeData)}</script>
+  <script${assets.runtimeModule ? ' type="module"' : ""} src="${escapeHtml(assets.runtimeScript ?? `${assetRoot}/documentation-runtime.js`)}" defer></script>
+</body>
+</html>`;
+}
+function renderFontFaces(theme) {
+  const fonts = [theme.bodyFont, theme.headingFont, theme.monoFont];
+  const seen = /* @__PURE__ */ new Set();
+  return fonts.flatMap((font) => {
+    if (!font?.source || !validFontSource(font.source)) return [];
+    const key = `${font.family}:${font.source}:${font.weight ?? "normal"}`;
+    if (seen.has(key)) return [];
+    seen.add(key);
+    const family = safeFontFamily(font.family);
+    const weight = typeof font.weight === "number" || /^(?:normal|bold|[1-9]00|[1-9]00\s+[1-9]00)$/i.test(String(font.weight)) ? String(font.weight ?? "normal") : "normal";
+    const format = font.format && /^[a-z0-9-]{2,20}$/i.test(font.format) ? ` format("${font.format}")` : "";
+    return [`@font-face{font-family:"${family}";src:url("${font.source}")${format};font-weight:${weight};font-display:swap}`];
+  }).join("");
+}
+function renderFontPreloads(theme) {
+  const sources = new Set(
+    [theme.bodyFont, theme.headingFont, theme.monoFont].flatMap((font) => font?.source && validFontSource(font.source) ? [font.source] : [])
+  );
+  return [...sources].map((source) => `<link rel="preload" href="${escapeHtml(source)}" as="font" type="font/woff2" crossorigin>`).join("\n  ");
+}
+function renderCustomMeta(metaTags) {
+  if (!metaTags) return "";
+  return Object.entries(metaTags).filter(([name]) => /^[a-z0-9][a-z0-9._:-]*$/i.test(name)).map(([name, content]) => `<meta name="${escapeHtml(name)}" content="${escapeHtml(content)}">`).join("\n  ");
+}
+function createNotFoundPage() {
+  return {
+    sourcePath: "",
+    relativePath: "",
+    route: "/404",
+    title: "Page not found",
+    description: "The documentation page you requested does not exist.",
+    hidden: true,
+    noindex: true,
+    markdown: "",
+    html: '<p>The page may have moved. Search this documentation or return to the documentation home.</p><p><a href="/">Go to documentation home</a></p>',
+    text: "Page not found",
+    headings: [],
+    sourceFormat: "generated",
+    kind: "page"
+  };
+}
+function createPageRuntime(options) {
+  const { config, page, pages, navigation } = options;
+  const data = createRuntimeData(config, page, pages, navigation, options.basePath);
+  return {
+    data,
+    document: createRuntimeRouteDocumentFromData(config, page, data)
+  };
+}
+function createRuntimeRouteDocumentFromData(config, page, runtimeData) {
+  const data = {
+    basePath: runtimeData.basePath,
+    page: runtimeData.page,
+    breadcrumbs: runtimeData.breadcrumbs,
+    ...runtimeData.previous ? { previous: runtimeData.previous } : {},
+    ...runtimeData.next ? { next: runtimeData.next } : {}
+  };
+  const canonical = config.url ? joinSiteUrl(config.url, page.route) : null;
+  const description = page.description ?? config.description ?? `${page.title} \u2014 ${config.name}`;
+  return {
+    canonical,
+    data,
+    description,
+    openGraph: {
+      "og:title": page.title,
+      "og:description": description,
+      "og:url": canonical
+    },
+    robots: page.noindex ? "noindex, nofollow" : null,
+    title: `${page.title} \xB7 ${config.name}`
+  };
+}
+function renderRedirect(to, basePath = "/docs") {
+  const safe = escapeHtml(documentationPublicPath(basePath, to));
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="robots" content="noindex"><meta http-equiv="refresh" content="0;url=${safe}"><link rel="canonical" href="${safe}"><title>Redirecting\u2026</title></head><body><p>Redirecting to <a href="${safe}">${safe}</a>.</p></body></html>`;
+}
+function publicTheme(theme, basePath) {
+  const publicAsset = (value) => {
+    if (!value) return value;
+    const logical = value.startsWith("/_documentation/") ? value.slice("/_documentation".length) : value;
+    return logical.startsWith("/media/") ? documentationPublicPath(basePath, logical) : logical;
+  };
+  const publicFont = (font) => font ? { ...font, source: publicAsset(font.source) } : font;
+  return {
+    ...theme,
+    logo: publicAsset(theme.logo),
+    logoDark: publicAsset(theme.logoDark),
+    favicon: publicAsset(theme.favicon),
+    bodyFont: publicFont(theme.bodyFont),
+    headingFont: publicFont(theme.headingFont),
+    monoFont: publicFont(theme.monoFont)
+  };
+}
+function publicPageHtml(html, basePath) {
+  return html.replace(
+    /(\b(?:href|src)=["'])(\/(?!\/)[^"']*)(["'])/gi,
+    (_match, prefix, value, suffix) => {
+      const logical = value.startsWith("/_documentation/") ? value.slice("/_documentation".length) : value;
+      const publicValue = basePath && (logical === basePath || logical.startsWith(`${basePath}/`)) ? logical : documentationPublicPath(basePath, logical);
+      return `${prefix}${publicValue}${suffix}`;
+    }
+  );
+}
+function createRuntimeData(config, page, pages, navigation, basePath) {
+  const ordered = orderedRoutes(navigation);
+  const pageIndex = ordered.indexOf(page.route);
+  const previous = pageIndex > 0 ? pages.find((candidate) => candidate.route === ordered[pageIndex - 1]) : void 0;
+  const next = pageIndex >= 0 ? pages.find((candidate) => candidate.route === ordered[pageIndex + 1]) : void 0;
+  return {
+    basePath,
+    config: {
+      name: config.name,
+      ...config.description ? { description: config.description } : {},
+      theme: publicTheme(config.theme, basePath),
+      links: config.links,
+      footer: config.footer,
+      assistant: config.assistant,
+      mcp: config.mcp,
+      contextual: config.contextual
+    },
+    page: {
+      route: page.route,
+      title: page.title,
+      ...page.description ? { description: page.description } : {},
+      html: publicPageHtml(page.html, basePath),
+      headings: page.headings,
+      kind: page.kind,
+      markdownUrl: markdownUrlForRoute(page.route, basePath),
+      ...page.openapi ? { openapi: page.openapi } : {}
+    },
+    navigation,
+    breadcrumbs: findBreadcrumbs(navigation, page.route) ?? [config.name, page.title],
+    ...previous ? { previous: { route: previous.route, title: previous.title } } : {},
+    ...next ? { next: { route: next.route, title: next.title } } : {}
+  };
+}
+function findBreadcrumbs(nodes, route, parents = []) {
+  for (const node of nodes) {
+    if (node.kind === "page" && node.route === route) return [...parents, node.label];
+    if (node.kind === "group") {
+      const result = findBreadcrumbs(node.items, route, [...parents, node.label]);
+      if (result) return result;
+    }
+  }
+  return void 0;
+}
+function orderedRoutes(nodes) {
+  return nodes.flatMap((node) => {
+    if (node.kind === "page") return [node.route];
+    if (node.kind === "group") return orderedRoutes(node.items);
+    return [];
+  });
+}
+function serializeBootstrap(data) {
+  return JSON.stringify(data).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function validCssColor(value) {
+  if (!value) return false;
+  return /^(?:#[0-9a-f]{3,8}|(?:rgb|hsl)a?\([0-9.,%\s]+\)|[a-z]{3,20})$/i.test(value);
+}
+function cssFontStack(value) {
+  const family = safeFontFamily(value ?? "Inter");
+  return `${family},ui-sans-serif,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif`;
+}
+function cssMonoFontStack(value) {
+  const family = safeFontFamily(value ?? "Geist Mono");
+  return `${family},ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace`;
+}
+function safeFontFamily(value) {
+  return /^[a-z0-9 ,.'-]{1,80}$/i.test(value) ? value : "Inter";
+}
+function validFontSource(value) {
+  return /^(?:\/[a-z0-9_./%-]+|https:\/\/[^\s"'()<>]+)$/i.test(value);
+}
+function themeBootstrap() {
+  try {
+    const stored = localStorage.getItem("deepspace-documentation-theme");
+    const configured = document.documentElement.dataset.themeMode || "system";
+    const strict = document.documentElement.dataset.themeStrict === "true";
+    const mode = !strict && (stored === "light" || stored === "dark" || stored === "system") ? stored : configured;
+    document.documentElement.dataset.themeMode = mode;
+    document.documentElement.dataset.theme = mode === "system" ? matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light" : mode;
+  } catch {
+    document.documentElement.dataset.theme = "light";
+  }
+}
+var DOCUMENTATION_THEME_BOOTSTRAP = `(${themeBootstrap.toString()})()
+`;
+
+// src/documentation/build.ts
+function buildDocumentation(options) {
+  const validation = validateDocumentation(options.appDir);
+  const outputDir = options.outputDir ? resolve7(options.outputDir) : validation.outputDir;
+  const output = new DocumentationOutput(outputDir, validation.appDir, validation.sourceDir);
+  const basePath = normalizeDocumentationBasePath(options.basePath ?? "/docs");
+  const renderConfig = options.baseUrl ? { ...validation.graph.config, url: options.baseUrl } : validation.graph.config;
+  const write = output.write.bind(output);
+  const customRuntime = buildCustomDocumentationRuntime(validation, basePath);
+  if (customRuntime) {
+    for (const asset of customRuntime.browserAssets) write(`assets/${asset.path}`, asset.content);
+  }
+  for (const page of validation.graph.pages) {
+    const artifactPaths = artifactPathsForRoute(page.route);
+    const renderOptions = {
+      config: renderConfig,
+      basePath,
+      page,
+      pages: validation.graph.pages,
+      navigation: validation.graph.navigation
+    };
+    const runtime = createPageRuntime(renderOptions);
+    write(artifactPaths.html, renderPage(renderOptions, customRuntime ? {
+      customStylesheets: customRuntime.stylesheets,
+      markup: customRuntime.render(runtime.data, page.route),
+      runtimeModule: true,
+      runtimeScript: documentationPublicPath(basePath, "/assets/documentation-custom-runtime.js")
+    } : {}, runtime));
+    write(artifactPaths.data, stableJson(runtime.document));
+    write(artifactPaths.markdown, pageMarkdown(page, basePath));
+  }
+  for (const [from, to] of Object.entries(validation.graph.config.redirects)) {
+    write(artifactPathsForRoute(from).html, renderRedirect(to, basePath));
+  }
+  const notFoundPage = createNotFoundPage();
+  const notFoundOptions = {
+    config: renderConfig,
+    basePath,
+    page: notFoundPage,
+    pages: [notFoundPage],
+    navigation: validation.graph.navigation
+  };
+  const notFoundRuntime = createPageRuntime(notFoundOptions);
+  write("404.html", renderPage(notFoundOptions, customRuntime ? {
+    customStylesheets: customRuntime.stylesheets,
+    markup: customRuntime.render(notFoundRuntime.data, notFoundPage.route),
+    runtimeModule: true,
+    runtimeScript: documentationPublicPath(basePath, "/assets/documentation-custom-runtime.js")
+  } : {}, notFoundRuntime));
+  write("assets/documentation.css", DOCUMENTATION_CSS.trimStart());
+  write("assets/documentation-theme.js", DOCUMENTATION_THEME_BOOTSTRAP);
+  if (!customRuntime) write("assets/documentation-runtime.js", buildDocumentationRuntime().trimStart());
+  write("search.json", stableJson(createSearchEntries(validation.graph.pages)));
+  write("assistant-index.json", stableJson(createAssistantChunks(validation.graph.pages)));
+  const openApiOperations = validation.graph.pages.flatMap(
+    (page) => page.openapi ? [{ route: page.route, ...page.openapi }] : []
+  );
+  if (openApiOperations.length > 0) write("openapi.json", stableJson(openApiOperations));
+  const machinePages = pagesInNavigationOrder(validation.graph.pages, validation.graph.navigation);
+  write("llms.txt", renderLlmsIndex(machinePages, validation.graph.config.name, basePath));
+  write("llms-full.txt", renderLlmsFull(machinePages, validation.graph.config.name, basePath));
+  const skill = createDocumentationSkillArtifacts(validation.graph, renderConfig.url, basePath);
+  write("skill.md", skill.markdown);
+  write(`.well-known/skills/${skill.name}/SKILL.md`, skill.markdown);
+  write(".well-known/skills/index.json", stableJson(skill.legacyIndex));
+  write(`.well-known/agent-skills/${skill.name}/skill.md`, skill.markdown);
+  write(".well-known/agent-skills/index.json", stableJson(skill.discoveryIndex));
+  write("sitemap.xml", renderSitemap(validation.graph.pages, renderConfig.url));
+  write("robots.txt", renderRobots(renderConfig.url, renderConfig.seo.noindex));
+  output.copyMedia(
+    validation.sourceDir,
+    new Set(
+      validation.graph.pages.filter((page) => page.kind === "openapi").map((page) => resolve7(page.sourcePath))
+    )
+  );
+  const resources = [...output.files].filter((file) => isNativeDocumentationResourcePath(`/${file}`)).map((file) => encodeNativeDocumentationPath(`/${file}`)).sort();
+  const outputHash = output.hash();
+  const manifest = {
+    version: DOCUMENTATION_MANIFEST_VERSION,
+    sourceHash: validation.graph.sourceHash,
+    outputHash,
+    name: validation.graph.config.name,
+    pageCount: validation.graph.pages.length,
+    routes: [
+      ...validation.graph.pages.map((page) => page.route),
+      ...Object.keys(validation.graph.config.redirects)
+    ].map(encodeNativeDocumentationPath).sort(),
+    resources,
+    assistant: validation.graph.config.assistant,
+    mcp: validation.graph.config.mcp,
+    domains: validation.graph.config.domains,
+    basePath
+  };
+  write("manifest.json", stableJson(manifest));
+  return {
+    ...validation,
+    outputDir,
+    manifest,
+    files: [...output.files].sort()
+  };
+}
+function buildDocumentationRuntime() {
+  const entry = runtimeEntry("documentation-runtime.js", "runtime/auto-client.tsx");
+  if (entry.endsWith(".js")) return readFileSync6(entry, "utf8");
+  const result = buildSync3({
+    entryPoints: [entry],
+    bundle: true,
+    write: false,
+    minify: true,
+    platform: "browser",
+    format: "iife",
+    target: ["es2022"],
+    jsx: "automatic",
+    define: { "process.env.NODE_ENV": '"production"' }
+  });
+  const output = result.outputFiles?.[0]?.text;
+  if (!output) {
+    throw new DocumentationError("Unable to compile the documentation browser runtime", "documentation_runtime_build_failed");
+  }
+  return output;
+}
+
+// src/documentation/vite.ts
+import { existsSync as existsSync7, readdirSync as readdirSync3, realpathSync as realpathSync3, rmSync as rmSync3 } from "fs";
+import { relative as relative6, resolve as resolve8, sep as sep5 } from "path";
+var IGNORED_DOCUMENTATION_WATCH_PATH = /^(?:\.deepspace|\.git|\.wrangler|dist|node_modules|public\/_documentation(?:-root)?|src\/router\.ts)(?:\/|$)/;
+function deepSpaceDocumentation() {
+  let appDir = process.cwd();
+  let outputDir = resolve8(appDir, ".deepspace", "documentation");
+  let result = null;
+  const rebuild = () => {
+    if (!existsSync7(resolve8(appDir, DOCUMENTATION_CONFIG_FILE))) {
+      rmSync3(outputDir, { recursive: true, force: true });
+      rmSync3(`${outputDir}-root`, { recursive: true, force: true });
+      result = null;
+      return null;
+    }
+    const baseUrl = process.env.DEEPSPACE_DOCUMENTATION_BASE_URL;
+    result = buildDocumentation({
+      appDir,
+      outputDir,
+      ...baseUrl ? { baseUrl } : {}
+    });
+    if (result.manifest.domains.length) {
+      buildDocumentation({
+        appDir,
+        outputDir: `${outputDir}-root`,
+        basePath: "",
+        baseUrl: `https://${result.manifest.domains[0]}`
+      });
+    } else rmSync3(`${outputDir}-root`, { recursive: true, force: true });
+    return result;
+  };
+  return {
+    name: "deepspace-documentation",
+    config(config, environment) {
+      appDir = resolve8(config.root ?? process.cwd());
+      outputDir = resolve8(appDir, "public", "_documentation");
+      if (environment.command === "serve") {
+        rmSync3(resolve8(appDir, ".deepspace", "documentation"), { recursive: true, force: true });
+        rmSync3(resolve8(appDir, ".deepspace", "documentation-root"), {
+          recursive: true,
+          force: true
+        });
+      }
+      try {
+        rebuild();
+      } catch (error) {
+        throw new Error(documentationBuildErrorMessage(error), { cause: error });
+      }
+      return {
+        server: {
+          watch: {
+            ignored: ["**/.deepspace/documentation*/**", "**/public/_documentation*/**"]
+          }
+        }
+      };
+    },
+    configResolved(config) {
+      const resolvedRoot = resolve8(config.root);
+      const rootChanged = !pathsReferToSameDirectory(appDir, resolvedRoot);
+      appDir = resolvedRoot;
+      outputDir = resolve8(appDir, "public", "_documentation");
+      if (rootChanged) rebuild();
+    },
+    configureServer(server) {
+      if (!result) return;
+      const configPath = resolve8(appDir, DOCUMENTATION_CONFIG_FILE);
+      const customRuntimePath = resolve8(appDir, "documentation.tsx");
+      const watchedPaths = [configPath, customRuntimePath, result.sourceDir];
+      const initialPaths = currentDocumentationPaths(appDir);
+      server.watcher.add(watchedPaths);
+      const initialReplayTimeout = setTimeout(() => initialPaths.clear(), 1e4);
+      initialReplayTimeout.unref();
+      server.watcher.on("ready", () => {
+        clearTimeout(initialReplayTimeout);
+        initialPaths.clear();
+      });
+      let timer;
+      server.watcher.on("all", (event, path) => {
+        const changed = canonicalPath(path);
+        if ((event === "add" || event === "addDir") && initialPaths.delete(changed)) return;
+        if (!shouldRebuildDocumentation(appDir, configPath, result?.sourceDir ?? "", changed))
+          return;
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(() => {
+          try {
+            const previousDomains = result?.manifest.domains ?? [];
+            const next = rebuild();
+            if (next) {
+              server.config.logger.info(
+                `[deepspace] rebuilt ${next.manifest.pageCount} documentation page(s)`
+              );
+              if (changed === canonicalPath(configPath) && !sameDomains(previousDomains, next.manifest.domains)) {
+                void server.restart().catch((error) => {
+                  server.config.logger.error(
+                    `[deepspace] development Worker restart failed: ${error instanceof Error ? error.message : String(error)}`
+                  );
+                });
+              }
+            }
+          } catch (error) {
+            server.config.logger.error(
+              `[deepspace] documentation rebuild failed: ${documentationBuildErrorMessage(error)}`
+            );
+          }
+        }, 120);
+      });
+    }
+  };
+}
+function documentationBuildErrorMessage(error) {
+  const diagnostics = error && typeof error === "object" && "diagnostics" in error ? error.diagnostics : void 0;
+  if (!diagnostics?.length) return error instanceof Error ? error.message : String(error);
+  return diagnostics.map(
+    (diagnostic) => `${diagnostic.file ?? "documentation.json"}${diagnostic.line ? `:${diagnostic.line}` : ""}: ${diagnostic.message}`
+  ).join("\n");
+}
+function sameDomains(left, right) {
+  if (left.length !== right.length) return false;
+  const expected = new Set(right);
+  return left.every((domain) => expected.has(domain));
+}
+function currentDocumentationPaths(appDir) {
+  const paths = /* @__PURE__ */ new Set();
+  const directories = [appDir];
+  for (const directory of directories) {
+    for (const entry of readdirSync3(directory, { withFileTypes: true })) {
+      const path = resolve8(directory, entry.name);
+      const relativePath = relative6(appDir, path).split(sep5).join("/");
+      if (IGNORED_DOCUMENTATION_WATCH_PATH.test(relativePath)) continue;
+      paths.add(canonicalPath(path));
+      if (entry.isDirectory()) directories.push(path);
+    }
+  }
+  return paths;
+}
+function canonicalPath(path) {
+  try {
+    return realpathSync3(path);
+  } catch {
+    return resolve8(path);
+  }
+}
+function pathsReferToSameDirectory(left, right) {
+  return canonicalPath(left) === canonicalPath(right);
+}
+function isWithinPath(root, candidate) {
+  if (!root) return false;
+  const path = relative6(resolve8(root), resolve8(candidate));
+  return path !== ".." && !path.startsWith(`..${sep5}`);
+}
+function shouldRebuildDocumentation(appDir, configPath, sourceDir, changed) {
+  appDir = canonicalPath(appDir);
+  configPath = canonicalPath(configPath);
+  sourceDir = canonicalPath(sourceDir);
+  if (changed === configPath || changed === resolve8(appDir, "documentation.tsx") || isWithinPath(sourceDir, changed)) {
+    return true;
+  }
+  if (!isWithinPath(appDir, changed) || !/\.(?:css|js|jsx|ts|tsx)$/i.test(changed)) return false;
+  const relativePath = relative6(appDir, changed).split(sep5).join("/");
+  return !IGNORED_DOCUMENTATION_WATCH_PATH.test(relativePath);
+}
+export {
+  AGENT_SKILLS_SCHEMA,
+  DEFAULT_DOCUMENTATION_CONTEXTUAL_ACTIONS,
+  DEFAULT_DOCUMENTATION_OPENAPI_EXAMPLES,
+  DOCUMENTATION_CONFIG_FILE,
+  DOCUMENTATION_CONTEXTUAL_ACTIONS,
+  DOCUMENTATION_MANIFEST_VERSION,
+  DOCUMENTATION_OPENAPI_SAMPLE_LANGUAGES,
+  DocumentationError,
+  buildDocumentation,
+  createDocumentationSkillArtifacts,
+  deepSpaceDocumentation,
+  documentationSkillName,
+  htmlToText,
+  loadDocumentationConfig,
+  normalizeRoute,
+  parseFrontmatter,
+  parseMarkdown,
+  routeFromRelativePath,
+  slugify,
+  validateDocumentation
+};
+//# sourceMappingURL=documentation.js.map