@minidocs/astro 0.0.0-stage → 0.1.0

package/dist/runtime.d.mts

@@ -0,0 +1,160 @@
+import { TocNode, TocOptions, findPath, neighbors, tocTree } from "@minidocs/core";
+import { AstroRenderer } from "astro";
+//#region src/llms.d.ts
+interface LlmsTxtOptions<E> {
+  /** Name of the site, the heading of the file. */
+  title: string;
+  /** Description of a page, shown after its link. The description of the `index` page also becomes the summary of the file. */
+  describe?: ((entry: E) => string | undefined) | undefined;
+}
+//#endregion
+//#region src/runtime.d.ts
+/** Site-wide types generated from the Astro config: `{ i18n: true; locale: ... }`, or `{ i18n: false }` for single-language sites. */
+export interface Config {}
+/** Per-collection types generated by `glob` from '@minidocs/astro/loaders'. Without them, ids fall back to `string`. */
+export interface Collections {}
+type IsI18n = Config extends {
+  i18n: true;
+} ? true : false;
+/** Locales of the site. */
+export type Locale = Config extends {
+  locale: infer L extends string;
+} ? L : string;
+type Known<C extends string> = C extends keyof Collections ? Collections[C] : never;
+type Lookup<T, L> = T extends string ? T : L extends keyof T ? Extract<T[L], string> : never;
+type Field<C extends string, K extends string, L> = [Known<C>] extends [never] ? string : Known<C> extends Record<K, infer T> ? Lookup<T, L> : string;
+/** Page ids that can be referenced in a locale: its own pages plus pages reachable through fallback. */
+export type PageIdOf<C extends string, L = Locale> = Field<C, 'pages', L>;
+/** Directories that contain pages in a locale. */
+export type DirOf<C extends string, L = Locale> = Field<C, 'dirs', L>;
+/** The minimal shape of a content collection entry minidocs works with. */
+export interface DocEntry {
+  collection: string;
+  filePath?: string | undefined;
+  data: {
+    title: string;
+  };
+}
+type Id<E extends DocEntry> = PageIdOf<E['collection']>;
+interface LocalizedPageRef<E extends DocEntry> {
+  id: Id<E>;
+  /** Locale of the tree the node belongs to. */
+  locale: Locale;
+  /** Locale `entry` comes from. Differs from `locale` only for fallback pages. */
+  contentLocale: Locale;
+  entry: E;
+  isFallback: boolean;
+}
+export interface DocNode<E extends DocEntry> {
+  label: string;
+  page?: IsI18n extends true ? LocalizedPageRef<E> : {
+    id: Id<E>;
+    entry: E;
+  };
+  /** External link target, never set together with `page`. */
+  href?: string;
+  children: DocNode<E>[];
+}
+interface TreeHelpers<E extends DocEntry, L> {
+  page: (id: PageIdOf<E['collection'], L>, children?: DocNode<E>[]) => DocNode<E>;
+  group: (label: string, children: DocNode<E>[]) => DocNode<E>;
+  /** Returns the contents of a directory, excluding the directory's own index page. */
+  dir: (path: DirOf<E['collection'], L>, options?: {
+    compare?: (a: DocNode<E>, b: DocNode<E>) => number;
+  }) => DocNode<E>[];
+  link: (label: string, href: string) => DocNode<E>;
+}
+/** For multilingual sites, one context per locale, so checking `locale` narrows which pages `page()` accepts. */
+export type BuildContext<E extends DocEntry> = IsI18n extends true ? { [L in Locale]: TreeHelpers<E, L> & {
+  locale: L;
+}; }[Locale] : TreeHelpers<E, Locale>;
+/** One tree per locale for multilingual sites, a single tree otherwise. */
+export type DocTree<E extends DocEntry> = IsI18n extends true ? Record<Locale, DocNode<E>[]> : DocNode<E>[];
+interface PageInfo<E extends DocEntry> {
+  id: Id<E>;
+  entry: E;
+  /** Route parameter for `src/pages/[...path].astro`. `undefined` is the site root. */
+  path: string | undefined;
+  href: string;
+  /** Route parameter for `src/pages/[...path].md.ts`. */
+  markdownPath: string;
+  /** Link to the Markdown version of the page. */
+  markdownHref: string;
+}
+interface LocalizedPageInfo<E extends DocEntry> extends PageInfo<E> {
+  /** Locale the page is shown in. */
+  locale: Locale;
+  /** Locale the content comes from. Differs from `locale` only for fallback pages. */
+  contentLocale: Locale;
+  isFallback: boolean;
+  /** Every locale this page exists in, translated or through fallback, including the current one. */
+  alternates: {
+    locale: Locale;
+    href: string;
+  }[];
+}
+export type DocPage<E extends DocEntry> = IsI18n extends true ? LocalizedPageInfo<E> : PageInfo<E>;
+type LocaleArgs = IsI18n extends true ? [locale: Locale] : [];
+/** Builds the navigation tree. Multilingual sites get one tree per locale, built by running `build` once for each. */
+export declare function defineTree<E extends DocEntry>(entries: readonly E[], build: (context: BuildContext<E>) => DocNode<E>[] | Promise<DocNode<E>[]>): Promise<DocTree<E>>;
+/** Link to a page, including `base` and the trailing slash Astro would use. */
+export declare function toHref(id: string, ...locale: LocaleArgs): string;
+/** Route parameter for a page in `src/pages/[...path].astro`. `undefined` is the site root. */
+export declare function toPath(id: string, ...locale: LocaleArgs): string | undefined;
+/** Whether a component renders for the Markdown version of a page, where it should output plain HTML that converts cleanly. */
+export declare function isMarkdown(astro: {
+  locals: object;
+}): boolean;
+export interface MarkdownOptions {
+  /** Container renderers for UI framework components in the content, e.g. `getContainerRenderer()` from `@astrojs/react`. MDX is added automatically. */
+  renderers?: AstroRenderer[];
+}
+/** A page to convert: one from `listPages`, or the `page` of a tree node. */
+export type MarkdownPage<E extends DocEntry> = IsI18n extends true ? {
+  id: Id<E>;
+  entry: E;
+  locale: Locale;
+} : {
+  id: Id<E>;
+  entry: E;
+};
+/**
+ * Renders the content of a page and converts it into Markdown for agents, without a title.
+ * Components can check `isMarkdown(Astro)` to render a form that converts cleanly.
+ */
+export declare function toMarkdown<E extends DocEntry>(page: MarkdownPage<E>, options?: MarkdownOptions): Promise<string>;
+/**
+ * Renders a tree as llms.txt. Top-level pages come first, every top-level node with children becomes a section,
+ * and links point to the Markdown versions of pages. The `index` page's description becomes the summary.
+ */
+export declare function toLlmsTxt<E extends DocEntry>(nodes: DocNode<E>[], options: LlmsTxtOptions<E>): string;
+/**
+ * Every page of a tree in reading order, as Markdown under its title and source URL, for llms-full.txt.
+ * Like llms.txt, links and images are full URLs when `site` is set.
+ */
+export declare function toLlmsFullTxt<E extends DocEntry>(nodes: DocNode<E>[], options?: MarkdownOptions): Promise<string>;
+/** Every page that needs a route. Multilingual sites include every locale and untranslated pages served through fallback. */
+export declare function listPages<E extends DocEntry>(entries: readonly E[]): DocPage<E>[];
+interface NavNode {
+  page?: {
+    id: string;
+    locale?: string;
+  } | undefined;
+  href?: string | undefined;
+  children: NavNode[];
+}
+/** Named after the props of navigation components, so it can be spread onto them. */
+export interface NodeState {
+  /** Link of a page or an external link, `undefined` for plain groups. */
+  href: string | undefined;
+  /** Whether the node is the current page. Only the first occurrence of a duplicated page counts. */
+  current: boolean;
+  /** Whether the current page is the node itself or below it. */
+  open: boolean;
+}
+/** Tracks where the current page sits in a tree. `of(node)` returns what navigation components need to render a node. */
+export declare function navState<N extends NavNode>(nodes: N[], id: string): {
+  of(node: N): NodeState;
+};
+//#endregion
+export { type LlmsTxtOptions, type TocNode, type TocOptions, findPath, neighbors, tocTree };

package/dist/runtime.mjs

@@ -0,0 +1,310 @@
+import { a as routePath, i as markdownPath, n as href, r as markdownHref, t as contentOptions } from "./routing-TMqRCY2Q.mjs";
+import { MissingPageError, createTree, findPath, listPages as listPages$1, navState as navState$1, neighbors, tocTree } from "@minidocs/core";
+import config from "virtual:minidocs/config";
+import { fromHtml } from "hast-util-from-html";
+import { defaultHandlers, toMdast } from "hast-util-to-mdast";
+import { gfmToMarkdown } from "mdast-util-gfm";
+import { toMarkdown as toMarkdown$1 } from "mdast-util-to-markdown";
+//#region src/llms.ts
+const escapeLabel = (text) => text.replace(/[[\]\\]/g, "\\$&");
+const oneLine = (text) => text.replace(/\s+/g, " ").trim();
+/** Pages of a tree in reading order, each page once. */
+function pagesInOrder(nodes) {
+	const pages = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		if (node.page && !pages.has(node.page.id)) pages.set(node.page.id, node.page);
+		node.children.forEach(visit);
+	};
+	nodes.forEach(visit);
+	return [...pages.values()];
+}
+/**
+* Renders a tree as llms.txt: the title, the `index` page's description as the summary,
+* top-level pages as a list, then a section for every top-level node with children.
+* `url` links a page to its Markdown version.
+*/
+function renderLlmsTxt(nodes, options, url) {
+	const item = (node, depth, withChildren = true) => {
+		const description = node.page && options.describe?.(node.page.entry);
+		const line = node.page ? `[${escapeLabel(node.label)}](${url(node.page)})${description ? `: ${oneLine(description)}` : ""}` : node.href ? `[${escapeLabel(node.label)}](${node.href})` : node.label;
+		const children = withChildren ? node.children.flatMap((child) => item(child, depth + 1)) : [];
+		return [`${"  ".repeat(depth)}- ${line}`, ...children];
+	};
+	const blocks = [`# ${options.title}`];
+	const index = pagesInOrder(nodes).find((page) => page.id === "index");
+	const summary = index && options.describe?.(index.entry);
+	if (summary) blocks.push(`> ${oneLine(summary)}`);
+	const loose = nodes.filter((node) => node.children.length === 0);
+	if (loose.length > 0) blocks.push(loose.flatMap((node) => item(node, 0)).join("\n"));
+	for (const node of nodes.filter((node) => node.children.length > 0)) {
+		const lines = [...node.page ? item(node, 0, false) : [], ...node.children.flatMap((child) => item(child, 0))];
+		blocks.push(`## ${node.label}\n\n${lines.join("\n")}`);
+	}
+	return `${blocks.join("\n\n")}\n`;
+}
+//#endregion
+//#region src/serialize.ts
+const ORIGIN = "http://minidocs.invalid";
+/** URL path of a link, in the form `pathKey` compares with. */
+function pathKey(href) {
+	return new URL(href, ORIGIN).pathname.replace(/\/+$/, "");
+}
+/**
+* Turns a URL on the site into a path, pointing pages at their Markdown versions.
+* Relative URLs resolve against the HTML page, since the Markdown file sits one level up.
+* Returns `undefined` for URLs to other sites and links within the page.
+*/
+function rewriteUrl(url, context) {
+	if (/^([a-z][a-z\d+.-]*:|\/\/|#)/i.test(url)) return void 0;
+	const resolved = new URL(url, ORIGIN + context.pageHref);
+	const target = context.markdownOf(pathKey(resolved.href));
+	const path = target ? target + resolved.hash : resolved.pathname + resolved.search + resolved.hash;
+	return context.resolve ? context.resolve(path) : path;
+}
+/** Hands an element to its default handler with one URL property rewritten. */
+const withUrl = (property, handle, context) => (state, node, parent) => {
+	const url = node.properties[property];
+	const rewritten = typeof url === "string" ? rewriteUrl(url, context) : void 0;
+	return handle(state, rewritten ? {
+		...node,
+		properties: {
+			...node.properties,
+			[property]: rewritten
+		}
+	} : node, parent);
+};
+const isElement = (node, tagName) => node?.type === "element" && node.tagName === tagName;
+const hasClass = (node, name) => [node.properties.className].flat().includes(name);
+/** Callouts, from the Markdown syntax or the `Callout` component, become GitHub alerts with the title in bold. */
+const callout = (state, node) => {
+	if (!hasClass(node, "md-callout") || typeof node.properties.dataType !== "string") return defaultHandlers.div(state, node);
+	const elements = node.children.filter((child) => child.type !== "text" || child.value.trim());
+	const title = isElement(elements[0], "p") && hasClass(elements[0], "md-callout-title") ? elements[0] : void 0;
+	const marker = {
+		type: "html",
+		value: `[!${node.properties.dataType.toUpperCase()}]`
+	};
+	const body = state.toFlow(state.all({
+		...node,
+		children: title ? elements.slice(1) : elements
+	}));
+	const [first, ...rest] = body;
+	const head = title ? {
+		type: "paragraph",
+		children: [
+			marker,
+			{
+				type: "text",
+				value: "\n"
+			},
+			{
+				type: "strong",
+				children: state.all(title)
+			}
+		]
+	} : first?.type === "paragraph" ? {
+		...first,
+		children: [
+			marker,
+			{
+				type: "text",
+				value: "\n"
+			},
+			...first.children
+		]
+	} : void 0;
+	const quote = {
+		type: "blockquote",
+		children: head ? [head, ...title ? body : rest] : [{
+			type: "paragraph",
+			children: [marker]
+		}, ...body]
+	};
+	state.patch(node, quote);
+	return quote;
+};
+/** Shiki puts the language on `<pre>`, but the converter only reads it from a `language-*` class on `<code>`. */
+const pre = (state, node) => {
+	const language = node.properties.dataLanguage;
+	const code = node.children.find((child) => isElement(child, "code"));
+	if (typeof language === "string" && language !== "plaintext" && code) code.properties.className = [`language-${language}`];
+	return defaultHandlers.pre(state, node);
+};
+/** Converts a page rendered by Astro into Markdown for agents. */
+function htmlToMarkdown(html, context) {
+	const handlers = {
+		a: withUrl("href", defaultHandlers.a, context),
+		img: withUrl("src", defaultHandlers.img, context),
+		div: callout,
+		pre
+	};
+	const mdast = toMdast(fromHtml(html, { fragment: true }), { handlers });
+	return toMarkdown$1(mdast, {
+		extensions: [gfmToMarkdown()],
+		bullet: "-",
+		rule: "-",
+		fences: true,
+		listItemIndent: "one"
+	});
+}
+//#endregion
+//#region src/runtime.ts
+function optionsFor(entries) {
+	const collection = entries[0]?.collection;
+	if (!collection) throw new Error("[minidocs] Expected at least one entry.");
+	const base = config.bases[collection];
+	if (base === void 0) throw new Error(`[minidocs] Collection "${collection}" must be loaded with glob from '@minidocs/astro/loaders'.`);
+	if (entries.some((entry) => entry.collection !== collection)) throw new Error("[minidocs] All entries must come from the same collection.");
+	return contentOptions(config, base);
+}
+/** Drops locale details from nodes of single-language sites, where they carry no meaning. */
+function withoutLocale(nodes) {
+	return nodes.map(({ page, children, ...node }) => ({
+		...node,
+		...page && { page: {
+			id: page.id,
+			entry: page.entry
+		} },
+		children: withoutLocale(children)
+	}));
+}
+/** Builds the navigation tree. Multilingual sites get one tree per locale, built by running `build` once for each. */
+async function defineTree(entries, build) {
+	const options = optionsFor(entries);
+	const run = build;
+	let tree;
+	try {
+		tree = await createTree(entries, {
+			...options,
+			label: (entry) => entry.data.title
+		}, config.i18n ? run : ({ locale: _, ...helpers }) => run(helpers));
+	} catch (error) {
+		if (error instanceof MissingPageError && config.pageIds[entries[0].collection]?.includes(error.id)) throw new Error(`[minidocs] Page "${error.id}" is in the collection but not among the entries passed to defineTree. To leave pages out, use the filter option of glob from '@minidocs/astro/loaders' instead of filtering the entries.`, { cause: error });
+		throw error;
+	}
+	return config.i18n ? tree : withoutLocale(tree[options.locales[0]]);
+}
+/** Link to a page, including `base` and the trailing slash Astro would use. */
+function toHref(id, ...locale) {
+	return href(config, id, locale[0]);
+}
+/** Route parameter for a page in `src/pages/[...path].astro`. `undefined` is the site root. */
+function toPath(id, ...locale) {
+	return routePath(config, id, locale[0]);
+}
+const MARKDOWN = "minidocs:markdown";
+/** Whether a component renders for the Markdown version of a page, where it should output plain HTML that converts cleanly. */
+function isMarkdown(astro) {
+	return astro.locals[MARKDOWN] === true;
+}
+const containers = /* @__PURE__ */ new Map();
+async function containerFor(extra) {
+	const { default: builtin } = await import("virtual:minidocs/renderers");
+	const renderers = [...builtin, ...extra];
+	const key = renderers.map(({ name }) => name).join(",");
+	let container = containers.get(key);
+	if (!container) {
+		container = (async () => {
+			const [{ experimental_AstroContainer }, { loadRenderers }] = await Promise.all([import("astro/container"), import("astro:container")]);
+			return experimental_AstroContainer.create({ renderers: await loadRenderers(renderers) });
+		})();
+		containers.set(key, container);
+	}
+	return container;
+}
+const markdownPages = /* @__PURE__ */ new Map();
+/** Markdown versions of every page in a collection, keyed by the URL path of the HTML page. */
+function markdownPagesOf(collection) {
+	let pages = markdownPages.get(collection);
+	if (!pages) {
+		pages = /* @__PURE__ */ new Map();
+		for (const id of config.pageIds[collection] ?? []) for (const locale of config.i18n?.locales ?? [void 0]) pages.set(pathKey(href(config, id, locale)), markdownHref(config, id, locale));
+		markdownPages.set(collection, pages);
+	}
+	return pages;
+}
+/** Full URL of a path when `site` is set, for text that is often pasted where paths do not resolve. */
+const fullUrl = (path) => config.site ? new URL(path, config.site).href : path;
+/**
+* Renders the content of a page and converts it into Markdown for agents, without a title.
+* Components can check `isMarkdown(Astro)` to render a form that converts cleanly.
+*/
+function toMarkdown(page, options = {}) {
+	return renderMarkdown(page, options);
+}
+/** `toMarkdown`, with every URL on the site passed through `resolve`. */
+async function renderMarkdown(page, options, resolve) {
+	const { id, entry } = page;
+	const locale = page.locale;
+	const [{ render }, container] = await Promise.all([import("astro:content"), containerFor(options.renderers ?? [])]);
+	const { Content } = await render(entry);
+	let html;
+	try {
+		html = await container.renderToString(Content, { locals: { [MARKDOWN]: true } });
+	} catch (error) {
+		if (error.name === "NoMatchingRenderer") throw new Error(`[minidocs] Page "${id}" uses a component the Markdown version cannot render. Pass its container renderer to toMarkdown, e.g. \`toMarkdown(page, { renderers: [getContainerRenderer()] })\` with getContainerRenderer from the framework's integration.`, { cause: error });
+		throw error;
+	}
+	return htmlToMarkdown(html, {
+		pageHref: href(config, id, locale),
+		markdownOf: (path) => markdownPagesOf(entry.collection).get(path),
+		resolve
+	});
+}
+const markdownUrl = ({ id, locale }) => fullUrl(markdownHref(config, id, locale));
+/**
+* Renders a tree as llms.txt. Top-level pages come first, every top-level node with children becomes a section,
+* and links point to the Markdown versions of pages. The `index` page's description becomes the summary.
+*/
+function toLlmsTxt(nodes, options) {
+	return renderLlmsTxt(nodes, options, markdownUrl);
+}
+/**
+* Every page of a tree in reading order, as Markdown under its title and source URL, for llms-full.txt.
+* Like llms.txt, links and images are full URLs when `site` is set.
+*/
+async function toLlmsFullTxt(nodes, options = {}) {
+	const pages = pagesInOrder(nodes);
+	return (await Promise.all(pages.map(async (page) => `# ${page.entry.data.title}\n\nSource: ${markdownUrl(page)}\n\n${await renderMarkdown(page, options, fullUrl)}`))).join("\n");
+}
+/** Every page that needs a route. Multilingual sites include every locale and untranslated pages served through fallback. */
+function listPages(entries) {
+	const pages = listPages$1(entries, optionsFor(entries));
+	if (!config.i18n) return pages.map(({ id, entry }) => ({
+		id,
+		entry,
+		path: routePath(config, id),
+		href: href(config, id),
+		markdownPath: markdownPath(config, id),
+		markdownHref: markdownHref(config, id)
+	}));
+	const alternates = /* @__PURE__ */ new Map();
+	for (const page of pages) {
+		const list = alternates.get(page.id) ?? [];
+		list.push({
+			locale: page.locale,
+			href: href(config, page.id, page.locale)
+		});
+		alternates.set(page.id, list);
+	}
+	return pages.map((page) => ({
+		...page,
+		path: routePath(config, page.id, page.locale),
+		href: href(config, page.id, page.locale),
+		markdownPath: markdownPath(config, page.id, page.locale),
+		markdownHref: markdownHref(config, page.id, page.locale),
+		alternates: alternates.get(page.id)
+	}));
+}
+/** Tracks where the current page sits in a tree. `of(node)` returns what navigation components need to render a node. */
+function navState(nodes, id) {
+	const state = navState$1(nodes, id);
+	return { of(node) {
+		return {
+			href: node.page ? href(config, node.page.id, node.page.locale) : node.href,
+			...state.of(node)
+		};
+	} };
+}
+//#endregion
+export { defineTree, findPath, isMarkdown, listPages, navState, neighbors, toHref, toLlmsFullTxt, toLlmsTxt, toMarkdown, toPath, tocTree };

package/package.json

@@ -1,6 +1,83 @@
 {
   "name": "@minidocs/astro",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Astro integration for building documentation sites from composable primitives",
+  "keywords": [
+    "astro",
+    "astro-integration",
+    "withastro",
+    "documentation",
+    "docs"
+  ],
+  "homepage": "https://github.com/Ivan-1F/minidocs#readme",
+  "bugs": "https://github.com/Ivan-1F/minidocs/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ivan-1F/minidocs.git",
+    "directory": "packages/astro"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./loaders": {
+      "types": "./dist/loaders.d.mts",
+      "default": "./dist/loaders.mjs"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.mts",
+      "default": "./dist/runtime.mjs"
+    },
+    "./behaviors": {
+      "types": "./dist/behaviors.d.mts",
+      "default": "./dist/behaviors.mjs"
+    },
+    "./components": "./src/components/index.ts",
+    "./styles.css": "./src/styles.css",
+    "./styles/*": "./src/styles/*"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "src/components/**/*.{astro,ts}",
+    "src/styles.css",
+    "src/styles",
+    "!**/*.test.ts"
+  ],
+  "peerDependencies": {
+    "astro": "^7.0.0"
+  },
+  "dependencies": {
+    "hast-util-from-html": "^2.0.3",
+    "hast-util-to-mdast": "^10.1.2",
+    "mdast-util-gfm": "^3.1.0",
+    "mdast-util-to-markdown": "^2.2.0",
+    "remark-directive": "^4.0.0",
+    "@minidocs/core": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/hast": "^3.0.5",
+    "@types/mdast": "^4.0.4",
+    "@types/node": "^24",
+    "astro": "^7.4.0",
+    "happy-dom": "^21.0.4",
+    "rehype-stringify": "^10.0.1",
+    "remark-parse": "^11.0.0",
+    "remark-rehype": "^11.1.2",
+    "satteri": "0.10.5",
+    "tsdown": "^0.23.1",
+    "typescript": "^7.0.2",
+    "unified": "^11.0.5",
+    "vitest": "^5.0.5"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p test-d/i18n && tsc --noEmit -p test-d/single"
+  }
 }

package/src/components/Prose.astro

@@ -0,0 +1,9 @@
+---
+import type { HTMLAttributes } from 'astro/types';
+
+type Props = HTMLAttributes<'article'>;
+
+const { class: className, ...attrs } = Astro.props;
+---
+
+<article class:list={['md-prose', className]} {...attrs}><slot /></article>

package/src/components/callout/Root.astro

@@ -0,0 +1,14 @@
+---
+import type { CalloutType } from '@minidocs/astro';
+import type { HTMLAttributes } from 'astro/types';
+
+interface Props extends HTMLAttributes<'div'> {
+  /** Decides the color in the default styles. */
+  type?: CalloutType;
+}
+
+// Same markup as the :::type and > [!TYPE] syntax renders, so both share the default styles
+const { type = 'note', class: className, ...attrs } = Astro.props;
+---
+
+<div class:list={['md-callout', className]} data-type={type} role="note" {...attrs}><slot /></div>

package/src/components/callout/Title.astro

@@ -0,0 +1,9 @@
+---
+import type { HTMLAttributes } from 'astro/types';
+
+type Props = HTMLAttributes<'p'>;
+
+const { class: className, ...attrs } = Astro.props;
+---
+
+<p class:list={['md-callout-title', className]} {...attrs}><slot /></p>

package/src/components/callout/index.ts

@@ -0,0 +1,2 @@
+export { default as Root } from './Root.astro';
+export { default as Title } from './Title.astro';

package/src/components/index.ts

@@ -0,0 +1,7 @@
+export * as Callout from './callout';
+export * as Layout from './layout';
+export { default as Prose } from './Prose.astro';
+export * as Pager from './pager';
+export * as Search from './search';
+export * as Sidebar from './sidebar';
+export * as Toc from './toc';

package/src/components/layout/Aside.astro

@@ -0,0 +1,29 @@
+---
+import { restoreAside } from '@minidocs/astro/behaviors';
+import type { HTMLAttributes } from 'astro/types';
+
+interface Props extends HTMLAttributes<'details'> {
+  /** Heading of the column, and the toggle when the aside collapses above the content. */
+  title: string;
+}
+
+const { title, class: className, ...attrs } = Astro.props;
+// The empty span is filled by attachAside with the heading being read, from md:toc-change events
+// Runs before the first paint, so a collapsible aside starts closed without a flash of its contents
+const restore = `(${restoreAside})(document.currentScript.parentElement)`;
+---
+
+<details class:list={['md-layout-aside', className]} open {...attrs}>
+  <summary class="md-layout-aside-title">
+    <span class="md-layout-aside-label">{title}</span>
+    <span class="md-layout-aside-current" data-md-aside-current></span>
+  </summary>
+  <slot />
+  <script is:inline set:html={restore} />
+</details>
+
+<script>
+import { attachAside } from '@minidocs/astro/behaviors';
+
+for (const aside of document.querySelectorAll<HTMLDetailsElement>('.md-layout-aside')) attachAside(aside);
+</script>

package/src/components/layout/Header.astro

@@ -0,0 +1,18 @@
+---
+import type { HTMLAttributes } from 'astro/types';
+
+type Props = HTMLAttributes<'header'>;
+
+const { class: className, ...attrs } = Astro.props;
+---
+
+<header class:list={['md-layout-header', className]} {...attrs}>
+  <div class="md-layout-header-inner">
+    <slot />
+    {Astro.slots.has('end') && (
+      <div class="md-layout-header-end">
+        <slot name="end" />
+      </div>
+    )}
+  </div>
+</header>

package/src/components/layout/Main.astro

@@ -0,0 +1,9 @@
+---
+import type { HTMLAttributes } from 'astro/types';
+
+type Props = HTMLAttributes<'main'>;
+
+const { class: className, ...attrs } = Astro.props;
+---
+
+<main class:list={['md-layout-main', className]} {...attrs}><slot /></main>