fumadocs-mdx 15.5.3 → 15.6.0

package/dist/adapter-DUcfPohH.js

@@ -0,0 +1,143 @@
+import { r as buildConfig } from "./build-TiTOkhq4.js";
+import { n as ValidationError } from "./core-CJjfu3ju.js";
+import { t as loadConfig } from "./load-from-file-gZlf7m88.js";
+import { existsSync, readFileSync } from "node:fs";
+import fs from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { parse } from "node:querystring";
+// 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(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) => {
+					if (existsSync(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(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(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, toWebpack as i, toNode as n, createStandaloneConfigLoader as o, toVite as r, toBun as t };

package/dist/{build-Bnz9TOnv.js → build-ClrPX9Ea.js}

@@ -3,10 +3,10 @@ import { t as __exportAll } from "./rolldown-runtime-D3KUYPsf.js";
 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-D8On1S2_.js");
+		const { buildSatteriMDX } = await import("./build-satteri-D5Wi9P9C.js");
 		return buildSatteriMDX(core, collection, options);
 	}
-	const { buildJSMDX } = await import("./build-default-BU_9K-PJ.js");
+	const { buildJSMDX } = await import("./build-default-CQWQe8Am.js");
 	return buildJSMDX(core, collection, options);
 }
 export { build_exports as n, buildMDX as t };

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

@@ -1,5 +1,7 @@
-import { t as applyMdxPreset } from "./preset-BLDvTSeK.js";
-import { t as resolveLastModified } from "./last-modified-COIEvwZu.js";
+import { t as applyMdxPreset } from "./preset-CUfyGsn3.js";
+import { t as listCode } from "./code-output-CvL35taM.js";
+import { r as walkBranches, t as resolveLastModified } from "./last-modified-CCz7qakL.js";
+import { Parser } from "acorn";
 import { remarkInclude } from "fumadocs-core/mdx-plugins/remark-include";
 import { createProcessor } from "@mdx-js/mdx";
 import { VFile } from "vfile";
@@ -43,15 +45,20 @@ function remarkPostprocess({ includeProcessedMarkdown = false, includeMDAST = fa
 			value: frontmatter
 		});
 		if (extractLinkReferences) {
-			const urls = [];
-			walk(tree, (node) => {
-				if (node.type !== "link") return;
-				urls.push({ href: node.url });
-				return "skip";
+			const items = [];
+			walkBranches(tree, (node, when) => {
+				if (node.type === "link") items.push({
+					code: JSON.stringify({ href: node.url }),
+					when
+				});
 			});
-			file.data["mdx-export"].push({
-				name: "extractedReferences",
-				value: urls
+			tree.children.unshift({
+				type: "mdxjsEsm",
+				value: "",
+				data: { estree: Parser.parse(`export const extractedReferences = ${listCode(items, false)};`, {
+					ecmaVersion: "latest",
+					sourceType: "module"
+				}) }
 			});
 		}
 		if (includeProcessedMarkdown) remarkLLMs(typeof includeProcessedMarkdown === "object" ? includeProcessedMarkdown : void 0)(tree, file, () => void 0);
@@ -110,7 +117,7 @@ function getMdastExport(name, value) {
 	};
 }
 // src/loaders/mdx/build-default.ts
-async function buildJSMDX(core, collection, { filePath, frontmatter, source, _compiler, environment, isDevelopment, importsOnly = false, params }) {
+async function buildJSMDX(core, collection, { filePath, frontmatter, source, _compiler, environment, isDevelopment, importsOnly = false }) {
 	const mdxOptions = await getMDXOptions(core.getConfig(), collection, environment);
 	function getProcessor(format) {
 		const cache = core.cache;
@@ -142,7 +149,8 @@ async function buildJSMDX(core, collection, { filePath, frontmatter, source, _co
 		cwd: collection?.cwd,
 		data: {
 			frontmatter,
-			_compiler
+			_compiler,
+			unstable_runtimeOutputs: collection !== void 0
 		}
 	});
 	if (collection) vfile = await core.transformVFile({
@@ -150,7 +158,6 @@ 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-D8On1S2_.js → build-satteri-D5Wi9P9C.js}

@@ -1,7 +1,8 @@
-import { t as resolveLastModified } from "./last-modified-COIEvwZu.js";
+import { n as showConditions, t as resolveLastModified } from "./last-modified-CCz7qakL.js";
+import { t as listCode } from "./code-output-CvL35taM.js";
 import { pathToFileURL } from "node:url";
 // src/loaders/mdx/build-satteri.ts
-async function buildSatteriMDX(core, collection, { filePath, frontmatter, source, _compiler, environment, isDevelopment, params }) {
+async function buildSatteriMDX(core, collection, { filePath, frontmatter, source, _compiler, environment, isDevelopment }) {
 	const satteriOptions = await getSatteriOptions(core.getConfig(), collection, environment);
 	const format = filePath.endsWith(".mdx") ? "mdx" : "md";
 	const postprocess = {
@@ -25,9 +26,9 @@ async function buildSatteriMDX(core, collection, { filePath, frontmatter, source
 	const data = {
 		frontmatter,
 		_compiler,
-		params,
 		_cwd: collection?.cwd,
-		_valueToExport: collection?.postprocess?.valueToExport
+		_valueToExport: collection?.postprocess?.valueToExport,
+		unstable_runtimeOutputs: collection !== void 0
 	};
 	const mdastPlugins = [remarkInclude({ cwd: collection?.cwd })];
 	if (satteriOptions.mdastPlugins) mdastPlugins.push(...satteriOptions.mdastPlugins);
@@ -59,10 +60,15 @@ function postprocessPlugin({ extractLinkReferences = false }, lastModified) {
 			if (!frontmatter.title && node.depth === 1) frontmatter.title = ctx.textContent(node);
 		},
 		link(node, ctx) {
-			if (extractLinkReferences) ctx.data.extractedReferences.push({ href: node.url });
+			if (!extractLinkReferences) return;
+			const when = showConditions(node, ctx);
+			ctx.data.extractedReferences.push({
+				code: JSON.stringify({ href: node.url }),
+				when
+			});
 		},
 		collectExports({ data, addExport }) {
-			if (extractLinkReferences) addExport("extractedReferences", JSON.stringify(data.extractedReferences));
+			if (extractLinkReferences) addExport("extractedReferences", listCode(data.extractedReferences, false));
 			if (lastModified) addExport("lastModified", `new Date(${lastModified.getTime()})`);
 		}
 	};

package/dist/bun/index.d.ts

@@ -1,4 +1,4 @@
-import { r as CoreOptions } from "../core-DA_zPpY3.js";
+import { r as CoreOptions } from "../core-CrKTFOR5.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,7 +1,8 @@
-import { t as createMdxLoader } from "../mdx-VmqU5Oaj.js";
+import { t as createMdxLoader } from "../mdx-onCcdgWo.js";
 import { r as buildConfig } from "../build-TiTOkhq4.js";
 import { t as createCore } from "../core-CJjfu3ju.js";
-import { a as createIntegratedConfigLoader, s as createMetaLoader, t as toBun } from "../adapter-C04Ekc4W.js";
+import { a as createIntegratedConfigLoader, t as toBun } from "../adapter-DUcfPohH.js";
+import { t as createMetaLoader } from "../meta-CmTae89C.js";
 import { r as metaLoaderGlob, t as mdxLoaderGlob } from "../loaders-3R0gLmlP.js";
 import { r as resolveMacroOptions } from "../options-B2o-zV4A.js";
 import { r as slash } from "../codegen-BAuFQ5Ew.js";

package/dist/code-BWwFhg-7.js

@@ -0,0 +1,168 @@
+import { statSync } from "node:fs";
+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";
+// ../shared/frontmatter-code.ts
+/**
+* The frontmatter in code of an ESM block, `export const frontmatter = ...`, as the module of `frontmatter(props = {})`:
+* with the imports it reads and the exports before it in the block. `remove` is what to leave out of the content.
+*
+* @param imports - the imports of the document with their code, they are hoisted
+*/
+function frontmatterModule(source, block, imports, range) {
+	let body = "";
+	const declarations = [];
+	for (const statement of block) {
+		const { declaration } = statement;
+		if (statement.type !== "ExportNamedDeclaration" || !declaration) continue;
+		body += `${source.slice(...range(declaration))}\n`;
+		declarations.push(declaration);
+		const [first, second] = declaration.declarations ?? [];
+		if (first?.id.type !== "Identifier" || first.id.name !== "frontmatter") continue;
+		const names = /* @__PURE__ */ new Set();
+		collectNames(declarations, names);
+		let code = "";
+		for (const [item, text] of imports) if (item.specifiers?.some(({ local }) => local.name && names.has(local.name))) code += `${text}\n`;
+		return {
+			module: `${code}export const frontmatter = (props = {}) => {\n${body}return frontmatter;\n};`,
+			remove: second ? [range(first)[0], range(second)[0]] : range(statement)
+		};
+	}
+}
+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);
+}
+/**
+* The data of a meta file in code, like `meta.ts`, from its exports: the 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 metaModule({ default: data, staticParams = data?.staticParams }) {
+	if (typeof data === "function") return {
+		data: { staticParams },
+		dataAt: data
+	};
+	return { data: {
+		...data,
+		staticParams
+	} };
+}
+// src/loaders/mdx/code.ts
+const esm = mdxjsEsm({
+	acorn: Parser.extend(acornJsx()),
+	acornOptions: {
+		ecmaVersion: "latest",
+		sourceType: "module"
+	},
+	addResult: true
+});
+/** the last run of each module: its code, the modification times of the files it read, its exports */
+const modules = /* @__PURE__ */ new Map();
+/**
+* Run a module in code synchronously, like a meta file in TypeScript. Every page of a dynamic folder reads its meta
+* file, it runs again only when it or a file it reads changes.
+*/
+function runModule(file, contents, addDependency) {
+	const cached = modules.get(file);
+	if (cached?.contents === contents && cached.inputs.every(([input, time]) => mtime(input) === time)) {
+		for (const [input] of cached.inputs) addDependency(input);
+		return cached.exports;
+	}
+	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
+	});
+	const inputs = [];
+	for (const input in metafile.inputs) {
+		if (input.startsWith("<")) continue;
+		const resolved = path.resolve(input);
+		addDependency(resolved);
+		inputs.push([resolved, mtime(resolved)]);
+	}
+	const module = { exports: {} };
+	compileFunction(outputFiles[0].text, [
+		"module",
+		"exports",
+		"require"
+	], { filename: file })(module, module.exports, createRequire(file));
+	modules.set(file, {
+		contents,
+		inputs,
+		exports: module.exports
+	});
+	return module.exports;
+}
+function mtime(file) {
+	return statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? -1;
+}
+/**
+* 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 range = (node) => node.range;
+	const imports = [];
+	for (const node of tree.children) if (node.type === "mdxjsEsm") {
+		for (const statement of node.data?.estree?.body ?? []) if (statement.type === "ImportDeclaration") imports.push([statement, content.slice(...range(statement))]);
+	}
+	for (const node of tree.children) {
+		if (node.type !== "mdxjsEsm" || !node.data?.estree) continue;
+		const frontmatter = frontmatterModule(content, node.data.estree.body, imports, range);
+		if (!frontmatter) continue;
+		const [start, end] = frontmatter.remove;
+		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, frontmatter.module, addDependency).frontmatter;
+			}
+		};
+	}
+}
+/**
+* The frontmatter of a page, validated: the YAML with its frontmatter in code. A dynamic file has the frontmatter in
+* code of each params in `_frontmatterAt`.
+*
+* @param listed - whether to run the frontmatter in code of a dynamic file
+*/
+async function resolveFrontmatter({ code, yaml, staticParams, validate, addDependency, listed = true }) {
+	if (!code || !staticParams) return await validate(code ? {
+		...yaml,
+		...code.compile(addDependency)()
+	} : yaml);
+	const frontmatterAt = {};
+	if (listed) {
+		const run = code.compile(addDependency);
+		for (const item of staticParams) frontmatterAt[JSON.stringify(item)] = await validate({
+			...yaml,
+			...run(item)
+		});
+	}
+	return {
+		...yaml,
+		_frontmatterAt: frontmatterAt
+	};
+}
+export { metaModule as i, resolveFrontmatter as n, runModule as r, frontmatterCode as t };

package/dist/code-output-CvL35taM.js

@@ -0,0 +1,40 @@
+// ../shared/code-output.ts
+/**
+* An element as an HTML tag, so search dialogs render it as an element: its attributes that are text or `true`, with
+* values and content on one line, values truncated.
+*/
+function toHtmlTag(name, attributes, inner) {
+	let open = `<${name}`;
+	for (const key in attributes) {
+		const value = attributes[key];
+		if (value === true) open += ` ${key}`;
+		if (key === "children" || typeof value !== "string" && typeof value !== "number") continue;
+		let text = String(value).replace(/\s+/g, " ");
+		if (text.length > 100) text = `${text.slice(0, 100)}…`;
+		open += ` ${key}="${text.replaceAll("&", "&amp;").replaceAll("\"", "&quot;")}"`;
+	}
+	const children = inner.replace(/\s+/g, " ");
+	return children ? `${open}>${children}</${name}>` : `${open} />`;
+}
+/** all of the conditions */
+function and(conditions) {
+	if (conditions.length > 0) return `(${conditions.join(") && (")})`;
+}
+/**
+* The code of a list output: a function of the props giving the items whose conditions hold, or the list when static.
+* The list is read in document order, so an entry with `run` can count the items that show.
+*
+* @param declaration - the code that declares the names of the items, see {@link componentsCode}
+*/
+function listCode(items, isStatic, declaration = "") {
+	let list = "[";
+	for (const { code, when, run } of items) {
+		const test = and(when);
+		const item = run ? `...((${code}), [])` : code;
+		list += test ? `...(${test} ? [${item}] : []),` : `${item},`;
+	}
+	list += "]";
+	if (isStatic) return list;
+	return declaration ? `(props) => {\n${declaration}\nreturn ${list};\n}` : `(props) => ${list}`;
+}
+export { toHtmlTag as n, listCode as t };

package/dist/config/index.d.ts

@@ -1,4 +1,4 @@
-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 { 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-CrKTFOR5.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<{

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-BLDvTSeK.js";
+import { t as applyMdxPreset } from "../preset-CUfyGsn3.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

package/dist/{core-DA_zPpY3.d.ts → core-CrKTFOR5.d.ts}

@@ -1,14 +1,14 @@
-import { FC } from "react";
-import "fumadocs-core/source";
+import { FC, ReactNode } from "react";
 import { metaSchema, pageSchema } from "fumadocs-core/source/schema";
 import { ProcessorOptions } from "@mdx-js/mdx";
 import { VFile } from "vfile";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 import { Pluggable } from "unified";
 import * as Plugins from "fumadocs-core/mdx-plugins";
-import { LLMsOptions, StructuredData } from "fumadocs-core/mdx-plugins";
+import { LLMsOptions } from "fumadocs-core/mdx-plugins";
 import "mdast";
 import { SatteriPresetOptions, SatteriPresetOptions as SatteriPresetOptions$1 } from "@fumadocs/satteri/preset";
+import { StructuredData, StructuredDataContent } from "fumadocs-core/mdx-plugins/remark-structure";
 import { TOCItemType } from "fumadocs-core/toc";
 import { MDXProps } from "mdx/types";
 import { FSWatcher } from "chokidar";
@@ -20,7 +20,6 @@ type DefaultMDXOptions = Omit<NonNullable<ProcessorOptions>, 'rehypePlugins' | '
    * Properties to export from `vfile.data`
    */
   valueToExport?: string[];
-  remarkShowOptions?: Plugins.RemarkShowOptions;
   remarkStructureOptions?: Plugins.StructureOptions | false;
   remarkHeadingOptions?: Plugins.RemarkHeadingOptions;
   remarkImageOptions?: Plugins.RemarkImageOptions | false;
@@ -67,29 +66,37 @@ interface PostprocessOptions {
  * @returns `null`/`undefined` when unknown (e.g. the file isn't committed).
  */
 type LastModifiedFn = (filePath: string) => Promise<Date | null | undefined>;
+/** a record of structured data that `remarkStructure` exports for props, a heading has an `id` */
+interface StructuredRecord extends Partial<Omit<StructuredDataContent, 'content'>> {
+  id?: string;
+  content: ReactNode;
+}
+/** the export of `remarkStructure` for props: the records that show for the props of a page, in document order */
+type StructuredRecords = (props: Record<string, unknown>) => StructuredRecord[];
+/** the exports of a compiled page, its content and runtime outputs read the params of a page as props */
 interface CompiledMDXProperties<Frontmatter = Record<string, unknown>> {
   frontmatter: Frontmatter;
-  structuredData: StructuredData;
-  toc: TOCItemType[];
+  structuredData: StructuredData | StructuredRecords;
+  toc: TOCItemType[] | ((props: Record<string, unknown>) => TOCItemType[]);
   default: FC<MDXProps>;
+  extractedReferences?: ExtractedReference[] | ((props: Record<string, unknown>) => ExtractedReference[]);
   /**
    * Enable from `postprocess` option.
    *
-   * A component with `output: 'function'` in `includeProcessedMarkdown`,
-   * render it with `renderToMarkdown` from `fumadocs-core/server`.
+   * A string, or for runtime output a component, render it with `renderToMarkdown` from `fumadocs-core/server`.
    */
   _markdown?: string | FC<MDXProps>;
   /**
    * Enable from `postprocess` option.
    */
   _mdast?: string;
-  /** for a dynamic file, the module compiled for each of its params, by the params as JSON */
-  _pages?: Record<string, CompiledMDXProperties<Frontmatter>>;
 }
 declare module 'satteri' {
   interface DataMap {
+    /** the code of references, with the conditions of the branches of `<show>` around them */
     extractedReferences?: {
-      href: string;
+      code: string;
+      when: string[];
     }[];
   }
 }

package/dist/{index-BghUMTgU.d.ts → index-Cwcc8D9G.d.ts}

@@ -1,4 +1,4 @@
-import "./core-DA_zPpY3.js";
+import "./core-CrKTFOR5.js";
 interface WebpackLoaderOptions {
   type: 'webpack' | 'turbopack';
   /** absolute path */

package/dist/{index-file-BKxOSG_x.js → index-file-BwHGQnO1.js}

@@ -1,10 +1,12 @@
 import { n as ident, r as slash, t as createCodegen } from "./codegen-BAuFQ5Ew.js";
-import { t as frontmatterCode } from "./code-BF5OS485.js";
+import { n as resolveFrontmatter, t as frontmatterCode } from "./code-BWwFhg-7.js";
+import { n as readStaticParams } from "./meta-CmTae89C.js";
 import { frontmatter } from "fumadocs-core/content/md/frontmatter";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createHash } from "node:crypto";
 import { glob } from "tinyglobby";
+import { getStaticParams } from "fumadocs-core/source";
 // src/utils/fs-cache.ts
 const map = /* @__PURE__ */ new Map();
 function createFSCache() {
@@ -167,13 +169,20 @@ async function generateDynamicIndexFile(ctx) {
 		const fullPath = normalizePath(absolutePath);
 		const content = await indexFileCache.read(fullPath).catch(() => "");
 		const parsed = frontmatter(content);
-		const data = await core.transformFrontmatter({
-			collection,
-			filePath: absolutePath,
-			source: content
-		}, {
-			...parsed.data,
-			...frontmatterCode(absolutePath, parsed.content)?.compile(() => void 0)()
+		const yaml = parsed.data;
+		const data = await resolveFrontmatter({
+			code: frontmatterCode(absolutePath, parsed.content),
+			yaml,
+			staticParams: getStaticParams(slash(path.relative(collection.dir, absolutePath)), {
+				staticParams: yaml.staticParams,
+				readStaticParams: (meta) => readStaticParams(collection.dir, meta, () => void 0)
+			}),
+			validate: (data) => core.transformFrontmatter({
+				collection,
+				filePath: absolutePath,
+				source: content
+			}, data),
+			addDependency: () => void 0
 		});
 		const hash = createHash("md5").update(content).digest("hex");
 		const infoStr = [`absolutePath: path.resolve(${JSON.stringify(fullPath)})`];

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { N as ExtractedReference, a as EmitOptions, c as PluginContext, d as TransformOptions, i as EmitEntry, j as CompiledMDXProperties, l as PluginOption, n as Core, o as EmitOutput, r as CoreOptions, s as Plugin, t as CompilationContext, u as ServerContext } from "./core-DA_zPpY3.js";
+import { N as ExtractedReference, a as EmitOptions, c as PluginContext, d as TransformOptions, i as EmitEntry, j as CompiledMDXProperties, l as PluginOption, n as Core, o as EmitOutput, r as CoreOptions, s as Plugin, t as CompilationContext, u as ServerContext } from "./core-CrKTFOR5.js";
 export type { CompilationContext, CompiledMDXProperties, Core, CoreOptions, EmitEntry, EmitOptions, EmitOutput, ExtractedReference, Plugin, PluginContext, PluginOption, ServerContext, TransformOptions };