fumadocs-mdx 15.5.0 → 15.5.2

package/dist/adapter-C30pL0Cs.js

@@ -0,0 +1,277 @@
+import { i as slash } from "./codegen-COHeuzzn.js";
+import { n as runModule } from "./code-BF5OS485.js";
+import { r as buildConfig } from "./build-TiTOkhq4.js";
+import { n as ValidationError } from "./core-BITOWTcu.js";
+import { t as loadConfig } from "./load-from-file-gZlf7m88.js";
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getStaticParams } from "fumadocs-core/source";
+import { parse } from "yaml";
+import { fileURLToPath } from "node:url";
+import { parse as parse$1 } from "node:querystring";
+// src/loaders/meta.ts
+const querySchema = z.looseObject({
+	collection: z.string().optional(),
+	workspace: z.string().optional(),
+	macro_id: z.string().optional()
+});
+/**
+* The data of a meta file. A module, like `meta.ts`, has a default export, which can be a function of the params of
+* its folder, and the `staticParams` as a named export or in its data.
+*/
+function parse$2(filePath, source, addDependency) {
+	if (/\.[jt]s$/.test(filePath)) {
+		const { default: data, staticParams = data?.staticParams } = runModule(filePath, source, addDependency);
+		if (typeof data === "function") return {
+			data: { staticParams },
+			dataAt: data
+		};
+		return { data: {
+			...data,
+			staticParams
+		} };
+	}
+	try {
+		if (filePath.endsWith(".json")) return { data: JSON.parse(source) };
+		if (filePath.endsWith(".yaml")) return { data: parse(source) };
+	} catch (e) {
+		throw new Error(`invalid data in ${filePath}`, { cause: e });
+	}
+	throw new Error("Unknown file type " + filePath);
+}
+/** read the `staticParams` of a meta file in `dir`, by its path without the extension, like `[framework]/meta` */
+function readStaticParams(dir, file, addDependency) {
+	for (const ext of [
+		".json",
+		".yaml",
+		".ts",
+		".js"
+	]) {
+		const metaFile = path.join(dir, file + ext);
+		addDependency(metaFile);
+		let content;
+		try {
+			content = readFileSync(metaFile, "utf-8");
+		} catch (error) {
+			if (error.code === "ENOENT") continue;
+			throw error;
+		}
+		return parse$2(metaFile, content, addDependency).data?.staticParams;
+	}
+}
+/**
+* load meta files, fallback to bundler's built-in plugins when ?collection is unspecified.
+*/
+function createMetaLoader({ getCore }, resolve = {}) {
+	const { json: resolveJson = "js" } = resolve;
+	function onMeta(source, { filePath, query, compiler }) {
+		const parsed = querySchema.safeParse(query);
+		if (!parsed.success) return null;
+		const { collection: collectionName, workspace, macro_id: macroId } = parsed.data;
+		if (!collectionName && macroId === void 0) return null;
+		return async () => {
+			let core = await getCore();
+			const macro = core.macro;
+			if (workspace) core = core.getWorkspaces().get(workspace) ?? core;
+			let metaCollection;
+			if (macro && macroId !== void 0) {
+				const resolved = await macro.resolve(macroId);
+				for (const input of resolved.inputs) compiler.addDependency(input);
+				const item = resolved.collection;
+				if (item.type === "docs") metaCollection = item.meta;
+				else if (item.type === "meta") metaCollection = item;
+			} else if (collectionName) {
+				const collection = core.getCollection(collectionName);
+				switch (collection?.type) {
+					case "meta":
+						metaCollection = collection;
+						break;
+					case "docs": metaCollection = collection.meta;
+				}
+			}
+			const { data, dataAt } = parse$2(filePath, source, compiler.addDependency);
+			if (!metaCollection) return data;
+			const options = {
+				collection: metaCollection,
+				filePath,
+				source
+			};
+			if (!dataAt) return core.transformMeta(options, data);
+			const { dir } = metaCollection;
+			const out = {
+				...data,
+				_dataAt: {}
+			};
+			const list = getStaticParams(slash(path.relative(dir, filePath)), { readStaticParams: (file) => readStaticParams(dir, file, compiler.addDependency) });
+			for (const params of list ?? []) out._dataAt[JSON.stringify(params)] = await core.transformMeta(options, {
+				staticParams: data.staticParams,
+				...dataAt(params)
+			});
+			return out;
+		};
+	}
+	return {
+		async load(input) {
+			const result = onMeta(await input.getSource(), input);
+			if (result === null) return null;
+			const data = await result();
+			if (input.filePath.endsWith(".json")) return {
+				moduleType: resolveJson,
+				code: resolveJson === "json" ? JSON.stringify(data) : `export default ${JSON.stringify(data)}`
+			};
+			else return {
+				moduleType: "js",
+				code: `export default ${JSON.stringify(data)}`
+			};
+		},
+		bun: { load(source, input) {
+			const result = onMeta(source, input);
+			if (result === null) return {
+				loader: "object",
+				exports: parse$2(input.filePath, source, () => void 0).data
+			};
+			return result().then((data) => ({
+				loader: "object",
+				exports: { default: data }
+			}));
+		} }
+	};
+}
+// src/loaders/config.ts
+function createStandaloneConfigLoader({ core, buildConfig: buildConfig$1, mode }) {
+	let prev;
+	async function getConfigHash() {
+		if (mode === "production") return "static";
+		const stats = await fs.stat(core.configPath).catch(() => void 0);
+		return stats ? stats.mtime.getTime() : "missing";
+	}
+	async function load(hash) {
+		if (hash === "missing") return buildConfig({}, process.cwd());
+		return (await loadConfig(core, buildConfig$1)).config;
+	}
+	return { async getCore() {
+		const hash = await getConfigHash();
+		if (!prev || hash !== prev.hash) prev = {
+			hash,
+			init: core.init({ config: load(hash) })
+		};
+		await prev.init;
+		return core;
+	} };
+}
+/**
+* create config loader from initialized core
+*/
+function createIntegratedConfigLoader(core) {
+	return { async getCore() {
+		return core;
+	} };
+}
+// src/loaders/adapter.ts
+function toNode(test, loader) {
+	return async (url, _context, nextLoad) => {
+		if (url.startsWith("file:///") && (!test || test.test(url))) {
+			const parsedUrl = new URL(url);
+			const filePath = fileURLToPath(parsedUrl);
+			const result = await loader.load({
+				filePath,
+				query: Object.fromEntries(parsedUrl.searchParams.entries()),
+				async getSource() {
+					return await fs.readFile(filePath, "utf-8");
+				},
+				development: false,
+				compiler: { addDependency() {} }
+			});
+			if (result) return {
+				source: result.code,
+				format: "module",
+				shortCircuit: true
+			};
+		}
+		return nextLoad(url);
+	};
+}
+function toVite(loader, getInput) {
+	return { async transform(value, id) {
+		const [file, query = ""] = id.split("?", 2);
+		try {
+			const parsedQuery = parse$1(query);
+			if ("raw" in parsedQuery) return null;
+			const result = await loader.load({
+				...getInput?.(),
+				filePath: file,
+				query: parsedQuery,
+				getSource() {
+					return value;
+				},
+				development: this.environment ? this.environment.mode === "dev" : false,
+				compiler: { addDependency: (file) => {
+					this.addWatchFile(file);
+				} }
+			});
+			if (result === null) return null;
+			return {
+				code: result.code,
+				map: result.map ?? { mappings: "" },
+				moduleType: result.moduleType
+			};
+		} catch (e) {
+			if (e instanceof ValidationError) throw new Error(await e.toStringFormatted(), { cause: e });
+			throw e;
+		}
+	} };
+}
+/**
+* need to handle the `test` regex in Webpack config instead.
+*/
+function toWebpack(loader) {
+	return async function(source, callback) {
+		try {
+			const result = await loader.load({
+				filePath: this.resourcePath,
+				query: parse$1(this.resourceQuery.slice(1)),
+				getSource() {
+					return source;
+				},
+				development: this.mode === "development",
+				compiler: this
+			});
+			if (result === null) callback(void 0, source);
+			else callback(void 0, result.code, result.map);
+		} catch (error) {
+			if (error instanceof ValidationError) return callback(new Error(await error.toStringFormatted()));
+			if (!(error instanceof Error)) throw error;
+			callback(error);
+		}
+	};
+}
+function toBun(test, loader) {
+	function toResult(output) {
+		if (!output) return;
+		return {
+			contents: output.code,
+			loader: output.moduleType ?? "js"
+		};
+	}
+	return (build) => {
+		build.onLoad({ filter: test ?? /.+/ }, (args) => {
+			const [filePath, query = ""] = args.path.split("?", 2);
+			const input = {
+				async getSource() {
+					return Bun.file(filePath).text();
+				},
+				query: parse$1(query),
+				filePath,
+				development: false,
+				compiler: { addDependency() {} }
+			};
+			if (loader.bun?.load) return loader.bun.load(readFileSync(filePath, "utf-8"), input);
+			const result = loader.load(input);
+			if (result instanceof Promise) return result.then(toResult);
+			return toResult(result);
+		});
+	};
+}
+export { createIntegratedConfigLoader as a, readStaticParams as c, toWebpack as i, toNode as n, createStandaloneConfigLoader as o, toVite as r, createMetaLoader as s, toBun as t };

package/dist/{build-6pmheBOc.js → build-Bnz9TOnv.js}

@@ -1,12 +1,12 @@
-import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.js";
+import { t as __exportAll } from "./rolldown-runtime-D3KUYPsf.js";
 // src/loaders/mdx/build.ts
 var build_exports = /* @__PURE__ */ __exportAll({ buildMDX: () => buildMDX });
 async function buildMDX(core, collection, options) {
 	if ((collection ? collection.compiler : core.getConfig().global.compiler) === "satteri") {
-		const { buildSatteriMDX } = await import("./build-satteri-BRRVAMZo.js");
+		const { buildSatteriMDX } = await import("./build-satteri-D8On1S2_.js");
 		return buildSatteriMDX(core, collection, options);
 	}
-	const { buildJSMDX } = await import("./build-default-DxRVIZIq.js");
+	const { buildJSMDX } = await import("./build-default-BU_9K-PJ.js");
 	return buildJSMDX(core, collection, options);
 }
 export { build_exports as n, buildMDX as t };

package/dist/build-TiTOkhq4.js

@@ -0,0 +1,89 @@
+import path from "node:path";
+import picomatch from "picomatch";
+// src/config/build.ts
+const SupportedFormats = {
+	doc: ["mdx", "md"],
+	meta: [
+		"json",
+		"yaml",
+		"js",
+		"ts"
+	]
+};
+/** the default `files` of collections, meta files in code are named like `meta.ts` */
+const SupportedPatterns = {
+	doc: "**/*.{mdx,md}",
+	meta: "**/{*.{json,yaml},meta{,.*}.{js,ts}}"
+};
+function buildCollection(name, collection, cwd) {
+	if (collection.type === "docs") return {
+		...collection,
+		type: "docs",
+		get dir() {
+			return this.docs.dir;
+		},
+		name,
+		meta: buildCollection(name, collection.meta, cwd),
+		docs: buildCollection(name, collection.docs, cwd),
+		hasFile(filePath) {
+			return this.docs.hasFile(filePath) || this.meta.hasFile(filePath);
+		},
+		isFileSupported(filePath) {
+			return this.docs.isFileSupported(filePath) || this.meta.isFileSupported(filePath);
+		},
+		cwd
+	};
+	return {
+		...collection,
+		...buildPrimitiveCollection(name, collection, cwd)
+	};
+}
+function buildPrimitiveCollection(name, config, cwd) {
+	const supportedFormats = SupportedFormats[config.type];
+	const patterns = config.files ?? [SupportedPatterns[config.type]];
+	let matcher;
+	return {
+		dir: path.resolve(cwd, config.dir),
+		cwd,
+		name,
+		patterns,
+		isFileSupported(filePath) {
+			return supportedFormats.some((format) => filePath.endsWith(`.${format}`));
+		},
+		hasFile(filePath) {
+			if (!this.isFileSupported(filePath)) return false;
+			const relativePath = path.relative(this.dir, filePath);
+			if (relativePath.startsWith(`..${path.sep}`)) return false;
+			return (matcher ??= picomatch(patterns))(relativePath);
+		}
+	};
+}
+function buildConfig(config, cwd) {
+	const collections = /* @__PURE__ */ new Map();
+	const loaded = {};
+	for (const [k, v] of Object.entries(config)) {
+		if (!v) continue;
+		if (typeof v === "object" && "type" in v) {
+			if (v.type === "docs" || v.type === "doc" || v.type === "meta") {
+				collections.set(k, buildCollection(k, v, cwd));
+				continue;
+			}
+		}
+		if (k === "default" && v) {
+			Object.assign(loaded, v);
+			continue;
+		}
+		throw new Error(`Unknown export "${k}", you can only export collections from source configuration file.`);
+	}
+	return {
+		global: loaded,
+		collections,
+		workspaces: Object.fromEntries(Object.entries(loaded.workspaces ?? {}).map(([key, value]) => {
+			return [key, {
+				dir: value.dir,
+				config: buildConfig(value.config, path.resolve(cwd, value.dir))
+			}];
+		}))
+	};
+}
+export { buildCollection as n, buildConfig as r, SupportedPatterns as t };

package/dist/{build-default-DxRVIZIq.js → build-default-BU_9K-PJ.js}

@@ -1,4 +1,4 @@
-import { t as applyMdxPreset } from "./preset-Vhfrb01t.js";
+import { t as applyMdxPreset } from "./preset-BLDvTSeK.js";
 import { t as resolveLastModified } from "./last-modified-COIEvwZu.js";
 import { remarkInclude } from "fumadocs-core/mdx-plugins/remark-include";
 import { createProcessor } from "@mdx-js/mdx";
@@ -110,7 +110,7 @@ function getMdastExport(name, value) {
 	};
 }
 // src/loaders/mdx/build-default.ts
-async function buildJSMDX(core, collection, { filePath, frontmatter, source, _compiler, environment, isDevelopment, importsOnly = false }) {
+async function buildJSMDX(core, collection, { filePath, frontmatter, source, _compiler, environment, isDevelopment, importsOnly = false, params }) {
 	const mdxOptions = await getMDXOptions(core.getConfig(), collection, environment);
 	function getProcessor(format) {
 		const cache = core.cache;
@@ -150,6 +150,7 @@ async function buildJSMDX(core, collection, { filePath, frontmatter, source, _co
 		filePath,
 		source
 	}, vfile);
+	vfile.data.params = params;
 	const lastModified = await resolveLastModified(collection, filePath);
 	if (lastModified) {
 		vfile.data["mdx-export"] ??= [];

package/dist/{build-satteri-BRRVAMZo.js → build-satteri-D8On1S2_.js}

@@ -1,7 +1,7 @@
 import { t as resolveLastModified } from "./last-modified-COIEvwZu.js";
 import { pathToFileURL } from "node:url";
 // src/loaders/mdx/build-satteri.ts
-async function buildSatteriMDX(core, collection, { filePath, frontmatter, source, _compiler, environment, isDevelopment }) {
+async function buildSatteriMDX(core, collection, { filePath, frontmatter, source, _compiler, environment, isDevelopment, params }) {
 	const satteriOptions = await getSatteriOptions(core.getConfig(), collection, environment);
 	const format = filePath.endsWith(".mdx") ? "mdx" : "md";
 	const postprocess = {
@@ -25,6 +25,7 @@ async function buildSatteriMDX(core, collection, { filePath, frontmatter, source
 	const data = {
 		frontmatter,
 		_compiler,
+		params,
 		_cwd: collection?.cwd,
 		_valueToExport: collection?.postprocess?.valueToExport
 	};

package/dist/bun/index.d.ts

@@ -1,4 +1,4 @@
-import { r as CoreOptions } from "../core-CdciznjV.js";
+import { r as CoreOptions } from "../core-DA_zPpY3.js";
 import { n as ResolvedMacroOptions, t as MacroPluginOption } from "../options-BCId5Url.js";
 import { BunPlugin } from "bun";
 export interface MdxPluginOptions extends Pick<CoreOptions, 'configPath' | 'outDir' | 'plugins'> {

package/dist/bun/index.js

@@ -1,10 +1,10 @@
-import { t as createMdxLoader } from "../mdx-wIFREygW.js";
-import { i as buildConfig, t as createCore } from "../core-B3ysiPKS.js";
-import { r as slash } from "../codegen-D-Cjx_kh.js";
-import { a as createIntegratedConfigLoader, t as toBun } from "../adapter-C_fAYz8a.js";
-import { t as createMetaLoader } from "../meta-B2-_R5y0.js";
-import { r as metaLoaderGlob, t as mdxLoaderGlob } from "../loaders-B_gj5Fq1.js";
+import { t as createMdxLoader } from "../mdx-BDszS448.js";
+import { r as buildConfig } from "../build-TiTOkhq4.js";
+import { t as createCore } from "../core-BITOWTcu.js";
+import { a as createIntegratedConfigLoader, s as createMetaLoader, t as toBun } from "../adapter-C30pL0Cs.js";
+import { r as metaLoaderGlob, t as mdxLoaderGlob } from "../loaders-3R0gLmlP.js";
 import { r as resolveMacroOptions } from "../options-B2o-zV4A.js";
+import { i as slash } from "../codegen-COHeuzzn.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
@@ -44,7 +44,7 @@ function createMdxPlugin(options = {}) {
 			await core.init({ config: buildConfig(configExports, process.cwd()) });
 			if (macroOptions) {
 				const root = process.cwd();
-				const { MacroCollector } = await import("../eval-BK4eWlcF.js").then((n) => n.r);
+				const { MacroCollector } = await import("../eval-DNSTLHS_.js").then((n) => n.r);
 				const pendingEvals = /* @__PURE__ */ new Map();
 				core.macro = new MacroCollector({
 					root,
@@ -76,7 +76,7 @@ function createMdxPlugin(options = {}) {
 						contents: await transform(source, file) ?? source,
 						loader
 					};
-					const { transformMacroModule } = await import("../transform-CVIZq8Al.js").then((n) => n.i);
+					const { transformMacroModule } = await import("../transform-6dcWqSld.js").then((n) => n.i);
 					return {
 						contents: (await transformMacroModule({
 							code: source,

package/dist/code-BF5OS485.js

@@ -0,0 +1,86 @@
+import path from "node:path";
+import { createRequire } from "node:module";
+import { compileFunction } from "node:vm";
+import { buildSync } from "esbuild";
+import { Parser } from "acorn";
+import acornJsx from "acorn-jsx";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { mdxFromMarkdown } from "mdast-util-mdx";
+import { mdxjsEsm } from "micromark-extension-mdxjs-esm";
+// src/loaders/mdx/code.ts
+const esm = mdxjsEsm({
+	acorn: Parser.extend(acornJsx()),
+	acornOptions: {
+		ecmaVersion: "latest",
+		sourceType: "module"
+	},
+	addResult: true
+});
+/** run a module in code synchronously, like a meta file in TypeScript */
+function runModule(file, contents, addDependency) {
+	const { outputFiles, metafile } = buildSync({
+		stdin: {
+			contents,
+			sourcefile: file,
+			resolveDir: path.dirname(file),
+			loader: file.endsWith(".mdx") ? "tsx" : "ts"
+		},
+		bundle: true,
+		format: "cjs",
+		platform: "node",
+		packages: "external",
+		write: false,
+		metafile: true
+	});
+	for (const input in metafile.inputs) if (!input.startsWith("<")) addDependency(path.resolve(input));
+	const module = { exports: {} };
+	compileFunction(outputFiles[0].text, [
+		"module",
+		"exports",
+		"require"
+	], { filename: file })(module, module.exports, createRequire(file));
+	return module.exports;
+}
+/**
+* The frontmatter in the code of a page, `export const frontmatter = {...}`. It runs at build time with the imports it
+* reads, the statements before it in its ESM block and the params of a page as `props`, the content no longer has it.
+*/
+function frontmatterCode(filePath, content) {
+	if (!filePath.endsWith(".mdx") || !/^export const frontmatter\b/m.test(content)) return;
+	const tree = fromMarkdown(content, {
+		extensions: [esm],
+		mdastExtensions: [mdxFromMarkdown()]
+	});
+	const imports = [];
+	for (const node of tree.children) {
+		if (node.type !== "mdxjsEsm" || !node.data?.estree) continue;
+		let body = "";
+		const declarations = [];
+		for (const statement of node.data.estree.body) {
+			if (statement.type === "ImportDeclaration") imports.push(statement);
+			if (statement.type !== "ExportNamedDeclaration" || !statement.declaration?.range) continue;
+			const { declaration } = statement;
+			body += `${content.slice(...statement.declaration.range)}\n`;
+			declarations.push(declaration);
+			if (declaration.type !== "VariableDeclaration" || !declaration.declarations.some((item) => item.id.type === "Identifier" && item.id.name === "frontmatter")) continue;
+			const names = /* @__PURE__ */ new Set();
+			collectNames(declarations, names);
+			let code = "";
+			for (const item of imports) if (item.range && item.specifiers.some((specifier) => names.has(specifier.local.name))) code += `${content.slice(...item.range)}\n`;
+			const [start, end] = statement.range;
+			return {
+				content: content.slice(0, start) + content.slice(start, end).replace(/[^\n]/g, "") + content.slice(end),
+				/** compile it into a function of the params */
+				compile(addDependency) {
+					return runModule(filePath, `${code}export const frontmatter = (props = {}) => {\n${body}return frontmatter;\n};`, addDependency).frontmatter;
+				}
+			};
+		}
+	}
+}
+function collectNames(node, out) {
+	if (typeof node !== "object" || node === null) return;
+	if ("type" in node && node.type === "Identifier" && "name" in node) out.add(node.name);
+	for (const value of Object.values(node)) collectNames(value, out);
+}
+export { runModule as n, frontmatterCode as t };

package/dist/{codegen-D-Cjx_kh.js → codegen-COHeuzzn.js}

@@ -83,10 +83,15 @@ function createCodegen({ target = "default", outDir = "", jsExtension = false, g
 /**
 * Serialize a query object into a `?`-prefixed, percent-encoded string.
 */
+/**
+* The meta loader outputs JavaScript, for meta files in code too. Vite's `lang.*` flag tells it the language of a module
+* with a query, the language of `meta.ts?macro_id=app%2Fsource.ts%23docs` isn't detected otherwise.
+*/
+const metaLang = { "lang.js": "" };
 function stringifyQuery(query = {}) {
 	const searchParams = new URLSearchParams();
 	for (const [k, v] of Object.entries(query)) if (v !== void 0) searchParams.set(k, v);
-	return searchParams.size > 0 ? `?${searchParams}` : "";
+	return searchParams.size > 0 ? `?${searchParams.toString().replaceAll(/=(?=&|$)/g, "")}` : "";
 }
 /**
 * convert into POSIX & relative file paths, such that Vite can accept it.
@@ -104,4 +109,4 @@ function slash(path) {
 function ident(code, tab = 1) {
 	return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
 }
-export { ident as n, slash as r, createCodegen as t };
+export { slash as i, ident as n, metaLang as r, createCodegen as t };

package/dist/config/index.d.ts

@@ -1,7 +1,8 @@
-import { C as DocsCollection, D as defineCollections, E as SatteriPresetOptions, F as DefaultMDXOptions, I as MDXPresetOptions, L as applyMdxPreset, O as defineConfig, P as PostprocessOptions, S as DocCollectionSatteri, T as MetaCollection, _ as BaseCollection, b as DocCollectionBase, g as AnyCollection, k as defineDocs, v as CollectionSchema, w as GlobalConfig, x as DocCollectionMdx, y as DocCollection } from "../core-CdciznjV.js";
+import { C as DocsCollection, D as defineCollections, E as SatteriPresetOptions, F as DefaultMDXOptions, I as MDXPresetOptions, L as applyMdxPreset, O as defineConfig, P as PostprocessOptions, S as DocCollectionSatteri, T as MetaCollection, _ as BaseCollection, b as DocCollectionBase, g as AnyCollection, k as defineDocs, v as CollectionSchema, w as GlobalConfig, x as DocCollectionMdx, y as DocCollection } from "../core-DA_zPpY3.js";
 import { remarkInclude } from "fumadocs-core/mdx-plugins/remark-include";
 /** @deprecated import `pageSchema` from `fumadocs-core/source/schema` instead (since 16.2.3) */
 export declare const frontmatterSchema: import("zod").ZodObject<{
+  staticParams: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>>;
   title: import("zod").ZodString;
   description: import("zod").ZodOptional<import("zod").ZodString>;
   icon: import("zod").ZodOptional<import("zod").ZodString>;
@@ -11,6 +12,7 @@ export declare const frontmatterSchema: import("zod").ZodObject<{
 }, import("zod/v4/core").$strip>;
 /** @deprecated import from `fumadocs-core/source/schema` instead (since 16.2.3) */
 export declare const metaSchema: import("zod").ZodObject<{
+  staticParams: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>>;
   title: import("zod").ZodOptional<import("zod").ZodString>;
   pages: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
   pagesIndex: import("zod").ZodOptional<import("zod").ZodString>;

package/dist/config/index.js

@@ -1,5 +1,5 @@
 import { n as defineConfig, r as defineDocs, t as defineCollections } from "../define-C2jwQBlt.js";
-import { t as applyMdxPreset } from "../preset-Vhfrb01t.js";
+import { t as applyMdxPreset } from "../preset-BLDvTSeK.js";
 import { metaSchema as metaSchema$1, pageSchema } from "fumadocs-core/source/schema";
 import { remarkInclude } from "fumadocs-core/mdx-plugins/remark-include";
 // src/config/index.ts