boltdocs 2.7.11 → 2.8.1

package/dist/node/index.d.mts

@@ -1,7 +1,7 @@
 
-import * as _$vite from "vite";
 import { InlineConfig, Plugin } from "vite";
 import { z } from "zod";
+import { EXIT, SKIP } from "unist-util-visit";
 //#region src/shared/types.d.ts
 /**
  * Represents a single social link in the configuration.
@@ -31,15 +31,15 @@ interface BoltdocsThemeConfig {
   };
   navbar?: Array<{
     label: string | Record<string, string>;
-    href: string;
+    href: BoltdocsRoutePathWithFallback;
     items?: Array<{
       label: string | Record<string, string>;
-      href: string;
+      href: BoltdocsRoutePathWithFallback;
     }>;
   }>;
   sidebar?: Record<string, Array<{
     text: string;
-    link: string;
+    link: BoltdocsRoutePathWithFallback;
   }>>;
   sidebarGroups?: Record<string, {
     title?: string | Record<string, string>;
@@ -109,24 +109,44 @@ interface BoltdocsVersionsConfig {
   prefix?: string;
   versions: BoltdocsVersionConfig[];
 }
+/**
+ * Shared badge value type used in frontmatter, RouteMeta, and ComponentRoute.
+ */
+type BadgeValue = string | {
+  text: string;
+  expires?: string;
+};
 /**
  * Defines a Boltdocs plugin.
+ *
+ * Use the `createPlugin()` helper from the node API for full type safety and
+ * access to lifecycle hooks.
  */
 interface BoltdocsPlugin {
   name: string;
   enforce?: 'pre' | 'post';
   version?: string;
   boltdocsVersion?: string;
-  permissions?: string[];
   remarkPlugins?: unknown[];
   rehypePlugins?: unknown[];
   vitePlugins?: Plugin[];
   components?: Record<string, string>;
-  hooks?: Record<string, any>;
+  /** Lifecycle hooks — use the `PluginLifecycleHooks` type from the node API. */
+  hooks?: Record<string, (ctx: unknown) => Promise<void> | void>;
 }
 /**
- * Configuration for security-related settings.
- */
+ * Configuration for the collections (blog) feature.
+ */
+interface BoltdocsCollectionsConfig {
+  /** Number of posts per page in collection listing pages. Defaults to 10. */
+  postsPerPage?: number;
+  /** The name of the default collection used by BlogList when none is specified. */
+  defaultCollection?: string;
+  /** Date format string for rendering post dates (e.g., 'MMMM dd, yyyy'). */
+  dateFormat?: string;
+  /** Field to sort posts by. Defaults to 'date'. */
+  sortBy?: 'date' | 'title' | 'sidebarPosition';
+}
 interface BoltdocsSecurityConfig {
   headers?: Record<string, string>;
   enableCSP?: boolean;
@@ -166,9 +186,18 @@ interface BoltdocsGTMConfig {
   dataLayerName?: string;
   preview?: string;
 }
+/**
+ * Configuration for Algolia DocSearch.
+ */
+interface BoltdocsAlgoliaConfig {
+  appId: string;
+  apiKey: string;
+  indexName: string;
+}
 interface BoltdocsIntegrationsConfig {
   ga4?: BoltdocsGA4Config;
   gtm?: BoltdocsGTMConfig;
+  algolia?: BoltdocsAlgoliaConfig;
 }
 /**
  * The root configuration object for Boltdocs.
@@ -181,6 +210,7 @@ interface BoltdocsConfig {
   i18n?: BoltdocsI18nConfig;
   versions?: BoltdocsVersionsConfig;
   plugins?: BoltdocsPlugin[];
+  collections?: BoltdocsCollectionsConfig;
   robots?: BoltdocsRobotsConfig;
   security?: BoltdocsSecurityConfig;
   seo?: BoltdocsSeoConfig;
@@ -196,8 +226,16 @@ interface BoltdocsConfig {
 declare global {
   namespace Boltdocs {
     interface Types {}
+    /**
+     * Marker interface augmented by generated code to provide strict route path typing.
+     * When no types have been generated (e.g., before first dev server start),
+     * keyof is never, and BoltdocsRoutePath falls back to string.
+     */
+    interface RoutePaths {}
   }
 }
+type BoltdocsRoutePath = keyof Boltdocs.RoutePaths;
+type BoltdocsRoutePathWithFallback = BoltdocsRoutePath extends never ? string : BoltdocsRoutePath;
 //#endregion
 //#region src/shared/config-utils.d.ts
 /**
@@ -205,6 +243,10 @@ declare global {
  * This is an identity function that provides IntelliSense in both
  * Node.js (config files) and client-side code (MDX examples).
  *
+ * @remarks
+ * Intended for use in `boltdocs.config.ts` (Node.js context). This function
+ * is **not** available as a client-side import from `boltdocs/client`.
+ *
  * @param config - The Boltdocs configuration object
  */
 declare function defineConfig(config: BoltdocsConfig): BoltdocsConfig;
@@ -238,7 +280,7 @@ interface BoltdocsPluginOptions {
  * @param config - The resolved Boltdocs configuration containing custom plugins and components
  * @returns A string of JavaScript code to be evaluated by the browser
  */
-declare function generateEntryCode(options: BoltdocsPluginOptions, config?: BoltdocsConfig, isBuild?: boolean): string;
+declare function generateEntryCode(options: BoltdocsPluginOptions, config?: BoltdocsConfig): string;
 //#endregion
 //#region src/node/routes/types.d.ts
 /**
@@ -279,14 +321,23 @@ interface RouteMeta {
   /** The version this route belongs to, if versioning is configured */
   version?: string;
   /** Optional badge to display next to the sidebar item (e.g., 'New', 'Experimental') */
-  badge?: string | {
-    text: string;
-    expires?: string;
-  };
+  badge?: BadgeValue;
   /** Optional icon to display (Lucide icon name or raw SVG) */
   icon?: string;
   /** The tab this route belongs to, if tabs are configured */
   tab?: string;
+  /** The collection this route belongs to (from [name] directories like [blog]) */
+  collection?: string;
+  /** Tags for blog posts or other taxonomy */
+  tags?: string[];
+  /** Author identifier for blog posts */
+  author?: string;
+  /** Draft flag — excluded from production builds */
+  draft?: boolean;
+  /** Short excerpt/summary for list displays */
+  excerpt?: string;
+  /** Cover image for blog posts */
+  coverImage?: string;
   /** The extracted plain-text content of the page for search indexing */
   _content?: string;
   /** The raw markdown content of the page */
@@ -332,126 +383,77 @@ declare function normalizePath(p: string): string;
 declare function sanitizeFilename(name: string): string;
 //#endregion
 //#region src/node/plugins/plugin-types.d.ts
-/**
- * Permissions that a plugin can request to access specific Boltdocs capabilities.
- */
-type PluginPermission = 'fs:read' | 'fs:write' | 'vite:config' | 'mdx:remark' | 'mdx:rehype' | 'components' | 'hooks:build' | 'hooks:dev' | 'analytics:track' | 'analytics:config';
-/**
- * Shared context injected into every plugin lifecycle hook.
- */
 interface PluginContext {
-  /** The full, resolved Boltdocs configuration (Readonly) */
   readonly config: BoltdocsConfig;
-  /** A plugin-specific logger */
   readonly logger: PluginLogger;
-  /** A shared store for dependency injection and state sharing between plugins */
   readonly store: PluginStore;
-  /** Metadata about the current plugin */
   readonly meta: PluginMeta;
+  readonly docsDir: string;
+  readonly rootDir: string;
 }
-/**
- * Simple logger interface for plugins.
- */
 interface PluginLogger {
   info(message: string): void;
   warn(message: string): void;
   error(message: string | Error): void;
   debug(message: string): void;
 }
-/**
- * A shared key-value store that allows plugins to share state and configuration.
- */
 interface PluginStore {
-  /** Get a value from the store. Keys are namespaced by plugin internally. */
   get<T = unknown>(pluginName: string, key: string): T | undefined;
-  /** Set a value in the store. */
   set(pluginName: string, key: string, value: unknown): void;
-  /** Check if a key exists in the store. */
   has(pluginName: string, key: string): boolean;
 }
-/**
- * Metadata for a plugin, used for identification and compatibility checks.
- */
 interface PluginMeta {
-  /** Unique identifier for the plugin */
   name: string;
-  /** Version of the plugin itself (semver) */
   version?: string;
-  /** Minimum required version of Boltdocs (semver range) */
   boltdocsVersion?: string;
 }
-/**
- * Lifecycle hooks that a plugin can implement to hook into the build and dev processes.
- */
 interface PluginLifecycleHooks {
-  /** Called before the build process starts */
   beforeBuild?: (ctx: PluginContext) => Promise<void> | void;
-  /** Called after the build process finishes successfully */
   afterBuild?: (ctx: PluginContext) => Promise<void> | void;
-  /** Called before the dev server starts */
   beforeDev?: (ctx: PluginContext) => Promise<void> | void;
-  /** Called after the dev server is ready (configureServer) */
   afterDev?: (ctx: PluginContext) => Promise<void> | void;
-  /** Called when the final Boltdocs config is resolved */
-  configResolved?: (ctx: PluginContext, config: BoltdocsConfig) => void;
-  /** Called when the build is closing */
   buildEnd?: (ctx: PluginContext) => Promise<void> | void;
+  transformMdx?: (ctx: PluginContext, params: {
+    code: string;
+    filePath: string;
+  }) => Promise<{
+    code: string;
+  }> | {
+    code: string;
+  };
+  transformHtml?: (ctx: PluginContext, params: {
+    html: string;
+    path: string;
+  }) => Promise<{
+    html: string;
+  }> | {
+    html: string;
+  };
 }
-/**
- * The extended, secure Boltdocs plugin interface.
- */
 interface SecureBoltdocsPlugin {
-  /** A unique name for the plugin (e.g., 'boltdocs-plugin-mermaid') */
   name: string;
-  /** Whether to run this plugin before or after default ones */
   enforce?: 'pre' | 'post';
-  /** Version of the plugin (optional, but recommended for security) */
   version?: string;
-  /** Minimum compatible Boltdocs version (optional, semver range) */
   boltdocsVersion?: string;
-  /** List of permissions this plugin requires to operate */
-  permissions?: PluginPermission[];
-  /** Optional remark plugins to add to the MDX pipeline (requires 'mdx:remark' permission) */
   remarkPlugins?: unknown[];
-  /** Optional rehype plugins to add to the MDX pipeline (requires 'mdx:rehype' permission) */
   rehypePlugins?: unknown[];
-  /** Optional Vite plugins to inject into the build process (requires 'vite:config' permission) */
   vitePlugins?: Plugin[];
-  /** Optional custom React components to register in MDX. Map of Name -> Module Path. (requires 'components' permission) */
   components?: Record<string, string>;
-  /** Implementation of lifecycle hooks (requires 'hooks:build' or 'hooks:dev' permissions) */
   hooks?: PluginLifecycleHooks;
 }
 //#endregion
 //#region src/node/plugins/plugin-errors.d.ts
-/**
- * Base class for all plugin-related errors in Boltdocs.
- */
 declare class PluginError extends Error {
   readonly pluginName: string;
-  constructor(pluginName: string, message: string);
+  name: string;
+  constructor(pluginName: string, message: string, options?: ErrorOptions);
 }
-/**
- * Specifically for schema or structure validation failures.
- */
 declare class PluginValidationError extends PluginError {
   constructor(pluginName: string, message: string);
 }
-/**
- * Specifically for version mismatch or compatibility issues.
- */
 declare class PluginCompatibilityError extends PluginError {
   constructor(pluginName: string, message: string);
 }
-/**
- * Specifically for attempts to use capabilities without proper permissions.
- */
-declare class PluginPermissionError extends PluginError {
-  constructor(pluginName: string, permission: string);
-}
-/**
- * Specifically for errors that occur during the execution of a lifecycle hook.
- */
 declare class PluginHookError extends PluginError {
   readonly hookName: string;
   constructor(pluginName: string, hookName: string, originalError: Error);
@@ -483,99 +485,205 @@ declare class BoltdocsPluginStore implements PluginStore {
 }
 //#endregion
 //#region src/node/plugins/plugin-validator.d.ts
-/**
- * Enhanced Zod schema for secure plugins.
- */
-declare const SecurePluginSchema: z.ZodObject<{
-  name: z.ZodString;
-  enforce: z.ZodOptional<z.ZodEnum<{
-    pre: "pre";
-    post: "post";
-  }>>;
-  remarkPlugins: z.ZodOptional<z.ZodArray<z.ZodAny>>;
-  rehypePlugins: z.ZodOptional<z.ZodArray<z.ZodAny>>;
-  vitePlugins: z.ZodOptional<z.ZodArray<z.ZodAny>>;
-  components: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-  version: z.ZodOptional<z.ZodString>;
-  boltdocsVersion: z.ZodOptional<z.ZodString>;
-  permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  hooks: z.ZodOptional<z.ZodObject<{
-    beforeBuild: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
-    afterBuild: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
-    beforeDev: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
-    afterDev: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
-    configResolved: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
-    buildEnd: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
-  }, z.core.$strip>>;
-}, z.core.$strip>;
-/**
- * Validates a list of plugins for correctness, security, and compatibility.
- */
 declare function validatePlugins(plugins: any[], boltdocsVersion: string): SecureBoltdocsPlugin[];
+//#endregion
+//#region src/node/plugins/plugin-lifecycle.d.ts
+declare class PluginLifecycleManager {
+  private plugins;
+  private config;
+  private store;
+  private docsDir;
+  private rootDir;
+  constructor(plugins: SecureBoltdocsPlugin[], config: BoltdocsConfig, docsDir?: string, rootDir?: string);
+  runHook(hookName: keyof PluginLifecycleHooks, ...args: unknown[]): Promise<void>;
+  runChain<TParams>(hookName: keyof PluginLifecycleHooks, initialParams: TParams): Promise<TParams>;
+  private getSortedPlugins;
+  private createStep;
+  private createContext;
+  private createLogger;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@types+unist@3.0.3/node_modules/@types/unist/index.d.ts
+// ## Interfaces
 /**
- * Helper to check if a specific permission is granted to a plugin.
+ * Info associated with nodes by the ecosystem.
+ *
+ * This space is guaranteed to never be specified by unist or specifications
+ * implementing unist.
+ * But you can use it in utilities and plugins to store data.
+ *
+ * This type can be augmented to register custom data.
+ * For example:
+ *
+ * ```ts
+ * declare module 'unist' {
+ *   interface Data {
+ *     // `someNode.data.myId` is typed as `number | undefined`
+ *     myId?: number | undefined
+ *   }
+ * }
+ * ```
  */
-declare function hasPermission(plugin: SecureBoltdocsPlugin, permission: PluginPermission): boolean;
-//#endregion
-//#region src/node/plugins/plugin-sandbox.d.ts
+interface Data {}
 /**
- * The Sandbox provides a protective layer that ensures plugins only use
- * the capabilities they have explicitly requested permissions for.
+ * One place in a source file.
  */
-declare class PluginSandbox {
+interface Point {
   /**
-   * Validates if a plugin has the required permission for a capability.
-   * Throws a PluginPermissionError if not granted.
+   * Line in a source file (1-indexed integer).
    */
-  static checkPermission(plugin: SecureBoltdocsPlugin, permission: PluginPermission): void;
+  line: number;
   /**
-   * Filters a plugin's capabilities based on its declared permissions.
-   * This is used when aggregating plugins (remark, rehype, vite, components).
+   * Column in a source file (1-indexed integer).
    */
-  static getSanitizedCapabilities(plugin: SecureBoltdocsPlugin): {
-    remarkPlugins: unknown[] | undefined;
-    rehypePlugins: unknown[] | undefined;
-    vitePlugins: _$vite.Plugin<any>[] | undefined;
-    components: Record<string, string> | undefined;
-  };
+  column: number;
   /**
-   * Wraps a hook execution with permission checks and error isolation.
+   * Character in a source file (0-indexed integer).
    */
-  static executeWithIsolation<T>(plugin: SecureBoltdocsPlugin, requiredPermission: PluginPermission, hookName: string, action: () => Promise<T> | T): Promise<T | undefined>;
+  offset?: number | undefined;
 }
-//#endregion
-//#region src/node/plugins/plugin-lifecycle.d.ts
 /**
- * Manages the lifecycle of all loaded plugins, ensuring hooks are executed
- * in the correct order with proper error isolation and context.
+ * Position of a node in a source document.
+ *
+ * A position is a range between two points.
  */
-declare class PluginLifecycleManager {
-  private plugins;
-  private config;
-  private store;
-  constructor(plugins: SecureBoltdocsPlugin[], config: BoltdocsConfig);
+interface Position {
   /**
-   * Runs a specific hook for all plugins that implement it.
+   * Place of the first character of the parsed source region.
    */
-  runHook(hookName: keyof PluginLifecycleHooks, ...args: any[]): Promise<void>;
+  start: Point;
   /**
-   * Sorts plugins based on their 'enforce' property (pre -> normal -> post).
+   * Place of the first character after the parsed source region.
    */
-  private getSortedPlugins;
+  end: Point;
+}
+/**
+ * Abstract unist node.
+ *
+ * The syntactic unit in unist syntax trees are called nodes.
+ *
+ * This interface is supposed to be extended.
+ * If you can use {@link Literal} or {@link Parent}, you should.
+ * But for example in markdown, a `thematicBreak` (`***`), is neither literal
+ * nor parent, but still a node.
+ */
+interface Node {
   /**
-   * Creates a specialized context for a plugin.
+   * Node type.
    */
-  private createContext;
+  type: string;
   /**
-   * Creates a namespaced logger for a plugin.
+   * Info from the ecosystem.
    */
-  private createLogger;
+  data?: Data | undefined;
+  /**
+   * Position of a node in a source document.
+   *
+   * Nodes that are generated (not in the original source document) must not
+   * have a position.
+   */
+  position?: Position | undefined;
+}
+/**
+ * Abstract unist node that contains other nodes (*children*).
+ *
+ * This interface is supposed to be extended.
+ *
+ * For example, in XML, an element is a parent of different things, such as
+ * comments, text, and further elements.
+ */
+interface Parent extends Node {
+  /**
+   * List of children.
+   */
+  children: Node[];
 }
 //#endregion
-//#region src/node/plugins/index.d.ts
+//#region src/node/mdx/types.d.ts
+interface MdxJsxAttributeValueExpression {
+  type: 'mdxJsxAttributeValueExpression';
+  value: string;
+  data?: {
+    estree?: any;
+  };
+}
+interface MdxJsxAttribute {
+  type: 'mdxJsxAttribute';
+  name: string;
+  value?: string | MdxJsxAttributeValueExpression;
+}
+interface MdxJsxElement {
+  type: 'mdxJsxFlowElement' | 'mdxJsxTextElement';
+  name: string | null;
+  attributes?: MdxJsxAttribute[];
+  children?: any[];
+}
+interface ElementNode {
+  type: 'element';
+  tagName: string;
+  properties?: Record<string, any>;
+  children?: any[];
+}
+//#endregion
+//#region src/node/mdx/shiki-adapter.d.ts
+interface ParsedMeta {
+  title?: string;
+  lineNumbers?: boolean;
+  wordWrap?: boolean;
+  [key: string]: any;
+}
 /**
- * Utility to create a Boltdocs plugin with full type safety.
+ * Parses a meta string into a structured ParsedMeta object.
  */
+declare function parseMetaString(metaStr: string): ParsedMeta;
+//#endregion
+//#region src/node/plugins/plugin-utils.d.ts
+interface NodeWithHProperties extends Node {
+  data?: {
+    hProperties?: Record<string, unknown>;
+    [key: string]: unknown;
+  };
+}
+/**
+ * General, type-safe utility to visit nodes in the AST (MDAST/HAST/MDX).
+ */
+declare function visitNodes<T extends Node>(tree: Node, test: string | string[] | ((node: Node) => boolean), callback: (node: T, index: number, parent: Parent) => void | number | boolean | symbol): void;
+declare function visitRehypeElements(tree: Node, tagName: string, callback: (node: ElementNode, index: number, parent: Parent) => void | number | boolean | symbol): void;
+declare function visitMdxElements(tree: Node, name: string | string[], callback: (node: MdxJsxElement, index: number, parent: Parent) => void | number | boolean | symbol): void;
+declare function setNodeProperty(node: NodeWithHProperties, key: string, value: unknown): void;
+declare function getNodeProperty(node: NodeWithHProperties, key: string): unknown;
+declare function createMdxAttribute(name: string, value: unknown): MdxJsxAttribute;
+declare function createRehypeElement(tagName: string, properties?: Record<string, unknown>, children?: Node[]): ElementNode;
+declare function createMdxElement(name: string, attributes?: Record<string, unknown>, children?: Node[], isFlow?: boolean): MdxJsxElement;
+declare function visitRemarkHeadings(tree: Node, callback: (node: any, index: number, parent: Parent) => void | number | boolean | symbol): void;
+declare function visitRemarkLinks(tree: Node, callback: (node: any, index: number, parent: Parent) => void | number | boolean | symbol): void;
+declare function addNodeClass(node: ElementNode, className: string): void;
+declare function removeNodeClass(node: ElementNode, className: string): void;
+declare function hasNodeClass(node: ElementNode, className: string): boolean;
+//#endregion
+//#region src/node/mdx/constants.d.ts
+declare const MDX_NODES: {
+  readonly ROOT: "root";
+  readonly ELEMENT: "element";
+  readonly TEXT: "text";
+  readonly COMMENT: "comment";
+  readonly CODE: "code";
+  readonly INLINE_CODE: "inlineCode";
+  readonly HEADING: "heading";
+  readonly PARAGRAPH: "paragraph";
+  readonly LINK: "link";
+  readonly IMAGE: "image";
+  readonly LIST: "list";
+  readonly LIST_ITEM: "listItem";
+  readonly JSX_FLOW_ELEMENT: "mdxJsxFlowElement";
+  readonly JSX_TEXT_ELEMENT: "mdxJsxTextElement";
+  readonly JSX_ATTRIBUTE: "mdxJsxAttribute";
+  readonly FLOW_EXPRESSION: "mdxFlowExpression";
+  readonly TEXT_EXPRESSION: "mdxTextExpression";
+  readonly ESM: "mdxjsEsm";
+};
+//#endregion
+//#region src/node/plugins/index.d.ts
 declare function createPlugin(plugin: SecureBoltdocsPlugin): SecureBoltdocsPlugin;
 //#endregion
 //#region src/node/index.d.ts
@@ -586,4 +694,4 @@ declare function boltdocs(options?: BoltdocsPluginOptions): Promise<Plugin[]>;
  */
 declare function createViteConfig(root: string, mode?: 'development' | 'production'): Promise<InlineConfig>;
 //#endregion
-export { type BoltdocsConfig, type BoltdocsPlugin, type BoltdocsPluginOptions, BoltdocsPluginStore, type BoltdocsThemeConfig, PluginCompatibilityError, PluginContext, PluginError, PluginHookError, PluginLifecycleHooks, PluginLifecycleManager, PluginLogger, PluginMeta, PluginPermission, PluginPermissionError, PluginSandbox, PluginStore, PluginValidationError, type RouteMeta, SecureBoltdocsPlugin, SecurePluginSchema, createPlugin, createViteConfig, boltdocs as default, defineConfig, generateEntryCode, hasPermission, normalizePath, resolveConfig, sanitizeFilename, validatePlugins };
+export { type BoltdocsConfig, type BoltdocsPlugin, type BoltdocsPluginOptions, BoltdocsPluginStore, type BoltdocsThemeConfig, EXIT, MDX_NODES, NodeWithHProperties, PluginCompatibilityError, PluginContext, PluginError, PluginHookError, PluginLifecycleHooks, PluginLifecycleManager, PluginLogger, PluginMeta, PluginStore, PluginValidationError, type RouteMeta, SKIP, SecureBoltdocsPlugin, addNodeClass, createMdxAttribute, createMdxElement, createPlugin, createRehypeElement, createViteConfig, boltdocs as default, defineConfig, generateEntryCode, getNodeProperty, hasNodeClass, normalizePath, parseMetaString, removeNodeClass, resolveConfig, sanitizeFilename, setNodeProperty, validatePlugins, visitMdxElements, visitNodes, visitRehypeElements, visitRemarkHeadings, visitRemarkLinks };

package/dist/node/index.mjs

@@ -3,4 +3,4 @@
  * Copyright (c) 2026 Jesus Alcala
  * Licensed under the MIT License.
  */
-import{d as e,l as t}from"../utils-CG65J0Sc.mjs";import{a as n,c as r,d as i,f as a,h as o,i as s,l as c,m as l,n as u,o as d,p as f,r as p,s as m,t as h,u as g}from"../node-BspZN3R2.mjs";import{a as _,s as v}from"../doctor-Be7Ly1oM.mjs";export{g as BoltdocsPluginStore,i as PluginCompatibilityError,a as PluginError,f as PluginHookError,n as PluginLifecycleManager,l as PluginPermissionError,d as PluginSandbox,o as PluginValidationError,m as SecurePluginSchema,s as createPlugin,u as createViteConfig,h as default,v as defineConfig,p as generateEntryCode,r as hasPermission,t as normalizePath,_ as resolveConfig,e as sanitizeFilename,c as validatePlugins};
+import{A as e,D as t,E as n,O as r,S as i,T as a,_ as o,a as s,b as c,c as l,d as u,f as d,g as f,h as p,i as m,k as h,l as g,m as _,n as v,o as y,p as b,r as x,s as S,t as C,u as w,v as T,x as E,y as D}from"../node-DruKROCt.mjs";import{f as O,u as k}from"../utils-BYITg7T5.mjs";import{m as A,p as j}from"../doctor-CgLA7_Uv.mjs";export{n as BoltdocsPluginStore,s as EXIT,E as MDX_NODES,t as PluginCompatibilityError,r as PluginError,h as PluginHookError,i as PluginLifecycleManager,e as PluginValidationError,y as SKIP,S as addNodeClass,l as createMdxAttribute,g as createMdxElement,m as createPlugin,w as createRehypeElement,v as createViteConfig,C as default,A as defineConfig,x as generateEntryCode,u as getNodeProperty,d as hasNodeClass,k as normalizePath,c as parseMetaString,b as removeNodeClass,j as resolveConfig,O as sanitizeFilename,_ as setNodeProperty,a as validatePlugins,p as visitMdxElements,f as visitNodes,o as visitRehypeElements,T as visitRemarkHeadings,D as visitRemarkLinks};

package/dist/node/routes/worker.cjs

@@ -3,4 +3,4 @@
  * Copyright (c) 2026 Jesus Alcala
  * Licensed under the MIT License.
  */
-require(`../../chunk-CU-zTemE.cjs`);const e=require(`../../parser-CdNbqN5y.cjs`);let t=require(`node:worker_threads`);if(!t.parentPort)throw Error(`This file must be run as a worker thread.`);t.parentPort.on(`message`,async n=>{if(n.type===`PARSE_FILE`)try{let r=await e.t(n.file,n.docsDir,n.basePath,n.config);t.parentPort?.postMessage({type:`SUCCESS`,file:n.file,result:r})}catch(e){t.parentPort?.postMessage({type:`ERROR`,file:n.file,error:e.message||`Unknown parsing error`})}});
+require(`../../chunk-CU-zTemE.cjs`);const e=require(`../../parser-B7-6PyQz.cjs`);let t=require(`node:worker_threads`);if(!t.parentPort)throw Error(`This file must be run as a worker thread.`);t.parentPort.on(`message`,async n=>{if(n.type===`PARSE_FILE`)try{let r=await e.t(n.file,n.docsDir,n.basePath,n.config);t.parentPort?.postMessage({type:`SUCCESS`,file:n.file,result:r})}catch(e){t.parentPort?.postMessage({type:`ERROR`,file:n.file,error:e.message||`Unknown parsing error`})}});

package/dist/node/routes/worker.mjs

@@ -3,4 +3,4 @@
  * Copyright (c) 2026 Jesus Alcala
  * Licensed under the MIT License.
  */
-import{n as e}from"../../parser-nE792MLO.mjs";import{parentPort as t}from"node:worker_threads";if(!t)throw Error(`This file must be run as a worker thread.`);t.on(`message`,async n=>{if(n.type===`PARSE_FILE`)try{let r=await e(n.file,n.docsDir,n.basePath,n.config);t?.postMessage({type:`SUCCESS`,file:n.file,result:r})}catch(e){t?.postMessage({type:`ERROR`,file:n.file,error:e.message||`Unknown parsing error`})}});export{};
+import{n as e}from"../../parser-B0YtJPDz.mjs";import{parentPort as t}from"node:worker_threads";if(!t)throw Error(`This file must be run as a worker thread.`);t.on(`message`,async n=>{if(n.type===`PARSE_FILE`)try{let r=await e(n.file,n.docsDir,n.basePath,n.config);t?.postMessage({type:`SUCCESS`,file:n.file,result:r})}catch(e){t?.postMessage({type:`ERROR`,file:n.file,error:e.message||`Unknown parsing error`})}});export{};