@takazudo/zudo-doc 5.28.2 → 6.0.1

package/dist/plugins/internal/agent-export/index.js

@@ -0,0 +1,123 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { agentItemKey, agentPageKey } from "../../../agent-docs/identity.js";
+import { AGENT_MAX_ITEMS, AGENT_MAX_MANIFEST_BYTES, AGENT_MAX_SEARCH_INDEX_BYTES } from "../../../agent-docs/limits.js";
+import { collectMdFiles, isExcluded, parseMarkdownFile, slugToUrl, stripMarkdown } from "../../../md-utils/index.js";
+import { chunkAgentText } from "./chunk.js";
+import { normalizeAgentMarkdown } from "./normalize.js";
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+const json = (value) => JSON.stringify(value);
+const order = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).sort(([a], [b]) => order(a, b)).map(([key, item]) => [key, canonical(item)]));
+  return value;
+}
+function prefix(base) {
+  return base === "/" ? "" : `/${base.replace(/^\/+|\/+$/g, "")}`;
+}
+function artifactUrl(options, path) {
+  const pathname = `${prefix(options.base)}/agent/v1/${path}`;
+  return options.siteUrl ? `${options.siteUrl.replace(/\/$/, "")}${pathname}` : pathname;
+}
+function projectAgentCorpus(options) {
+  const roots = [{ code: options.defaultLocale, dir: options.defaultLocaleDir, default: true }, ...(options.locales ?? []).map(({ code, dir }) => ({ code, dir, default: false }))];
+  const seen = /* @__PURE__ */ new Set();
+  const sources = roots.flatMap((root) => collectMdFiles(resolve(root.dir)).flatMap(({ filePath, slug: fileSlug }) => {
+    const parsed = parseMarkdownFile(filePath);
+    if (!parsed || isExcluded(parsed.data)) return [];
+    const slug = parsed.data.slug ?? fileSlug;
+    const url = slugToUrl(slug, root.default ? null : root.code, options.base, options.siteUrl);
+    return [{ root, filePath, parsed, slug, url }];
+  }));
+  const sourceUrls = new Map(sources.map((source) => [source.filePath, source.url]));
+  const documents = sources.map(({ root, filePath, parsed, slug, url }) => {
+    const id = agentPageKey(root.code, slug);
+    if (seen.has(id)) throw new Error(`Duplicate agent page ID: ${id}`);
+    seen.add(id);
+    const normalized = normalizeAgentMarkdown(parsed.content, url, (target) => {
+      try {
+        const source = new URL(target, pathToFileURL(filePath));
+        if (!/\.mdx?$/.test(source.pathname)) return void 0;
+        const page = sourceUrls.get(fileURLToPath(source));
+        return page === void 0 ? void 0 : page + source.search + source.hash;
+      } catch {
+        return void 0;
+      }
+    });
+    const title = parsed.data.title ?? slug;
+    const description = parsed.data.description ?? stripMarkdown(parsed.content).split("\n").find(Boolean) ?? "";
+    const metadata = {
+      locale: root.code,
+      pageId: id,
+      ...description ? { description } : {},
+      ...normalized.unsupportedDynamicContent ? { unsupportedDynamicContent: true } : {}
+    };
+    return {
+      id,
+      key: id,
+      locale: root.code,
+      slug,
+      title,
+      description,
+      url,
+      text: normalized.text,
+      unsupportedDynamicContent: normalized.unsupportedDynamicContent,
+      parts: chunkAgentText(normalized.text, title, url, metadata)
+    };
+  }).sort((a, b) => order(a.locale, b.locale) || order(a.slug, b.slug));
+  const site = { name: options.siteName, url: options.siteUrl ?? "", base: options.base };
+  const locales = roots.map(({ code }) => code);
+  const fingerprint = hash(json(canonical({ schemaVersion: 1, site, defaultLocale: options.defaultLocale, locales, documents })));
+  const pages = /* @__PURE__ */ new Map();
+  const items = /* @__PURE__ */ new Map();
+  const indexed = [];
+  const manifest = { schemaVersion: 1, fingerprint, site, defaultLocale: options.defaultLocale, locales, searchIndex: { url: artifactUrl(options, "search-index.json"), sha256: "" }, documents: [], items: [] };
+  for (const doc of documents) {
+    pages.set(doc.key, doc.text);
+    const itemIds = [];
+    doc.parts.forEach((text, index2) => {
+      const part = index2 + 1;
+      const id = agentItemKey(doc.id, part);
+      itemIds.push(id);
+      const item = { id, title: doc.parts.length === 1 ? doc.title : `${doc.title} (part ${part}/${doc.parts.length})`, text, url: doc.url, metadata: { locale: doc.locale, pageId: doc.id, fingerprint, part, partCount: doc.parts.length, ...doc.description ? { description: doc.description } : {}, ...doc.unsupportedDynamicContent ? { unsupportedDynamicContent: true } : {} } };
+      const bytes = json(item);
+      items.set(id, bytes);
+      indexed.push(item);
+      manifest.items.push({ id, key: id, pageId: doc.id, url: doc.url, artifactUrl: artifactUrl(options, `items/${id}.json`), sha256: hash(bytes), part, partCount: doc.parts.length });
+    });
+    manifest.documents.push({ id: doc.id, key: doc.key, locale: doc.locale, title: doc.title, url: doc.url, markdownUrl: artifactUrl(options, `pages/${doc.key}.md`), itemIds });
+  }
+  if (indexed.length > AGENT_MAX_ITEMS) throw new Error("Agent corpus exceeds the item limit.");
+  const index = { schemaVersion: 1, fingerprint, items: indexed };
+  const indexBytes = json(index);
+  if (Buffer.byteLength(indexBytes) > AGENT_MAX_SEARCH_INDEX_BYTES) throw new Error("Agent search index exceeds the byte limit.");
+  manifest.searchIndex.sha256 = hash(indexBytes);
+  if (Buffer.byteLength(json(manifest)) > AGENT_MAX_MANIFEST_BYTES) throw new Error("Agent manifest exceeds the byte limit.");
+  return { manifest, index, pages, items };
+}
+function emitAgentCorpus(options) {
+  const corpus = projectAgentCorpus(options);
+  const segment = options.copyPublicWithBase === false ? "" : prefix(options.base).slice(1);
+  const root = join(options.outDir, segment, "agent", "v1");
+  rmSync(root, { recursive: true, force: true });
+  mkdirSync(join(root, "items"), { recursive: true });
+  mkdirSync(join(root, "pages"), { recursive: true });
+  const written = [];
+  const write = (path, body) => {
+    const target = join(root, path);
+    writeFileSync(target, body);
+    written.push(target);
+  };
+  write("manifest.json", json(corpus.manifest));
+  write("search-index.json", json(corpus.index));
+  for (const [key, body] of corpus.items) write(`items/${key}.json`, body);
+  for (const [key, body] of corpus.pages) write(`pages/${key}.md`, body);
+  return written;
+}
+export {
+  emitAgentCorpus,
+  projectAgentCorpus
+};

package/dist/plugins/internal/agent-export/normalize.d.ts

@@ -0,0 +1,5 @@
+/** Normalize MDX for a published text corpus without evaluating its modules. */
+export declare function normalizeAgentMarkdown(source: string, pageUrl: string, resolveSourceLink?: (target: string) => string | undefined): {
+    text: string;
+    unsupportedDynamicContent: boolean;
+};

package/dist/plugins/internal/agent-export/normalize.js

@@ -0,0 +1,73 @@
+function normalizeAgentMarkdown(source, pageUrl, resolveSourceLink) {
+  let unsupportedDynamicContent = false;
+  const literals = [];
+  let marker = "\0agent-code:";
+  while (source.includes(marker)) marker += ":";
+  const shield = (value) => `${marker}${literals.push(value) - 1}\0`;
+  let fence;
+  const fenced = [];
+  const lines = source.replace(/\r\n?/g, "\n").split("\n");
+  const prose = [];
+  for (const line of lines) {
+    const match = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
+    if (fence) {
+      fenced.push(line);
+      if (match && match[1][0] === fence[0] && match[1].length >= fence.length && !match[2].trim()) {
+        prose.push(shield(fenced.join("\n")));
+        fenced.length = 0;
+        fence = void 0;
+      }
+    } else if (match) {
+      fence = match[1];
+      fenced.push(line);
+    } else prose.push(line);
+  }
+  if (fenced.length) prose.push(shield(fenced.join("\n")));
+  let text = prose.join("\n");
+  const runs = [...text.matchAll(/`+/g)];
+  let offset = 0;
+  let protectedText = "";
+  for (let i = 0; i < runs.length; i++) {
+    const opening = runs[i];
+    const closingIndex = runs.findIndex((run, j) => j > i && run[0].length === opening[0].length);
+    if (closingIndex < 0) continue;
+    const end = runs[closingIndex].index + opening[0].length;
+    protectedText += text.slice(offset, opening.index) + shield(text.slice(opening.index, end));
+    offset = end;
+    i = closingIndex;
+  }
+  text = protectedText + text.slice(offset);
+  text = text.replace(/\{\/\*[\s\S]*?\*\/\}/g, "");
+  text = text.replace(/^[ \t]*import[ \t]+(?:type[ \t]+)?(?:[\w$]+[ \t]*,[ \t]*)?\{[^}]*\}[ \t]*from[ \t]*["'][^"'\n]+["'][ \t]*;?[ \t]*$/gm, "");
+  text = text.replace(/^\s*(?:import|export)[^\S\n]+.*$/gm, "");
+  const resolveLink = (target) => {
+    if (/^(?:[a-z][a-z\d+.-]*:|\/|\{)/i.test(target)) return target;
+    const sourceUrl = resolveSourceLink?.(target);
+    if (sourceUrl !== void 0) return sourceUrl;
+    try {
+      const absolute = new URL(target, new URL(pageUrl, "https://agent.invalid"));
+      return absolute.origin === "https://agent.invalid" ? absolute.pathname + absolute.search + absolute.hash : absolute.toString();
+    } catch {
+      return target;
+    }
+  };
+  text = text.replace(
+    /(!?\[[^\]]*\]\()(?:<([^>]+)>|([^\s)]+))([^)]*\))/g,
+    (_all, before, angled, plain, after) => shield(before + (angled !== void 0 ? `<${resolveLink(angled)}>` : resolveLink(plain)) + after)
+  );
+  text = text.replace(
+    /^( {0,3}\[[^\]]+\]:[ \t]*)(?:<([^>]+)>|([^\s]+))/gm,
+    (_all, before, angled, plain) => shield(before + (angled !== void 0 ? `<${resolveLink(angled)}>` : resolveLink(plain)))
+  );
+  text = text.replace(/<([A-Z][\w.]*)\b[^>]*>/g, () => {
+    unsupportedDynamicContent = true;
+    return "[Dynamic content unavailable in text export]";
+  });
+  text = text.replace(/<\/([A-Z][\w.]*)\s*>/g, "");
+  text = text.replace(/<\/?[a-z][\w-]*(?=[\s/>])[^>]*>/g, "");
+  for (let i = literals.length - 1; i >= 0; i--) text = text.replaceAll(`${marker}${i}\0`, () => literals[i]);
+  return { text: text.trim(), unsupportedDynamicContent };
+}
+export {
+  normalizeAgentMarkdown
+};

package/dist/plugins/internal/llms-txt/dev-middleware.d.ts

@@ -19,6 +19,12 @@ export interface LlmsTxtDevMiddlewareOptions extends LlmsTxtSiteMeta {
     base: string;
     /** Optional absolute site URL; see `LlmsTxtLoadOptions.siteUrl`. */
     siteUrl?: string;
+    /** Actual default locale code; needed to match agent-export page IDs. */
+    defaultLocale?: string;
+    /** Link slim-index docs to agent-export Markdown artifacts when enabled. */
+    agentExport?: boolean;
+    /** Include the stateless read-only endpoint in the slim index when enabled. */
+    mcp?: boolean;
     /** Default-locale content directory. */
     defaultLocaleDir: string;
     /** Additional locales (e.g. `[{ code: "ja", dir: "src/content/docs-ja" }]`). */

package/dist/plugins/internal/llms-txt/dev-middleware.js

@@ -1,6 +1,6 @@
 import { loadLlmsAssetEntries } from "./assets.js";
 import { generateLlmsFullTxt, generateLlmsTxt } from "./generate.js";
-import { loadDocEntries } from "./load.js";
+import { loadDocEntries, withLlmsBase } from "./load.js";
 const LLMS_KIND_PATTERN = /^(?:\/(.+?))?\/(llms|llms-full)\.txt$/;
 function createLlmsTxtDevMiddleware(options, logger) {
   const meta = {
@@ -13,6 +13,10 @@ function createLlmsTxtDevMiddleware(options, logger) {
   );
   const base = options.base ?? "";
   const siteUrl = options.siteUrl || void 0;
+  const generationOptions = {
+    agentExport: options.agentExport === true,
+    ...options.mcp === true ? { mcpEndpointUrl: withLlmsBase("/mcp", base, siteUrl) } : {}
+  };
   return (req, res, next) => {
     const url = req.url ?? "";
     const match = matchLlmsRoute(stripBase(url, base), localeCodes);
@@ -38,7 +42,8 @@ function createLlmsTxtDevMiddleware(options, logger) {
         contentDir,
         locale: match.locale,
         base,
-        siteUrl
+        siteUrl,
+        ...options.agentExport === true ? { agentExportLocale: match.locale ?? options.defaultLocale ?? "en" } : {}
       });
       const assets = loadLlmsAssetEntries({
         projectRoot: options.projectRoot,
@@ -47,7 +52,7 @@ function createLlmsTxtDevMiddleware(options, logger) {
       }).filter(
         (asset) => match.locale === null ? asset.locale === void 0 : asset.locale === match.locale
       );
-      const body = match.kind === "llms" ? generateLlmsTxt(entries, meta, assets) : generateLlmsFullTxt(entries, meta, assets);
+      const body = match.kind === "llms" ? generateLlmsTxt(entries, meta, assets, generationOptions) : generateLlmsFullTxt(entries, meta, assets);
       res.statusCode = 200;
       res.setHeader("Content-Type", "text/plain; charset=utf-8");
       res.end(body);

package/dist/plugins/internal/llms-txt/emit.js

@@ -2,7 +2,7 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { generateLlmsFullTxt, generateLlmsTxt } from "./generate.js";
 import { loadLlmsAssetEntries } from "./assets.js";
-import { loadDocEntries } from "./load.js";
+import { loadDocEntries, withLlmsBase } from "./load.js";
 function assetsForLocale(assets, locale) {
   return assets.filter(
     (asset) => locale === null ? asset.locale === void 0 : asset.locale === locale
@@ -19,23 +19,36 @@ function emitLlmsTxt(options) {
     locales = [],
     logger,
     projectRoot,
-    assetScan
+    assetScan,
+    defaultLocale,
+    agentExport,
+    mcp
   } = options;
   const meta = { siteName, siteDescription };
   const written = [];
   const assetEntries = loadLlmsAssetEntries({ projectRoot, assetScan, siteUrl });
+  const generationOptions = {
+    agentExport: agentExport === true,
+    ...mcp === true ? { mcpEndpointUrl: withLlmsBase("/mcp", base, siteUrl) } : {}
+  };
   const defaultEntries = loadDocEntries({
     contentDir: defaultLocaleDir,
     locale: null,
     base,
-    siteUrl
+    siteUrl,
+    ...agentExport === true ? { agentExportLocale: defaultLocale ?? "en" } : {}
   });
   mkdirSync(outDir, { recursive: true });
   const defaultIndexPath = join(outDir, "llms.txt");
   const defaultFullPath = join(outDir, "llms-full.txt");
   writeFileSync(
     defaultIndexPath,
-    generateLlmsTxt(defaultEntries, meta, assetsForLocale(assetEntries, null))
+    generateLlmsTxt(
+      defaultEntries,
+      meta,
+      assetsForLocale(assetEntries, null),
+      generationOptions
+    )
   );
   writeFileSync(
     defaultFullPath,
@@ -50,14 +63,18 @@ function emitLlmsTxt(options) {
       contentDir: dir,
       locale: code,
       base,
-      siteUrl
+      siteUrl,
+      ...agentExport === true ? { agentExportLocale: code } : {}
     });
     const localeDir = join(outDir, code);
     mkdirSync(localeDir, { recursive: true });
     const indexPath = join(localeDir, "llms.txt");
     const fullPath = join(localeDir, "llms-full.txt");
     const localeAssets = assetsForLocale(assetEntries, code);
-    writeFileSync(indexPath, generateLlmsTxt(localeEntries, meta, localeAssets));
+    writeFileSync(
+      indexPath,
+      generateLlmsTxt(localeEntries, meta, localeAssets, generationOptions)
+    );
     writeFileSync(fullPath, generateLlmsFullTxt(localeEntries, meta, localeAssets));
     written.push(indexPath, fullPath);
     logger?.info(

package/dist/plugins/internal/llms-txt/generate.d.ts

@@ -10,11 +10,17 @@
  * — the file shape is part of the project's public surface.
  */
 import { type LlmsAssetEntry, type LlmsDocEntry, type LlmsTxtSiteMeta } from "./types.js";
+export interface LlmsTxtGenerationOptions {
+    /** Replace eligible document links with their per-page Markdown artifacts. */
+    agentExport?: boolean;
+    /** Add an MCP discovery section with this base-aware endpoint URL. */
+    mcpEndpointUrl?: string;
+}
 /**
  * Slim index — site header followed by a markdown bullet per page with
  * `[title](url): description`.
  */
-export declare function generateLlmsTxt(entries: readonly LlmsDocEntry[], meta: LlmsTxtSiteMeta, assets?: readonly LlmsAssetEntry[]): string;
+export declare function generateLlmsTxt(entries: readonly LlmsDocEntry[], meta: LlmsTxtSiteMeta, assets?: readonly LlmsAssetEntry[], options?: LlmsTxtGenerationOptions): string;
 /**
  * Full content concatenation — site header followed by every page's
  * stripped body separated by `---` rules.

package/dist/plugins/internal/llms-txt/generate.js

@@ -33,7 +33,7 @@ function renderAssetBody(entry) {
   return `${content}
 ${TRUNCATED_ASSET_MARKER}`;
 }
-function generateLlmsTxt(entries, meta, assets = []) {
+function generateLlmsTxt(entries, meta, assets = [], options = {}) {
   const lines = [];
   lines.push(`# ${meta.siteName}`);
   lines.push("");
@@ -42,7 +42,8 @@ function generateLlmsTxt(entries, meta, assets = []) {
   lines.push("## Docs");
   lines.push("");
   for (const entry of entries) {
-    lines.push(`- [${entry.title}](${entry.url}): ${entry.description}`);
+    const url = options.agentExport && entry.agentMarkdownUrl ? entry.agentMarkdownUrl : entry.url;
+    lines.push(`- [${entry.title}](${url}): ${entry.description}`);
   }
   lines.push("");
   if (assets.length > 0) {
@@ -53,6 +54,12 @@ function generateLlmsTxt(entries, meta, assets = []) {
     }
     lines.push("");
   }
+  if (options.mcpEndpointUrl !== void 0) {
+    lines.push("## MCP");
+    lines.push("");
+    lines.push(`- [Read-only MCP endpoint](${options.mcpEndpointUrl})`);
+    lines.push("");
+  }
   return lines.join("\n");
 }
 function generateLlmsFullTxt(entries, meta, assets = []) {

package/dist/plugins/internal/llms-txt/load.d.ts

@@ -9,6 +9,8 @@
  * surface is unchanged.
  */
 import type { LlmsDocEntry, LlmsTxtLoadOptions } from "./types.js";
+/** Resolve an artifact path with the same base/site URL rules as agent-export. */
+export declare function withLlmsBase(path: string, base: string, siteUrl?: string): string;
 export { collectMdFiles, isExcluded, parseMarkdownFile, slugToUrl, } from "../../../md-utils/index.js";
 /**
  * Build the sorted {@link LlmsDocEntry} list for a single content root.

package/dist/plugins/internal/llms-txt/load.js

@@ -6,7 +6,13 @@ import {
   slugToUrl,
   stripMarkdown
 } from "../../../md-utils/index.js";
+import { agentPageKey } from "../../../agent-docs/identity.js";
 import { stripImportsAndJsx } from "./strip.js";
+function withLlmsBase(path, base, siteUrl) {
+  const basePrefix = base === "/" ? "" : `/${base.replace(/^\/+|\/+$/g, "")}`;
+  const pathname = `${basePrefix}/${path.replace(/^\/+/, "")}`;
+  return siteUrl ? `${siteUrl.replace(/\/$/, "")}${pathname}` : pathname;
+}
 import {
   collectMdFiles as collectMdFiles2,
   isExcluded as isExcluded2,
@@ -14,7 +20,7 @@ import {
   slugToUrl as slugToUrl2
 } from "../../../md-utils/index.js";
 function loadDocEntries(options) {
-  const { contentDir, locale, base, siteUrl } = options;
+  const { contentDir, locale, base, siteUrl, agentExportLocale } = options;
   const absDir = resolve(contentDir);
   const files = collectMdFiles(absDir);
   const entries = [];
@@ -29,13 +35,22 @@ function loadDocEntries(options) {
       const stripped = stripMarkdown(content);
       description = stripped.split("\n").find((l) => l.trim().length > 0) ?? "";
     }
-    entries.push({
+    const entry = {
       title: data.title ?? slug,
       description,
       url: slugToUrl(slug, locale, base, siteUrl),
       content: stripImportsAndJsx(content),
       sidebarPosition: data.sidebar_position
-    });
+    };
+    if (agentExportLocale !== void 0) {
+      const pageId = agentPageKey(agentExportLocale, slug);
+      entry.agentMarkdownUrl = withLlmsBase(
+        `/agent/v1/pages/${pageId}.md`,
+        base,
+        siteUrl
+      );
+    }
+    entries.push(entry);
   }
   entries.sort((a, b) => {
     const posA = a.sidebarPosition ?? Number.MAX_SAFE_INTEGER;
@@ -49,5 +64,6 @@ export {
   isExcluded2 as isExcluded,
   loadDocEntries,
   parseMarkdownFile2 as parseMarkdownFile,
-  slugToUrl2 as slugToUrl
+  slugToUrl2 as slugToUrl,
+  withLlmsBase
 };

package/dist/plugins/internal/llms-txt/types.d.ts

@@ -41,6 +41,8 @@ export interface LlmsDocEntry {
     content: string;
     /** `frontmatter.sidebar_position`, undefined when not declared. */
     sidebarPosition: number | undefined;
+    /** Base-aware Markdown artifact URL; present only when agent export is enabled. */
+    agentMarkdownUrl?: string;
 }
 /**
  * One generated asset-viewer page in the llms outputs.
@@ -101,6 +103,8 @@ export interface LlmsTxtLoadOptions {
      * empty, URLs are returned path-only for projects that omit `siteUrl`.
      */
     siteUrl?: string;
+    /** Actual locale code used by the agent export page identity, including for the default locale. */
+    agentExportLocale?: string;
 }
 /**
  * Top-level options for {@link emitLlmsTxt}. The current zfb plugin supplies
@@ -113,6 +117,12 @@ export interface LlmsTxtEmitOptions extends LlmsTxtSiteMeta {
     base: string;
     /** Optional absolute site URL; see {@link LlmsTxtLoadOptions}. */
     siteUrl?: string;
+    /** Actual default locale code; needed to match agent-export page IDs. */
+    defaultLocale?: string;
+    /** Link slim-index docs to agent-export Markdown artifacts when enabled. */
+    agentExport?: boolean;
+    /** Include the stateless read-only endpoint in the slim index when enabled. */
+    mcp?: boolean;
     /**
      * Default-locale content directory. Emitted at `outDir/llms.txt` and
      * `outDir/llms-full.txt`.

package/dist/plugins/routes.js

@@ -27,6 +27,10 @@ function deriveRoutes(settings, options) {
   const hasVersions = Array.isArray(settings.versions) && settings.versions.length > 0;
   const docTags = settings.docTags === true;
   const aiAssistant = settings.aiAssistant === true;
+  if (settings.mcp === true) {
+    const base = `/${String(settings.base ?? "").split("/").filter(Boolean).join("/")}`.replace(/\/$/, "");
+    routes.push({ pattern: `${base}/mcp`, entrypoint: "@takazudo/zudo-doc/routes/mcp", opts: { prerender: false }, includedInDtpShadowDiagnostic: false });
+  }
   if (options.packageOwnedRoutes === false) {
     if (options.assetViewer === true) {
       routes.push({

package/dist/preset.d.ts

@@ -4,10 +4,10 @@
  * `zudoDocPreset()` returns the zfb config fragment that every zudo-doc
  * project previously hand-wrote in its `zfb.config.ts` (collections loop,
  * markdown.features, class-mode codeHighlight, resolveMarkdownLinks,
- * stripMdExt, trailingSlash, minifyHtml, and the integration plugins array). The host
- * config spreads this fragment into `defineConfig` and supplies only the
- * project-specific shell fields it still owns (`framework`, `port`,
- * `tailwind`, `bundle`, `base`, `adapter`).
+ * stripMdExt, trailingSlash, minifyHtml, integration plugins, and the
+ * package-owned wind preset). The host config spreads this fragment into
+ * `defineConfig` and supplies project-specific shell fields (`port`, `bundle`,
+ * `base`, `adapter`, and an optional top-level `wind` override).
  *
  * ──────────────────────────────────────────────────────────────────────────
  * NODE-BUILTIN-FREE EVAL GRAPH (non-negotiable — guarded by a unit test)
@@ -29,13 +29,14 @@
  *     specifier and dispatches lifecycle hooks against it; importing the
  *     plugin modules here would pull their `node:fs` / `node:path` graph into
  *     the config eval.
- *   - The only runtime dependency is `zod` (for `z.toJSONSchema`), which
- *     bundles cleanly under `--platform=neutral` (verified: zero `node:*`).
+ *   - Runtime dependencies are `zod` (for `z.toJSONSchema`) and zfb's
+ *     `definePreset` helper (for the package-owned wind fragment). Both bundle
+ *     cleanly under `--platform=neutral` (verified: zero `node:*`).
  */
 import { z } from "zod";
+import type { DirectiveSpec, ZfbConfig } from "@takazudo/zfb/config";
 import type { ColorScheme } from "./color-scheme-utils.js";
 import type { AssetViewerIndexingConfig, TagVocabularyEntry, FaviconConfig, HomeConfig } from "./settings.js";
-import type { DirectiveSpec } from "@takazudo/zfb/config";
 /** A single locale's content directory (`settings.locales[code]`). */
 export interface PresetLocaleConfig {
     dir: string;
@@ -118,6 +119,10 @@ export interface PresetSettings {
     transclude?: boolean;
     onBrokenMarkdownLinks: "warn" | "error" | "ignore";
     llmsTxt?: boolean;
+    /** Generate the package-owned static agent documentation feed. */
+    agentExport?: boolean;
+    /** Enable the stateless read-only MCP endpoint; requires `agentExport: true`. */
+    mcp?: boolean;
     changelogs?: PresetChangelogConfig[] | false;
     /** Metadata fields shown in the doc metadata area. */
     docMetainfoFields?: Array<"created" | "updated" | "author">;
@@ -305,14 +310,21 @@ export interface PresetMarkdown {
         footnoteDefinition: boolean;
     };
 }
+/** MCP-only bundler options required for SDK CommonJS dependency resolution. */
+export interface PresetBundle {
+    mainFields: string[];
+}
 export interface PresetCodeHighlight {
     mode: "class";
     defaultStylesheet: true;
 }
 /** The config fragment returned by {@link zudoDocPreset}. */
 export interface ZudoDocPresetResult {
+    presets: Partial<ZfbConfig>[];
     collections: PresetCollection[];
     plugins: PresetPlugin[];
+    /** Present only when MCP is enabled. */
+    bundle?: PresetBundle;
     markdown: PresetMarkdown;
     codeHighlight: PresetCodeHighlight;
     resolveMarkdownLinks: PresetResolveMarkdownLinks;
@@ -327,9 +339,7 @@ export interface ZudoDocPresetResult {
  *
  * ```ts
  * export default defineConfig({
- *   framework: "preact",
  *   port: 4321,
- *   tailwind: { enabled: true },
  *   bundle: { exclude: [...] },
  *   base: settings.base,
  *   adapter: "@takazudo/zfb-adapter-cloudflare",

package/dist/preset.js

@@ -4,9 +4,11 @@ import {
   assertNoEmptyStringFaviconOrLogo,
   assertZdtpBundlingConsistent,
   assertValidSearchMaxBodyLength,
+  assertAgentDocsConsistent,
   resolvesBundleZdtp,
   warnAmbiguousDropdownCategoryMatch
 } from "./config-assertions/index.js";
+import { zudoDocWindPreset } from "./wind/index.js";
 function zudoDocPreset({
   settings,
   buildDocsSchema,
@@ -19,11 +21,14 @@ function zudoDocPreset({
   assertNoEmptyStringFaviconOrLogo(settings);
   assertZdtpBundlingConsistent(settings);
   assertValidSearchMaxBodyLength(settings.searchMaxBodyLength);
+  assertAgentDocsConsistent(settings);
   warnAmbiguousDropdownCategoryMatch(settings.headerNav);
   const docsSchemaJson = z.toJSONSchema(buildDocsSchema());
   return {
+    presets: [zudoDocWindPreset],
     collections: buildCollections(settings, docsSchemaJson),
     plugins: buildPlugins(settings, { translations, tagVocabulary, colorSchemes }),
+    ...settings.mcp === true ? { bundle: { mainFields: ["module", "main"] } } : {},
     markdown: {
       features: buildMarkdownFeatures(settings, directiveVocabulary),
       ...settings.cjkFriendly !== void 0 ? { cjkFriendly: settings.cjkFriendly } : {},
@@ -183,7 +188,7 @@ function buildPlugins(settings, routeContext) {
     // the route catalog from `settings.locales` / `settings.versions`. Listed
     // FIRST so an injected route is registered before the other plugins'
     // preBuild work runs (ordering is cosmetic — injection happens in `setup`).
-    ...effectivePackageOwnedRoutes || assetViewer || homeIntro ? [
+    ...effectivePackageOwnedRoutes || assetViewer || homeIntro || settings.mcp === true ? [
       {
         name: "@takazudo/zudo-doc/plugins/routes",
         options: {
@@ -285,12 +290,26 @@ function buildPlugins(settings, routeContext) {
           siteDescription: settings.siteDescription,
           base: settings.base,
           siteUrl: settings.siteUrl,
+          defaultLocale: settings.defaultLocale ?? "en",
+          agentExport: settings.agentExport === true,
+          mcp: settings.mcp === true,
           defaultLocaleDir: settings.docsDir,
           locales: localeArray,
           assetScan
         }
       }
     ] : [],
+    ...settings.agentExport ? [{
+      name: "@takazudo/zudo-doc/plugins/agent-export",
+      options: {
+        siteName: settings.siteName,
+        siteUrl: settings.siteUrl,
+        base: settings.base,
+        defaultLocale: settings.defaultLocale ?? "en",
+        defaultLocaleDir: settings.docsDir,
+        locales: localeArray
+      }
+    }] : [],
     ...Array.isArray(settings.changelogs) && settings.changelogs.length > 0 ? [
       {
         name: "@takazudo/zudo-doc/plugins/changelog",

package/dist/route-context-payload/index.js

@@ -1,4 +1,4 @@
-import { DEFAULT_SETTINGS } from "../config.js";
+import { DEFAULT_SETTINGS } from "../settings-defaults.js";
 import { defaultTranslations } from "../i18n-defaults/index.js";
 import { defaultColorSchemes } from "../color-schemes-defaults/index.js";
 import { buildThemePackRegistry } from "../theme-packs-registry/build-registry.js";

package/dist/routes/404.d.ts

@@ -1,7 +1,6 @@
 /** @jsxRuntime automatic */
-/** @jsxImportSource preact */
-import type { JSX } from "preact";
+import type { Child } from "@takazudo/zfb/zudo-react";
 export declare const frontmatter: {
     title: string;
 };
-export default function NotFoundPage(): JSX.Element;
+export default function NotFoundPage(): Child;

package/dist/routes/404.js

@@ -1,4 +1,4 @@
-import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
+import { Fragment, jsx, jsxs } from "@takazudo/zfb/zudo-react/jsx-runtime";
 import { DocLayoutWithDefaults } from "../doclayout/index.js";
 import { resolveThemePackSsrSlug } from "../theme/theme-pack-provider.js";
 import { settings, defaultLocale, withBase, themePackRegistry } from "./_context.js";