nimbus-docs 0.0.2

package/dist/index.js

@@ -0,0 +1,1478 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import mdx from "@astrojs/mdx";
+import { satteri } from "@astrojs/markdown-satteri";
+import sitemap from "@astrojs/sitemap";
+import fs from "node:fs/promises";
+import { transformerMetaHighlight, transformerMetaWordHighlight, transformerNotationDiff, transformerNotationErrorLevel, transformerNotationFocus, transformerNotationHighlight, transformerNotationWordHighlight } from "@shikijs/transformers";
+import { z } from "astro/zod";
+
+//#region src/_internal/runtime-config.ts
+let _cached = null;
+async function loadNimbusConfig() {
+	if (_cached) return _cached;
+	_cached = (await import("virtual:nimbus/config")).config;
+	return _cached;
+}
+
+//#endregion
+//#region src/_internal/content.ts
+/** Primary collection name. Hard-coded — see also `getDocsStaticPaths`. */
+const PRIMARY_COLLECTION$1 = "docs";
+/**
+* Return visible entries from one or more collections. Drafts are
+* filtered out in production builds (matching the existing
+* single-collection behaviour).
+*
+* Defaults to `["docs"]` — the framework's primary collection.
+* Cross-collection callers (llms.txt aggregators, custom indexes,
+* etc.) pass an explicit list.
+*
+* Returns a flat `CollectionEntry<string>[]` so cross-collection
+* traversal doesn't need to know the user's collection names at type
+* time. Callers that need per-collection type safety should call
+* `getCollection("api")` directly.
+*/
+async function getVisibleEntries(collections = [PRIMARY_COLLECTION$1]) {
+	const { getCollection } = await import("astro:content");
+	const all = (await Promise.all(collections.map((name) => getCollection(name).catch(() => [])))).flat();
+	return import.meta.env.PROD ? all.filter((entry) => !entry.data.draft) : all;
+}
+/**
+* Return visible entries grouped by collection. Used by the sidebar
+* builder so `collection:` autogenerate can look up entries by name
+* without re-fetching.
+*/
+async function getVisibleEntriesByCollection(collections) {
+	const { getCollection } = await import("astro:content");
+	const out = {};
+	await Promise.all(collections.map(async (name) => {
+		const all = await getCollection(name).catch(() => []);
+		out[name] = import.meta.env.PROD ? all.filter((entry) => !entry.data.draft) : all;
+	}));
+	return out;
+}
+
+//#endregion
+//#region src/_internal/sidebar.ts
+const sortKeyByItem = /* @__PURE__ */ new WeakMap();
+function sortSidebarItems(a, b) {
+	const orderDiff = a.order - b.order;
+	if (orderDiff !== 0) return orderDiff;
+	const keyA = sortKeyByItem.get(a) ?? ("href" in a ? a.href : a.label);
+	const keyB = sortKeyByItem.get(b) ?? ("href" in b ? b.href : b.label);
+	const keyDiff = keyA.localeCompare(keyB);
+	if (keyDiff !== 0) return keyDiff;
+	return a.type.localeCompare(b.type);
+}
+/** Ensure internal href has leading /, no trailing slash (except root) */
+function normalizeInternalHref(href) {
+	let h = href.split("?")[0].split("#")[0];
+	if (!h.startsWith("/")) h = `/${h}`;
+	if (h.length > 1 && h.endsWith("/")) h = h.slice(0, -1);
+	return h;
+}
+/** Strip query and hash for active-state matching */
+function stripQueryHash(href) {
+	return href.split("?")[0].split("#")[0];
+}
+function buildEntryIndex(entries) {
+	const visible = entries.filter((e) => !e.data.sidebar?.hidden);
+	const byId = /* @__PURE__ */ new Map();
+	for (const entry of visible) byId.set(entry.id, entry);
+	const hasChildren = /* @__PURE__ */ new Set();
+	for (const entry of visible) {
+		const parts = entry.id.split("/");
+		for (let i = 1; i < parts.length; i++) hasChildren.add(parts.slice(0, i).join("/"));
+	}
+	return {
+		visible,
+		byId,
+		hasChildren
+	};
+}
+/** Compose a final href for an entry. `hrefPrefix` is the collection mount path (e.g. `/api`). */
+function joinHref(hrefPrefix, entryId) {
+	return `${hrefPrefix.replace(/\/$/, "")}/${entryId}`;
+}
+function createLink(entry, currentPath, hrefPrefix = "") {
+	const href = joinHref(hrefPrefix, entry.id);
+	const badge = entry.data.draft ? entry.data.sidebar?.badge ?? {
+		text: "Draft",
+		variant: "warning"
+	} : entry.data.sidebar?.badge;
+	const link = {
+		type: "link",
+		label: entry.data.sidebar?.label ?? entry.data.title,
+		href,
+		isCurrent: currentPath === href,
+		badge,
+		order: entry.data.sidebar?.order ?? Number.MAX_VALUE
+	};
+	sortKeyByItem.set(link, entry.id);
+	return link;
+}
+function buildFilesystemTree(entries, currentPath, directory, hrefPrefix = "") {
+	const { visible, byId, hasChildren } = buildEntryIndex(entries);
+	const scoped = directory ? visible.filter((e) => e.id === directory || e.id.startsWith(`${directory}/`)) : visible;
+	function buildLevel(parentPath) {
+		const result = [];
+		const groupsAtLevel = /* @__PURE__ */ new Map();
+		for (const entry of scoped) {
+			if (entry.id === "index") continue;
+			const id = entry.id;
+			const relativeTo = directory ?? "";
+			const relativeId = relativeTo ? id === relativeTo ? "" : id.slice(relativeTo.length + 1) : id;
+			if (parentPath === "") if (!relativeId || relativeId.includes("/") === false) {
+				if (!relativeId) continue;
+				if (hasChildren.has(id)) {
+					if (!groupsAtLevel.has(id)) {
+						const group = createGroupFromEntry(id, entry, currentPath, byId);
+						groupsAtLevel.set(id, group);
+						result.push(group);
+					}
+				} else result.push(createLink(entry, currentPath, hrefPrefix));
+			} else {
+				const firstSeg = relativeId.split("/")[0];
+				const topDir = directory ? `${directory}/${firstSeg}` : firstSeg;
+				if (!groupsAtLevel.has(topDir)) {
+					const group = createGroupFromEntry(topDir, byId.get(topDir), currentPath, byId);
+					groupsAtLevel.set(topDir, group);
+					result.push(group);
+				}
+			}
+			else {
+				if (!id.startsWith(`${parentPath}/`)) continue;
+				const remainderParts = id.slice(parentPath.length + 1).split("/");
+				if (remainderParts.length === 1) if (hasChildren.has(id)) {
+					if (!groupsAtLevel.has(id)) {
+						const group = createGroupFromEntry(id, entry, currentPath, byId);
+						groupsAtLevel.set(id, group);
+						result.push(group);
+					}
+				} else result.push(createLink(entry, currentPath, hrefPrefix));
+				else {
+					const nextDir = `${parentPath}/${remainderParts[0]}`;
+					if (!groupsAtLevel.has(nextDir)) {
+						const group = createGroupFromEntry(nextDir, byId.get(nextDir), currentPath, byId);
+						groupsAtLevel.set(nextDir, group);
+						result.push(group);
+					}
+				}
+			}
+		}
+		for (const [groupPath, group] of groupsAtLevel) {
+			const nestedChildren = buildLevel(groupPath);
+			group.children = [...group.children, ...nestedChildren].sort(sortSidebarItems);
+			if (group.children.length > 0) {
+				const minChildOrder = Math.min(...group.children.map((item) => item.order));
+				group.order = Math.min(group.order, minChildOrder);
+			}
+		}
+		return result.sort(sortSidebarItems);
+	}
+	function createGroupFromEntry(dirPath, indexEntry, currentPath, _byId) {
+		const dirSegment = dirPath.split("/").pop();
+		const groupLabel = indexEntry?.data.sidebar?.label ?? formatLabel(dirSegment);
+		const groupOrder = indexEntry?.data.sidebar?.order ?? Number.MAX_VALUE;
+		const children = [];
+		if (indexEntry) children.push(createLink(indexEntry, currentPath, hrefPrefix));
+		const group = {
+			type: "group",
+			label: groupLabel,
+			order: groupOrder,
+			badge: indexEntry?.data.sidebar?.badge,
+			children,
+			_indexId: indexEntry?.id
+		};
+		sortKeyByItem.set(group, dirPath);
+		return group;
+	}
+	if (directory) return buildLevel(directory);
+	return buildLevel("");
+}
+function resolveConfigItems(configItems, entriesByCollection, primaryCollection, currentPath, orderStart = 0) {
+	const primaryEntries = entriesByCollection[primaryCollection] ?? [];
+	const { byId } = buildEntryIndex(primaryEntries);
+	const result = [];
+	for (let i = 0; i < configItems.length; i++) {
+		const item = configItems[i];
+		const order = orderStart + i;
+		if (typeof item === "string") {
+			const entry = byId.get(item);
+			if (entry) {
+				const link = createLink(entry, currentPath);
+				link.order = order;
+				result.push(link);
+			} else console.warn(`[sidebar] Page "${item}" referenced in config but not found in primary collection "${primaryCollection}"`);
+		} else if ("link" in item) if (!item.link.startsWith("/")) {
+			const extLink = {
+				type: "external",
+				label: item.label,
+				href: item.link,
+				badge: item.badge,
+				order
+			};
+			result.push(extLink);
+		} else {
+			const href = normalizeInternalHref(item.link);
+			const matchPath = stripQueryHash(href);
+			const lookup = href.slice(1);
+			if (!lookup.includes("/") && href !== "/" && !byId.has(lookup)) console.warn(`[sidebar] Internal link "${item.link}" (label: "${item.label}") does not match any entry in primary collection "${primaryCollection}"`);
+			const link = {
+				type: "link",
+				label: item.label,
+				href,
+				isCurrent: currentPath === matchPath,
+				badge: item.badge,
+				order
+			};
+			result.push(link);
+		}
+		else if ("autogenerate" in item) {
+			let autoItems;
+			if ("collection" in item.autogenerate) {
+				const collectionName = item.autogenerate.collection;
+				const collectionEntries = entriesByCollection[collectionName];
+				if (!collectionEntries) {
+					console.warn(`[sidebar] autogenerate references collection "${collectionName}" which is not registered in nimbus.config.collections; skipping`);
+					autoItems = [];
+				} else autoItems = buildFilesystemTree(collectionEntries, currentPath, void 0, item.autogenerate.prefix ?? (collectionName === primaryCollection ? "" : `/${collectionName}`));
+			} else autoItems = buildFilesystemTree(primaryEntries, currentPath, item.autogenerate.directory);
+			if (item.label) {
+				const group = {
+					type: "group",
+					label: item.label,
+					order,
+					collapsed: item.collapsed,
+					badge: item.badge,
+					children: autoItems
+				};
+				result.push(group);
+			} else {
+				if (item.collapsed !== void 0) {
+					for (const ai of autoItems) if (ai.type === "group") ai.collapsed = item.collapsed;
+				}
+				result.push(...autoItems);
+			}
+		} else if ("items" in item) {
+			const children = resolveConfigItems(item.items, entriesByCollection, primaryCollection, currentPath);
+			const group = {
+				type: "group",
+				label: item.label,
+				order,
+				collapsed: item.collapsed,
+				badge: item.badge,
+				children
+			};
+			result.push(group);
+		}
+	}
+	return result;
+}
+/**
+* Return only the children of the top-level group containing the current
+* page. Falls back to the full tree if the current page isn't inside any
+* group (e.g. a top-level link, or a path that doesn't resolve).
+*/
+function scopeToCurrentSection(items, currentPath) {
+	if (!currentPath.split("/").filter(Boolean)[0]) return items;
+	for (const item of items) if (item.type === "group") {
+		if (hasActivePage(item, currentPath)) return item.children;
+	}
+	return items;
+}
+function hasActivePage(item, currentPath) {
+	if (item.type === "link") return item.isCurrent === true;
+	if (item.type === "external") return false;
+	return item.children.some((child) => hasActivePage(child, currentPath));
+}
+/**
+* Derive one section per top-level group in the sidebar tree. Used by
+* `Header.astro` to render the section tab strip. Caller must pass the
+* *un-scoped* tree (the result of `buildSidebarTree`, not `getSidebar`);
+* otherwise only the current section's children are visible and the
+* derivation collapses to a single item.
+*/
+function deriveSidebarSections(items) {
+	return items.flatMap((item) => {
+		if (item.type !== "group") return [];
+		const links = flattenLinks(item.children);
+		if (links.length === 0) return [];
+		return [{
+			label: item.label,
+			href: links[0].href,
+			isActive: links.some((link) => link.isCurrent === true)
+		}];
+	});
+}
+/** Depth-first walk; collect every internal link descendant. */
+function flattenLinks(items) {
+	const out = [];
+	for (const item of items) if (item.type === "link") out.push(item);
+	else if (item.type === "group") out.push(...flattenLinks(item.children));
+	return out;
+}
+/**
+* Build the un-scoped sidebar tree from config + content entries.
+*
+* `entriesByCollection` is a name → entries map covering every
+* collection the user listed in `NimbusConfig.collections`. The
+* `primaryCollection` (first entry of that list) is what
+* filesystem-fallback, `directory:` autogenerate, and bare-slug
+* references read from. Other collections only contribute when an
+* explicit `autogenerate: { collection: "<name>" }` references them.
+*
+* - If config has items: resolve them (config takes priority)
+* - If config has no items: auto-generate from primary collection
+*
+* Always returns the full top-level tree. Scoping (showing only the
+* current section's children in the rail) is applied by the public
+* `getSidebar` helper via `scopeToCurrentSection`.
+*/
+function buildSidebarTree(entriesByCollection, primaryCollection, currentPath, config) {
+	const primaryEntries = entriesByCollection[primaryCollection] ?? [];
+	let items;
+	if (config?.items && config.items.length > 0) items = resolveConfigItems(config.items, entriesByCollection, primaryCollection, currentPath);
+	else items = buildFilesystemTree(primaryEntries, currentPath);
+	const pooledEntries = Object.values(entriesByCollection).flat();
+	items = processHideChildren(items, pooledEntries);
+	return items;
+}
+/**
+* Process hideChildren: replace groups whose index has hideChildren=true
+* with a single link to the index page.
+*/
+function processHideChildren(items, entries) {
+	const entryById = /* @__PURE__ */ new Map();
+	for (const e of entries) entryById.set(e.id, e);
+	function process(items) {
+		const result = [];
+		for (const item of items) {
+			if (item.type !== "group") {
+				result.push(item);
+				continue;
+			}
+			if (item._indexId) {
+				if (entryById.get(item._indexId)?.data.sidebar?.hideChildren) {
+					const indexHref = `/${item._indexId}`;
+					const indexLink = item.children.find((c) => c.type === "link" && c.href === indexHref);
+					if (indexLink) {
+						const link = {
+							...indexLink,
+							label: item.label
+						};
+						result.push(link);
+						continue;
+					}
+				}
+			}
+			item.children = process(item.children);
+			result.push(item);
+		}
+		return result;
+	}
+	return process(items);
+}
+/**
+* Walk a sidebar config items array (recursively, through nested
+* `items:` groups) and collect every collection name referenced by an
+* `autogenerate: { collection: ... }` entry.
+*
+* The framework uses this to figure out which collections to load for
+* the sidebar — there's no separate `collections: string[]` config
+* field. The primary collection (`docs`) is always included by the
+* caller; this helper returns only the *extra* names referenced by
+* sidebar items.
+*/
+function collectSidebarCollectionRefs(items) {
+	if (!items) return [];
+	const found = /* @__PURE__ */ new Set();
+	function walk(items) {
+		for (const item of items) {
+			if (typeof item === "string") continue;
+			if ("autogenerate" in item && "collection" in item.autogenerate) found.add(item.autogenerate.collection);
+			else if ("items" in item) walk(item.items);
+		}
+	}
+	walk(items);
+	return [...found];
+}
+/** Flatten sidebar tree into a list of links (for pagination) */
+function flattenSidebar(items) {
+	const flat = [];
+	for (const item of items) if (item.type === "link") flat.push(item);
+	else if (item.type === "group") flat.push(...flattenSidebar(item.children));
+	return flat;
+}
+function formatLabel(segment) {
+	return segment.replace(/-/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function buildSidebarIdentity(items) {
+	return items.flatMap((item) => item.type === "group" ? item.label + buildSidebarIdentity(item.children) : item.label + ("href" in item ? item.href : "")).join("");
+}
+/** Hash the sidebar structure into a short string for sessionStorage invalidation. */
+function sidebarHash(items) {
+	const identity = buildSidebarIdentity(items);
+	let hash = 0;
+	for (let i = 0; i < identity.length; i++) hash = (hash << 5) - hash + identity.charCodeAt(i);
+	return (hash >>> 0).toString(36).padStart(7, "0");
+}
+
+//#endregion
+//#region src/_internal/transform.ts
+function protectCode(markdown) {
+	const protectedChunks = [];
+	function store(chunk) {
+		const token = `@@NIMBUS_MD_CODE_${protectedChunks.length}@@`;
+		protectedChunks.push(chunk.startsWith("```") ? chunk.replace(/\n[ \t]{4}/g, "\n") : chunk);
+		return token;
+	}
+	let next = markdown.replace(/```[\s\S]*?```/g, store);
+	next = next.replace(/`[^`\n]+`/g, store);
+	return {
+		markdown: next,
+		restore(value) {
+			return value.replace(/@@NIMBUS_MD_CODE_(\d+)@@/g, (_match, index) => protectedChunks[Number(index)] ?? "");
+		}
+	};
+}
+function parseAttrs(raw = "") {
+	const attrs = {};
+	for (const match of raw.matchAll(/([A-Za-z_:][\w:.-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|\{([^}]*)\}|([^\s>]+)))?/g)) {
+		const [, name, dq, sq, expr, bare] = match;
+		if (!name) continue;
+		attrs[name] = dq ?? sq ?? expr?.trim() ?? bare ?? true;
+	}
+	return attrs;
+}
+function cleanChildren(children) {
+	return children.replace(/^\s+/g, "").replace(/\s+$/g, "").replace(/\n[ \t]+/g, "\n");
+}
+function blockquote(body) {
+	return body.split("\n").map((line) => line ? `> ${line}` : ">").join("\n");
+}
+function asTitle(value, fallback) {
+	return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function renderPackageManagers(attrs) {
+	const pkg = typeof attrs.pkg === "string" ? attrs.pkg : void 0;
+	const args = typeof attrs.args === "string" ? attrs.args : void 0;
+	const type = typeof attrs.type === "string" ? attrs.type : "install";
+	const dev = attrs.dev === true || attrs.dev === "true";
+	let commands;
+	if (type === "run") {
+		const command = args ?? "dev";
+		commands = [
+			`npm run ${command}`,
+			`pnpm ${command}`,
+			`yarn ${command}`,
+			`bun run ${command}`
+		];
+	} else if (type === "exec") {
+		const command = args ?? pkg ?? "";
+		commands = [
+			`npx ${command}`,
+			`pnpm exec ${command}`,
+			`yarn exec ${command}`,
+			`bunx ${command}`
+		];
+	} else if (type === "dlx") {
+		const command = args ?? pkg ?? "";
+		commands = [
+			`npx ${command}`,
+			`pnpm dlx ${command}`,
+			`yarn dlx ${command}`,
+			`bunx ${command}`
+		];
+	} else if (pkg) commands = [
+		`npm install ${dev ? "--save-dev " : ""}${pkg}`,
+		`pnpm add ${dev ? "-D " : ""}${pkg}`,
+		`yarn add ${dev ? "-D " : ""}${pkg}`,
+		`bun add ${dev ? "-d " : ""}${pkg}`
+	];
+	else return "";
+	return [
+		"```sh",
+		...commands,
+		"```"
+	].join("\n");
+}
+function applyDefaultComponentTransforms(markdown) {
+	let out = markdown;
+	out = out.replace(/<PackageManagers\b([^>]*)\/>/g, (_match, rawAttrs) => renderPackageManagers(parseAttrs(rawAttrs)));
+	out = out.replace(/<Aside\b([^>]*)>([\s\S]*?)<\/Aside>/g, (_match, rawAttrs, children) => {
+		const attrs = parseAttrs(rawAttrs);
+		const type = asTitle(attrs.type, "note").toUpperCase();
+		return blockquote(`**${asTitle(attrs.title, type.charAt(0) + type.slice(1).toLowerCase())}**\n\n${cleanChildren(children)}`);
+	});
+	out = out.replace(/<Card\b([^>]*)>([\s\S]*?)<\/Card>/g, (_match, rawAttrs, children) => {
+		const title = asTitle(parseAttrs(rawAttrs).title, "Card");
+		const body = cleanChildren(children);
+		return `- **${title}**${body ? ` — ${body}` : ""}`;
+	});
+	out = out.replace(/<\/?CardGrid\b[^>]*>/g, "");
+	out = out.replace(/<Steps\b[^>]*>([\s\S]*?)<\/Steps>/g, (_match, children) => {
+		let index = 0;
+		return children.replace(/<Step\b([^>]*)>([\s\S]*?)<\/Step>/g, (_stepMatch, rawAttrs, stepChildren) => {
+			index += 1;
+			const title = asTitle(parseAttrs(rawAttrs).title, `Step ${index}`);
+			const body = cleanChildren(stepChildren);
+			return `${index}. **${title}**${body ? `\n\n   ${body.replace(/\n/g, "\n   ")}` : ""}`;
+		});
+	});
+	out = out.replace(/<Tabs\b[^>]*>([\s\S]*?)<\/Tabs>/g, (_match, children) => children.replace(/<TabItem\b([^>]*)>([\s\S]*?)<\/TabItem>/g, (_tabMatch, rawAttrs, tabChildren) => {
+		return `### ${asTitle(parseAttrs(rawAttrs).label, "Option")}\n\n${cleanChildren(tabChildren)}`;
+	}));
+	out = out.replace(/<([A-Z][A-Za-z0-9]*)\b[^>]*>([\s\S]*?)<\/\1>/g, "$2");
+	out = out.replace(/<([A-Z][A-Za-z0-9]*)\b[^>]*\/>/g, "");
+	return out;
+}
+function applyCustomComponentTransforms(markdown, componentMap) {
+	let out = markdown;
+	for (const [name, render] of Object.entries(componentMap)) {
+		const paired = new RegExp(`<${name}\\b([^>]*)>([\\s\\S]*?)<\\/${name}>`, "g");
+		out = out.replace(paired, (_match, rawAttrs, children) => render({
+			name,
+			attrs: parseAttrs(rawAttrs),
+			children: cleanChildren(children)
+		}));
+		const selfClosing = new RegExp(`<${name}\\b([^>]*)\\/>`, "g");
+		out = out.replace(selfClosing, (_match, rawAttrs) => render({
+			name,
+			attrs: parseAttrs(rawAttrs),
+			children: ""
+		}));
+	}
+	return out;
+}
+/**
+* Render an Astro content entry's raw MDX body as plain markdown.
+*
+* This handles the starter's default MDX components. Users can pass a
+* `componentMap` to override individual component renderers or replace this
+* function entirely from their user-owned `.md` route.
+*/
+function renderEntryAsMarkdown(entry, options = {}) {
+	const stripFrontmatter = options.stripFrontmatter ?? true;
+	let markdown = entry.body ?? "";
+	if (stripFrontmatter) markdown = markdown.replace(/^---\n[\s\S]*?\n---\n?/, "");
+	const protectedCode = protectCode(markdown);
+	markdown = protectedCode.markdown;
+	if (options.componentMap) markdown = applyCustomComponentTransforms(markdown, options.componentMap);
+	markdown = applyDefaultComponentTransforms(markdown);
+	markdown = protectedCode.restore(markdown);
+	return markdown.replace(/^[ \t]+(- \*\*)/gm, "$1").replace(/^[ \t]+(\d+\. \*\*)/gm, "$1").replace(/^[ \t]+(### )/gm, "$1").replace(/^[ \t]+(```)/gm, "$1").replace(/^[ \t]+$/gm, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+//#endregion
+//#region src/_internal/navigation.ts
+function getBreadcrumbs$1(slug, homeLabel = "Home") {
+	const parts = slug.split("/").filter(Boolean);
+	const crumbs = [{
+		label: homeLabel,
+		href: "/"
+	}];
+	let path = "";
+	for (const part of parts) {
+		path += `/${part}`;
+		crumbs.push({
+			label: part.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+			href: path
+		});
+	}
+	return crumbs;
+}
+function normalizeInternalPath(path) {
+	const [withoutHash] = path.split("#", 1);
+	const [pathname] = withoutHash.split("?", 1);
+	return pathname || "/";
+}
+function resolveOverride(override, fallback, validInternalLinks) {
+	if (override === false) return void 0;
+	if (override === void 0) return fallback;
+	if (typeof override === "string") {
+		if (!fallback) return void 0;
+		return {
+			label: override,
+			href: fallback.href
+		};
+	}
+	if (override.link && !override.link.startsWith("/") && !override.link.startsWith("http")) throw new Error(`prev/next override link "${override.link}" must be an absolute path (starting with /) or a full URL`);
+	if (override.link?.startsWith("/") && validInternalLinks) {
+		const targetPath = normalizeInternalPath(override.link);
+		if (!validInternalLinks.has(targetPath)) throw new Error(`prev/next override link "${override.link}" does not match any existing internal docs route`);
+	}
+	const label = override.label ?? fallback?.label;
+	const href = override.link ?? fallback?.href;
+	if (!fallback && (label === void 0 || href === void 0)) throw new Error("prev/next object override requires both `label` and `link` when no sidebar neighbor exists");
+	if (!href) return void 0;
+	return {
+		label: label ?? "",
+		href
+	};
+}
+function getPrevNext$1(currentPath, sidebarTree, overrides, validInternalLinks) {
+	const flat = flattenSidebar(sidebarTree);
+	const index = flat.findIndex((item) => item.href === currentPath);
+	const sidebarPrev = index > 0 ? {
+		label: flat[index - 1].label,
+		href: flat[index - 1].href
+	} : void 0;
+	const sidebarNext = index >= 0 && index < flat.length - 1 ? {
+		label: flat[index + 1].label,
+		href: flat[index + 1].href
+	} : void 0;
+	if (!overrides) return {
+		prev: sidebarPrev,
+		next: sidebarNext
+	};
+	return {
+		prev: resolveOverride(overrides.prev, sidebarPrev, validInternalLinks),
+		next: resolveOverride(overrides.next, sidebarNext, validInternalLinks)
+	};
+}
+
+//#endregion
+//#region src/_internal/toc.ts
+function getHeadings(headings, config) {
+	const min = config?.minHeadingLevel ?? 2;
+	const max = config?.maxHeadingLevel ?? 3;
+	return headings.filter((h) => h.depth >= min && h.depth <= max);
+}
+
+//#endregion
+//#region src/_internal/git-last-updated.ts
+/**
+* git-last-updated.ts — Derive a per-page `lastUpdated` from `git log`.
+*
+* Uses the **author date** (`%aI`) instead of the committer date (`%cI`)
+* so the value stays stable when a branch is rebased: rebases rewrite
+* commit dates but preserve author dates for unchanged content. Squash
+* merges produce a single new commit that touches the file, so the
+* date naturally reflects the squash moment — which is the right answer
+* for "when did this content last change in the published history."
+*
+* Returns `undefined` on every failure mode so the caller can fall back
+* cleanly to frontmatter (or render nothing):
+*
+*   - `git` not on PATH (CI image without git, container without it)
+*   - File isn't tracked yet (new content in a draft branch, untracked)
+*   - Repo is a shallow clone / partial clone and the file's history
+*     isn't in the local pack (Vercel default `fetch-depth: 1`,
+*     Cloudflare Pages similar). Users who want git-derived dates in
+*     production should set `fetch-depth: 0` on `actions/checkout` or
+*     equivalent.
+*   - Process isn't inside a git working tree at all
+*
+* Results are cached per-process. A typical docs build calls this once
+* per entry; the cache prevents redundant subprocess spawns when the
+* same entry's filePath shows up across multiple pages (e.g. sidebar
+* preview, full render).
+*/
+const execFileAsync = promisify(execFile);
+const cache = /* @__PURE__ */ new Map();
+/**
+* Run `git log -1 --format=%aI -- <filePath>` and parse the result as a
+* `Date`. Returns `undefined` on any error or empty result.
+*
+* Pass either the entry's `filePath` (Astro provides this on every
+* content entry) or an explicit relative path. Relative paths resolve
+* against the current working directory (Astro builds run from the
+* project root, which is inside the git repo).
+*/
+async function getLastUpdatedFromGit(filePath) {
+	if (!filePath) return void 0;
+	if (cache.has(filePath)) return cache.get(filePath);
+	let result;
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"log",
+			"-1",
+			"--format=%aI",
+			"--",
+			filePath
+		], { windowsHide: true });
+		const trimmed = stdout.trim();
+		if (trimmed) {
+			const parsed = new Date(trimmed);
+			if (!Number.isNaN(parsed.getTime())) result = parsed;
+		}
+	} catch {
+		result = void 0;
+	}
+	cache.set(filePath, result);
+	return result;
+}
+
+//#endregion
+//#region src/_internal/parse-components-registry.ts
+/**
+* Extract registered MDX global names from the user's `src/components.ts`.
+*
+* The framework needs this list to validate PascalCase tags in MDX at
+* build time, but it must not execute user code at build time. Strategy:
+* read the file as text, locate the `export const components = { ... }`
+* declaration, and parse its top-level keys.
+*
+* Supported entry shapes inside the object literal:
+*   - shorthand:   `Foo,`            → "Foo"
+*   - aliased:     `Foo: Other,`     → "Foo" (the key)
+*   - string key:  `"Foo": Other,`   → "Foo"
+*
+* Skipped (no false-positive failures):
+*   - spread elements (`...other`)
+*   - computed keys (`[expr]: value`)
+*   - lowercase keys (not PascalCase, so not validator-relevant)
+*
+* Returns:
+*   - `string[]` of registered names when the file exists and the pattern
+*     matches.
+*   - `null` when the file is missing OR present but doesn't expose a
+*     parseable `export const components = { ... }`. The caller decides
+*     whether to warn or skip validation.
+*/
+const EXPORT_PATTERN = /export\s+const\s+components\s*(?::\s*[^=]+)?=\s*\{([\s\S]*?)\n\s*\}\s*(?:as\s+const)?\s*;?/;
+async function parseComponentsRegistry(filePath) {
+	let source;
+	try {
+		source = await fs.readFile(filePath, "utf8");
+	} catch (err) {
+		if (err.code === "ENOENT") return null;
+		throw err;
+	}
+	const match = source.match(EXPORT_PATTERN);
+	if (!match) return null;
+	const body = match[1].replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+	const names = [];
+	for (const raw of splitTopLevelCommas(body)) {
+		const entry = raw.trim();
+		if (!entry) continue;
+		if (entry.startsWith("...")) continue;
+		if (entry.startsWith("[")) continue;
+		const colonIdx = entry.indexOf(":");
+		const key = (colonIdx === -1 ? entry : entry.slice(0, colonIdx)).trim().replace(/^['"`]|['"`]$/g, "");
+		if (/^[A-Z][A-Za-z0-9_]*$/.test(key)) names.push(key);
+	}
+	return names;
+}
+/**
+* Split a string on commas that are at depth 0 (not inside `{}`, `[]`,
+* `()`, or string literals). Required because object entries can themselves
+* contain commas (e.g. `Foo: bar({ a: 1, b: 2 })`).
+*/
+function splitTopLevelCommas(input) {
+	const result = [];
+	let depth = 0;
+	let start = 0;
+	let inString = null;
+	for (let i = 0; i < input.length; i++) {
+		const ch = input[i];
+		if (inString) {
+			if (ch === "\\") {
+				i++;
+				continue;
+			}
+			if (ch === inString) inString = null;
+			continue;
+		}
+		if (ch === "\"" || ch === "'" || ch === "`") inString = ch;
+		else if (ch === "{" || ch === "[" || ch === "(") depth++;
+		else if (ch === "}" || ch === "]" || ch === ")") depth--;
+		else if (ch === "," && depth === 0) {
+			result.push(input.slice(start, i));
+			start = i + 1;
+		}
+	}
+	result.push(input.slice(start));
+	return result;
+}
+
+//#endregion
+//#region src/_internal/code-transformers.ts
+/**
+* Parse Shiki meta string (the bit after the language fence:
+* ```ts title="src/foo.ts" {1,3}`) for the `title="..."` key.
+* Returns `undefined` when the meta has no title.
+*/
+function parseTitle(meta) {
+	if (!meta) return void 0;
+	return (meta.match(/\btitle="([^"]+)"/) ?? meta.match(/\btitle='([^']+)'/))?.[1];
+}
+/**
+* The canonical Shiki transformer chain for Nimbus. Returns a fresh
+* array each call so callers don't accidentally mutate a shared list.
+*
+* Used by:
+*   - `integration.ts` → `shikiConfig.transformers` (fenced MDX blocks)
+*   - `Code.astro` in the starter → `transformers` prop on Astro's
+*     built-in `<Code>` component (and by extension, anything that
+*     composes `<Code>` such as `<CodeGroup>`)
+*/
+function defaultCodeTransformers() {
+	return [
+		transformerNotationDiff(),
+		transformerNotationHighlight(),
+		transformerNotationFocus(),
+		transformerNotationErrorLevel(),
+		transformerNotationWordHighlight(),
+		transformerMetaHighlight(),
+		transformerMetaWordHighlight(),
+		titleAndLangTransformer()
+	];
+}
+function titleAndLangTransformer() {
+	return {
+		name: "nimbus:title-and-lang",
+		pre(preNode) {
+			const lang = this.options.lang || "text";
+			const meta = this.options.meta?.__raw;
+			const title = parseTitle(meta);
+			preNode.properties = preNode.properties ?? {};
+			preNode.properties["data-nb-lang"] = lang;
+			if (!title) return preNode;
+			return {
+				type: "element",
+				tagName: "figure",
+				properties: {
+					class: "nb-code-figure",
+					"data-nb-lang": lang
+				},
+				children: [{
+					type: "element",
+					tagName: "figcaption",
+					properties: { class: "nb-code-title" },
+					children: [{
+						type: "element",
+						tagName: "span",
+						properties: { class: "nb-code-title-name" },
+						children: [{
+							type: "text",
+							value: title
+						}]
+					}, {
+						type: "element",
+						tagName: "span",
+						properties: { class: "nb-code-title-lang" },
+						children: [{
+							type: "text",
+							value: lang
+						}]
+					}]
+				}, preNode]
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/_internal/levenshtein.ts
+/**
+* Tiny Levenshtein distance + "did you mean" suggester.
+*
+* Used by the MDX PascalCase validator and any framework diagnostic that
+* wants to suggest a near-match on a misspelled name. Kept internal — user
+* code that wants the same hint duplicates ~10 lines rather than depending
+* on a framework wrapper. See the north-star guardrail on thin wrappers.
+*/
+function levenshtein(a, b) {
+	if (a === b) return 0;
+	if (a.length === 0) return b.length;
+	if (b.length === 0) return a.length;
+	const v0 = new Array(b.length + 1);
+	const v1 = new Array(b.length + 1);
+	for (let i = 0; i <= b.length; i++) v0[i] = i;
+	for (let i = 0; i < a.length; i++) {
+		v1[0] = i + 1;
+		for (let j = 0; j < b.length; j++) {
+			const cost = a[i] === b[j] ? 0 : 1;
+			v1[j + 1] = Math.min(v1[j] + 1, v0[j + 1] + 1, v0[j] + cost);
+		}
+		for (let j = 0; j <= b.length; j++) v0[j] = v1[j];
+	}
+	return v1[b.length];
+}
+/**
+* Return the closest candidate within `maxDist`, or null.
+*
+* Comparison is case-insensitive (so "tabs" suggests "Tabs"), but the
+* returned name keeps its original casing.
+*/
+function suggest(target, candidates, maxDist = 3) {
+	const targetLower = target.toLowerCase();
+	let best = null;
+	for (const c of candidates) {
+		const dist = levenshtein(targetLower, c.toLowerCase());
+		if (dist <= maxDist && (!best || dist < best.dist)) best = {
+			name: c,
+			dist
+		};
+	}
+	return best?.name ?? null;
+}
+
+//#endregion
+//#region src/_internal/validate-mdx-content.ts
+/**
+* MDX PascalCase tag validator — runs as a content pass, not a remark
+* plugin, so it works regardless of which markdown processor the user
+* has wired into `markdown.processor` (Sätteri replaces unified's
+* pipeline, which silently disables remark plugins attached via
+* `mdx({ remarkPlugins })`).
+*
+* Strategy:
+*
+*   1. Walk the configured content directories for `.mdx` files.
+*   2. For each file: split frontmatter, parse imports + JSX tags from
+*      the body, validate every PascalCase tag against globals + per-file
+*      imports.
+*   3. Collect every failure across every file (don't fail-fast), then
+*      throw one error with all locations and "did you mean" hints.
+*
+* Parsing approach is intentionally regex-based and not a full MDX
+* parser. Tradeoffs:
+*
+*   - Pro: zero MDX/remark deps, runs in milliseconds, no pipeline
+*     coupling. Survives processor swaps (satteri / unified / future).
+*   - Pro: tolerates malformed MDX — the validator's job is to find
+*     unknown tags, not to be the parser of record.
+*   - Con: a few edge cases (JSX inside string literals inside expression
+*     children, deeply nested fenced code with `~~~`) can produce false
+*     positives. Code blocks (``` and indented) are stripped before
+*     scanning to keep the common case clean.
+*
+* Catches the silent-failure case where MDX renders unknown PascalCase
+* tags as literal text on the deployed page — the bug appears in
+* production, not in the build log.
+*/
+async function validateMdxContent(options) {
+	const globalsSet = new Set(options.globals);
+	const failures = [];
+	for (const dir of options.contentDirs) {
+		const files = await walkMdx(dir);
+		for (const file of files) {
+			if (options.skip?.(file)) continue;
+			const fileFailures = scanFile(await fs.readFile(file, "utf8"), globalsSet);
+			for (const f of fileFailures) {
+				const knownNames = [...globalsSet, ...f.imports];
+				failures.push({
+					filePath: options.projectRoot ? path.relative(options.projectRoot, file) : file,
+					tag: f.tag,
+					line: f.line,
+					column: f.column,
+					hint: suggest(f.tag, knownNames)
+				});
+			}
+		}
+	}
+	return failures;
+}
+/**
+* Format a list of failures into a single multi-line error message
+* suitable for `throw new Error(...)`.
+*/
+function formatFailures(failures, globalsCount) {
+	const lines = failures.map((f) => {
+		const fix = f.hint ? `Did you mean <${f.hint} />?` : globalsCount === 0 ? `Register it in src/components.ts, or add an explicit \`import\` at the top of this file.` : `Register it in src/components.ts, or add an explicit \`import\` at the top of this file.`;
+		return `  ${f.filePath}:${f.line}:${f.column}  <${f.tag} />  →  ${fix}`;
+	});
+	return `[nimbus-docs] Unknown MDX component ${failures.length === 1 ? "tag" : "tags"}:\n` + lines.join("\n") + "\n\nA PascalCase tag in MDX must either be registered in src/components.ts (the global registry) or imported at the top of the file. Without either, MDX renders the tag as literal text on the page — a silent failure this validator turns into a build error.";
+}
+async function walkMdx(dir) {
+	const out = [];
+	async function visit(current) {
+		let entries;
+		try {
+			entries = await fs.readdir(current, { withFileTypes: true });
+		} catch (err) {
+			if (err.code === "ENOENT") return;
+			throw err;
+		}
+		for (const entry of entries) {
+			const full = path.join(current, entry.name);
+			if (entry.isDirectory()) {
+				if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+				await visit(full);
+			} else if (entry.isFile() && entry.name.endsWith(".mdx")) out.push(full);
+		}
+	}
+	await visit(dir);
+	return out;
+}
+function scanFile(source, globalsSet) {
+	const { body, bodyOffset } = stripFrontmatter(source);
+	const imports = parseImports(body);
+	const tags = findPascalCaseTags(stripCodeBlocks(body));
+	const failures = [];
+	for (const tag of tags) {
+		if (globalsSet.has(tag.name) || imports.has(tag.name)) continue;
+		const position = absolutePosition(source, bodyOffset + tag.offset);
+		failures.push({
+			tag: tag.name,
+			line: position.line,
+			column: position.column,
+			imports
+		});
+	}
+	return failures;
+}
+function stripFrontmatter(source) {
+	const match = source.match(/^---\n[\s\S]*?\n---\n?/);
+	if (!match) return {
+		body: source,
+		bodyOffset: 0
+	};
+	return {
+		body: source.slice(match[0].length),
+		bodyOffset: match[0].length
+	};
+}
+/**
+* Extract names introduced by top-level `import` statements. Handles
+* default, named (with optional aliases), and namespace imports.
+*/
+function parseImports(body) {
+	const names = /* @__PURE__ */ new Set();
+	for (const match of body.matchAll(/^\s*import\s+([^"';]+?)\s+from\s+["'][^"']+["']\s*;?/gm)) {
+		const clause = match[1];
+		const namespaceMatch = clause.match(/\*\s+as\s+([A-Za-z_$][\w$]*)/);
+		if (namespaceMatch) {
+			names.add(namespaceMatch[1]);
+			continue;
+		}
+		const beforeBrace = clause.split("{")[0].trim().replace(/,\s*$/, "");
+		if (beforeBrace && /^[A-Za-z_$][\w$]*$/.test(beforeBrace)) names.add(beforeBrace);
+		const braceMatch = clause.match(/\{([^}]*)\}/);
+		if (braceMatch) for (const raw of braceMatch[1].split(",")) {
+			const spec = raw.trim();
+			if (!spec) continue;
+			const aliasMatch = spec.match(/^[A-Za-z_$][\w$]*\s+as\s+([A-Za-z_$][\w$]*)$/);
+			if (aliasMatch) names.add(aliasMatch[1]);
+			else if (/^[A-Za-z_$][\w$]*$/.test(spec)) names.add(spec);
+		}
+	}
+	return names;
+}
+/**
+* Remove fenced code blocks and inline code spans so JSX-looking text
+* inside code samples doesn't trip the validator.
+*/
+function stripCodeBlocks(body) {
+	return body.replace(/```[\s\S]*?```/g, (m) => " ".repeat(m.length)).replace(/~~~[\s\S]*?~~~/g, (m) => " ".repeat(m.length)).replace(/`[^`\n]*`/g, (m) => " ".repeat(m.length));
+}
+/**
+* Find PascalCase JSX-like tags. Matches `<Capital...` at the start of
+* an element (opening or self-closing). Closing tags `</Capital>` and
+* JSX fragments `<>` are not counted (the opener already covers
+* registration; counting closers would double-report).
+*/
+function findPascalCaseTags(body) {
+	const out = [];
+	for (const match of body.matchAll(/<([A-Z][A-Za-z0-9_]*)\b/g)) out.push({
+		name: match[1],
+		offset: match.index ?? 0
+	});
+	return out;
+}
+/**
+* Compute 1-based line + column for an absolute character offset in the
+* original source.
+*/
+function absolutePosition(source, offset) {
+	let line = 1;
+	let column = 1;
+	const end = Math.min(offset, source.length);
+	for (let i = 0; i < end; i++) if (source[i] === "\n") {
+		line++;
+		column = 1;
+	} else column++;
+	return {
+		line,
+		column
+	};
+}
+
+//#endregion
+//#region src/_internal/validate.ts
+/**
+* Config validation.
+*
+* Errors target content authors, not framework developers.
+* Astro 6 ships Zod v4 via `astro/zod` — single `error` field, not v3 patterns.
+*/
+const headElementSchema = z.object({
+	tag: z.enum([
+		"meta",
+		"link",
+		"script",
+		"style"
+	]),
+	attrs: z.record(z.string(), z.string()).default({}),
+	content: z.string().optional()
+});
+const featuresSchema = z.object({
+	search: z.boolean().default(true),
+	editLinks: z.boolean().default(true),
+	pagination: z.boolean().default(true),
+	toc: z.boolean().default(true)
+}).default({
+	search: true,
+	editLinks: true,
+	pagination: true,
+	toc: true
+});
+const searchSchema = z.union([z.literal(false), z.object({ provider: z.enum(["pagefind", "custom"]).default("pagefind") })]).optional();
+const sidebarSchema = z.object({ items: z.array(z.unknown()).optional() }).passthrough().optional();
+const nimbusConfigSchema = z.object({
+	site: z.string().url({ message: "\"site\" must be a valid URL" }),
+	title: z.string(),
+	description: z.string().optional(),
+	logo: z.string().max(2),
+	locale: z.string().default("en"),
+	homeLabel: z.string().default("Home"),
+	github: z.string().url().nullable().default(null),
+	editPattern: z.string().nullable().default(null).refine((v) => v === null || v.includes("{path}"), { message: "\"editPattern\" must contain the \"{path}\" placeholder, which is replaced with the entry source path. Example: \"https://github.com/my-org/my-repo/edit/main/{path}\"" }),
+	footer: z.string().default("Built with Nimbus"),
+	socialImage: z.string({ error: "\"socialImage\" must be a string (path or URL)" }).optional(),
+	socialImageAlt: z.string({ error: "\"socialImageAlt\" must be a string" }).optional(),
+	head: z.array(headElementSchema).default([]),
+	sidebar: sidebarSchema,
+	features: featuresSchema,
+	search: searchSchema
+});
+function validateNimbusConfig(input) {
+	const result = nimbusConfigSchema.safeParse(input);
+	if (result.success) return result.data;
+	const issues = result.error.issues.map((issue) => {
+		const issuePath = issue.path.filter((p) => typeof p !== "symbol");
+		const display = issuePath.length > 0 ? issuePath.join(".") : "(root)";
+		const received = formatReceived(input, issuePath);
+		const tail = received === null ? "" : `\n      received: ${received}`;
+		return `  - ${display}: ${issue.message}${tail}`;
+	}).join("\n");
+	throw new Error(`Invalid nimbus.config — fix these issues:\n${issues}\n\nSee https://nimbus-docs.dev/config for the full config schema.`);
+}
+/**
+* Resolve the value at `path` inside the raw input and format it for an
+* error message. Returns null when the path is unreachable (e.g. a
+* required key is missing entirely — in that case the message itself
+* already says "Required", so we don't double up).
+*/
+function formatReceived(input, path) {
+	let cursor = input;
+	for (const key of path) {
+		if (cursor === null || typeof cursor !== "object") return null;
+		cursor = cursor[key];
+		if (cursor === void 0) return null;
+	}
+	if (cursor === void 0) return null;
+	try {
+		const json = JSON.stringify(cursor);
+		if (json === void 0) return String(cursor);
+		return json.length > 120 ? `${json.slice(0, 117)}...` : json;
+	} catch {
+		return String(cursor);
+	}
+}
+
+//#endregion
+//#region src/_internal/virtual-config.ts
+const VIRTUAL_ID = "virtual:nimbus/config";
+const RESOLVED_ID = `\0${VIRTUAL_ID}`;
+function virtualConfigPlugin(config) {
+	return {
+		name: "nimbus-docs:virtual-config",
+		resolveId(id) {
+			if (id === VIRTUAL_ID) return RESOLVED_ID;
+		},
+		load(id) {
+			if (id === RESOLVED_ID) return `export const config = ${JSON.stringify(config)};\n`;
+		}
+	};
+}
+
+//#endregion
+//#region src/integration.ts
+/**
+* The Nimbus Astro integration.
+*
+* Responsibilities:
+*   - Validate the user-supplied config (throws on invalid input).
+*   - Bridge `nimbusConfig.site` → Astro's top-level `site` so the
+*     sitemap integration and `Astro.site` read from one source.
+*   - Register `@astrojs/mdx` and `@astrojs/sitemap`.
+*   - Install the Sätteri markdown processor — handles heading slugs +
+*     ships with built-in Shiki dual-theme highlighting (configured via
+*     Astro's `markdown.shikiConfig`).
+*   - Build-time MDX PascalCase tag validation against the user's
+*     `src/components.ts` registry plus per-file imports. Catches the
+*     silent-failure case where MDX renders an unknown PascalCase tag
+*     as literal text on the deployed site. Opt out via
+*     `validateMdx: false`.
+*   - Expose validated config via `virtual:nimbus/config`.
+*   - Inject TypeScript types for the virtual module so consumers get
+*     intellisense without manual ambient declarations.
+*
+* Not framework territory (the user's `content.config.ts` owns these):
+*   - Content collection registration. The user imports
+*     `docsCollection()` / `partialsCollection()` from
+*     `nimbus-docs/content` and registers them themselves.
+*   - MDX globals injection. The user passes `components={components}`
+*     when rendering `<Content />`.
+*
+* Planned (not shipped):
+*   - `/llms.txt` and `/robots.txt` route injection.
+*/
+function nimbus(rawConfig, options = {}) {
+	const config = validateNimbusConfig(rawConfig);
+	return {
+		name: "nimbus-docs",
+		hooks: {
+			"astro:config:setup": async (params) => {
+				const { updateConfig, config: astroConfig, logger } = params;
+				const integrationsToAdd = [];
+				if (options.validateMdx !== false) {
+					const validateOpts = typeof options.validateMdx === "object" ? options.validateMdx : {};
+					const projectRoot = fileURLToPath(astroConfig.root);
+					const componentsPath = path.isAbsolute(validateOpts.componentsPath ?? "") ? validateOpts.componentsPath : path.join(projectRoot, validateOpts.componentsPath ?? "src/components.ts");
+					const globals = await parseComponentsRegistry(componentsPath);
+					if (globals === null) logger.warn(`MDX validation disabled: \`${path.relative(projectRoot, componentsPath)}\` is missing or does not export a parseable \`components\` object. Create the file with \`export const components = { /* ... */ };\` or set \`validateMdx: false\` to silence this warning.`);
+					else {
+						const contentDirs = (validateOpts.contentDirs ?? ["src/content"]).map((d) => path.isAbsolute(d) ? d : path.join(projectRoot, d));
+						const failures = await validateMdxContent({
+							globals,
+							contentDirs,
+							skip: validateOpts.skip,
+							projectRoot
+						});
+						if (failures.length > 0) throw new Error(formatFailures(failures, globals.length));
+						logger.info(`MDX validation passed — ${globals.length} global component${globals.length === 1 ? "" : "s"} registered, ${contentDirs.length} content dir${contentDirs.length === 1 ? "" : "s"} scanned.`);
+					}
+				}
+				integrationsToAdd.push(mdx(options.mdx ?? {}));
+				if (options.sitemap !== false && Boolean(config.site)) integrationsToAdd.push(sitemap());
+				updateConfig({
+					...config.site ? { site: config.site } : {},
+					integrations: integrationsToAdd,
+					markdown: {
+						processor: satteri(),
+						shikiConfig: {
+							themes: {
+								light: "github-light",
+								dark: "github-dark"
+							},
+							defaultColor: false,
+							transformers: defaultCodeTransformers()
+						}
+					},
+					vite: { plugins: [virtualConfigPlugin(config)] }
+				});
+			},
+			"astro:config:done": ({ injectTypes }) => {
+				injectTypes({
+					filename: "virtual-config.d.ts",
+					content: [
+						"declare module \"virtual:nimbus/config\" {",
+						"  import type { NimbusConfig } from \"nimbus-docs/types\";",
+						"  export const config: NimbusConfig;",
+						"}",
+						""
+					].join("\n")
+				});
+			},
+			"astro:build:done": async ({ dir }) => {
+				if (config.search === false || config.search?.provider === "custom") return;
+				await runPagefind(fileURLToPath(dir));
+			}
+		}
+	};
+}
+function runPagefind(siteDir) {
+	const bin = process.platform === "win32" ? "pagefind.cmd" : "pagefind";
+	return new Promise((resolve) => {
+		execFile(bin, ["--site", siteDir], (error, stdout, stderr) => {
+			if (stdout) process.stdout.write(stdout);
+			if (stderr) process.stderr.write(stderr);
+			if (error) console.warn(`[nimbus-docs] Pagefind did not run. Install pagefind as a devDependency or set search: false in your Nimbus config.\n${error.message}`);
+			resolve();
+		});
+	});
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* Main entry for `nimbus-docs`.
+*
+* Exports the Astro integration (default), config helper, and the four
+* data helpers (sidebar, prev/next, breadcrumbs, TOC). Phase 6 will
+* add page composition helpers (`getDocsStaticPaths`, `getDocsPageProps`).
+*
+* Helpers read the user's config from `virtual:nimbus/config` (provided
+* by our Vite plugin) and content entries from `astro:content`. Both
+* are external in tsdown and resolved at the consumer's build time.
+*/
+/** Primary collection name — kept in sync with `_internal/content.ts`. */
+const PRIMARY_COLLECTION = "docs";
+/**
+* Define a typed Nimbus config. Returns the config unchanged but inferred.
+*/
+function defineConfig(config) {
+	return config;
+}
+/**
+* Build the sidebar tree for the given current path, scoped to the
+* top-level section containing that page.
+*
+* Reads `sidebar` from the user's nimbus.config. If `sidebar.items` is set,
+* resolves config-driven sidebar. Otherwise auto-generates from filesystem
+* (i.e. the `docs` collection's entry IDs).
+*
+* The returned tree is always scoped: only the current section's children
+* are returned. To enumerate every top-level section (for header tabs or
+* a section switcher), use `getSidebarSections`.
+*
+* @param currentSlug - The current page's URL path (e.g. "/getting-started").
+*                     Used to set `isCurrent` on matching links and to pick
+*                     which top-level section to surface.
+*/
+async function getSidebar(currentSlug) {
+	return scopeToCurrentSection(await buildFullSidebarTree(currentSlug), currentSlug);
+}
+/**
+* Derive one section per top-level group in the sidebar — used by
+* `Header.astro` to render the section tab strip (and by any other
+* cross-section navigation).
+*
+* Reads the un-scoped tree so every section is visible, then collapses
+* each top-level group to `{ label, href, isActive }`.
+*/
+async function getSidebarSections(currentSlug) {
+	return deriveSidebarSections(await buildFullSidebarTree(currentSlug));
+}
+/**
+* Internal: build the un-scoped sidebar tree. Shared by `getSidebar` and
+* `getSidebarSections`.
+*/
+async function buildFullSidebarTree(currentSlug) {
+	const runtimeConfig = await loadNimbusConfig();
+	return buildSidebarTree(await getVisibleEntriesByCollection([PRIMARY_COLLECTION, ...collectSidebarCollectionRefs(runtimeConfig.sidebar?.items).filter((c) => c !== PRIMARY_COLLECTION)]), PRIMARY_COLLECTION, currentSlug, runtimeConfig.sidebar);
+}
+/**
+* Resolve prev/next links for the current page.
+*
+* Walks the flattened sidebar; returns the surrounding entries. Honors
+* `prev`/`next` frontmatter overrides if provided.
+*/
+async function getPrevNext(currentSlug, options) {
+	return getPrevNext$1(currentSlug, options?.sidebarTree ?? await getSidebar(currentSlug), options?.overrides);
+}
+/**
+* Build breadcrumb trail from "/" to the current page.
+*
+* Phase 5: simple URL-segment derivation. Later phases may enrich with
+* sidebar-aware labels.
+*/
+async function getBreadcrumbs(currentSlug, options) {
+	return getBreadcrumbs$1(currentSlug, options?.homeLabel ?? "Home");
+}
+/**
+* Build an edit URL for a content entry using `config.editPattern`.
+*
+* `{path}` is replaced with the entry's source path when Astro provides it,
+* falling back to the default docs collection path convention.
+*/
+async function getEditUrl(entry) {
+	const runtimeConfig = await loadNimbusConfig();
+	if (!runtimeConfig.editPattern) return void 0;
+	const path = entry.filePath ?? `src/content/docs/${entry.id}.mdx`;
+	return runtimeConfig.editPattern.replace("{path}", path);
+}
+/**
+* Resolve a content entry's `lastUpdated` date from `git log`.
+*
+* Reads the author date (`%aI`) of the most recent commit that touched
+* the entry's source file. Author date is stable across rebases — the
+* value reflects when the content was actually changed, not when the
+* commit happened to land in this branch.
+*
+* Returns `undefined` when git can't answer (no `.git`, shallow clone,
+* file untracked, command not on PATH, etc.) so the caller can chain a
+* fallback:
+*
+*   const lastUpdated = entry.data.lastUpdated ?? await getLastUpdated(entry);
+*
+* Frontmatter always wins. Per-process cached so repeated calls for
+* the same entry don't re-spawn `git`.
+*
+* Production note: most CI/CD systems do shallow clones by default
+* (Vercel, Cloudflare Pages, GitHub Actions checkout@v4) — set
+* `fetch-depth: 0` to make full history available, otherwise git
+* returns nothing and the helper falls back to frontmatter or nothing.
+*/
+async function getLastUpdated(entry) {
+	return getLastUpdatedFromGit(entry.filePath ?? `src/content/docs/${entry.id}.mdx`);
+}
+/**
+* Filter heading list to the configured min/max heading levels.
+*
+* @param headings - Raw `headings` from Astro's `render(entry)` return value.
+* @param options - Override min/max heading levels. Defaults: min=2, max=3.
+*/
+function getTOC(headings, options) {
+	return getHeadings(headings, options);
+}
+/**
+* `getStaticPaths` implementation for a docs catch-all route.
+*
+* Returns one path per visible entry in the `docs` collection. Drafts are
+* filtered in production. Each path passes `{ entry }` as props so the
+* page component can access it via `getDocsPageProps(Astro)`.
+*
+* Usage:
+*
+*   // src/pages/[...slug].astro
+*   export const prerender = true;
+*   export const getStaticPaths = getDocsStaticPaths;
+*
+* The entry's `id` is used verbatim as the slug. So `docs/index.mdx` →
+* `/index`, `docs/guides/setup.mdx` → `/guides/setup`. If you want a docs
+* entry at the root URL, name it appropriately and decide whether to use
+* a static `pages/index.astro` or let the catch-all handle root.
+*/
+const getDocsStaticPaths = async () => {
+	return (await getVisibleEntries(["docs"])).map((entry) => ({
+		params: { slug: entry.id },
+		props: { entry }
+	}));
+};
+/**
+* Read the current entry from `Astro.props`, render it, and return the
+* pieces a docs page needs: the typed entry, the renderable `<Content />`
+* component, and the headings list (for TOC generation).
+*
+* Pass the page's `Astro` global. Throws if `Astro.props.entry` is missing,
+* which indicates the page didn't wire `getDocsStaticPaths` (or a custom
+* equivalent) correctly.
+*
+* Usage:
+*
+*   const { entry, Content, headings } = await getDocsPageProps(Astro);
+*/
+async function getDocsPageProps(astro) {
+	const entry = astro.props.entry;
+	if (!entry) throw new Error("getDocsPageProps(): expected `entry` in Astro.props. Ensure your route uses `getStaticPaths = getDocsStaticPaths` (or passes an entry via custom getStaticPaths).");
+	const { render } = await import("astro:content");
+	const { Content, headings } = await render(entry);
+	return {
+		entry,
+		Content,
+		headings
+	};
+}
+
+//#endregion
+export { nimbus as default, defaultCodeTransformers, defineConfig, getBreadcrumbs, getDocsPageProps, getDocsStaticPaths, getEditUrl, getLastUpdated, getPrevNext, getSidebar, getSidebarSections, getTOC, getVisibleEntries, renderEntryAsMarkdown, sidebarHash };
+//# sourceMappingURL=index.js.map