@docubook/core 1.8.2 → 2.0.0-alpha.1

package/dist/chunk-J7CN2VUH.js

@@ -0,0 +1,188 @@
+// src/mdx-compiler/serialize.ts
+import { compile } from "@mdx-js/mdx";
+import { VFile } from "vfile";
+import { matter } from "vfile-matter";
+
+// src/mdx-compiler/format-mdx-error.ts
+function createFormattedMDXError(error, _source) {
+  return new Error(`[mdx] error compiling MDX:
+${error?.message ?? error}`);
+}
+
+// src/mdx-compiler/plugins/remove-imports-exports.ts
+import { remove } from "unist-util-remove";
+function removeImportsExportsPlugin() {
+  return (tree) => remove(tree, "mdxjsEsm");
+}
+
+// src/mdx-compiler/plugins/remove-javascript-expressions.ts
+import { visit, SKIP } from "unist-util-visit";
+var removeJavaScriptExpressions = () => {
+  return (tree) => {
+    visit(tree, (node, index, parent) => {
+      if (node.type === "mdxFlowExpression" || node.type === "mdxTextExpression") {
+        if (parent && typeof index === "number") {
+          parent.children.splice(index, 1);
+          return [SKIP, index];
+        }
+      }
+      if (node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") {
+        const el = node;
+        if (el.attributes) {
+          el.attributes = el.attributes.filter((attr) => {
+            if (attr.type === "mdxJsxAttribute") {
+              return attr.value === null || typeof attr.value === "string" || attr.value && attr.value.type !== "mdxJsxAttributeValueExpression";
+            }
+            return attr.type !== "mdxJsxExpressionAttribute";
+          });
+        }
+      }
+    });
+  };
+};
+
+// src/mdx-compiler/plugins/remove-dangerous-javascript-expressions.ts
+var BLOCKED_GLOBALS = [
+  // Code execution
+  "eval",
+  "Function",
+  "AsyncFunction",
+  "GeneratorFunction",
+  // Module system
+  "require",
+  "module",
+  "exports",
+  "__dirname",
+  "__filename",
+  // Runtime
+  "process",
+  "global",
+  "globalThis",
+  "Reflect",
+  // File system / network
+  "child_process",
+  "fs",
+  "net",
+  "http",
+  "https",
+  "vm",
+  "worker_threads",
+  // Browser-like (available in Node/Deno)
+  "fetch",
+  "setTimeout",
+  "setInterval",
+  "setImmediate",
+  "queueMicrotask",
+  "XMLHttpRequest"
+];
+var BLOCKED_PROPERTIES = [
+  "constructor",
+  "prototype",
+  "__proto__",
+  "eval",
+  "Reflect",
+  "Function",
+  "AsyncFunction",
+  "GeneratorFunction",
+  "require"
+];
+function walk(node, blockedGlobals, blockedProperties) {
+  if (!node || typeof node !== "object") return;
+  if (node.type === "Identifier" && blockedGlobals.includes(node.name)) {
+    const parent = node.parent;
+    const isProperty = parent?.type === "MemberExpression" && parent.property === node && !parent.computed;
+    const isParam = parent?.type === "FunctionDeclaration" || parent?.type === "FunctionExpression";
+    if (!isProperty && !isParam) {
+      throw new Error(`Security: Access to '${node.name}' is not allowed`);
+    }
+  }
+  if (node.type === "CallExpression" && node.callee?.type === "Identifier" && blockedGlobals.includes(node.callee.name)) {
+    throw new Error(`Security: ${node.callee.name}() calls are not allowed`);
+  }
+  if (node.type === "ImportExpression") {
+    throw new Error("Security: Dynamic import() is not allowed");
+  }
+  if (node.type === "TaggedTemplateExpression" && node.tag?.type === "Identifier" && blockedGlobals.includes(node.tag.name)) {
+    throw new Error(`Security: ${node.tag.name}\`...\` tagged template is not allowed`);
+  }
+  if (node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.computed) {
+    throw new Error("Security: Function calls via computed property access are not allowed");
+  }
+  if (node.type === "MemberExpression" && !node.computed) {
+    const prop = node.property;
+    if (prop?.type === "Identifier" && blockedProperties.includes(prop.name)) {
+      throw new Error(`Security: .${prop.name} access is not allowed`);
+    }
+  }
+  if (node.type === "NewExpression" && node.callee?.type === "Identifier" && blockedGlobals.includes(node.callee.name)) {
+    throw new Error(`Security: new ${node.callee.name}() is not allowed`);
+  }
+  for (const key in node) {
+    if (key === "parent" || key === "position") continue;
+    const value = node[key];
+    if (Array.isArray(value)) {
+      value.forEach((child) => {
+        if (child && typeof child === "object") walk(child, blockedGlobals, blockedProperties);
+      });
+    } else if (value && typeof value === "object") {
+      walk(value, blockedGlobals, blockedProperties);
+    }
+  }
+}
+var CreateRemoveDangerousCallsPlugin = (blockedGlobals, blockedProperties) => {
+  return () => (tree) => {
+    walk(tree, blockedGlobals ?? BLOCKED_GLOBALS, blockedProperties ?? BLOCKED_PROPERTIES);
+    return tree;
+  };
+};
+
+// src/mdx-compiler/serialize.ts
+function getCompileOptions(mdxOptions = {}, rsc = false, blockJS = true, outputFormat = "function-body", format = "mdx") {
+  const remarkPlugins = [
+    ...mdxOptions?.remarkPlugins ?? [],
+    removeImportsExportsPlugin,
+    ...blockJS ? [removeJavaScriptExpressions] : [],
+    // Defense-in-depth: audit remaining AST for dangerous patterns.
+    CreateRemoveDangerousCallsPlugin()
+  ];
+  return {
+    ...mdxOptions,
+    remarkPlugins,
+    rehypePlugins: mdxOptions?.rehypePlugins ?? [],
+    format,
+    outputFormat,
+    providerImportSource: rsc ? void 0 : "@mdx-js/react",
+    development: process.env.NODE_ENV !== "production"
+  };
+}
+async function serialize(source, {
+  scope = {},
+  mdxOptions = {},
+  parseFrontmatter = false,
+  blockJS = true,
+  outputFormat = "function-body",
+  format = "mdx"
+} = {}, rsc = false) {
+  const vfile = new VFile(source);
+  if (parseFrontmatter) {
+    matter(vfile, { strip: true });
+  }
+  let compiledSource;
+  try {
+    compiledSource = String(
+      await compile(vfile, getCompileOptions(mdxOptions, rsc, blockJS, outputFormat, format))
+    );
+  } catch (error) {
+    throw createFormattedMDXError(error, String(vfile));
+  }
+  return {
+    compiledSource,
+    frontmatter: vfile.data.matter ?? {},
+    scope
+  };
+}
+
+export {
+  serialize
+};
+//# sourceMappingURL=chunk-J7CN2VUH.js.map

package/dist/chunk-J7CN2VUH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mdx-compiler/serialize.ts","../src/mdx-compiler/format-mdx-error.ts","../src/mdx-compiler/plugins/remove-imports-exports.ts","../src/mdx-compiler/plugins/remove-javascript-expressions.ts","../src/mdx-compiler/plugins/remove-dangerous-javascript-expressions.ts"],"sourcesContent":["// MPL-2.0 — derived from next-mdx-remote (IBM). See LICENSE-MPL-2.0.\nimport { compile } from \"@mdx-js/mdx\";\nimport { VFile } from \"vfile\";\nimport { matter } from \"vfile-matter\";\nimport { createFormattedMDXError } from \"./format-mdx-error.js\";\nimport { removeImportsExportsPlugin } from \"./plugins/remove-imports-exports.js\";\nimport { removeJavaScriptExpressions } from \"./plugins/remove-javascript-expressions.js\";\nimport { CreateRemoveDangerousCallsPlugin } from \"./plugins/remove-dangerous-javascript-expressions.js\";\nimport type { Pluggable } from \"unified\";\n\n/** @internal — re-exported from unified. */\ntype RemarkPlugins = Pluggable[];\ntype RehypePlugins = Pluggable[];\n\nexport type { MDXRemoteSerializeResult } from \"./types\";\n\nexport type SerializeOptions = {\n  scope?: Record<string, unknown>;\n  mdxOptions?: {\n    remarkPlugins?: RemarkPlugins;\n    rehypePlugins?: RehypePlugins;\n  };\n  parseFrontmatter?: boolean;\n  /**\n   * MDX compile output shape.\n   * - `\"function-body\"` (default): JS function body string for `<MDXRemote>`.\n   * - `\"program\"`: full ESM module source (imports + `export default MDXContent`)\n   *   for static bundling / hydration without `new Function`.\n   * @default \"function-body\"\n   */\n  outputFormat?: \"function-body\" | \"program\";\n  /**\n   * MDX input format.\n   * - `\"mdx\"` (default): JSX tags are parsed and resolve via the components map.\n   * - `\"md\"`: plain markdown — authored JSX tags are NOT parsed (dropped,\n   *   content kept as text). Markdown directives (`:::`/`::`/`::::`) still\n   *   work; this is the v2 authoring contract (no JSX tags).\n   * @default \"mdx\"\n   */\n  format?: \"mdx\" | \"md\";\n  /**\n   * Strip JavaScript expressions from MDX (default: true).\n   * When true, removes all `{expression}` and JSX attribute expression nodes\n   * before compilation. When false, expressions are preserved but a\n   * security sanitizer audits the AST for dangerous patterns.\n   * @default true\n   */\n  blockJS?: boolean;\n};\n\nexport type SerializeResult = {\n  compiledSource: string;\n  frontmatter: Record<string, unknown>;\n  scope: Record<string, unknown>;\n};\n\nfunction getCompileOptions(\n  mdxOptions: SerializeOptions[\"mdxOptions\"] = {},\n  rsc = false,\n  blockJS = true,\n  outputFormat: NonNullable<SerializeOptions[\"outputFormat\"]> = \"function-body\",\n  format: NonNullable<SerializeOptions[\"format\"]> = \"mdx\"\n) {\n  const remarkPlugins = [\n    ...(mdxOptions?.remarkPlugins ?? []),\n    removeImportsExportsPlugin,\n    ...(blockJS ? [removeJavaScriptExpressions] : []),\n    // Defense-in-depth: audit remaining AST for dangerous patterns.\n    CreateRemoveDangerousCallsPlugin(),\n  ];\n\n  return {\n    ...mdxOptions,\n    remarkPlugins,\n    rehypePlugins: mdxOptions?.rehypePlugins ?? [],\n    format,\n    outputFormat,\n    providerImportSource: rsc ? undefined : \"@mdx-js/react\",\n    development: process.env.NODE_ENV !== \"production\",\n  };\n}\n\n/**\n * Compile raw MDX string into a serialized result that can be rendered.\n */\nexport async function serialize(\n  source: string,\n  {\n    scope = {},\n    mdxOptions = {},\n    parseFrontmatter = false,\n    blockJS = true,\n    outputFormat = \"function-body\",\n    format = \"mdx\",\n  }: SerializeOptions = {},\n  rsc = false\n): Promise<SerializeResult> {\n  const vfile = new VFile(source);\n\n  if (parseFrontmatter) {\n    matter(vfile, { strip: true });\n  }\n\n  let compiledSource: string;\n  try {\n    compiledSource = String(\n      await compile(vfile, getCompileOptions(mdxOptions, rsc, blockJS, outputFormat, format))\n    );\n  } catch (error: any) {\n    throw createFormattedMDXError(error, String(vfile));\n  }\n\n  return {\n    compiledSource,\n    frontmatter: (vfile.data.matter ?? {}) as Record<string, unknown>,\n    scope,\n  };\n}\n","// MPL-2.0 — derived from next-mdx-remote (IBM). See LICENSE-MPL-2.0.\n/**\n * Wraps raw MDX compilation errors with a clear message prefix.\n */\nexport function createFormattedMDXError(error: any, _source: string): Error {\n  return new Error(`[mdx] error compiling MDX:\\n${error?.message ?? error}`);\n}\n","// MPL-2.0 — derived from next-mdx-remote (IBM). See LICENSE-MPL-2.0.\nimport { remove } from \"unist-util-remove\";\nimport type { Node } from \"unist\";\n\n/** remark plugin: strips all `mdxjsEsm` nodes (import/export statements). */\nexport function removeImportsExportsPlugin() {\n  return (tree: Node) => remove(tree, \"mdxjsEsm\");\n}\n","// MPL-2.0 — derived from next-mdx-remote (IBM). See LICENSE-MPL-2.0.\nimport { visit, SKIP } from \"unist-util-visit\";\nimport type { Node } from \"unist\";\n\n/**\n * remark plugin: removes JS expression nodes ({variable}, {func()}) from MDX.\n * Preserves JSX (<Component />) and plain markdown.\n */\nexport const removeJavaScriptExpressions = () => {\n  return (tree: Node) => {\n    visit(tree, (node: Node, index: number | undefined, parent: Node | undefined) => {\n      if (node.type === \"mdxFlowExpression\" || node.type === \"mdxTextExpression\") {\n        if (parent && typeof index === \"number\") {\n          (parent as any).children.splice(index, 1);\n          return [SKIP, index] as const;\n        }\n      }\n\n      if (node.type === \"mdxJsxFlowElement\" || node.type === \"mdxJsxTextElement\") {\n        const el = node as any;\n        if (el.attributes) {\n          el.attributes = el.attributes.filter((attr: any) => {\n            if (attr.type === \"mdxJsxAttribute\") {\n              return (\n                attr.value === null ||\n                typeof attr.value === \"string\" ||\n                (attr.value && attr.value.type !== \"mdxJsxAttributeValueExpression\")\n              );\n            }\n            return attr.type !== \"mdxJsxExpressionAttribute\";\n          });\n        }\n      }\n    });\n  };\n};\n","// MPL-2.0 — derived from next-mdx-remote (IBM). See LICENSE-MPL-2.0.\nimport type { Node } from \"unist\";\n\nconst BLOCKED_GLOBALS = [\n  // Code execution\n  \"eval\",\n  \"Function\",\n  \"AsyncFunction\",\n  \"GeneratorFunction\",\n  // Module system\n  \"require\",\n  \"module\",\n  \"exports\",\n  \"__dirname\",\n  \"__filename\",\n  // Runtime\n  \"process\",\n  \"global\",\n  \"globalThis\",\n  \"Reflect\",\n  // File system / network\n  \"child_process\",\n  \"fs\",\n  \"net\",\n  \"http\",\n  \"https\",\n  \"vm\",\n  \"worker_threads\",\n  // Browser-like (available in Node/Deno)\n  \"fetch\",\n  \"setTimeout\",\n  \"setInterval\",\n  \"setImmediate\",\n  \"queueMicrotask\",\n  \"XMLHttpRequest\",\n];\n\nconst BLOCKED_PROPERTIES = [\n  \"constructor\",\n  \"prototype\",\n  \"__proto__\",\n  \"eval\",\n  \"Reflect\",\n  \"Function\",\n  \"AsyncFunction\",\n  \"GeneratorFunction\",\n  \"require\",\n];\n\nfunction walk(node: any, blockedGlobals: string[], blockedProperties: string[]) {\n  if (!node || typeof node !== \"object\") return;\n\n  if (node.type === \"Identifier\" && blockedGlobals.includes(node.name)) {\n    const parent = node.parent;\n    const isProperty =\n      parent?.type === \"MemberExpression\" && parent.property === node && !parent.computed;\n    const isParam = parent?.type === \"FunctionDeclaration\" || parent?.type === \"FunctionExpression\";\n    if (!isProperty && !isParam) {\n      throw new Error(`Security: Access to '${node.name}' is not allowed`);\n    }\n  }\n\n  // Block direct calls to blocked globals: eval(), Function(), fetch(), etc.\n  if (\n    node.type === \"CallExpression\" &&\n    node.callee?.type === \"Identifier\" &&\n    blockedGlobals.includes(node.callee.name)\n  ) {\n    throw new Error(`Security: ${node.callee.name}() calls are not allowed`);\n  }\n\n  // Block dynamic import(): import(\"node:fs\")\n  if (node.type === \"ImportExpression\") {\n    throw new Error(\"Security: Dynamic import() is not allowed\");\n  }\n\n  // Block tagged template literals on blocked globals: eval`...`\n  if (\n    node.type === \"TaggedTemplateExpression\" &&\n    node.tag?.type === \"Identifier\" &&\n    blockedGlobals.includes(node.tag.name)\n  ) {\n    throw new Error(`Security: ${node.tag.name}\\`...\\` tagged template is not allowed`);\n  }\n\n  // Block computed MemberExpression calls on any object identifier\n  // Catches: Object[\"constructor\"](...), Object[\"con\"+\"structor\"](...), etc.\n  if (\n    node.type === \"CallExpression\" &&\n    node.callee?.type === \"MemberExpression\" &&\n    node.callee.computed\n  ) {\n    throw new Error(\"Security: Function calls via computed property access are not allowed\");\n  }\n\n  // Block non-computed property access to dangerous properties:\n  // obj.constructor, obj.prototype, obj.__proto__\n  if (node.type === \"MemberExpression\" && !node.computed) {\n    const prop = node.property;\n    if (prop?.type === \"Identifier\" && blockedProperties.includes(prop.name)) {\n      throw new Error(`Security: .${prop.name} access is not allowed`);\n    }\n  }\n\n  // Block new expressions: new Function(...)\n  if (\n    node.type === \"NewExpression\" &&\n    node.callee?.type === \"Identifier\" &&\n    blockedGlobals.includes(node.callee.name)\n  ) {\n    throw new Error(`Security: new ${node.callee.name}() is not allowed`);\n  }\n\n  for (const key in node) {\n    if (key === \"parent\" || key === \"position\") continue;\n    const value = node[key];\n    if (Array.isArray(value)) {\n      value.forEach((child: any) => {\n        if (child && typeof child === \"object\") walk(child, blockedGlobals, blockedProperties);\n      });\n    } else if (value && typeof value === \"object\") {\n      walk(value, blockedGlobals, blockedProperties);\n    }\n  }\n}\n\nexport const CreateRemoveDangerousCallsPlugin = (\n  blockedGlobals?: string[],\n  blockedProperties?: string[]\n) => {\n  return () => (tree: Node) => {\n    walk(tree, blockedGlobals ?? BLOCKED_GLOBALS, blockedProperties ?? BLOCKED_PROPERTIES);\n    return tree;\n  };\n};\n"],"mappings":"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","names":[]}

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-import { ReactNode } from 'react';
 export { cn, formatDate, formatDate2, parseDate, stringToDate, toIsoDateOnly } from './utils.js';
-import { compileMDX } from '@docubook/mdx-remote/rsc';
-import { Node } from 'unist';
 import { Pluggable } from 'unified';
-export { MDXRemote } from '@docubook/mdx-remote';
-export { serialize } from '@docubook/mdx-remote/serialize';
+import { Node } from 'unist';
+import { ZodType } from 'zod';
+import { MDXComponents } from 'mdx/types.js';
+import React from 'react';
+import { MDXRemoteSerializeResult } from './mdx-compiler/serialize.js';
+export { SerializeOptions, SerializeResult, serialize } from './mdx-compiler/serialize.js';
 import 'clsx';
 
 type TocItem = {
@@ -12,32 +13,52 @@ type TocItem = {
     text: string;
     href: string;
 };
-type MdxCompileResult<Frontmatter> = {
-    content: ReactNode;
-    frontmatter: Frontmatter;
-    scope?: Record<string, unknown>;
-};
 
-type CompileMdxInput = Parameters<typeof compileMDX<Record<string, unknown>>>[0];
-type CompileMdxOptions = NonNullable<CompileMdxInput["options"]>;
-type CompilerMdxOptions = NonNullable<CompileMdxOptions["mdxOptions"]>;
-type ParseMdxOptions = {
-    components?: CompileMdxInput["components"];
-    rehypePlugins?: CompilerMdxOptions["rehypePlugins"];
-    remarkPlugins?: CompilerMdxOptions["remarkPlugins"];
+/**
+ * Custom merge function.
+ */
+type MergeComponents = (currentComponents: Readonly<MDXComponents>) => MDXComponents;
+/**
+ * Configuration for `MDXProvider`.
+ */
+type Props = {
     /**
-     * Whether to parse frontmatter during MDX compilation.
-     * Set to `false` when frontmatter is already extracted separately
-     * (e.g. via gray-matter) to avoid redundant parsing.
-     * Defaults to `true`.
+     * Children (optional).
      */
-    parseFrontmatter?: boolean;
+    children?: React.ReactNode | null | undefined;
+    /**
+     * Additional components to use or a function that creates them (optional).
+     */
+    components?: Readonly<MDXComponents> | MergeComponents | null | undefined;
+    /**
+     * Turn off outer component context (default: `false`).
+     */
+    disableParentContext?: boolean | null | undefined;
+};
+
+/** Props for the client-side `<MDXRemote>` (accepts pre-serialized result). */
+type MDXRemoteProps = MDXRemoteSerializeResult & {
+    components?: Record<string, React.ComponentType<any>>;
+    /** Defer hydration to an idle callback */
+    lazy?: boolean;
 };
+/**
+ * Client-side MDX renderer.
+ *
+ * Accepts a pre-compiled result from `serialize()` and renders it via
+ * `MDXProvider` for custom component injection.
+ */
+declare function MDXRemote({ compiledSource, frontmatter, scope, components, lazy, }: MDXRemoteProps): React.DetailedReactHTMLElement<{
+    dangerouslySetInnerHTML: {
+        __html: string;
+    };
+    suppressHydrationWarning: true;
+}, HTMLElement> | React.FunctionComponentElement<Readonly<Props>> | React.DetailedReactHTMLElement<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+
 declare const preProcess: () => (tree: Node) => Node;
 declare const postProcess: () => (tree: Node) => Node;
 declare function createDefaultRehypePlugins(): Pluggable[];
 declare function createDefaultRemarkPlugins(): Pluggable[];
-declare function parseMdx<Frontmatter>(rawMdx: string, options?: ParseMdxOptions): Promise<MdxCompileResult<Frontmatter>>;
 
 declare const handleCodeTitles: () => (tree: Node) => void;
 
@@ -54,65 +75,48 @@ declare const handleCodeExpandable: () => (tree: Node) => void;
  */
 declare const rehypeMermaid: () => (tree: Node) => void;
 
+/**
+ * Remark plugin: convert markdown directives into MDX component elements.
+ *
+ * Contract (docubook):
+ * - `:::name{attrs} … :::` — container: EVERY component that holds content
+ *   (tabs, tab, accordions, accordion, steps, step, cards, card, files,
+ *   folder, note + variants). Children are the block between the opening
+ *   `:::` and closing `:::` — bounded by micromark's container grammar, so
+ *   a component can never trap siblings that follow it.
+ * - `::name{attrs}` — self-closing leaf (no children): file, youtube,
+ *   mermaid.
+ * - `:tooltip[label]{tip="…"}` — the ONE inline (single-colon) directive.
+ *   Every other text directive is rebuilt as literal text
+ *   (`localhost:3000` stays intact). `::tooltip` (block leaf) is removed
+ *   in v2 — tooltips are inline only.
+ *
+ * Names are PascalCased to match the components map (`file-tree` → `FileTree`).
+ * Bare attributes (`{horizontal}`) become boolean props (JSX bare attribute).
+ * Callout variants (`:::tip`, `:::info`, …) map to their own registry entries
+ * (`Tip`/`Info`/…) which wrap the `Callout` component with the type set.
+ */
+declare function remarkDirectiveToMdx(): (tree: Node) => Node;
+
 declare function sluggify(text: string): string;
 declare function extractTocsFromRawMdx(rawMdx: string): TocItem[];
 declare function extractFrontmatter<Frontmatter>(content: string): Frontmatter;
 /**
  * Extract frontmatter and return both the parsed data and the content
- * with the frontmatter block stripped. Avoids a second parse by compileMDX.
+ * with the frontmatter block stripped. Avoids a second parse during
+ * compilation.
+ *
+ * Optionally validates the parsed frontmatter with a Zod schema.
+ * YAML coerces unquoted values (e.g. `date: 2026-06-10` → Date, `3.5` → number),
+ * so use `z.coerce.*` for fields that must remain strings.
  */
 declare function extractFrontmatterWithContent<Frontmatter>(content: string): {
     frontmatter: Frontmatter;
     strippedContent: string;
 };
-
-type CacheFn = <T extends (...args: any[]) => any>(fn: T) => T;
-type ReadMdxFileResult = {
-    content: string;
-    /** Relative path used for UI links (e.g. "docs/getting-started/index.mdx"). */
-    filePath: string;
-    /** Absolute path on disk — available when file was read by readMdxFileBySlug. */
-    absoluteFilePath?: string;
-};
-type ParsedMdxFile<Frontmatter, T extends TocItem = TocItem> = {
-    /** Raw content with frontmatter block stripped — ready to pass to compileMDX. */
-    content: string;
-    filePath: string;
+declare function extractFrontmatterWithContent<Frontmatter>(content: string, schema: ZodType<Frontmatter>): {
     frontmatter: Frontmatter;
-    tocs: T[];
-};
-type CompiledMdxFile<Frontmatter, T extends TocItem = TocItem> = MdxCompileResult<Frontmatter> & {
-    filePath: string;
-    tocs: T[];
-};
-type ReadMdxBySlugOptions = {
-    rootDir?: string;
-    docsDir?: string;
-};
-declare function readMdxFileBySlug(slug: string, options?: ReadMdxBySlugOptions): Promise<ReadMdxFileResult>;
-type ParseMdxFileOptions<T extends TocItem> = {
-    tocsExtractor?: (rawMdx: string) => T[];
-};
-declare function parseMdxFile<Frontmatter, T extends TocItem = TocItem>(raw: ReadMdxFileResult, options?: ParseMdxFileOptions<T>): ParsedMdxFile<Frontmatter, T>;
-declare function compileParsedMdxFile<Frontmatter, T extends TocItem = TocItem>(parsed: ParsedMdxFile<Frontmatter, T>, options?: ParseMdxOptions): Promise<CompiledMdxFile<Frontmatter, T>>;
-type CreateMdxContentServiceOptions<Frontmatter, T extends TocItem = TocItem> = {
-    parseOptions?: ParseMdxOptions;
-    readOptions?: ReadMdxBySlugOptions;
-    tocsExtractor?: (rawMdx: string) => T[];
-    cacheFn?: CacheFn;
-    /**
-     * Optional hook to enrich or transform frontmatter after parsing.
-     * Called with the parsed frontmatter and the absolute file path.
-     * Runs at build time during static generation — ideal for injecting
-     * fallback values (e.g. git last-modified date when `date` is absent).
-     */
-    frontmatterEnricher?: (frontmatter: Frontmatter, absoluteFilePath: string) => Frontmatter | Promise<Frontmatter>;
-};
-declare function createMdxContentService<Frontmatter, T extends TocItem = TocItem>(options?: CreateMdxContentServiceOptions<Frontmatter, T>): {
-    getParsedForSlug: (slug: string) => Promise<ParsedMdxFile<Frontmatter, T>>;
-    getCompiledForSlug: (slug: string) => Promise<CompiledMdxFile<Frontmatter, T>>;
-    getFrontmatterForSlug: (slug: string) => Promise<Frontmatter>;
-    getTocsForSlug: (slug: string) => Promise<T[]>;
+    strippedContent: string;
 };
 
-export { type CompiledMdxFile, type CreateMdxContentServiceOptions, type MdxCompileResult, type ParseMdxOptions, type ParsedMdxFile, type ReadMdxFileResult, type TocItem, compileParsedMdxFile, createDefaultRehypePlugins, createDefaultRemarkPlugins, createMdxContentService, extractFrontmatter, extractFrontmatterWithContent, extractTocsFromRawMdx, handleCodeExpandable, handleCodeExpandableRemark, handleCodeTitles, parseMdx, parseMdxFile, postProcess, preProcess, readMdxFileBySlug, rehypeMermaid, sluggify };
+export { MDXRemote, type MDXRemoteProps, MDXRemoteSerializeResult, type TocItem, createDefaultRehypePlugins, createDefaultRemarkPlugins, extractFrontmatter, extractFrontmatterWithContent, extractTocsFromRawMdx, handleCodeExpandable, handleCodeExpandableRemark, handleCodeTitles, postProcess, preProcess, rehypeMermaid, remarkDirectiveToMdx, sluggify };