@minidocs/astro 0.0.0-stage → 0.2.0

package/dist/routing-D28b92w8.mjs

@@ -0,0 +1,60 @@
+//#region src/routing.ts
+/** The locale every page of a single-language site belongs to inside core. Never exposed to users. */
+const SINGLE_LOCALE = "default";
+/** Options for core: locale directories for multilingual sites, one implicit locale otherwise. */
+function contentOptions(settings, base) {
+	return settings.i18n ? {
+		base,
+		locales: settings.i18n.locales,
+		fallback: settings.i18n.fallback
+	} : {
+		base,
+		locales: [SINGLE_LOCALE],
+		localeDirs: false
+	};
+}
+/** The URL segment of a page id: the root index page has none. */
+function slugOf(id) {
+	return id === "index" ? "" : id;
+}
+const normalizeLocale = (locale) => locale.replaceAll("_", "-").toLowerCase();
+/** The URL segment of a locale, `undefined` for the default locale when it is not prefixed, as rest parameters expect. */
+function localeParam(settings, locale) {
+	const { i18n } = settings;
+	if (!i18n || locale === void 0 || locale === i18n.defaultLocale && !i18n.prefixDefaultLocale) return void 0;
+	return normalizeLocale(locale);
+}
+/**
+* Path of a page below `base`, e.g. `en/docs/getting-started`, without slashes around it.
+* `undefined` stands for the site root.
+*/
+function routePath(settings, collection, id, locale) {
+	return [
+		localeParam(settings, locale),
+		collection.prefix,
+		slugOf(id)
+	].filter(Boolean).join("/") || void 0;
+}
+/** Link to a page, including `base` and the trailing slash Astro would use. */
+function href(settings, collection, id, locale) {
+	const path = [settings.base, routePath(settings, collection, id, locale)].filter(Boolean).join("/");
+	if (!path) return "/";
+	return `/${path}${settings.trailingSlash ? "/" : ""}`;
+}
+/**
+* Path of the Markdown version of a page below the locale segment, e.g. `docs/getting-started`.
+* The root of a site without a prefix has no segment of its own, so it becomes `index`.
+*/
+function markdownPath(collection, id) {
+	return [collection.prefix, slugOf(id)].filter(Boolean).join("/") || "index";
+}
+/** Link to the Markdown version of a page, including `base`. */
+function markdownHref(settings, collection, id, locale) {
+	return `/${[
+		settings.base,
+		localeParam(settings, locale),
+		markdownPath(collection, id)
+	].filter(Boolean).join("/")}.md`;
+}
+//#endregion
+export { markdownPath as a, markdownHref as i, href as n, routePath as o, localeParam as r, slugOf as s, contentOptions as t };

package/dist/runtime.d.mts

@@ -0,0 +1,202 @@
+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;
+/** Names of the collections loaded with minidocs' glob, or any string before their types are generated. */
+export type CollectionName = [keyof Collections] extends [never] ? string : Extract<keyof Collections, 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 parameters for `src/pages/docs/[...slug].astro`. `slug` is `undefined` for the root page of the collection. */
+  params: {
+    slug: string | undefined;
+  };
+  href: string;
+  /** Route parameters for `src/pages/[...path].md.ts`, which serves the Markdown versions of every collection. */
+  markdownParams: {
+    path: string;
+  };
+  /** Link to the Markdown version of the page. */
+  markdownHref: string;
+}
+interface LocalizedPageInfo<E extends DocEntry> extends PageInfo<E> {
+  /** Route parameters for `src/pages/[...locale]/docs/[...slug].astro`. `locale` is `undefined` for the default locale when it is not prefixed. */
+  params: {
+    locale: string | undefined;
+    slug: string | undefined;
+  };
+  /** Route parameters for `src/pages/[...locale]/[...path].md.ts`, which serves the Markdown versions of every collection. */
+  markdownParams: {
+    locale: string | undefined;
+    path: string;
+  };
+  /** 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. Multilingual sites take a locale. */
+export declare function toHref<C extends CollectionName>(collection: C, id: PageIdOf<C>, ...locale: LocaleArgs): string;
+/**
+ * The `[...locale]` route parameter of a locale, for the site's own pages such as a home page or a 404 page.
+ * `undefined` for the default locale when it is not prefixed.
+ */
+export declare function toLocaleParam(locale: Locale): 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(page: MarkdownPage<DocEntry>, options?: MarkdownOptions): Promise<string>;
+/** A node of a tree from any collection, so trees of several collections can be joined into one file. */
+interface TreeNode {
+  label: string;
+  page?: {
+    id: string;
+    entry: DocEntry;
+  } | undefined;
+  href?: string | undefined;
+  children: readonly TreeNode[];
+}
+/**
+ * Entries of every collection found in a tree, which may join trees of several collections.
+ * A tree node is structurally the same as a group wrapping it, so the walk stops at a fixed depth instead.
+ */
+type EntryOf<N, Depth extends unknown[] = []> = Depth['length'] extends 4 ? never : N extends {
+  page?: infer P;
+  children: readonly (infer C)[];
+} ? (P extends {
+  entry: infer E;
+} ? E : never) | EntryOf<C, [...Depth, unknown]> : never;
+/**
+ * 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<N extends TreeNode>(nodes: readonly N[], options: LlmsTxtOptions<EntryOf<N>>): 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<N extends TreeNode>(nodes: readonly N[], 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;
+    entry: {
+      collection: 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,327 @@
+import { a as markdownPath, i as markdownHref, n as href, r as localeParam, s as slugOf, t as contentOptions } from "./routing-D28b92w8.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. Trees of several collections can be joined, so a page is its collection and id. */
+function pagesInOrder(nodes) {
+	const pages = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		const key = node.page && `${node.page.entry.collection}\0${node.page.id}`;
+		if (key && !pages.has(key)) pages.set(key, 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 collectionNamed(name) {
+	const collection = config.collections[name];
+	if (!collection) throw new Error(`[minidocs] Collection "${name}" must be loaded with glob from '@minidocs/astro/loaders'.`);
+	return collection;
+}
+function collectionOf(entries) {
+	const name = entries[0]?.collection;
+	if (!name) throw new Error("[minidocs] Expected at least one entry.");
+	if (entries.some((entry) => entry.collection !== name)) throw new Error("[minidocs] All entries must come from the same collection.");
+	return collectionNamed(name);
+}
+/** 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 collection = collectionOf(entries);
+	const options = contentOptions(config, collection.base);
+	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 && collection.pageIds.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. Multilingual sites take a locale. */
+function toHref(collection, id, ...locale) {
+	return href(config, collectionNamed(collection), id, locale[0]);
+}
+/**
+* The `[...locale]` route parameter of a locale, for the site's own pages such as a home page or a 404 page.
+* `undefined` for the default locale when it is not prefixed.
+*/
+function toLocaleParam(locale) {
+	if (!config.i18n) throw new Error("[minidocs] toLocaleParam requires `i18n` in your Astro config.");
+	return localeParam(config, locale);
+}
+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;
+}
+let markdownPages;
+/** Markdown versions of every page on the site, keyed by the URL path of the HTML page, so links into any collection convert. */
+function markdownPagesOnSite() {
+	if (!markdownPages) {
+		markdownPages = /* @__PURE__ */ new Map();
+		for (const collection of Object.values(config.collections)) {
+			const locales = config.i18n?.locales ?? [void 0];
+			for (const id of collection.pageIds) for (const locale of locales) markdownPages.set(pathKey(href(config, collection, id, locale)), markdownHref(config, collection, id, locale));
+		}
+	}
+	return markdownPages;
+}
+/** 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, collectionNamed(entry.collection), id, locale),
+		markdownOf: (path) => markdownPagesOnSite().get(path),
+		resolve
+	});
+}
+const markdownUrl = ({ id, locale, entry }) => fullUrl(markdownHref(config, collectionNamed(entry.collection), 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 collection = collectionOf(entries);
+	const pages = listPages$1(entries, contentOptions(config, collection.base));
+	if (!config.i18n) return pages.map(({ id, entry }) => ({
+		id,
+		entry,
+		params: { slug: slugOf(id) || void 0 },
+		href: href(config, collection, id),
+		markdownParams: { path: markdownPath(collection, id) },
+		markdownHref: markdownHref(config, collection, 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, collection, page.id, page.locale)
+		});
+		alternates.set(page.id, list);
+	}
+	return pages.map((page) => ({
+		...page,
+		params: {
+			locale: localeParam(config, page.locale),
+			slug: slugOf(page.id) || void 0
+		},
+		href: href(config, collection, page.id, page.locale),
+		markdownParams: {
+			locale: localeParam(config, page.locale),
+			path: markdownPath(collection, page.id)
+		},
+		markdownHref: markdownHref(config, collection, 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, collectionNamed(node.page.entry.collection), node.page.id, node.page.locale) : node.href,
+			...state.of(node)
+		};
+	} };
+}
+//#endregion
+export { defineTree, findPath, isMarkdown, listPages, navState, neighbors, toHref, toLlmsFullTxt, toLlmsTxt, toLocaleParam, toMarkdown, 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.2.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.2.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>