@takazudo/zudo-doc 0.2.20 → 0.2.22

package/dist/nav-source-docs/index.js

@@ -0,0 +1,123 @@
+import { memoizeDerived } from "../nav-source-cache/index.js";
+import { mergeLocaleDocs } from "../locale-merge/index.js";
+function optionSig(o) {
+  return `dlo=${o.applyDefaultLocaleOnlyFilter ? 1 : 0};ku=${o.keepUnlisted ? 1 : 0}`;
+}
+const EMPTY_SLUG_SET = /* @__PURE__ */ new Set();
+function createNavSourceDocs(ctx) {
+  const {
+    defaultLocale,
+    docsDir,
+    getVersions,
+    getLocaleConfig,
+    loadCategoryMeta,
+    isNavVisible,
+    isDefaultLocaleOnlyPath,
+    stableDocs
+  } = ctx;
+  const mergedCategoryMetaCache = /* @__PURE__ */ new Map();
+  function stableMergeCategoryMeta(baseDir, localeDir) {
+    const key = `${baseDir}
+${localeDir}`;
+    const cached = mergedCategoryMetaCache.get(key);
+    if (cached) return cached;
+    const merged = new Map([
+      ...loadCategoryMeta(baseDir),
+      ...loadCategoryMeta(localeDir)
+    ]);
+    mergedCategoryMetaCache.set(key, merged);
+    return merged;
+  }
+  function stableNavDocs(docs) {
+    return memoizeDerived(
+      [docs],
+      "navVisible",
+      () => docs.filter(isNavVisible)
+    );
+  }
+  const EMPTY_DOCS = [];
+  function resolveVersionedLocaleSource(versionSlug, versionDocsDir, lang, localeDir, options = {}) {
+    const sig = optionSig(options);
+    const baseDocs = stableDocs(`docs-v-${versionSlug}`);
+    const localeDocs = localeDir ? stableDocs(`docs-v-${versionSlug}-${lang}`) : EMPTY_DOCS;
+    const merged = memoizeDerived(
+      localeDir ? [baseDocs, localeDocs] : [baseDocs],
+      `vmerge;${lang};${sig}`,
+      () => mergeLocaleDocs({
+        baseDocs,
+        localeDocs,
+        applyDefaultLocaleOnlyFilter: options.applyDefaultLocaleOnlyFilter,
+        keepUnlisted: options.keepUnlisted,
+        isDefaultLocaleOnlyPath
+      })
+    );
+    const docs = merged.docs;
+    const resolvedVersionDocsDir = versionDocsDir ?? docsDir;
+    const categoryMeta = localeDir ? stableMergeCategoryMeta(resolvedVersionDocsDir, localeDir) : loadCategoryMeta(resolvedVersionDocsDir);
+    const navDocs = stableNavDocs(docs);
+    return { docs, navDocs, categoryMeta, localeSlugSet: merged.localeSlugSet };
+  }
+  function resolveNavSource(lang, currentVersion, options = {}) {
+    const sig = optionSig(options);
+    if (currentVersion) {
+      const versions = getVersions();
+      const versionConfig = Array.isArray(versions) ? versions.find((v) => v.slug === currentVersion) : void 0;
+      const localeDir2 = versionConfig?.locales?.[lang]?.dir;
+      if (lang !== defaultLocale && localeDir2) {
+        return resolveVersionedLocaleSource(
+          currentVersion,
+          versionConfig?.docsDir,
+          lang,
+          localeDir2,
+          options
+        );
+      }
+      const docs2 = stableDocs(`docs-v-${currentVersion}`);
+      const categoryMeta2 = loadCategoryMeta(
+        versionConfig?.docsDir ?? docsDir
+      );
+      const navDocs2 = stableNavDocs(docs2);
+      return { docs: docs2, navDocs: navDocs2, categoryMeta: categoryMeta2, localeSlugSet: EMPTY_SLUG_SET };
+    }
+    if (lang === defaultLocale) {
+      const docs2 = stableDocs("docs");
+      const categoryMeta2 = loadCategoryMeta(docsDir);
+      const navDocs2 = stableNavDocs(docs2);
+      return { docs: docs2, navDocs: navDocs2, categoryMeta: categoryMeta2, localeSlugSet: EMPTY_SLUG_SET };
+    }
+    const baseDocs = stableDocs("docs");
+    const localeDocs = stableDocs(`docs-${lang}`);
+    const merged = memoizeDerived(
+      [baseDocs, localeDocs],
+      `merge;${sig}`,
+      () => mergeLocaleDocs({
+        baseDocs,
+        localeDocs,
+        applyDefaultLocaleOnlyFilter: options.applyDefaultLocaleOnlyFilter,
+        keepUnlisted: options.keepUnlisted,
+        isDefaultLocaleOnlyPath
+      })
+    );
+    const docs = merged.docs;
+    const localeDir = getLocaleConfig(lang)?.dir ?? docsDir;
+    const categoryMeta = stableMergeCategoryMeta(docsDir, localeDir);
+    const navDocs = stableNavDocs(docs);
+    return { docs, navDocs, categoryMeta, localeSlugSet: merged.localeSlugSet };
+  }
+  function loadNavSourceDocs(lang, currentVersion) {
+    return resolveNavSource(lang, currentVersion, {
+      applyDefaultLocaleOnlyFilter: true,
+      keepUnlisted: true
+    });
+  }
+  return {
+    resolveNavSource,
+    resolveVersionedLocaleSource,
+    loadNavSourceDocs,
+    stableMergeCategoryMeta,
+    stableNavDocs
+  };
+}
+export {
+  createNavSourceDocs
+};

package/dist/page-loading/index.d.ts

@@ -1,2 +1 @@
-export { PAGE_LOADING_OVERLAY_ID, default as PageLoadingOverlay, PageLoadingOverlayProps, buildPageLoadingOverlayBootstrap } from './page-loading-overlay.js';
-import 'preact';
+export { default as PageLoadingOverlay, PAGE_LOADING_OVERLAY_ID, buildPageLoadingOverlayBootstrap, type PageLoadingOverlayProps, } from "./page-loading-overlay.js";

package/dist/page-loading/page-loading-overlay.d.ts

@@ -1,10 +1,8 @@
-import * as preact from 'preact';
-
 /** @jsxRuntime automatic */
 /** @jsxImportSource preact */
 /** Default `id` for the overlay element. Stable so test rigs can target it. */
-declare const PAGE_LOADING_OVERLAY_ID = "page-loading-overlay";
-interface PageLoadingOverlayProps {
+export declare const PAGE_LOADING_OVERLAY_ID = "page-loading-overlay";
+export interface PageLoadingOverlayProps {
     /**
      * Override the DOM `id` used by both the overlay element and the
      * bootstrap script. Useful when multiple overlays could co-exist on
@@ -16,7 +14,7 @@ interface PageLoadingOverlayProps {
  * Build the inline bootstrap script body. Exported so test rigs can
  * inspect / snapshot it without rendering the component.
  */
-declare function buildPageLoadingOverlayBootstrap(overlayId: string): string;
+export declare function buildPageLoadingOverlayBootstrap(overlayId: string): string;
 /**
  * Full-page loading overlay shown during view-transition navigations.
  *
@@ -30,6 +28,4 @@ declare function buildPageLoadingOverlayBootstrap(overlayId: string): string;
  * element-permitted-content and fails html-validate (same fix applied to the
  * version-switcher in zudolab/zudo-doc#1505; regression caught in W2A #1543).
  */
-declare function PageLoadingOverlay({ id, }?: PageLoadingOverlayProps): preact.JSX.Element;
-
-export { PAGE_LOADING_OVERLAY_ID, type PageLoadingOverlayProps, buildPageLoadingOverlayBootstrap, PageLoadingOverlay as default };
+export default function PageLoadingOverlay({ id, }?: PageLoadingOverlayProps): import("preact").JSX.Element;

package/dist/plugins/claude-resources.d.ts

@@ -0,0 +1,3 @@
+import type { ZfbPlugin } from "@takazudo/zfb/plugins";
+declare const plugin: ZfbPlugin;
+export default plugin;

package/dist/plugins/claude-resources.js

@@ -0,0 +1,27 @@
+import { runClaudeResourcesPreStep } from "../integrations/claude-resources/index.js";
+const PLUGIN_NAME = "@takazudo/zudo-doc-claude-resources";
+const plugin = {
+  name: PLUGIN_NAME,
+  async preBuild(ctx) {
+    const claudeDir = ctx.options["claudeDir"];
+    if (typeof claudeDir !== "string" || claudeDir.length === 0) {
+      throw new Error(
+        `[${PLUGIN_NAME}] preBuild: options.claudeDir must be a non-empty string (got ${JSON.stringify(claudeDir)})`
+      );
+    }
+    const projectRootOpt = ctx.options["projectRoot"];
+    const docsDirOpt = ctx.options["docsDir"];
+    const result = await runClaudeResourcesPreStep({
+      claudeDir,
+      projectRoot: typeof projectRootOpt === "string" ? projectRootOpt : ctx.projectRoot,
+      docsDir: typeof docsDirOpt === "string" ? docsDirOpt : "src/content/docs"
+    });
+    ctx.logger.info(
+      `claude-resources: ${result.claudemd} CLAUDE.md, ${result.commands} commands, ${result.skills} skills, ${result.agents} agents`
+    );
+  }
+};
+var claude_resources_default = plugin;
+export {
+  claude_resources_default as default
+};

package/dist/plugins/connect-adapter.d.ts

@@ -0,0 +1,31 @@
+import type { ZfbDevMiddlewareRequest, ZfbDevMiddlewareResponse } from "@takazudo/zfb/plugins";
+/**
+ * Connect-style middleware: `(req, res, next) => void`.
+ * The req/res parameters are typed as `any` here because this adapter
+ * intentionally passes a plain-object shim that structurally satisfies the
+ * subset of `IncomingMessage` / `ServerResponse` that the v2 integration
+ * middlewares actually access — not the full Node.js types.
+ */
+type ConnectMiddleware = (req: any, res: any, next: (err?: unknown) => void) => void;
+/**
+ * Convert a Connect-style middleware to a zfb devMiddleware handler.
+ * The returned async function takes a `ZfbDevMiddlewareRequest` and
+ * returns either `undefined` (passthrough — zfb falls through to its
+ * built-in routes) or a `ZfbDevMiddlewareResponse` envelope.
+ *
+ * Behaviour:
+ *
+ *   - `next()` from the middleware → resolves with `undefined`
+ *     (passthrough).
+ *   - `res.end(body)` → resolves with `{ status, headers, body }`.
+ *     `status` defaults to 200 if the middleware didn't set one,
+ *     mirroring Node's `ServerResponse` default.
+ *   - `next(err)` or a thrown error → rejects so the host surfaces a
+ *     500 with the error message the same way it does for any other
+ *     plugin throw.
+ *   - Binary bodies (Buffer / Uint8Array) → encoded as base64 and
+ *     flagged `bodyEncoding: "base64"` so the JSON envelope round-trip
+ *     stays loss-less.
+ */
+export declare function connectToZfbHandler(middleware: ConnectMiddleware): (zfbReq: ZfbDevMiddlewareRequest) => Promise<ZfbDevMiddlewareResponse | undefined>;
+export {};

package/dist/plugins/connect-adapter.js

@@ -0,0 +1,78 @@
+import { Buffer } from "node:buffer";
+function connectToZfbHandler(middleware) {
+  return (zfbReq) => {
+    return new Promise((resolveResponse, rejectResponse) => {
+      const req = {
+        method: zfbReq.method,
+        url: zfbReq.url,
+        headers: zfbReq.headers ?? {}
+      };
+      let statusCode = 200;
+      const headers = {};
+      let settled = false;
+      const finish = (body) => {
+        if (settled) return;
+        settled = true;
+        const normalisedHeaders = {};
+        for (const [k, v] of Object.entries(headers)) {
+          normalisedHeaders[k.toLowerCase()] = String(v);
+        }
+        if (Buffer.isBuffer(body) || body instanceof Uint8Array) {
+          resolveResponse({
+            status: statusCode,
+            headers: normalisedHeaders,
+            body: Buffer.from(body).toString("base64"),
+            bodyEncoding: "base64"
+          });
+          return;
+        }
+        resolveResponse({
+          status: statusCode,
+          headers: normalisedHeaders,
+          body: body == null ? "" : String(body),
+          bodyEncoding: "utf8"
+        });
+      };
+      const res = {
+        get statusCode() {
+          return statusCode;
+        },
+        set statusCode(v) {
+          statusCode = v;
+        },
+        setHeader(name, value) {
+          headers[name.toLowerCase()] = String(value);
+        },
+        getHeader(name) {
+          return headers[name.toLowerCase()];
+        },
+        get headersSent() {
+          return settled;
+        },
+        end(body) {
+          finish(body);
+        }
+      };
+      const next = (err) => {
+        if (settled) return;
+        if (err) {
+          settled = true;
+          rejectResponse(err instanceof Error ? err : new Error(String(err)));
+          return;
+        }
+        settled = true;
+        resolveResponse(void 0);
+      };
+      try {
+        middleware(req, res, next);
+      } catch (err) {
+        if (settled) return;
+        settled = true;
+        rejectResponse(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  };
+}
+export {
+  connectToZfbHandler
+};

package/dist/plugins/doc-history.d.ts

@@ -0,0 +1,3 @@
+import type { ZfbPlugin } from "@takazudo/zfb/plugins";
+declare const plugin: ZfbPlugin;
+export default plugin;

package/dist/plugins/doc-history.js

@@ -0,0 +1,54 @@
+import {
+  runDocHistoryMetaStep,
+  runDocHistoryPostBuild,
+  createDocHistoryDevMiddleware
+} from "../integrations/doc-history/index.js";
+import { connectToZfbHandler } from "./connect-adapter.js";
+import { getBasePrefix } from "./plugin-utils.js";
+const plugin = {
+  name: "doc-history",
+  async preBuild(ctx) {
+    const { docsDir, locales } = ctx.options;
+    if (locales != null) {
+      for (const [key, entry] of Object.entries(locales)) {
+        if (entry == null || typeof entry !== "object" || typeof entry["dir"] !== "string" || entry["dir"].length === 0) {
+          throw new Error(
+            `[doc-history] invalid locales entry "${key}": expected { dir: string }`
+          );
+        }
+      }
+    }
+    await runDocHistoryMetaStep({
+      projectRoot: ctx.projectRoot,
+      docsDir: typeof docsDir === "string" ? docsDir : "src/content/docs",
+      locales: locales != null ? locales : void 0
+    });
+  },
+  async postBuild(ctx) {
+    try {
+      await runDocHistoryPostBuild(ctx.options, {
+        outDir: ctx.outDir,
+        logger: ctx.logger
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (ctx.logger?.warn) {
+        ctx.logger.warn(`[doc-history] postBuild failed (non-fatal): ${msg}`);
+      } else {
+        console.warn(`[doc-history] postBuild failed (non-fatal): ${msg}`);
+      }
+    }
+  },
+  devMiddleware(ctx) {
+    const middleware = createDocHistoryDevMiddleware(
+      ctx.options,
+      ctx.logger
+    );
+    const basePrefix = getBasePrefix(ctx.options["base"]);
+    ctx.register(`${basePrefix}/doc-history`, connectToZfbHandler(middleware));
+  }
+};
+var doc_history_default = plugin;
+export {
+  doc_history_default as default
+};

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

@@ -0,0 +1,3 @@
+import type { ZfbPlugin } from "@takazudo/zfb/plugins";
+declare const plugin: ZfbPlugin;
+export default plugin;

package/dist/plugins/llms-txt.js

@@ -0,0 +1,48 @@
+import { emitLlmsTxt, createLlmsTxtDevMiddleware } from "../integrations/llms-txt/index.js";
+import { connectToZfbHandler } from "./connect-adapter.js";
+import { getBasePrefix } from "./plugin-utils.js";
+const plugin = {
+  name: "llms-txt",
+  async postBuild(ctx) {
+    await emitLlmsTxt({
+      ...ctx.options,
+      outDir: ctx.outDir,
+      // siteUrl is normalised to undefined when falsy because the runner
+      // switches between absolute and root-relative URLs based on its
+      // presence (matches legacy Astro behaviour).
+      siteUrl: ctx.options["siteUrl"] || void 0,
+      logger: ctx.logger
+    });
+  },
+  devMiddleware(ctx) {
+    const middleware = createLlmsTxtDevMiddleware(
+      ctx.options,
+      ctx.logger
+    );
+    const handler = connectToZfbHandler(middleware);
+    const basePrefix = getBasePrefix(ctx.options["base"]);
+    ctx.register(`${basePrefix}/llms.txt`, handler);
+    ctx.register(`${basePrefix}/llms-full.txt`, handler);
+    const locales = ctx.options["locales"];
+    if (Array.isArray(locales)) {
+      for (const locale of locales) {
+        if (locale && typeof locale === "object" && typeof locale["code"] === "string") {
+          const code = locale["code"];
+          ctx.register(`${basePrefix}/${code}/llms.txt`, handler);
+          ctx.register(`${basePrefix}/${code}/llms-full.txt`, handler);
+        } else {
+          const repr = JSON.stringify(locale);
+          if (ctx.logger?.warn) {
+            ctx.logger.warn(`[llms-txt] skipping malformed locale entry (expected { code: string }): ${repr}`);
+          } else {
+            console.warn(`[llms-txt] skipping malformed locale entry (expected { code: string }): ${repr}`);
+          }
+        }
+      }
+    }
+  }
+};
+var llms_txt_default = plugin;
+export {
+  llms_txt_default as default
+};

package/dist/plugins/plugin-utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Remove a trailing slash from a string. Returns an empty string for any
+ * empty or non-string input.
+ */
+export declare function stripTrailingSlash(s: string): string;
+/**
+ * Derive the base prefix to prepend to registered dev-middleware routes.
+ *
+ * zfb's `register(path, handler)` matches against the FULL request URL (no
+ * base-stripping), so for a non-root base (e.g. "/my-docs/") the caller must
+ * register the full base-prefixed route. For `base="/"` the prefix is empty
+ * and the caller's path is used as-is.
+ *
+ * @param base - The `base` field from the plugin's `ctx.options` (may be
+ *               undefined/non-string if not set by the host config).
+ */
+export declare function getBasePrefix(base: unknown): string;

package/dist/plugins/plugin-utils.js

@@ -0,0 +1,11 @@
+function stripTrailingSlash(s) {
+  if (typeof s !== "string" || s.length === 0) return "";
+  return s.endsWith("/") ? s.slice(0, -1) : s;
+}
+function getBasePrefix(base) {
+  return stripTrailingSlash(typeof base === "string" ? base : "");
+}
+export {
+  getBasePrefix,
+  stripTrailingSlash
+};

package/dist/plugins/search-index.d.ts

@@ -0,0 +1,3 @@
+import type { ZfbPlugin } from "@takazudo/zfb/plugins";
+declare const plugin: ZfbPlugin;
+export default plugin;

package/dist/plugins/search-index.js

@@ -0,0 +1,24 @@
+import { emitSearchIndex, createSearchIndexDevMiddleware } from "../integrations/search-index/index.js";
+import { connectToZfbHandler } from "./connect-adapter.js";
+import { getBasePrefix } from "./plugin-utils.js";
+const plugin = {
+  name: "search-index",
+  async postBuild(ctx) {
+    await emitSearchIndex({
+      ...ctx.options,
+      outDir: ctx.outDir,
+      logger: ctx.logger
+    });
+  },
+  devMiddleware(ctx) {
+    const middleware = createSearchIndexDevMiddleware(
+      ctx.options
+    );
+    const basePrefix = getBasePrefix(ctx.options["base"]);
+    ctx.register(`${basePrefix}/search-index.json`, connectToZfbHandler(middleware));
+  }
+};
+var search_index_default = plugin;
+export {
+  search_index_default as default
+};

package/dist/preset.d.ts

@@ -0,0 +1,152 @@
+/**
+ * `@takazudo/zudo-doc/preset` — the package-first config preset.
+ *
+ * `zudoDocPreset()` returns the zfb config fragment that every zudo-doc
+ * project previously hand-wrote in its `zfb.config.ts` (collections loop,
+ * markdown.features, dual-theme codeHighlight, resolveMarkdownLinks,
+ * stripMdExt, trailingSlash, 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`).
+ *
+ * ──────────────────────────────────────────────────────────────────────────
+ * NODE-BUILTIN-FREE EVAL GRAPH (non-negotiable — guarded by a unit test)
+ * ──────────────────────────────────────────────────────────────────────────
+ * zfb evaluates the config module through esbuild with `--platform=neutral`
+ * (mirrors zfb's `loader.rs:277`); a transitive `node:*` import fails the
+ * load. This preset is the central node in that eval graph, so it MUST stay
+ * free of `node:*` builtins:
+ *
+ *   - The signature takes `buildDocsSchema` and `directiveVocabulary` as
+ *     INPUTS rather than importing the project's `src/config/*` singletons.
+ *     Those singletons (`settings`, `tag-vocabulary`, `docs-schema`) are
+ *     already pulled into the config eval at the call site; re-importing them
+ *     here would (a) double-import the singletons and (b) risk dragging a
+ *     `node:*` dependency into this module's own import graph.
+ *   - Plugins are emitted as **bare-specifier descriptors**
+ *     (`{ name: "@takazudo/zudo-doc/plugins/<x>", options }`), NEVER imported
+ *     plugin functions. zfb's plugin runtime loads each `name` as a module
+ *     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:*`).
+ */
+import { z } from "zod";
+/** A single locale's content directory (`settings.locales[code]`). */
+export interface PresetLocaleConfig {
+    dir: string;
+}
+/** A single docs version (`settings.versions[n]`). */
+export interface PresetVersionConfig {
+    slug: string;
+    docsDir: string;
+    locales?: Record<string, {
+        dir: string;
+    }>;
+}
+/** The `settings.claudeResources` block (or `false` when disabled). */
+export interface PresetClaudeResourcesConfig {
+    claudeDir: string;
+    projectRoot?: string;
+}
+/**
+ * The subset of `settings` the preset reads. Any concrete `typeof settings`
+ * (this repo's or a generated project's) is assignable to this — the preset
+ * only consumes these fields.
+ */
+export interface PresetSettings {
+    docsDir: string;
+    locales: Record<string, PresetLocaleConfig>;
+    versions?: PresetVersionConfig[] | false;
+    base: string;
+    siteName: string;
+    siteDescription: string;
+    siteUrl: string;
+    trailingSlash: boolean;
+    mermaid: boolean;
+    onBrokenMarkdownLinks: "warn" | "error" | "ignore";
+    headingIdStrategy: "flat" | "hierarchical";
+    llmsTxt?: boolean;
+    docHistory?: boolean;
+    claudeResources?: PresetClaudeResourcesConfig | false;
+    /** "owner/repo" — when set, enables `#123` / SHA autolinks in markdown. Omit to disable entirely. */
+    githubAutolinksRepo?: string;
+}
+/**
+ * The directives recipe map (`markdown.features.directives`): directive name →
+ * the JSX component name it resolves to (registered in the host's
+ * `pages/_mdx-components.ts`). Passed in rather than hardcoded so a project can
+ * register its own directives without editing the preset; the showcase passes
+ * the canonical seven (note/tip/info/warning/danger/caution/details).
+ */
+export type DirectiveVocabulary = Record<string, string>;
+/** Arguments to `zudoDocPreset`. */
+export interface ZudoDocPresetArgs {
+    /** The project's `settings` object (structurally `PresetSettings`). */
+    settings: PresetSettings;
+    /**
+     * The project's `buildDocsSchema` — the zod schema builder from
+     * `src/config/docs-schema.ts`. Passed (not imported) so the preset never
+     * re-imports the project's `settings` / `tag-vocabulary` singletons, keeping
+     * this module's import graph node-builtin-free. Called once; the result is
+     * converted to JSON Schema and reused for every collection.
+     */
+    buildDocsSchema: () => z.ZodType;
+    /**
+     * The directives recipe map. See {@link DirectiveVocabulary}.
+     */
+    directiveVocabulary: DirectiveVocabulary;
+}
+export interface PresetCollection {
+    name: string;
+    path: string;
+    schema: Record<string, unknown>;
+}
+export interface PresetPlugin {
+    name: string;
+    options?: Record<string, unknown>;
+}
+export interface PresetResolveMarkdownLinks {
+    enabled: boolean;
+    dirs: Array<{
+        dir: string;
+        routePrefix: string;
+    }>;
+    onBrokenLinks: "warn" | "error" | "ignore";
+}
+export interface PresetMarkdown {
+    features: Record<string, boolean | Record<string, unknown>>;
+}
+export interface PresetCodeHighlight {
+    themeLight: string;
+    themeDark: string;
+}
+/** The config fragment returned by {@link zudoDocPreset}. */
+export interface ZudoDocPresetResult {
+    collections: PresetCollection[];
+    plugins: PresetPlugin[];
+    markdown: PresetMarkdown;
+    codeHighlight: PresetCodeHighlight;
+    resolveMarkdownLinks: PresetResolveMarkdownLinks;
+    stripMdExt: boolean;
+    trailingSlash: boolean;
+}
+/**
+ * Build the zudo-doc zfb config fragment from project settings.
+ *
+ * Spread the result into `defineConfig`:
+ *
+ * ```ts
+ * export default defineConfig({
+ *   framework: "preact",
+ *   port: 4321,
+ *   tailwind: { enabled: true },
+ *   bundle: { exclude: [...] },
+ *   base: settings.base,
+ *   adapter: "@takazudo/zfb-adapter-cloudflare",
+ *   ...zudoDocPreset({ settings, buildDocsSchema, directiveVocabulary }),
+ * });
+ * ```
+ */
+export declare function zudoDocPreset({ settings, buildDocsSchema, directiveVocabulary, }: ZudoDocPresetArgs): ZudoDocPresetResult;