fumadocs-mdx 13.0.7 → 14.0.0

package/dist/runtime/dynamic.d.cts

@@ -0,0 +1,27 @@
+import * as fumadocs_core_source from 'fumadocs-core/source';
+import { FileInfo, AsyncDocCollectionEntry, AsyncDocsCollectionEntry } from './server.cjs';
+import { C as CoreOptions, D as DocCollection, b as DocsCollection } from '../index-D7JdSMpp.cjs';
+import * as _standard_schema_spec from '@standard-schema/spec';
+import 'fumadocs-core/mdx-plugins';
+import 'fumadocs-core/toc';
+import 'mdx/types';
+import 'mdast';
+import '@mdx-js/mdx';
+import 'react';
+import 'unified';
+import 'zod';
+import 'chokidar';
+import 'vfile';
+
+interface LazyEntry<Data = unknown> {
+    info: FileInfo;
+    data: Data;
+    hash?: string;
+}
+type CreateDynamic<Config> = ReturnType<typeof fromConfigDynamic<Config>>;
+declare function fromConfigDynamic<Config>(configExports: Config, coreOptions: CoreOptions): Promise<{
+    doc<Name extends keyof Config>(name: Name, base: string, entries: LazyEntry<unknown>[]): Promise<Config[Name] extends DocCollection<infer Schema extends _standard_schema_spec.StandardSchemaV1<unknown, unknown>> | DocsCollection<infer Schema extends _standard_schema_spec.StandardSchemaV1<unknown, unknown>, _standard_schema_spec.StandardSchemaV1<unknown, unknown>> ? AsyncDocCollectionEntry<_standard_schema_spec.StandardSchemaV1.InferOutput<Schema>>[] : never>;
+    docs<Name extends keyof Config>(name: Name, base: string, meta: Record<string, unknown>, entries: LazyEntry<unknown>[]): Promise<Config[Name] extends DocsCollection<infer Page extends _standard_schema_spec.StandardSchemaV1<unknown, unknown>, infer Meta extends _standard_schema_spec.StandardSchemaV1<unknown, unknown>> ? _standard_schema_spec.StandardSchemaV1.InferOutput<Page> extends fumadocs_core_source.PageData ? _standard_schema_spec.StandardSchemaV1.InferOutput<Meta> extends fumadocs_core_source.MetaData ? AsyncDocsCollectionEntry<_standard_schema_spec.StandardSchemaV1.InferOutput<Page>, _standard_schema_spec.StandardSchemaV1.InferOutput<Meta>> : never : never : never>;
+}>;
+
+export { type CreateDynamic, type LazyEntry, fromConfigDynamic };

package/dist/runtime/dynamic.d.ts

@@ -0,0 +1,27 @@
+import * as fumadocs_core_source from 'fumadocs-core/source';
+import { FileInfo, AsyncDocCollectionEntry, AsyncDocsCollectionEntry } from './server.js';
+import { C as CoreOptions, D as DocCollection, b as DocsCollection } from '../index-D7JdSMpp.js';
+import * as _standard_schema_spec from '@standard-schema/spec';
+import 'fumadocs-core/mdx-plugins';
+import 'fumadocs-core/toc';
+import 'mdx/types';
+import 'mdast';
+import '@mdx-js/mdx';
+import 'react';
+import 'unified';
+import 'zod';
+import 'chokidar';
+import 'vfile';
+
+interface LazyEntry<Data = unknown> {
+    info: FileInfo;
+    data: Data;
+    hash?: string;
+}
+type CreateDynamic<Config> = ReturnType<typeof fromConfigDynamic<Config>>;
+declare function fromConfigDynamic<Config>(configExports: Config, coreOptions: CoreOptions): Promise<{
+    doc<Name extends keyof Config>(name: Name, base: string, entries: LazyEntry<unknown>[]): Promise<Config[Name] extends DocCollection<infer Schema extends _standard_schema_spec.StandardSchemaV1<unknown, unknown>> | DocsCollection<infer Schema extends _standard_schema_spec.StandardSchemaV1<unknown, unknown>, _standard_schema_spec.StandardSchemaV1<unknown, unknown>> ? AsyncDocCollectionEntry<_standard_schema_spec.StandardSchemaV1.InferOutput<Schema>>[] : never>;
+    docs<Name extends keyof Config>(name: Name, base: string, meta: Record<string, unknown>, entries: LazyEntry<unknown>[]): Promise<Config[Name] extends DocsCollection<infer Page extends _standard_schema_spec.StandardSchemaV1<unknown, unknown>, infer Meta extends _standard_schema_spec.StandardSchemaV1<unknown, unknown>> ? _standard_schema_spec.StandardSchemaV1.InferOutput<Page> extends fumadocs_core_source.PageData ? _standard_schema_spec.StandardSchemaV1.InferOutput<Meta> extends fumadocs_core_source.MetaData ? AsyncDocsCollectionEntry<_standard_schema_spec.StandardSchemaV1.InferOutput<Page>, _standard_schema_spec.StandardSchemaV1.InferOutput<Meta>> : never : never : never>;
+}>;
+
+export { type CreateDynamic, type LazyEntry, fromConfigDynamic };

package/dist/runtime/dynamic.js

@@ -0,0 +1,78 @@
+import {
+  buildMDX
+} from "../chunk-SLY7WXTX.js";
+import {
+  fromConfig
+} from "../chunk-5YXP7JLN.js";
+import "../chunk-FBLMK4RS.js";
+import {
+  buildConfig
+} from "../chunk-ZY6UZ7NH.js";
+import "../chunk-E5DJTSIM.js";
+import {
+  createCore
+} from "../chunk-7L2KNF6B.js";
+import "../chunk-PKI7ZDA5.js";
+import {
+  fumaMatter
+} from "../chunk-VWJKRQZR.js";
+
+// src/runtime/dynamic.ts
+import { executeMdx } from "@fumadocs/mdx-remote/client";
+import { pathToFileURL } from "url";
+import fs from "fs/promises";
+async function fromConfigDynamic(configExports, coreOptions) {
+  const core = await createCore(coreOptions).init({
+    config: buildConfig(configExports)
+  });
+  const create = fromConfig();
+  function getDocCollection(name) {
+    const collection = core.getConfig().getCollection(name);
+    if (!collection) return;
+    if (collection.type === "docs") return collection.docs;
+    else if (collection.type === "doc") return collection;
+  }
+  function convertLazyEntries(collection, entries) {
+    const head = {};
+    const body = {};
+    async function compile({ info, data }) {
+      let content = (await fs.readFile(info.fullPath)).toString();
+      content = fumaMatter(content).content;
+      const compiled = await buildMDX(core, collection, {
+        filePath: info.fullPath,
+        source: content,
+        frontmatter: data,
+        isDevelopment: false,
+        environment: "runtime"
+      });
+      return await executeMdx(String(compiled.value), {
+        baseUrl: pathToFileURL(info.fullPath)
+      });
+    }
+    for (const entry of entries) {
+      head[entry.info.path] = () => entry.data;
+      let cachedResult;
+      body[entry.info.path] = () => cachedResult ??= compile(entry);
+    }
+    return { head, body };
+  }
+  return {
+    async doc(name, base, entries) {
+      const collection = getDocCollection(name);
+      if (!collection)
+        throw new Error(`the doc collection ${name} doesn't exist.`);
+      const { head, body } = convertLazyEntries(collection, entries);
+      return create.docLazy(name, base, head, body);
+    },
+    async docs(name, base, meta, entries) {
+      const collection = getDocCollection(name);
+      if (!collection)
+        throw new Error(`the doc collection ${name} doesn't exist.`);
+      const docs = convertLazyEntries(collection, entries);
+      return create.docsLazy(name, base, meta, docs.head, docs.body);
+    }
+  };
+}
+export {
+  fromConfigDynamic
+};

package/dist/runtime/server.cjs

@@ -0,0 +1,173 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtime/server.ts
+var server_exports = {};
+__export(server_exports, {
+  fromConfig: () => fromConfig,
+  toFumadocsSource: () => toFumadocsSource
+});
+module.exports = __toCommonJS(server_exports);
+var path = __toESM(require("path"), 1);
+function fromConfig() {
+  function fileInfo(file, base) {
+    if (file.startsWith("./")) {
+      file = file.slice(2);
+    }
+    return {
+      path: file,
+      fullPath: path.join(base, file)
+    };
+  }
+  function mapDocData(entry) {
+    return {
+      body: entry.default,
+      toc: entry.toc,
+      extractedReferences: entry.extractedReferences,
+      structuredData: entry.structuredData,
+      lastModified: entry.lastModified,
+      _exports: entry
+    };
+  }
+  return {
+    async doc(_name, base, glob) {
+      const out = await Promise.all(
+        Object.entries(glob).map(async ([k, v]) => {
+          const data = typeof v === "function" ? await v() : v;
+          return {
+            ...mapDocData(data),
+            ...data.frontmatter,
+            ...createDocMethods(fileInfo(k, base), () => data)
+          };
+        })
+      );
+      return out;
+    },
+    async docLazy(_name, base, head, body) {
+      const out = await Promise.all(
+        Object.entries(head).map(async ([k, v]) => {
+          const data = typeof v === "function" ? await v() : v;
+          const content = body[k];
+          return {
+            ...data,
+            ...createDocMethods(fileInfo(k, base), content),
+            async load() {
+              return mapDocData(await content());
+            }
+          };
+        })
+      );
+      return out;
+    },
+    async meta(_name, base, glob) {
+      const out = await Promise.all(
+        Object.entries(glob).map(async ([k, v]) => {
+          const data = typeof v === "function" ? await v() : v;
+          return {
+            info: fileInfo(k, base),
+            ...data
+          };
+        })
+      );
+      return out;
+    },
+    async docs(name, base, metaGlob, docGlob) {
+      const entry = {
+        docs: await this.doc(name, base, docGlob),
+        meta: await this.meta(name, base, metaGlob),
+        toFumadocsSource() {
+          return toFumadocsSource(this.docs, this.meta);
+        }
+      };
+      return entry;
+    },
+    async docsLazy(name, base, metaGlob, docHeadGlob, docBodyGlob) {
+      const entry = {
+        docs: await this.docLazy(name, base, docHeadGlob, docBodyGlob),
+        meta: await this.meta(name, base, metaGlob),
+        toFumadocsSource() {
+          return toFumadocsSource(this.docs, this.meta);
+        }
+      };
+      return entry;
+    }
+  };
+}
+function toFumadocsSource(pages, metas) {
+  const files = [];
+  for (const entry of pages) {
+    files.push({
+      type: "page",
+      path: entry.info.path,
+      absolutePath: entry.info.fullPath,
+      data: entry
+    });
+  }
+  for (const entry of metas) {
+    files.push({
+      type: "meta",
+      path: entry.info.path,
+      absolutePath: entry.info.fullPath,
+      data: entry
+    });
+  }
+  return {
+    files
+  };
+}
+function createDocMethods(info, load) {
+  return {
+    info,
+    async getText(type) {
+      if (type === "raw") {
+        const fs = await import("fs/promises");
+        return (await fs.readFile(info.fullPath)).toString();
+      }
+      const data = await load();
+      if (typeof data._markdown !== "string")
+        throw new Error(
+          "getText('processed') requires `includeProcessedMarkdown` to be enabled in your collection config."
+        );
+      return data._markdown;
+    },
+    async getMDAST() {
+      const data = await load();
+      if (!data._mdast)
+        throw new Error(
+          "getMDAST() requires `includeMDAST` to be enabled in your collection config."
+        );
+      return JSON.parse(data._mdast);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fromConfig,
+  toFumadocsSource
+});

package/dist/runtime/server.d.cts

@@ -0,0 +1,161 @@
+import { PageData, MetaData, Source } from 'fumadocs-core/source';
+import { StructuredData } from 'fumadocs-core/mdx-plugins';
+import { TOCItemType } from 'fumadocs-core/toc';
+import { MDXProps, MDXContent } from 'mdx/types';
+import { E as ExtractedReference, D as DocCollection, b as DocsCollection, M as MetaCollection } from '../index-D7JdSMpp.cjs';
+import { Root } from 'mdast';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { createProcessor } from '@mdx-js/mdx';
+import { FC } from 'react';
+import 'unified';
+import 'zod';
+import 'chokidar';
+import 'vfile';
+
+type Processor = ReturnType<typeof createProcessor>;
+interface CompilerOptions {
+    addDependency: (file: string) => void;
+}
+interface CompiledMDXProperties<Frontmatter = Record<string, unknown>> {
+    frontmatter: Frontmatter;
+    structuredData: StructuredData;
+    toc: TOCItemType[];
+    default: FC<MDXProps>;
+    /**
+     * Added by the `last-modified` plugin.
+     */
+    lastModified?: Date;
+    /**
+     * Enable from `postprocess` option.
+     */
+    extractedReferences?: ExtractedReference[];
+    /**
+     * Enable from `postprocess` option.
+     */
+    _markdown?: string;
+    /**
+     * Enable from `postprocess` option.
+     */
+    _mdast?: string;
+}
+interface FumadocsDataMap {
+    /**
+     * [Fumadocs MDX] raw frontmatter, you can modify it
+     */
+    frontmatter?: Record<string, unknown>;
+    /**
+     * [Fumadocs MDX] additional ESM exports to write
+     */
+    'mdx-export'?: {
+        name: string;
+        value: unknown;
+    }[];
+    /**
+     * [Fumadocs MDX] The compiler object from loader
+     */
+    _compiler?: CompilerOptions;
+    /**
+     * [Fumadocs MDX] get internal processor, do not use this on user land.
+     */
+    _getProcessor?: (format: 'md' | 'mdx') => Processor;
+}
+declare module 'vfile' {
+    interface DataMap extends FumadocsDataMap {
+    }
+}
+
+interface FileInfo {
+    /**
+     * virtualized path for Source API
+     */
+    path: string;
+    /**
+     * the file path in file system
+     */
+    fullPath: string;
+}
+interface DocData {
+    /**
+     * Compiled MDX content (as component)
+     */
+    body: MDXContent;
+    /**
+     * table of contents generated from content.
+     */
+    toc: TOCItemType[];
+    /**
+     * structured data for document search indexing.
+     */
+    structuredData: StructuredData;
+    /**
+     * Raw exports from the compiled MDX file.
+     */
+    _exports: Record<string, unknown>;
+    /**
+     * Last modified date of document file, obtained from version control.
+     *
+     * Added by the `last-modified` plugin.
+     */
+    lastModified?: Date;
+    /**
+     * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
+     */
+    extractedReferences?: ExtractedReference[];
+}
+interface DocMethods {
+    /**
+     * file info
+     */
+    info: FileInfo;
+    /**
+     * get document as text.
+     *
+     * - `type: raw` - read the original content from file system.
+     * - `type: processed` - get the processed Markdown content, only available when `includeProcessedMarkdown` is enabled on collection config.
+     */
+    getText: (type: 'raw' | 'processed') => Promise<string>;
+    getMDAST: () => Promise<Root>;
+}
+interface MetaMethods {
+    /**
+     * file info
+     */
+    info: FileInfo;
+}
+type MetaCollectionEntry<Data> = Data & MetaMethods;
+type DocCollectionEntry<Frontmatter> = DocData & DocMethods & Frontmatter;
+type AsyncDocCollectionEntry<Frontmatter> = DocMethods & {
+    load: () => Promise<DocData>;
+} & Frontmatter;
+type CompiledMDXFile<Frontmatter> = CompiledMDXProperties<Frontmatter> & Record<string, unknown>;
+interface DocsCollectionEntry<Frontmatter extends PageData, Meta extends MetaData> {
+    docs: DocCollectionEntry<Frontmatter>[];
+    meta: MetaCollectionEntry<Meta>[];
+    toFumadocsSource: () => Source<{
+        pageData: DocCollectionEntry<Frontmatter>;
+        metaData: MetaCollectionEntry<Meta>;
+    }>;
+}
+interface AsyncDocsCollectionEntry<Frontmatter extends PageData, Meta extends MetaData> {
+    docs: AsyncDocCollectionEntry<Frontmatter>[];
+    meta: MetaCollectionEntry<Meta>[];
+    toFumadocsSource: () => Source<{
+        pageData: AsyncDocCollectionEntry<Frontmatter>;
+        metaData: MetaCollectionEntry<Meta>;
+    }>;
+}
+type AwaitableGlobEntries<T> = Record<string, T | (() => Promise<T>)>;
+type ServerCreate<Config> = ReturnType<typeof fromConfig<Config>>;
+declare function fromConfig<Config>(): {
+    doc<Name extends keyof Config>(_name: Name, base: string, glob: AwaitableGlobEntries<unknown>): Promise<Config[Name] extends DocCollection<infer Schema extends StandardSchemaV1<unknown, unknown>> | DocsCollection<infer Schema extends StandardSchemaV1<unknown, unknown>, StandardSchemaV1<unknown, unknown>> ? DocCollectionEntry<StandardSchemaV1.InferOutput<Schema>>[] : never>;
+    docLazy<Name extends keyof Config>(_name: Name, base: string, head: AwaitableGlobEntries<unknown>, body: Record<string, () => Promise<unknown>>): Promise<Config[Name] extends DocCollection<infer Schema extends StandardSchemaV1<unknown, unknown>> | DocsCollection<infer Schema extends StandardSchemaV1<unknown, unknown>, StandardSchemaV1<unknown, unknown>> ? AsyncDocCollectionEntry<StandardSchemaV1.InferOutput<Schema>>[] : never>;
+    meta<Name extends keyof Config>(_name: Name, base: string, glob: AwaitableGlobEntries<unknown>): Promise<Config[Name] extends MetaCollection<infer Schema extends StandardSchemaV1<unknown, unknown>> | DocsCollection<StandardSchemaV1<unknown, unknown>, infer Schema extends StandardSchemaV1<unknown, unknown>> ? MetaCollectionEntry<StandardSchemaV1.InferOutput<Schema>>[] : never>;
+    docs<Name extends keyof Config>(name: Name, base: string, metaGlob: AwaitableGlobEntries<unknown>, docGlob: AwaitableGlobEntries<unknown>): Promise<Config[Name] extends DocsCollection<infer Page extends StandardSchemaV1<unknown, unknown>, infer Meta extends StandardSchemaV1<unknown, unknown>> ? StandardSchemaV1.InferOutput<Page> extends PageData ? StandardSchemaV1.InferOutput<Meta> extends MetaData ? DocsCollectionEntry<StandardSchemaV1.InferOutput<Page>, StandardSchemaV1.InferOutput<Meta>> : never : never : never>;
+    docsLazy<Name extends keyof Config>(name: Name, base: string, metaGlob: AwaitableGlobEntries<unknown>, docHeadGlob: AwaitableGlobEntries<unknown>, docBodyGlob: Record<string, () => Promise<unknown>>): Promise<Config[Name] extends DocsCollection<infer Page extends StandardSchemaV1<unknown, unknown>, infer Meta extends StandardSchemaV1<unknown, unknown>> ? StandardSchemaV1.InferOutput<Page> extends PageData ? StandardSchemaV1.InferOutput<Meta> extends MetaData ? AsyncDocsCollectionEntry<StandardSchemaV1.InferOutput<Page>, StandardSchemaV1.InferOutput<Meta>> : never : never : never>;
+};
+declare function toFumadocsSource<Page extends DocMethods & PageData, Meta extends MetaMethods & MetaData>(pages: Page[], metas: Meta[]): Source<{
+    pageData: Page;
+    metaData: Meta;
+}>;
+
+export { type AsyncDocCollectionEntry, type AsyncDocsCollectionEntry, type CompiledMDXFile, type DocCollectionEntry, type DocData, type DocMethods, type DocsCollectionEntry, type FileInfo, type MetaCollectionEntry, type MetaMethods, type ServerCreate, fromConfig, toFumadocsSource };

package/dist/runtime/server.d.ts

@@ -0,0 +1,161 @@
+import { PageData, MetaData, Source } from 'fumadocs-core/source';
+import { StructuredData } from 'fumadocs-core/mdx-plugins';
+import { TOCItemType } from 'fumadocs-core/toc';
+import { MDXProps, MDXContent } from 'mdx/types';
+import { E as ExtractedReference, D as DocCollection, b as DocsCollection, M as MetaCollection } from '../index-D7JdSMpp.js';
+import { Root } from 'mdast';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { createProcessor } from '@mdx-js/mdx';
+import { FC } from 'react';
+import 'unified';
+import 'zod';
+import 'chokidar';
+import 'vfile';
+
+type Processor = ReturnType<typeof createProcessor>;
+interface CompilerOptions {
+    addDependency: (file: string) => void;
+}
+interface CompiledMDXProperties<Frontmatter = Record<string, unknown>> {
+    frontmatter: Frontmatter;
+    structuredData: StructuredData;
+    toc: TOCItemType[];
+    default: FC<MDXProps>;
+    /**
+     * Added by the `last-modified` plugin.
+     */
+    lastModified?: Date;
+    /**
+     * Enable from `postprocess` option.
+     */
+    extractedReferences?: ExtractedReference[];
+    /**
+     * Enable from `postprocess` option.
+     */
+    _markdown?: string;
+    /**
+     * Enable from `postprocess` option.
+     */
+    _mdast?: string;
+}
+interface FumadocsDataMap {
+    /**
+     * [Fumadocs MDX] raw frontmatter, you can modify it
+     */
+    frontmatter?: Record<string, unknown>;
+    /**
+     * [Fumadocs MDX] additional ESM exports to write
+     */
+    'mdx-export'?: {
+        name: string;
+        value: unknown;
+    }[];
+    /**
+     * [Fumadocs MDX] The compiler object from loader
+     */
+    _compiler?: CompilerOptions;
+    /**
+     * [Fumadocs MDX] get internal processor, do not use this on user land.
+     */
+    _getProcessor?: (format: 'md' | 'mdx') => Processor;
+}
+declare module 'vfile' {
+    interface DataMap extends FumadocsDataMap {
+    }
+}
+
+interface FileInfo {
+    /**
+     * virtualized path for Source API
+     */
+    path: string;
+    /**
+     * the file path in file system
+     */
+    fullPath: string;
+}
+interface DocData {
+    /**
+     * Compiled MDX content (as component)
+     */
+    body: MDXContent;
+    /**
+     * table of contents generated from content.
+     */
+    toc: TOCItemType[];
+    /**
+     * structured data for document search indexing.
+     */
+    structuredData: StructuredData;
+    /**
+     * Raw exports from the compiled MDX file.
+     */
+    _exports: Record<string, unknown>;
+    /**
+     * Last modified date of document file, obtained from version control.
+     *
+     * Added by the `last-modified` plugin.
+     */
+    lastModified?: Date;
+    /**
+     * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
+     */
+    extractedReferences?: ExtractedReference[];
+}
+interface DocMethods {
+    /**
+     * file info
+     */
+    info: FileInfo;
+    /**
+     * get document as text.
+     *
+     * - `type: raw` - read the original content from file system.
+     * - `type: processed` - get the processed Markdown content, only available when `includeProcessedMarkdown` is enabled on collection config.
+     */
+    getText: (type: 'raw' | 'processed') => Promise<string>;
+    getMDAST: () => Promise<Root>;
+}
+interface MetaMethods {
+    /**
+     * file info
+     */
+    info: FileInfo;
+}
+type MetaCollectionEntry<Data> = Data & MetaMethods;
+type DocCollectionEntry<Frontmatter> = DocData & DocMethods & Frontmatter;
+type AsyncDocCollectionEntry<Frontmatter> = DocMethods & {
+    load: () => Promise<DocData>;
+} & Frontmatter;
+type CompiledMDXFile<Frontmatter> = CompiledMDXProperties<Frontmatter> & Record<string, unknown>;
+interface DocsCollectionEntry<Frontmatter extends PageData, Meta extends MetaData> {
+    docs: DocCollectionEntry<Frontmatter>[];
+    meta: MetaCollectionEntry<Meta>[];
+    toFumadocsSource: () => Source<{
+        pageData: DocCollectionEntry<Frontmatter>;
+        metaData: MetaCollectionEntry<Meta>;
+    }>;
+}
+interface AsyncDocsCollectionEntry<Frontmatter extends PageData, Meta extends MetaData> {
+    docs: AsyncDocCollectionEntry<Frontmatter>[];
+    meta: MetaCollectionEntry<Meta>[];
+    toFumadocsSource: () => Source<{
+        pageData: AsyncDocCollectionEntry<Frontmatter>;
+        metaData: MetaCollectionEntry<Meta>;
+    }>;
+}
+type AwaitableGlobEntries<T> = Record<string, T | (() => Promise<T>)>;
+type ServerCreate<Config> = ReturnType<typeof fromConfig<Config>>;
+declare function fromConfig<Config>(): {
+    doc<Name extends keyof Config>(_name: Name, base: string, glob: AwaitableGlobEntries<unknown>): Promise<Config[Name] extends DocCollection<infer Schema extends StandardSchemaV1<unknown, unknown>> | DocsCollection<infer Schema extends StandardSchemaV1<unknown, unknown>, StandardSchemaV1<unknown, unknown>> ? DocCollectionEntry<StandardSchemaV1.InferOutput<Schema>>[] : never>;
+    docLazy<Name extends keyof Config>(_name: Name, base: string, head: AwaitableGlobEntries<unknown>, body: Record<string, () => Promise<unknown>>): Promise<Config[Name] extends DocCollection<infer Schema extends StandardSchemaV1<unknown, unknown>> | DocsCollection<infer Schema extends StandardSchemaV1<unknown, unknown>, StandardSchemaV1<unknown, unknown>> ? AsyncDocCollectionEntry<StandardSchemaV1.InferOutput<Schema>>[] : never>;
+    meta<Name extends keyof Config>(_name: Name, base: string, glob: AwaitableGlobEntries<unknown>): Promise<Config[Name] extends MetaCollection<infer Schema extends StandardSchemaV1<unknown, unknown>> | DocsCollection<StandardSchemaV1<unknown, unknown>, infer Schema extends StandardSchemaV1<unknown, unknown>> ? MetaCollectionEntry<StandardSchemaV1.InferOutput<Schema>>[] : never>;
+    docs<Name extends keyof Config>(name: Name, base: string, metaGlob: AwaitableGlobEntries<unknown>, docGlob: AwaitableGlobEntries<unknown>): Promise<Config[Name] extends DocsCollection<infer Page extends StandardSchemaV1<unknown, unknown>, infer Meta extends StandardSchemaV1<unknown, unknown>> ? StandardSchemaV1.InferOutput<Page> extends PageData ? StandardSchemaV1.InferOutput<Meta> extends MetaData ? DocsCollectionEntry<StandardSchemaV1.InferOutput<Page>, StandardSchemaV1.InferOutput<Meta>> : never : never : never>;
+    docsLazy<Name extends keyof Config>(name: Name, base: string, metaGlob: AwaitableGlobEntries<unknown>, docHeadGlob: AwaitableGlobEntries<unknown>, docBodyGlob: Record<string, () => Promise<unknown>>): Promise<Config[Name] extends DocsCollection<infer Page extends StandardSchemaV1<unknown, unknown>, infer Meta extends StandardSchemaV1<unknown, unknown>> ? StandardSchemaV1.InferOutput<Page> extends PageData ? StandardSchemaV1.InferOutput<Meta> extends MetaData ? AsyncDocsCollectionEntry<StandardSchemaV1.InferOutput<Page>, StandardSchemaV1.InferOutput<Meta>> : never : never : never>;
+};
+declare function toFumadocsSource<Page extends DocMethods & PageData, Meta extends MetaMethods & MetaData>(pages: Page[], metas: Meta[]): Source<{
+    pageData: Page;
+    metaData: Meta;
+}>;
+
+export { type AsyncDocCollectionEntry, type AsyncDocsCollectionEntry, type CompiledMDXFile, type DocCollectionEntry, type DocData, type DocMethods, type DocsCollectionEntry, type FileInfo, type MetaCollectionEntry, type MetaMethods, type ServerCreate, fromConfig, toFumadocsSource };

package/dist/runtime/server.js

@@ -0,0 +1,8 @@
+import {
+  fromConfig,
+  toFumadocsSource
+} from "../chunk-5YXP7JLN.js";
+export {
+  fromConfig,
+  toFumadocsSource
+};