@takazudo/zudo-doc 5.28.2 → 6.0.0

package/dist/image-enlarge/index.js

@@ -1,17 +1,28 @@
 "use client";
-import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
-import { useState, useEffect } from "preact/compat";
+import { Fragment, jsx, jsxs } from "@takazudo/zfb/zudo-react/jsx-runtime";
+import { computed, getScope, Show, signal } from "@takazudo/zfb/zudo-react";
 import { AFTER_NAVIGATE_EVENT } from "../transitions/index.js";
-import { useModalDialog } from "../use-modal-dialog/index.js";
+import { modalDialog } from "../use-modal-dialog/index.js";
 import {
   IMAGE_ENLARGE_DIALOG_CLASS,
   ENLARGE_DIALOG_STYLE
 } from "../island-types/index.js";
 function ImageEnlarge() {
-  const [imgData, setImgData] = useState(null);
-  useEffect(() => {
+  const scope = getScope();
+  const imgData = signal(null);
+  const isOpen = computed(() => imgData.value !== null);
+  const imageSrc = computed(() => {
+    const current = imgData.value;
+    return current ? current.currentSrc || current.src : "";
+  });
+  const imageSrcset = computed(() => imgData.value?.srcset ?? "");
+  const imageHasSrcset = computed(() => Boolean(imgData.value?.srcset));
+  const imageAlt = computed(() => imgData.value?.alt ?? "");
+  scope.onActivate(() => {
+    let active = true;
     const observedImages = /* @__PURE__ */ new Set();
     const sharedResizeObserver = new ResizeObserver((entries) => {
+      if (!active) return;
       for (const entry of entries) {
         evaluateEligibility(entry.target);
       }
@@ -46,35 +57,41 @@ function ImageEnlarge() {
       }
     }
     function scanContent() {
-      const scope = document.querySelector("main .zd-content");
-      if (!scope) return;
-      scope.querySelectorAll(".zd-enlargeable img").forEach(observeImage);
+      const content = document.querySelector("main .zd-content");
+      if (!content) return;
+      content.querySelectorAll(".zd-enlargeable img").forEach(observeImage);
     }
     function startObserving() {
-      const scope = document.querySelector("main .zd-content");
-      if (scope) {
+      const content = document.querySelector("main .zd-content");
+      if (content) {
         mutationObserver = new MutationObserver((mutations) => {
+          if (!active) return;
           for (const mutation of mutations) {
             for (const node of mutation.addedNodes) {
               if (!(node instanceof Element)) continue;
               if (node.matches(".zd-enlargeable")) {
                 node.querySelectorAll("img").forEach(observeImage);
               }
+              if (node instanceof HTMLImageElement && node.closest(".zd-enlargeable")) {
+                observeImage(node);
+              }
               node.querySelectorAll(".zd-enlargeable img").forEach(observeImage);
             }
           }
         });
-        mutationObserver.observe(scope, { childList: true, subtree: true });
+        mutationObserver.observe(content, { childList: true, subtree: true });
       }
       scanContent();
     }
     function handleWindowResize() {
       clearTimeout(resizeTimer);
       resizeTimer = window.setTimeout(() => {
+        if (!active) return;
         observedImages.forEach((img) => evaluateEligibility(img));
       }, 150);
     }
-    function handleAfterSwap() {
+    function handleAfterNavigate() {
+      if (!active) return;
       sharedResizeObserver.disconnect();
       observedImages.clear();
       mutationObserver?.disconnect();
@@ -85,22 +102,25 @@ function ImageEnlarge() {
     }
     startObserving();
     window.addEventListener("resize", handleWindowResize);
-    document.addEventListener(AFTER_NAVIGATE_EVENT, handleAfterSwap);
+    document.addEventListener(AFTER_NAVIGATE_EVENT, handleAfterNavigate);
     return () => {
+      active = false;
       sharedResizeObserver.disconnect();
       observedImages.clear();
       mutationObserver?.disconnect();
       loadAbortController.abort();
       window.removeEventListener("resize", handleWindowResize);
-      document.removeEventListener(AFTER_NAVIGATE_EVENT, handleAfterSwap);
+      document.removeEventListener(AFTER_NAVIGATE_EVENT, handleAfterNavigate);
       clearTimeout(resizeTimer);
     };
-  }, []);
-  useEffect(() => {
-    function handleDocumentClick(e) {
-      const sel = window.getSelection();
-      if (sel && !sel.isCollapsed) return;
-      const target = e.target;
+  });
+  scope.onActivate(() => {
+    let active = true;
+    function handleDocumentClick(event) {
+      if (!active || !(event.target instanceof Element)) return;
+      const target = event.target;
+      const selection = window.getSelection();
+      if (selection && !selection.isCollapsed) return;
       const container = target.closest(".zd-enlargeable");
       if (!container) return;
       if (!target.closest(".zd-enlarge-btn") && !target.closest("img")) return;
@@ -108,7 +128,7 @@ function ImageEnlarge() {
       if (!btn || btn.hasAttribute("hidden")) return;
       const img = container.querySelector("img");
       if (!img) return;
-      setImgData({
+      imgData.value = {
         src: img.src,
         currentSrc: img.currentSrc,
         srcset: img.srcset || void 0,
@@ -116,14 +136,19 @@ function ImageEnlarge() {
         alt: img.alt,
         naturalWidth: img.naturalWidth,
         naturalHeight: img.naturalHeight
-      });
+      };
     }
     document.addEventListener("click", handleDocumentClick);
-    return () => document.removeEventListener("click", handleDocumentClick);
-  }, []);
-  const handleClose = () => setImgData(null);
-  const { dialogRef, handleBackdropClick } = useModalDialog({
-    isOpen: imgData !== null,
+    return () => {
+      active = false;
+      document.removeEventListener("click", handleDocumentClick);
+    };
+  });
+  const handleClose = () => {
+    imgData.value = null;
+  };
+  const { dialogRef, handleBackdropClick } = modalDialog(scope, {
+    isOpen,
     onClose: handleClose,
     navigateEvent: AFTER_NAVIGATE_EVENT,
     backdropClickClose: true
@@ -132,45 +157,45 @@ function ImageEnlarge() {
     "dialog",
     {
       ref: dialogRef,
-      onClick: handleBackdropClick,
-      className: IMAGE_ENLARGE_DIALOG_CLASS,
+      "on:click": handleBackdropClick,
+      class: IMAGE_ENLARGE_DIALOG_CLASS,
       style: ENLARGE_DIALOG_STYLE,
-      children: imgData && /* @__PURE__ */ jsxs(Fragment, { children: [
-        /* @__PURE__ */ jsx("div", { className: "relative", children: /* @__PURE__ */ jsx(
-          "img",
-          {
-            src: imgData.currentSrc || imgData.src,
-            srcSet: imgData.srcset,
-            sizes: imgData.srcset ? "85vw" : void 0,
-            alt: imgData.alt,
-            className: "block max-h-[85vh] max-w-[85vw] object-contain"
-          }
-        ) }),
+      children: /* @__PURE__ */ jsx(Show, { when: isOpen, children: () => /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsxs("div", { class: "relative", children: [
+          /* @__PURE__ */ jsx(Show, { when: imageHasSrcset, children: () => /* @__PURE__ */ jsx(
+            "img",
+            {
+              src: imageSrc,
+              srcset: imageSrcset,
+              sizes: "85vw",
+              alt: imageAlt,
+              class: "block max-h-[85vh] max-w-[85vw] object-contain"
+            }
+          ) }),
+          /* @__PURE__ */ jsx(Show, { when: computed(() => !imageHasSrcset.value), children: () => /* @__PURE__ */ jsx(
+            "img",
+            {
+              src: imageSrc,
+              alt: imageAlt,
+              class: "block max-h-[85vh] max-w-[85vw] object-contain"
+            }
+          ) })
+        ] }),
         /* @__PURE__ */ jsx(
           "button",
           {
             type: "button",
-            onClick: () => dialogRef.current?.close(),
-            className: "zd-enlarge-dialog-close",
+            "on:click": () => dialogRef.current?.close(),
+            class: "zd-enlarge-dialog-close",
             "aria-label": "Close enlarged image",
-            children: /* @__PURE__ */ jsx("svg", { viewBox: "0 0 161.03 161.03", fill: "currentColor", "aria-hidden": "true", focusable: "false", children: /* @__PURE__ */ jsx("polygon", { points: "161.03 10.27 150.76 0 80.51 70.24 10.27 0 0 10.27 70.24 80.51 0 150.76 10.27 161.03 80.51 90.78 150.76 161.03 161.03 150.76 90.78 80.51 161.03 10.27" }) })
+            children: /* @__PURE__ */ jsx("svg", { viewBox: "0 0 161.03 161.03", fill: "currentColor", "aria-hidden": "true", children: /* @__PURE__ */ jsx("polygon", { points: "161.03 10.27 150.76 0 80.51 70.24 10.27 0 0 10.27 70.24 80.51 0 150.76 10.27 161.03 80.51 90.78 150.76 161.03 161.03 150.76 90.78 80.51 161.03 10.27" }) })
           }
         )
-      ] })
+      ] }) })
     }
   );
 }
 ImageEnlarge.displayName = "ImageEnlarge";
-function ImageEnlargeSsrFallback() {
-  return /* @__PURE__ */ jsx(
-    "dialog",
-    {
-      className: IMAGE_ENLARGE_DIALOG_CLASS,
-      style: ENLARGE_DIALOG_STYLE
-    }
-  );
-}
 export {
-  ImageEnlarge,
-  ImageEnlargeSsrFallback
+  ImageEnlarge
 };

package/dist/image-enlarge/public.d.ts

@@ -0,0 +1,2 @@
+export { ImageEnlarge } from "./index.js";
+export { ImageEnlargeSsrFallback } from "./ssr-fallback.js";

package/dist/image-enlarge/public.js

@@ -0,0 +1,6 @@
+import { ImageEnlarge } from "./index.js";
+import { ImageEnlargeSsrFallback } from "./ssr-fallback.js";
+export {
+  ImageEnlarge,
+  ImageEnlargeSsrFallback
+};

package/dist/image-enlarge/ssr-fallback.d.ts

@@ -0,0 +1,2 @@
+/** Closed dialog shell rendered before island activation. */
+export declare function ImageEnlargeSsrFallback(): import("@takazudo/zfb").Description;

package/dist/image-enlarge/ssr-fallback.js

@@ -0,0 +1,8 @@
+import { jsx } from "@takazudo/zfb/zudo-react/jsx-runtime";
+import { IMAGE_ENLARGE_DIALOG_CLASS, ENLARGE_DIALOG_STYLE } from "../island-types/index.js";
+function ImageEnlargeSsrFallback() {
+  return /* @__PURE__ */ jsx("dialog", { class: IMAGE_ENLARGE_DIALOG_CLASS, style: ENLARGE_DIALOG_STYLE });
+}
+export {
+  ImageEnlargeSsrFallback
+};

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 /**
  * @takazudo/zudo-doc — framework primitives that sit on top of zfb's engine.
  *
- * **Use the subpath exports for actual imports.** This root barrel deliberately
- * stays empty so consumers don't drag in the entire framework when they only
- * need one piece. Each topic area publishes its own subpath (declared in
+ * **Use the subpath exports for runtime imports.** This root barrel exposes
+ * shared public types only, so consumers do not drag in runtime code when they
+ * need type contracts. Each topic area publishes its own subpath (declared in
  * `package.json#exports`):
  *
  *   import { buildSidebarTree, type SidebarNode } from "@takazudo/zudo-doc/sidebar-tree";
@@ -23,4 +23,11 @@
  *
  * See packages/zudo-doc/README.md for the topic map.
  */
-export {};
+export type { ChromeContext, ChromeHostBindings, FactoryComponent, FactoryComponents, FactoryContext, FactoryI18n, NavSource, RouteContext, RouteContextPayload, RouteHrefBuilder, TagInfo, } from "./factory-context/index.js";
+export type { BodyEndIslandsSlotProps, BreadcrumbSlotProps, ChromeBindingsInput, DesignTokenPanelBootstrapSlotProps, DocHistorySlotProps, DocPagerSlotProps, FooterSlotProps, FooterTagEntry, FrontmatterRendererSlotProps, HeaderSlotProps, SearchWidgetSlotProps, SidebarSlotProps, TocSlotProps, } from "./chrome-bindings.js";
+export type { HeaderNavChildItem, HeaderNavItem, HeaderRightBuiltinComponentName, HeaderRightComponentItem, HeaderRightComponentName, HeaderRightComponentProps, HeaderRightComponentRegistry, HeaderRightHtmlItem, HeaderRightItem, HeaderRightLinkItem, HeaderRightTriggerItem, HeaderRightTriggerName, Locale, } from "./header/types.js";
+export type { HeaderRightItemFlags } from "./header/right-items.js";
+export type { FrontmatterCellRenderer, FrontmatterCellRendererProps, } from "./metainfo/frontmatter-preview.js";
+export type { ThemePackDialogComponent, ThemePackDialogProps, } from "./theme-pack-switcher/index.js";
+export type { ModalDialogOptions, ModalDialogResult } from "./use-modal-dialog/index.js";
+export type { ChatMessage, DocHistoryData, DocHistoryEntry, EnlargeDialogProps, } from "./island-types/index.js";

package/dist/inline-version-switcher/index.d.ts

@@ -1,6 +1,5 @@
 /** @jsxRuntime automatic */
-/** @jsxImportSource preact */
-import type { JSX } from "preact";
+import type { JSX } from "@takazudo/zfb/zudo-react/jsx-runtime";
 /** Minimal version config entry needed by the inline version switcher. */
 export interface InlineVersionSwitcherVersionEntry {
     slug: string;

package/dist/inline-version-switcher/index.js

@@ -1,4 +1,4 @@
-import { jsx } from "preact/jsx-runtime";
+import { jsx } from "@takazudo/zfb/zudo-react/jsx-runtime";
 import {
   VersionSwitcher
 } from "../i18n-version/index.js";

package/dist/island-types/index.d.ts

@@ -28,7 +28,7 @@ export interface DocHistoryData {
 /** Shared inline style centering an enlarge `<dialog>` transform-free. */
 export declare const ENLARGE_DIALOG_STYLE: {
     readonly position: "fixed";
-    readonly inset: "0";
+    readonly inset: 0;
     readonly margin: "auto";
 };
 /** Class string for the image-enlarge `<dialog>` (hydrated + SSR fallback). */
@@ -38,7 +38,7 @@ export declare const MERMAID_ENLARGE_DIALOG_CLASS = "zd-mermaid-dialog z-modal m
 /** Shared shape an enlarge `<dialog>` is rendered with. */
 export interface EnlargeDialogProps {
     /** Tailwind class string for the `<dialog>`. */
-    className: string;
+    class: string;
     /** Inline style centering the dialog transform-free. */
     style: typeof ENLARGE_DIALOG_STYLE;
 }

package/dist/island-types/index.js

@@ -1,8 +1,4 @@
-const ENLARGE_DIALOG_STYLE = {
-  position: "fixed",
-  inset: "0",
-  margin: "auto"
-};
+const ENLARGE_DIALOG_STYLE = { position: "fixed", inset: 0, margin: "auto" };
 const IMAGE_ENLARGE_DIALOG_CLASS = "zd-enlarge-dialog z-modal mx-auto max-h-[90vh] max-w-[90vw] overflow-hidden border border-muted bg-surface p-0 backdrop:z-modal-backdrop";
 const MERMAID_ENLARGE_DIALOG_CLASS = "zd-mermaid-dialog z-modal mx-auto h-[90vh] max-h-[90vh] w-[90vw] max-w-[90vw] overflow-hidden border border-muted bg-surface p-0 backdrop:z-modal-backdrop";
 export {

package/dist/math-block/index.d.ts

@@ -1,6 +1,5 @@
 /** @jsxRuntime automatic */
-/** @jsxImportSource preact */
-import type { VNode } from "preact";
+import type { Child } from "@takazudo/zfb/zudo-react";
 export interface MathBlockProps {
     /** Raw LaTeX source string. */
     latex: string;
@@ -10,9 +9,7 @@ export interface MathBlockProps {
 /**
  * Server-rendered KaTeX math component.
  *
- * Block mode wraps the output in `<div class="math math-display">`;
- * inline mode uses `<span class="math math-inline">`. The class names
- * match the standard rehype-katex output so existing CSS (e.g. the
- * KaTeX stylesheet) still applies.
+ * Block mode wraps the output in `<div data-math="display">`; inline mode
+ * uses `<span data-math="inline">`. KaTeX owns the styled inner classes.
  */
-export declare function MathBlock({ latex, block }: MathBlockProps): VNode;
+export declare function MathBlock({ latex, block }: MathBlockProps): Child;

package/dist/math-block/index.js

@@ -1,4 +1,4 @@
-import { jsx } from "preact/jsx-runtime";
+import { jsx } from "@takazudo/zfb/zudo-react/jsx-runtime";
 function pickKatex(m) {
   let cur = m;
   for (let i = 0; i < 3 && cur && typeof cur === "object"; i++) {
@@ -21,16 +21,16 @@ function MathBlock({ latex, block = false }) {
     return /* @__PURE__ */ jsx(
       "div",
       {
-        class: "math math-display",
-        dangerouslySetInnerHTML: { __html: html }
+        "data-math": "display",
+        rawHtml: html
       }
     );
   }
   return /* @__PURE__ */ jsx(
     "span",
     {
-      class: "math math-inline",
-      dangerouslySetInnerHTML: { __html: html }
+      "data-math": "inline",
+      rawHtml: html
     }
   );
 }

package/dist/mcp/handler.d.ts

@@ -0,0 +1,8 @@
+import { type ReadAsset } from "./loader.js";
+export interface McpHandlerOptions {
+    read: ReadAsset;
+    base: string;
+    siteUrl?: string;
+}
+/** A deployment-scoped loader is safe to reuse; every operation re-reads the current manifest. */
+export declare function createMcpHandler(options: McpHandlerOptions): (request: Request) => Promise<Response>;

package/dist/mcp/handler.js

@@ -0,0 +1,129 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { z } from "zod";
+import { AGENT_MAX_POST_BYTES, AGENT_MAX_TOOL_RESPONSE_BYTES } from "../agent-docs/limits.js";
+import { searchAgentIndex } from "../agent-docs/search.js";
+import { AgentCorpusLoader, CorpusUnavailable } from "./loader.js";
+const encoder = new TextEncoder();
+const annotations = { readOnlyHint: true, idempotentHint: true, destructiveHint: false, openWorldHint: false };
+function json(body, status) {
+  return new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json; charset=utf-8" } });
+}
+function absolute(url, origin) {
+  return new URL(url, origin).href;
+}
+function toolResult(value, error = false) {
+  return error ? { content: [{ type: "text", text: JSON.stringify(value) }], isError: true } : { structuredContent: value, content: [{ type: "text", text: JSON.stringify(value) }] };
+}
+async function cappedBody(request) {
+  if (!request.body) return new Uint8Array();
+  const reader = request.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.length;
+      if (size > AGENT_MAX_POST_BYTES) {
+        await reader.cancel();
+        return void 0;
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return bytes;
+}
+function createMcpHandler(options) {
+  const loader = new AgentCorpusLoader(options.read, options.base);
+  return async (request) => {
+    const requestOrigin = new URL(request.url).origin;
+    const origin = request.headers.get("origin");
+    const allowed = /* @__PURE__ */ new Set([requestOrigin]);
+    if (options.siteUrl) {
+      try {
+        allowed.add(new URL(options.siteUrl).origin);
+      } catch {
+      }
+    }
+    const cors = origin && allowed.has(origin) ? origin : void 0;
+    const finish = (response) => {
+      const headers = new Headers(response.headers);
+      headers.set("cache-control", "no-store");
+      headers.set("vary", "Origin");
+      if (cors) headers.set("access-control-allow-origin", cors);
+      return new Response(response.body, { status: response.status, headers });
+    };
+    if (origin && !cors) return finish(json({ error: "Origin not allowed." }, 403));
+    if (request.method === "OPTIONS") return finish(new Response(null, { status: 204, headers: { allow: "POST, OPTIONS", "access-control-allow-methods": "POST, OPTIONS", "access-control-allow-headers": "content-type, accept, mcp-protocol-version" } }));
+    if (request.method !== "POST") {
+      const response = json({ error: "Method not allowed." }, 405);
+      response.headers.set("allow", "POST, OPTIONS");
+      return finish(response);
+    }
+    const mediaType = request.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase();
+    if (mediaType !== "application/json") return finish(json({ error: "Expected application/json." }, 415));
+    const bytes = await cappedBody(request);
+    if (!bytes) return finish(json({ error: "Request body exceeds 65536 bytes." }, 413));
+    try {
+      const corpus = await loader.corpus();
+      let envelope;
+      try {
+        envelope = JSON.parse(new TextDecoder().decode(bytes));
+      } catch {
+      }
+      if (envelope && typeof envelope === "object" && !Array.isArray(envelope)) {
+        const call = envelope;
+        const id = call.params?.arguments?.id;
+        if (call.method === "tools/call" && call.params?.name === "fetch" && typeof id === "string" && corpus.manifest.items.some((item) => item.id === id)) {
+          await loader.item(id);
+        }
+      }
+    } catch (error) {
+      if (error instanceof CorpusUnavailable) return finish(json({ error: error.message }, 503));
+      throw error;
+    }
+    const server = new McpServer({ name: "zudo-doc", version: "1.0.0" });
+    const publicOrigin = options.siteUrl ? new URL(options.siteUrl).origin : requestOrigin;
+    server.registerTool("search", { description: "Search published documentation.", inputSchema: { query: z.string() }, outputSchema: { results: z.array(z.object({ id: z.string(), title: z.string(), url: z.string() })) }, annotations }, async ({ query }) => {
+      const corpus = await loader.corpus();
+      const outcome = searchAgentIndex(corpus.index, query);
+      if (!outcome.ok) return toolResult({ error: outcome.error }, true);
+      const currentIds = new Set(corpus.manifest.items.map((item) => item.id));
+      const results = outcome.results.filter((item) => currentIds.has(item.id)).map((item) => ({ ...item, url: absolute(item.url, publicOrigin) }));
+      while (encoder.encode(JSON.stringify(toolResult({ results }))).length * 2 > AGENT_MAX_TOOL_RESPONSE_BYTES && results.length) results.pop();
+      return toolResult({ results });
+    });
+    server.registerTool("fetch", { description: "Fetch a published documentation item by search result ID.", inputSchema: { id: z.string() }, outputSchema: { id: z.string(), title: z.string(), text: z.string(), url: z.string(), metadata: z.record(z.string(), z.unknown()) }, annotations }, async ({ id }) => {
+      const item = await loader.item(id);
+      if (!item) return toolResult({ error: `Documentation item not found: ${id}` }, true);
+      const result = { ...item, url: absolute(item.url, publicOrigin) };
+      return toolResult(result);
+    });
+    const transport = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: void 0, enableJsonResponse: true });
+    try {
+      await server.connect(transport);
+      const sdkRequest = new Request(request.url, { method: "POST", headers: request.headers, body: new Uint8Array(bytes) });
+      const response = await transport.handleRequest(sdkRequest);
+      const body = await response.text();
+      if (encoder.encode(body).length > AGENT_MAX_TOOL_RESPONSE_BYTES) return finish(json({ error: "MCP response exceeds byte limit." }, 503));
+      return finish(new Response(body, { status: response.status, headers: response.headers }));
+    } catch (error) {
+      if (error instanceof CorpusUnavailable) return finish(json({ error: error.message }, 503));
+      throw error;
+    } finally {
+      await server.close();
+    }
+  };
+}
+export {
+  createMcpHandler
+};

package/dist/mcp/index.d.ts

@@ -0,0 +1,4 @@
+export { createMcpHandler } from "./handler.js";
+export { AgentCorpusLoader, CorpusUnavailable } from "./loader.js";
+export type { McpHandlerOptions } from "./handler.js";
+export type { ReadAsset } from "./loader.js";

package/dist/mcp/index.js

@@ -0,0 +1,7 @@
+import { createMcpHandler } from "./handler.js";
+import { AgentCorpusLoader, CorpusUnavailable } from "./loader.js";
+export {
+  AgentCorpusLoader,
+  CorpusUnavailable,
+  createMcpHandler
+};

package/dist/mcp/loader.d.ts

@@ -0,0 +1,19 @@
+import { type BuiltAgentSearchIndex } from "../agent-docs/search.js";
+import type { AgentItem, AgentManifest } from "../agent-docs/types.js";
+export type ReadAsset = (path: string) => Promise<Response>;
+export declare class CorpusUnavailable extends Error {
+}
+export declare class AgentCorpusLoader {
+    private readonly read;
+    private readonly base;
+    private current?;
+    private loading?;
+    constructor(read: ReadAsset, base: string);
+    private load;
+    corpus(): Promise<{
+        fingerprint: string;
+        manifest: AgentManifest;
+        index: BuiltAgentSearchIndex;
+    }>;
+    item(id: string): Promise<AgentItem | undefined>;
+}