@waveso/docs 0.1.0 → 0.3.0

package/dist/map-pooled.d.ts

@@ -0,0 +1,26 @@
+//#region src/map-pooled.d.ts
+/**
+ * Bounded-concurrency `Promise.all`.
+ *
+ * Private — deliberately not an entry point in `package.json`.
+ */
+/**
+ * Like `Promise.all(items.map(fn))`, but with at most `limit` calls in flight.
+ *
+ * Results keep input order, and the first rejection rejects the whole call,
+ * exactly as `Promise.all` does. Workers also stop pulling new items once one
+ * has thrown: a build that is going to fail on page 3 should not render the
+ * other 1,997 first. In-flight calls are not cancelled — there is nothing to
+ * cancel them with — so up to `limit - 1` may still settle after the rejection.
+ *
+ * `Promise.all` over a whole documentation set is fine only while the mapped
+ * function is effectively synchronous — which is true of the markdown pipeline
+ * today, and stops being true the moment a consumer wires the async
+ * `imageResolver` the docs recommend. At that point every page's tree is live
+ * at once, and a 2,000-page site holds 2,000 hast trees plus 2,000 in-flight
+ * resolver calls in memory to produce output that was always going to be
+ * written in order.
+ */
+declare function mapPooled<TItem, TResult>(items: readonly TItem[], limit: number, fn: (item: TItem, index: number) => Promise<TResult>): Promise<TResult[]>;
+//#endregion
+export { mapPooled };

package/dist/map-pooled.js

@@ -0,0 +1,45 @@
+//#region src/map-pooled.ts
+/**
+* Bounded-concurrency `Promise.all`.
+*
+* Private — deliberately not an entry point in `package.json`.
+*/
+/**
+* Like `Promise.all(items.map(fn))`, but with at most `limit` calls in flight.
+*
+* Results keep input order, and the first rejection rejects the whole call,
+* exactly as `Promise.all` does. Workers also stop pulling new items once one
+* has thrown: a build that is going to fail on page 3 should not render the
+* other 1,997 first. In-flight calls are not cancelled — there is nothing to
+* cancel them with — so up to `limit - 1` may still settle after the rejection.
+*
+* `Promise.all` over a whole documentation set is fine only while the mapped
+* function is effectively synchronous — which is true of the markdown pipeline
+* today, and stops being true the moment a consumer wires the async
+* `imageResolver` the docs recommend. At that point every page's tree is live
+* at once, and a 2,000-page site holds 2,000 hast trees plus 2,000 in-flight
+* resolver calls in memory to produce output that was always going to be
+* written in order.
+*/
+async function mapPooled(items, limit, fn) {
+	if (items.length <= limit) return Promise.all(items.map((item, index) => fn(item, index)));
+	const results = new Array(items.length);
+	let next = 0;
+	let failed = false;
+	const worker = async () => {
+		while (next < items.length && !failed) {
+			const index = next++;
+			try {
+				results[index] = await fn(items[index], index);
+			} catch (error) {
+				failed = true;
+				throw error;
+			}
+		}
+	};
+	const workers = Math.max(1, Math.min(limit, items.length));
+	await Promise.all(Array.from({ length: workers }, () => worker()));
+	return results;
+}
+//#endregion
+export { mapPooled };

package/dist/meta.d.ts

@@ -67,9 +67,13 @@ declare function readDocsMeta(dirPath: string): Promise<DocsMeta | undefined>;
  * @param entries - The directory's children.
  * @param meta - Its validated `meta.json`, if any.
  * @param metaPath - Path to that `meta.json`, used in error messages.
- * @throws When `pages` names a child that does not exist — always a typo, and
- *   catching it here is the entire reason `meta.json` is validated at build.
+ * @param depth - How far this directory sits below the content root, which
+ *   decides whether its own `index.md` is listed by default. See
+ *   {@link isListedByDefault}.
+ * @throws When `pages` names a child that does not exist, or names one twice —
+ *   always a typo, and catching it here is the entire reason `meta.json` is
+ *   validated at build.
  */
-declare function orderNavEntries(entries: readonly MetaDirEntry[], meta: DocsMeta | undefined, metaPath: string): DocNavNode[];
+declare function orderNavEntries(entries: readonly MetaDirEntry[], meta: DocsMeta | undefined, metaPath: string, depth: number): DocNavNode[];
 //#endregion
 export { MetaDirEntry, docsMetaSchema, orderNavEntries, parseDocsMeta, readDocsMeta };

package/dist/meta.js

@@ -1,3 +1,4 @@
+import { docsError } from "./docs-error.js";
 import { z } from "zod";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
@@ -40,7 +41,7 @@ function parseDocsMeta(raw, filePath) {
 	const result = docsMetaSchema.safeParse(raw);
 	if (result.success) return result.data;
 	const details = result.error.issues.map((issue) => `  - ${issue.path.join(".") || "(root)"}: ${issue.message}`).join("\n");
-	throw new Error(`Invalid meta.json at ${filePath}:\n${details}`);
+	throw docsError("invalid-meta", `Invalid meta.json at ${filePath}:\n${details}`);
 }
 /**
 * Read and validate `<dirPath>/meta.json`. Resolves to `undefined` when the
@@ -60,7 +61,7 @@ async function readDocsMeta(dirPath) {
 		parsed = JSON.parse(raw);
 	} catch (err) {
 		const reason = err instanceof Error ? err.message : String(err);
-		throw new Error(`Could not parse ${filePath} as JSON: ${reason}`);
+		throw docsError("invalid-meta", `Could not parse ${filePath} as JSON: ${reason}`, { cause: err });
 	}
 	return parseDocsMeta(parsed, filePath);
 }
@@ -75,12 +76,16 @@ async function readDocsMeta(dirPath) {
 * @param entries - The directory's children.
 * @param meta - Its validated `meta.json`, if any.
 * @param metaPath - Path to that `meta.json`, used in error messages.
-* @throws When `pages` names a child that does not exist — always a typo, and
-*   catching it here is the entire reason `meta.json` is validated at build.
+* @param depth - How far this directory sits below the content root, which
+*   decides whether its own `index.md` is listed by default. See
+*   {@link isListedByDefault}.
+* @throws When `pages` names a child that does not exist, or names one twice —
+*   always a typo, and catching it here is the entire reason `meta.json` is
+*   validated at build.
 */
-function orderNavEntries(entries, meta, metaPath) {
+function orderNavEntries(entries, meta, metaPath, depth) {
 	const pages = meta?.pages;
-	if (pages === void 0) return dropEmptyGroups(sortEntries(entries.filter((entry) => isListedByDefault(entry))).map((entry) => entry.node));
+	if (pages === void 0) return dropEmptyGroups(sortEntries(entries.filter((entry) => isListedByDefault(entry, depth))).map((entry) => entry.node));
 	const byName = indexByName(entries, metaPath);
 	const used = /* @__PURE__ */ new Set();
 	const nodes = [];
@@ -104,29 +109,42 @@ function orderNavEntries(entries, meta, metaPath) {
 			continue;
 		}
 		if (page === REST) {
-			if (restAt !== -1) throw new Error(`${metaPath} has more than one "..." entry. A directory has a single set of unnamed pages, so only one wildcard can be honoured — remove the extra.`);
+			if (restAt !== -1) throw docsError("invalid-meta", `${metaPath} has more than one "..." entry. A directory has a single set of unnamed pages, so only one wildcard can be honoured — remove the extra.`);
 			restAt = nodes.length;
 			continue;
 		}
 		if (page.startsWith(REST)) {
 			const name = page.slice(3);
 			const target = byName.get(name);
-			if (!target?.inlineChildren) throw new Error(`${metaPath} entry "${page}" expands a directory named "${name}", which is not a subdirectory here. ${describeAvailable(entries, true)}`);
+			if (!target?.inlineChildren) throw docsError("invalid-meta", `${metaPath} entry "${page}" expands a directory named "${name}", which is not a subdirectory here. ${describeAvailable(entries, true)}`);
+			assertUnused(used, name, page, metaPath);
 			used.add(name);
 			if (target.indexNode !== void 0) nodes.push(target.indexNode);
 			nodes.push(...target.inlineChildren);
 			continue;
 		}
 		const target = byName.get(page);
-		if (!target) throw new Error(`${metaPath} lists "${page}", which does not exist. ${describeAvailable(entries, false)}`);
+		if (!target) throw docsError("invalid-meta", `${metaPath} lists "${page}", which does not exist. ${describeAvailable(entries, false)}`);
+		assertUnused(used, page, page, metaPath);
 		used.add(page);
 		if (!target.hidden) nodes.push(target.node);
 	}
 	if (restAt !== -1) {
-		const rest = sortEntries(entries.filter((entry) => isListedByDefault(entry) && !used.has(entry.name))).map((entry) => entry.node);
+		const rest = sortEntries(entries.filter((entry) => isListedByDefault(entry, depth) && !used.has(entry.name))).map((entry) => entry.node);
 		nodes.splice(restAt, 0, ...rest);
 	}
-	return dropEmptyGroups(nodes);
+	return dropDanglingSeparators(dropEmptyGroups(nodes));
+}
+/**
+* A child named twice is a typo, not an instruction.
+*
+* It renders the page twice, both copies highlighted on the page they link to,
+* and the sidebar keys its items positionally — so there is no duplicate-key
+* warning either. Every other ambiguity in this file is a build error; this
+* one only looked deliberate because nothing checked for it.
+*/
+function assertUnused(used, name, written, metaPath) {
+	if (used.has(name)) throw docsError("invalid-meta", `${metaPath} lists "${written}" more than once. It would appear twice in the sidebar, both copies marked as the current page. Remove the duplicate.`);
 }
 /**
 * Index the directory's children by the name `pages` addresses them with.
@@ -141,7 +159,7 @@ function indexByName(entries, metaPath) {
 	const byName = /* @__PURE__ */ new Map();
 	for (const entry of entries) {
 		const clash = byName.get(entry.name);
-		if (clash !== void 0) throw new Error(`${metaPath} cannot address "${entry.name}": ${describeEntry(clash)} and ${describeEntry(entry)} both claim that name. Rename one.`);
+		if (clash !== void 0) throw docsError("invalid-meta", `${metaPath} cannot address "${entry.name}": ${describeEntry(clash)} and ${describeEntry(entry)} both claim that name. Rename one.`);
 		byName.set(entry.name, entry);
 	}
 	return byName;
@@ -157,9 +175,37 @@ function describeEntry(entry) {
 function dropEmptyGroups(nodes) {
 	return nodes.filter((node) => node.type !== "group" || node.children.length > 0 || node.href !== void 0);
 }
-/** An entry appears without being named: not the index, not a draft. */
-function isListedByDefault(entry) {
-	return entry.isIndex !== true && entry.hidden !== true;
+/**
+* A separator labels whatever follows it. When that turned out to be nothing —
+* every page in the next group a draft, or two separators in a row after one
+* of them emptied — the heading is left standing over nothing.
+*
+* Runs after {@link dropEmptyGroups}, which is what empties them, and cannot be
+* left to the author to notice: `includeDrafts` is how a docs site is
+* previewed, and it is exactly the mode where the group is not empty.
+*/
+function dropDanglingSeparators(nodes) {
+	const kept = [];
+	for (const node of [...nodes].reverse()) {
+		const next = kept.at(-1);
+		if (node.type === "separator" && (next === void 0 || next.type === "separator")) continue;
+		kept.push(node);
+	}
+	return kept.reverse();
+}
+/**
+* An entry appears without being named: not a draft, and not the directory's
+* own `index.md` — which is the group heading's link, and would be a second
+* entry for a page the sidebar already shows.
+*
+* The content root is the exception, and the case the rule never considered:
+* nothing encloses it, so its `index.md` is the one page that has no heading
+* to carry its href. Without this, the site's landing page is missing from its
+* own sidebar — a reader who follows any link cannot get back — and every
+* install writes a `meta.json` whose only purpose is to undo the default.
+*/
+function isListedByDefault(entry, depth) {
+	return entry.hidden !== true && (entry.isIndex !== true || depth === 0);
 }
 function sortEntries(entries) {
 	return [...entries].sort(compareEntries);

package/dist/next.d.ts

@@ -1,48 +1,55 @@
-import { DocFile, DocFrontmatter, DocsConfig, ImageResolver, LinkResolver, RenderedDoc } from "./types.js";
+import { DocFile, DocFrontmatter, DocsConfig, ImageResolver, LinkResolver, RenderedDoc, SearchRecord } from "./types.js";
 import { DocsHighlighter, DocsLang, DocsTheme, DocsThemes } from "./highlighter.js";
 import { MarkdownComponents } from "./react/markdown-components.js";
+import { DocsLabels } from "./react/shell-labels.js";
+import { DocsLayoutSearchProps } from "./react/layout.js";
 import { DocsSource } from "./source.js";
 import { ReactNode } from "react";
+import { PluggableList } from "unified";
+import { Options } from "minisearch";
 //#region src/next.d.ts
 interface DocsRouteOptions<TFrontmatter extends DocFrontmatter = DocFrontmatter> extends DocsConfig<TFrontmatter> {
   /** Overrides merged over the Next-flavoured defaults (`next/link` + `next/image`). */
-  components?: MarkdownComponents;
+  components?: MarkdownComponents | undefined;
   /** Reuse an existing Shiki highlighter. */
-  highlighter?: DocsHighlighter | Promise<DocsHighlighter>;
+  highlighter?: DocsHighlighter | Promise<DocsHighlighter> | undefined;
   /** Grammars to load, when building the default highlighter. */
-  langs?: readonly DocsLang[];
+  langs?: readonly DocsLang[] | undefined;
   /** Theme pair. */
-  themes?: DocsThemes;
+  themes?: DocsThemes | undefined;
+  /**
+   * Fence languages Shiki must not touch, e.g. `['mermaid']`.
+   *
+   * The `<pre><code class="language-mermaid">` then reaches your `pre`/`code`
+   * component untouched, which is what lets you render a diagram instead of a
+   * monochrome block of DSL.
+   */
+  excludeLangs?: readonly string[] | undefined;
   /**
    * Prepend an `<h1>` from `frontmatter.title` when the markdown has none.
    * Defaults to `true`; turn it off if your layout renders the title itself.
    */
-  titleHeading?: boolean;
+  titleHeading?: boolean | undefined;
   /**
-   * `id` of the rendered `<article>`, which is also what
-   * `@waveso/docs/react/skip-link` targets by default. Defaults to
-   * `'docs-content'`. Pass `false` to render no id at all.
+   * Extra remark plugins, attached after `remarkGfm` and before link
+   * resolution — so anything they emit is folded, contained and asserted like
+   * authored markdown.
    */
-  contentId?: string | false;
+  remarkPlugins?: PluggableList | undefined;
   /**
-   * Re-read the content directory on every request.
-   *
-   * Defaults to `true` outside `NODE_ENV=production`. Markdown files are not in
-   * Next's module graph, so nothing re-evaluates a route module when one
-   * changes: without this, `next dev` serves whatever it read on the first
-   * request until the server restarts, and a file added afterwards is never
-   * found. A rescan of a few hundred small files costs single-digit
-   * milliseconds; a production build reads the tree once, as it should.
+   * Extra rehype plugins, attached after heading ids and permalinks exist and
+   * before the code steps — so a `<pre>` is still the author's text rather
+   * than Shiki's token spans.
    */
-  rescanPerRequest?: boolean;
+  rehypePlugins?: PluggableList | undefined;
   /** Replaces the built-in markdown-link resolution. */
-  linkResolver?: LinkResolver;
+  linkResolver?: LinkResolver | undefined;
   /**
    * Resolves image `src` to a public URL and intrinsic dimensions. Without one,
    * markdown images render as a plain `<img>`: `next/image` refuses to render
    * without dimensions, and markdown carries none.
    */
-  imageResolver?: ImageResolver;
+  imageResolver?: ImageResolver | undefined;
   /**
    * Absolute site origin, e.g. `'https://example.com'`.
    *
@@ -50,7 +57,65 @@ interface DocsRouteOptions<TFrontmatter extends DocFrontmatter = DocFrontmatter>
    * root-relative path, which Next resolves against `metadataBase` — so if you
    * set neither, you ship pages with no usable canonical.
    */
-  siteUrl?: string;
+  siteUrl?: string | undefined;
+  /**
+   * MiniSearch overrides for the index {@link DocsRoute.searchIndex} builds.
+   *
+   * ⚠️ THE IDENTICAL OBJECT MUST REACH THE DIALOG — pass it to `DocsSearch`'s
+   * (or `SearchDialog`'s) `miniSearchOptions`. MiniSearch reads `tokenize` and
+   * `processTerm` both when indexing and when querying, so applying one here
+   * and not there produces an index whose terms no query can spell: zero
+   * results, no error, nothing in the console.
+   */
+  miniSearchOptions?: Partial<Options<SearchRecord>> | undefined;
+}
+/**
+ * Props for {@link DocsRoute.Layout}.
+ *
+ * Four, and the fourth is a boolean. Everything else a docs shell is asked for
+ * turned out to be reachable already: an announcement banner renders *above*
+ * `<docs.Layout>` in your own `layout.tsx`, because this does not own `<body>`;
+ * a content footer goes inside `children`; and sidebar links, social icons and
+ * separators are `DocNavNode`s authored in `meta.json`. The header bar is the
+ * one region nothing else can reach, which is what `actions` is for.
+ *
+ * A `slots` map was the alternative, and it can still be added later — two node
+ * props can become a slots map, a slots map cannot become two props.
+ */
+interface DocsLayoutProps {
+  children: ReactNode;
+  /**
+   * Brand at the header start. A string, or your own logo component.
+   *
+   * `ReactNode`, so it cannot also serve as the `<title>` or as the header's
+   * accessible name; the landmark carries a fixed label instead.
+   */
+  title?: ReactNode;
+  /** Header end, after search: a theme toggle, a version switcher, a link. */
+  actions?: ReactNode;
+  /**
+   * The search trigger. Defaults to on, and the URL is always derived.
+   *
+   * `false` omits it. An object configures the dialog — `placeholder`,
+   * `hotkey`, `miniSearchOptions` and the rest of `DocsSearch`'s surface,
+   * minus `indexUrl`.
+   *
+   * You do not need to pass `miniSearchOptions` here to match what
+   * `createDocsRoute` was given: the route's own value is forwarded, so the
+   * object that built the index is the object that queries it. Pass one only
+   * to override that.
+   */
+  search?: boolean | DocsLayoutSearchProps | undefined;
+  /**
+   * The four strings the shell renders itself: the navigation landmark's name,
+   * the drawer's open and close buttons, and the skip link.
+   *
+   * Everything else a reader sees is your markdown or your `title`. This is the
+   * whole of what a non-English site has to say — and it is the fifth prop,
+   * added deliberately: a documentation shell nobody can translate is not a
+   * shell for the whole ecosystem.
+   */
+  labels?: DocsLabels | undefined;
 }
 /** Props Next hands a page in the App Router. */
 interface DocsPageProps {
@@ -142,13 +207,17 @@ interface DocsRoute<TFrontmatter extends DocFrontmatter = DocFrontmatter> {
    * is documented in one place and typed as `false`, not so it can be
    * forwarded.
    *
-   * Declaring it is not optional. Next defaults `dynamicParams` to `true`,
-   * which means a URL that `generateStaticParams` never listed is still
-   * rendered on demand — so `/docs/typo` reaches the source layer,
-   * `fs.readFile` throws `ENOENT`, and Next answers **HTTP 500**. Google
-   * treats a 5xx as a crawl failure and retries it; it treats a 404 as an
-   * answer. With the full page set known at build time there is nothing to
-   * render on demand anyway.
+   * Declaring it is not optional. Next defaults `dynamicParams` to `true`, so
+   * a URL `generateStaticParams` never listed is still invoked on demand: the
+   * route runs on a server at request time to produce a 404 that was already
+   * knowable at build time. `output: 'export'` refuses to build without it at
+   * all. With the full page set known ahead of time there is nothing to render
+   * on demand anyway, and a prerendered 404 is both faster and cacheable.
+   *
+   * (An earlier version of this note claimed an unlisted URL reached
+   * `fs.readFile` and returned HTTP 500. It does not: `find()` is a lookup in
+   * the map built by the directory walk, so a miss is just `undefined`. The
+   * export is still required, for the reasons above.)
    */
   dynamicParams: false;
   /**
@@ -163,11 +232,89 @@ interface DocsRoute<TFrontmatter extends DocFrontmatter = DocFrontmatter> {
    */
   getPage: (segments: string[]) => Promise<RenderedDoc<TFrontmatter> | undefined>;
   /**
-   * Every published page, rendered. The input to
-   * `extractSearchRecords`/`writeSearchIndex` — nothing builds the search index
-   * for you.
+   * Every published page, rendered. The escape hatch behind
+   * {@link DocsRoute.searchIndex}, for anyone building their own artifact out
+   * of `extractSearchRecords`.
    */
   renderAll: () => Promise<Array<RenderedDoc<TFrontmatter>>>;
+  /**
+   * `GET` handler for `app/<basePath>/search-index.json/route.ts`, serving the
+   * MiniSearch index the dialog fetches.
+   *
+   * ```ts
+   * // app/docs/search-index.json/route.ts — the whole file
+   * import { docs } from '@/lib/docs';
+   *
+   * export const GET = docs.searchIndex;
+   * export const dynamic = 'force-static'; // a literal, see below
+   * ```
+   *
+   * **`dynamic = 'force-static'` is not optional and must be a literal**, for
+   * the same reason as {@link DocsRoute.dynamicParams}: route segment config is
+   * parsed out of the module before any of it runs. Without it Next marks the
+   * route `ƒ` (Dynamic) and re-renders your entire corpus on every request —
+   * from markdown that output tracing did not put in the deployment bundle, so
+   * on a serverless host it does not merely get slow, it throws, at the reader,
+   * inside the search dialog. The build prints no warning for this, so the
+   * handler detects it at runtime and throws with `code:
+   * 'search-index-dynamic'` instead of failing quietly.
+   *
+   * The index is built from the same `renderAll()` → `extractSearchRecords` →
+   * `buildSearchIndex` pipeline you could write by hand, with the `charset`-free
+   * `application/json` content type, a strong `ETag` and
+   * `cache-control: public, max-age=0, must-revalidate` — Next's default for a
+   * prerendered route is a year of `s-maxage` with no validator, which on a
+   * stable URL means a CDN serving last year's index until someone purges it.
+   */
+  searchIndex: () => Promise<Response>;
+  /**
+   * Default export for `app/<basePath>/layout.tsx` — the entire docs shell.
+   *
+   * ```tsx
+   * // app/docs/layout.tsx — the whole file
+   * import '@waveso/docs/styles.css';
+   * import { docs } from '@/lib/docs';
+   *
+   * export default docs.Layout;
+   * ```
+   *
+   * Or, with your own chrome in the header:
+   *
+   * ```tsx
+   * export default function DocsLayout({ children }: { children: ReactNode }) {
+   *   return (
+   *     <docs.Layout title={<Logo />} actions={<ThemeToggle />}>
+   *       {children}
+   *     </docs.Layout>
+   *   );
+   * }
+   * ```
+   *
+   * It owns the skip link, the header, the sidebar column, the mobile drawer
+   * and the grid, and it reads `source.nav()` and `searchIndexUrl` itself — so
+   * there is no nav to fetch and no URL to pass. It does **not** own the table
+   * of contents: a Next layout receives `{children, params}` and cannot know
+   * which page is rendering, so `docs.Page` emits the TOC as its second child
+   * and the grid places it.
+   *
+   * Your `layout.tsx` stays a Server Component. The two pieces that need a
+   * client — the nav's `usePathname`, the search dialog — carry their own
+   * `'use client'` boundaries inside the package.
+   *
+   * Next passes `{ children, params }`; the extra `params` is ignored, which is
+   * why `export default docs.Layout` type-checks as a layout.
+   */
+  Layout: (props: DocsLayoutProps) => Promise<ReactNode>;
+  /**
+   * `${basePath}/search-index.json` — hand it to `DocsSearch`'s `indexUrl`.
+   *
+   * Derived from the route's own `basePath`, so it is right when the docs are
+   * mounted at `/`, at `/docs`, or under a nested prefix. It is *not* prefixed
+   * with Next's `basePath` config, which Next applies to `<Link>` and to
+   * navigation but never to a client `fetch()` — on a site setting that, prefix
+   * it yourself.
+   */
+  searchIndexUrl: string;
 }
 /**
  * Create the route handlers for a documentation tree.
@@ -191,9 +338,9 @@ interface DocsSitemapOptions<TFrontmatter extends DocFrontmatter = DocFrontmatte
    */
   siteUrl: string;
   /** Applied to every entry. Omitted by default — Google ignores it anyway. */
-  changeFrequency?: DocsSitemapEntry['changeFrequency'];
+  changeFrequency?: DocsSitemapEntry['changeFrequency'] | undefined;
   /** Applied to every entry. Omitted by default. */
-  priority?: number;
+  priority?: number | undefined;
   /**
    * Override the last-modified date per page.
    *
@@ -253,4 +400,4 @@ interface DocsRedirect {
  */
 declare function createDocsRedirects(config: DocsConfig): Promise<DocsRedirect[]>;
 //#endregion
-export { type DocsLang, DocsPageMetadata, DocsPageProps, DocsRedirect, DocsRoute, DocsRouteOptions, DocsSitemapEntry, DocsSitemapOptions, type DocsTheme, type DocsThemes, createDocsRedirects, createDocsRoute, createDocsSitemap };
+export { type DocsLang, DocsLayoutProps, DocsPageMetadata, DocsPageProps, DocsRedirect, DocsRoute, DocsRouteOptions, DocsSitemapEntry, DocsSitemapOptions, type DocsTheme, type DocsThemes, createDocsRedirects, createDocsRoute, createDocsSitemap };