wuppycms 0.0.0-stage → 0.2.0

package/dist/admin-fo4l4lu2.mjs

@@ -0,0 +1,59 @@
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, extname, join, resolve, sep } from "node:path";
+
+//#region src/astro/admin.ts
+const TYPES = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".map": "application/json",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".ico": "image/x-icon",
+	".woff2": "font/woff2"
+};
+const CSP = "default-src 'self'; img-src 'self' data: blob:; style-src 'self' 'unsafe-inline'; frame-ancestors 'none'";
+const notFound = () => new Response("Not found", { status: 404 });
+/** Serves the built admin SPA from `dist`; extensionless paths fall back to index.html (client-side routing). */
+async function serveAdmin(dist, rel) {
+	let path;
+	try {
+		path = decodeURIComponent(rel);
+	} catch {
+		return notFound();
+	}
+	const root = resolve(dist);
+	const ext = extname(path);
+	const target = resolve(root, ext ? path : "index.html");
+	if (!target.startsWith(root + sep)) return notFound();
+	try {
+		const body = await readFile(target);
+		const html = ext === "" || ext === ".html";
+		return new Response(body, { headers: {
+			"content-type": TYPES[html ? ".html" : ext] ?? "application/octet-stream",
+			"x-content-type-options": "nosniff",
+			"cache-control": html ? "no-cache" : "public, max-age=31536000, immutable",
+			...html ? { "content-security-policy": CSP } : {}
+		} });
+	} catch {
+		return notFound();
+	}
+}
+const findAdminDist = () => {
+	const req = createRequire(import.meta.url);
+	const candidates = [];
+	try {
+		const dir = dirname(req.resolve("wuppycms/package.json"));
+		candidates.push(join(dir, "node_modules", "@wuppycms", "admin", "dist"), join(dir, "..", "admin", "dist"), join(dir, "..", "..", "packages", "admin", "dist"));
+	} catch {}
+	candidates.push(join(process.cwd(), "node_modules", "@wuppycms", "admin", "dist"), join(process.cwd(), "packages", "admin", "dist"));
+	const found = candidates.find((dir) => existsSync(join(dir, "index.html")));
+	if (!found) throw new Error("Cannot locate @wuppycms/admin/dist");
+	return found;
+};
+const adminDist = (_resolveFrom) => findAdminDist();
+
+//#endregion
+export { serveAdmin as n, adminDist as t };

package/dist/astro.d.mts

@@ -0,0 +1,20 @@
+import { AstroIntegration } from "astro";
+
+//#region src/astro/integration.d.ts
+/** Turn off a route the site already serves itself (e.g. `sitemap: false` next to @astrojs/sitemap). */
+interface WuppyIntegrationOptions {
+  sitemap?: boolean;
+  robots?: boolean;
+  rss?: boolean;
+  /** Read Wuppy collections from disk on each request so edits show without a rebuild (default true). */
+  live?: boolean;
+}
+declare function wuppycms(options?: WuppyIntegrationOptions): AstroIntegration;
+/**
+ * A page that renders one of the project's Astro components by name, without props, for the visual editor's canvas.
+ * It is generated (one static import per component) so the project's own Astro compiles it, styles included. It only
+ * renders design code the site already ships, and takes no input but a name from that list, so it needs no sign-in.
+ */
+declare function componentPreview(root: string): Promise<string | undefined>;
+//#endregion
+export { WuppyIntegrationOptions, componentPreview, wuppycms as default };

package/dist/astro.mjs

@@ -0,0 +1,302 @@
+import "./frontmatter-DGaz9--t.mjs";
+import { a as themeComponentsPlugin, i as mapSource, n as themePageRel, o as quietHmrPlugin, r as themePagesPlugin } from "./theme-pages-CRsBm1EX.mjs";
+import { t as listThemeComponents } from "./components-BrGAEPly.mjs";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+//#region src/astro/live-content.ts
+/**
+* Build-time half of live content (see live-runtime.ts). A Vite plugin swaps `astro:content` for a module that reads
+* Wuppy collections from disk on each request, and pages that read collections are rendered on request instead of
+* prerendered, so edits made in the admin show at once on the public site.
+*/
+const SHIM = "\0wuppy:live-content";
+const CONTENT_CONFIGS = [
+	"src/content.config.ts",
+	"src/content.config.mts",
+	"src/content.config.js",
+	"src/content.config.mjs",
+	"src/content/config.ts",
+	"src/content/config.js",
+	"src/content/config.mjs"
+];
+const posix = (p) => p.split(sep).join("/");
+const isConfig = (importer) => /[\\/](content\.config|content[\\/]config|live\.config)\.[mc]?[jt]s$/.test(importer);
+/** Whether a page route should render on request: it reads content collections and did not opt into prerendering. */
+function isLiveRoute(root, component) {
+	if (!component.startsWith("src/pages/") || !/\.(astro|ts|js|mjs)$/.test(component)) return false;
+	let source;
+	try {
+		source = readFileSync(join(root, component), "utf8");
+	} catch {
+		return false;
+	}
+	if (!source.includes("astro:content") || /export\s+const\s+prerender\s*=\s*true/.test(source)) return false;
+	return component.endsWith(".astro") || !source.includes("getStaticPaths");
+}
+/** `src/pages/posts/[slug].astro` -> `/posts/[slug]`. */
+const routePattern = (component) => `/${component.replace(/^src\/pages\//, "").replace(/\.[^.]+$/, "").replace(/(^|\/)index$/, "")}`;
+/** Wraps the compiled page's default export so it gets its props from getStaticPaths() at request time. */
+function wrapPage(code, runtime, pattern) {
+	if (!/\bgetStaticPaths\b/.test(code)) return null;
+	let name;
+	const out = code.replace(/export\s+default\s+(\$\$\w+)\s*;?/, (_, n) => (name = n, "")).replace(/(\$\$\w+)\s+as\s+default\b/, (_, n) => (name = n, `${n} as __wuppyPage`));
+	if (!name) return null;
+	return `import { livePage as __wuppyLivePage } from ${JSON.stringify(runtime)};\n${out}\nexport default __wuppyLivePage(${name}, getStaticPaths, ${JSON.stringify(pattern)});\n`;
+}
+function liveContentPlugin(o) {
+	const contentConfig = CONTENT_CONFIGS.map((f) => join(o.root, f)).find((f) => existsSync(f));
+	return {
+		name: "wuppy:live-content",
+		enforce: "pre",
+		resolveId: {
+			order: "pre",
+			handler(id, importer) {
+				if (id !== "astro:content" || !importer || importer === SHIM || isConfig(importer)) return null;
+				if (this.environment?.config?.consumer === "client") return null;
+				return SHIM;
+			}
+		},
+		async load(id) {
+			if (id !== SHIM) return null;
+			const astro = realpathSync(join(o.root, "node_modules/astro/package.json"));
+			const from = async (spec, importer = astro) => {
+				const r = await this.resolve(spec, importer, { skipSelf: true });
+				if (!r) throw new Error(`[wuppy] live content: cannot resolve ${spec}`);
+				return JSON.stringify(r.id);
+			};
+			return {
+				code: `import * as real from "astro:content";
+${contentConfig ? `import * as site from ${JSON.stringify(contentConfig)};` : "const site = { collections: {} };"}
+import { z } from ${await from("astro/zod", join(o.root, "package.json"))};
+import { parseFrontmatter } from ${await from("@astrojs/internal-helpers/frontmatter")};
+import xxhash from ${await from("xxhash-wasm")};
+import { pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { createLive, markdownRenderer, mdxContent } from ${JSON.stringify(o.runtime)};
+export * from "astro:content";
+
+const settings = ${JSON.stringify(o.markdown())};
+const hasher = xxhash();
+const schemas = new Map();
+const live = createLive({
+	root: process.cwd(),
+	built: (name) => real.getCollection(name),
+	schema(name) {
+		if (!schemas.has(name)) {
+			let schema = site.collections?.[name]?.schema;
+			// shortcut: image() fields stay plain strings for edited entries; unchanged ones keep Astro's optimised image.
+			if (typeof schema === "function") schema = schema({ image: () => z.string() });
+			schemas.set(name, schema);
+		}
+		return schemas.get(name);
+	},
+	parseFrontmatter: (source) => parseFrontmatter(source),
+	digest: async (source) => (await hasher).h64ToString(source),
+	async renderMarkdown(body, data, filePath) {
+		const renderer = await markdownRenderer(process.cwd(), settings);
+		const result = await renderer.render(body, { frontmatter: data, fileURL: pathToFileURL(join(process.cwd(), filePath)) });
+		return { html: result.code, metadata: { ...result.metadata, imagePaths: [] } };
+	},
+});
+
+export async function getCollection(name, filter) {
+	return (await live.isLive(name)) ? live.getCollection(name, filter) : real.getCollection(name, filter);
+}
+export async function getEntry(collectionOrRef, id) {
+	const name = typeof collectionOrRef === "string" ? collectionOrRef : collectionOrRef?.collection;
+	if (!(await live.isLive(name))) return real.getEntry(collectionOrRef, id);
+	return live.getEntry(name, typeof collectionOrRef === "string" ? id : (collectionOrRef.id ?? collectionOrRef.slug));
+}
+// An MDX entry changed since the build has no compiled module: compile it now, with the site's Markdown settings.
+export async function render(entry, ...rest) {
+	if (!live.rendersAtRuntime(entry)) return real.render(entry, ...rest);
+	try {
+		const { Content, headings } = await mdxContent(entry.body ?? "", { markdown: settings });
+		return { Content, headings, remarkPluginFrontmatter: {} };
+	} catch (e) {
+		// An entry this theme cannot render (a component it lacks, an import) must not take every page listing it down.
+		if (!String(e?.message).startsWith("[wuppy] MDX not allowed")) throw e;
+		console.warn(\`\${e.message} in \${entry.filePath}; its body is left out\`);
+		const { Content } = await mdxContent("", { markdown: settings });
+		return { Content, headings: [], remarkPluginFrontmatter: {} };
+	}
+}
+export async function getEntries(refs) {
+	return Promise.all(refs.map((ref) => getEntry(ref)));
+}
+`,
+				meta: { astro: {
+					hydratedComponents: [],
+					clientOnlyComponents: [],
+					serverComponents: [],
+					scripts: [],
+					propagation: "in-tree",
+					containsHead: false,
+					pageOptions: {}
+				} }
+			};
+		},
+		transform: {
+			order: "post",
+			handler(code, id) {
+				if (!id.endsWith(".astro")) return null;
+				const component = posix(relative(o.root, id));
+				if (!o.liveRoutes.has(component)) return null;
+				const out = wrapPage(code, o.runtime, routePattern(component));
+				return out === null ? null : {
+					code: out,
+					map: null
+				};
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/astro/integration.ts
+const ext = import.meta.url.endsWith(".ts") ? "ts" : "mjs";
+const CONFIG_FILES = [
+	"wuppy.config.ts",
+	"wuppy.config.mjs",
+	"wuppy.config.js"
+];
+const entry = (path) => new URL(`./${path}.${ext}`, import.meta.url);
+function wuppycms(options = {}) {
+	let root = process.cwd();
+	let markdown;
+	let image;
+	const liveRoutes = /* @__PURE__ */ new Set();
+	let live = false;
+	let site;
+	const settings = () => JSON.parse(JSON.stringify({
+		features: (markdown?.processor?.options)?.features ?? {},
+		shared: {
+			image,
+			syntaxHighlight: markdown?.syntaxHighlight,
+			shikiConfig: markdown?.shikiConfig,
+			gfm: markdown?.gfm,
+			smartypants: markdown?.smartypants
+		}
+	}));
+	return {
+		name: "wuppycms",
+		hooks: {
+			"astro:config:setup": async ({ config, injectRoute, addMiddleware, updateConfig }) => {
+				root = fileURLToPath(config.root);
+				live = options.live !== false && CONFIG_FILES.some((f) => existsSync(join(root, f)));
+				const runtime = fileURLToPath(entry("live-runtime"));
+				site = process.env.WUPPY_BASE_ROOT && resolve(process.env.WUPPY_BASE_ROOT) !== resolve(root) ? process.env.WUPPY_BASE_ROOT : void 0;
+				if (live) updateConfig({ vite: { plugins: [liveContentPlugin({
+					root,
+					runtime,
+					liveRoutes,
+					markdown: settings
+				}), ...site ? [themePagesPlugin({
+					root,
+					runtime,
+					markdown: settings
+				})] : []] } });
+				if (site) updateConfig({ devToolbar: { enabled: true } });
+				updateConfig({ vite: { plugins: [themeComponentsPlugin(root), quietHmrPlugin()] } });
+				updateConfig({ vite: { server: { watch: { ignored: [`${join(root, ".wuppy")}/**`] } } } });
+				if (ext === "ts") updateConfig({ vite: { ssr: { noExternal: [/^@wuppycms\//] } } });
+				addMiddleware({
+					entrypoint: entry("redirect-middleware"),
+					order: "pre"
+				});
+				addMiddleware({
+					entrypoint: entry("page-cache-middleware"),
+					order: "post"
+				});
+				addMiddleware({
+					entrypoint: entry("visual-middleware"),
+					order: "post"
+				});
+				if (site) addMiddleware({
+					entrypoint: entry("theme-seo-middleware"),
+					order: "post"
+				});
+				if (options.sitemap !== false) injectRoute({
+					pattern: "/sitemap.xml",
+					entrypoint: entry("routes/sitemap")
+				});
+				if (options.robots !== false) injectRoute({
+					pattern: "/robots.txt",
+					entrypoint: entry("routes/robots")
+				});
+				if (options.rss !== false) injectRoute({
+					pattern: "/rss.xml",
+					entrypoint: entry("routes/rss")
+				});
+				injectRoute({
+					pattern: "/api/[...path]",
+					entrypoint: entry("routes/api")
+				});
+				injectRoute({
+					pattern: "/uploads/[...path]",
+					entrypoint: entry("routes/uploads")
+				});
+				injectRoute({
+					pattern: "/admin/[...path]",
+					entrypoint: entry("routes/admin")
+				});
+				injectRoute({
+					pattern: "/icons.svg",
+					entrypoint: entry("routes/icons")
+				});
+				const preview = await componentPreview(root);
+				if (preview) injectRoute({
+					pattern: "/_wuppy/component/[name]",
+					entrypoint: preview
+				});
+			},
+			"astro:route:setup": ({ route }) => {
+				if (!live) return;
+				if (site && themePageRel(root, join(root, route.component))) route.prerender = false;
+				if (!isLiveRoute(root, route.component)) return;
+				route.prerender = false;
+				liveRoutes.add(route.component);
+			},
+			"astro:config:done": ({ config, logger }) => {
+				markdown = config.markdown;
+				image = config.image;
+				if (live && config.markdown.processor?.name !== "satteri") logger.warn(`Live content renders edited Markdown with Astro's default processor, not "${config.markdown.processor?.name}"; plugins from it apply after the next build.`);
+			}
+		}
+	};
+}
+/**
+* A page that renders one of the project's Astro components by name, without props, for the visual editor's canvas.
+* It is generated (one static import per component) so the project's own Astro compiles it, styles included. It only
+* renders design code the site already ships, and takes no input but a name from that list, so it needs no sign-in.
+*/
+async function componentPreview(root) {
+	const list = await listThemeComponents(root);
+	if (!list.length) return void 0;
+	const file = join(root, "node_modules", ".wuppy", "component-preview.astro");
+	await mkdir(join(file, ".."), { recursive: true });
+	await writeFile(file, [
+		"---",
+		mapSource(list.map((c) => ({
+			...c,
+			path: join(root, c.path)
+		}))),
+		"export const prerender = false;",
+		"const map = __wuppyComponents;",
+		"const name = Astro.params.name ?? \"\";",
+		"const Component = Object.hasOwn(map, name) ? map[name] : undefined;",
+		"if (!Component) return new Response(null, { status: 404 });",
+		"Astro.response.headers.set(\"x-robots-tag\", \"noindex\");",
+		"---",
+		"<Component />",
+		""
+	].join("\n"));
+	return file;
+}
+
+//#endregion
+export { componentPreview, wuppycms as default };

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+import { b as findDisallowed, i as capabilityHash$1, n as loadConfig } from "./config-CM8_-x_W.mjs";
+import "./frontmatter-DGaz9--t.mjs";
+import { o as importRepo, s as init, t as generateTypes } from "./generate-iX4B_2U2.mjs";
+import { access, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { isFilter, manifestSchema } from "@wuppycms/plugin-types";
+
+//#region src/cli/mdx-to-md.ts
+/** Code (fenced and inline) is copied as is, so it is left out of the checks. */
+const prose = (body) => body.replace(/^(```|~~~)[^\n]*\n[\s\S]*?^\1[ \t]*$/gm, "").replace(/`[^`\n]*`/g, "");
+/**
+* One `.mdx` body as Markdown: drops `import`/`export` lines, turns `{/* comments *\/}` into HTML comments and
+* `className` into `class`. Returns the reasons it cannot be converted (components, expressions) instead.
+*/
+async function mdxToMarkdown(source) {
+	const front = /^---\r?\n[\s\S]*?\r?\n---\r?\n?/.exec(source)?.[0] ?? "";
+	const raw = source.slice(front.length).replace(/^(import|export)\s[^\n]*\n?/gm, "");
+	const body = raw.replace(/\{\/\*([\s\S]*?)\*\/\}/g, "<!--$1-->").replace(/(<[a-z][\w-]*\b[^>]*?\s)className=/g, "$1class=").replace(/^\n+/, "");
+	const problems = [];
+	if (/\{[^}\n]*\}/.test(prose(body).replace(/<!--[\s\S]*?-->/g, ""))) problems.push("JSX expression {…}");
+	problems.push(...await findDisallowed(raw, [], "mdx"));
+	return problems.length ? { problems } : { markdown: front + body };
+}
+/** `wuppycms mdx-to-md [dir]`: converts the `.mdx` entries of every collection (or one folder) to `.md`, once. */
+async function convertMdx(cwd, dir) {
+	let dirs;
+	try {
+		dirs = dir ? [dir] : (await loadConfig(cwd)).collections.map((c) => c.dir);
+	} catch (e) {
+		return {
+			code: 1,
+			stdout: "",
+			stderr: e.message
+		};
+	}
+	const lines = [];
+	let kept = 0;
+	for (const d of dirs) {
+		const names = await readdir(join(cwd, d), { recursive: true }).catch(() => []);
+		for (const name of names.filter((n) => n.endsWith(".mdx"))) {
+			const file = join(cwd, d, name);
+			const target = file.replace(/\.mdx$/, ".md");
+			const rel = relative(cwd, file);
+			const out = await access(target).then(() => true, () => false) ? { problems: [`${relative(cwd, target)} already exists`] } : await mdxToMarkdown(await readFile(file, "utf8"));
+			if ("problems" in out) {
+				kept++;
+				lines.push(`kept      ${rel}: ${out.problems.join(", ")}`);
+				continue;
+			}
+			await writeFile(target, out.markdown);
+			await rm(file);
+			lines.push(`converted ${rel}`);
+		}
+	}
+	if (!lines.length) lines.push("No .mdx files found.");
+	else if (kept) lines.push("", `${kept} file(s) kept as .mdx: move their components into .astro files, then run this again.`);
+	return {
+		code: 0,
+		stdout: lines.join("\n") + "\n",
+		stderr: ""
+	};
+}
+
+//#endregion
+//#region src/cli/upgrade.ts
+const git = promisify(execFile);
+/** Data files are parsed with defaults, so no release has needed a migration yet; add one here when a format changes. */
+const MIGRATIONS = [];
+const parts = (v) => v.split(/[.-]/).slice(0, 3).map((n) => Number.parseInt(n, 10) || 0);
+const compareVersions = (a, b) => {
+	const [x, y] = [parts(a), parts(b)];
+	for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return (x[i] ?? 0) - (y[i] ?? 0);
+	return 0;
+};
+const readJson = async (path) => readFile(path, "utf8").then((text) => JSON.parse(text), () => null);
+/**
+* Brings project data up to the installed `wuppycms` version. Install the new version first (`pnpm up wuppycms`);
+* the previous state is whatever Git has, so a dirty tree is refused: rolling back is `git checkout`.
+*/
+async function upgrade(cwd, { force = false } = {}) {
+	const installed = (await readJson(join(cwd, "node_modules", "wuppycms", "package.json")))?.version;
+	if (!installed) return {
+		code: 1,
+		message: "wuppy is not installed here. Run your package manager's install first."
+	};
+	const stateFile = join(cwd, ".wuppy", "version.json");
+	const from = (await readJson(stateFile))?.version ?? "0.0.0";
+	if (compareVersions(installed, from) < 0) return {
+		code: 1,
+		message: `Installed ${installed} is older than the data (${from}). Downgrades are not supported; restore from Git or a backup.`
+	};
+	const pending = MIGRATIONS.filter((m) => compareVersions(m.to, from) > 0 && compareVersions(m.to, installed) <= 0);
+	const isRepo = await access(join(cwd, ".git")).then(() => true, () => false);
+	if (pending.length > 0 && isRepo && !force) {
+		const { stdout } = await git("git", ["status", "--porcelain"], { cwd });
+		if (stdout.trim()) return {
+			code: 1,
+			message: "Commit or stash your changes first, so the upgrade can be undone with `git checkout .` (or pass --force)."
+		};
+	}
+	for (const m of pending) await m.run(cwd);
+	await mkdir(join(cwd, ".wuppy"), { recursive: true });
+	await writeFile(stateFile, JSON.stringify({ version: installed }) + "\n");
+	return {
+		code: 0,
+		message: `Upgraded ${from} -> ${installed}\n${pending.length ? pending.map((m) => `  - ${m.title}`).join("\n") : "  (no data changes needed)"}\nRun \`wuppycms types\` to refresh generated types. To undo data changes: git checkout . && git clean -fd .wuppy/data`
+	};
+}
+
+//#endregion
+//#region src/cli/index.ts
+const USAGE = "Usage: wuppycms init [--force] | wuppycms import [<git-url> <dir>] | wuppycms plugin hash <plugin-dir> | wuppycms doctor | wuppycms types | wuppycms upgrade [--force] | wuppycms mdx-to-md [<dir>]";
+const exists = (p) => access(p).then(() => true, () => false);
+/** Checks the things that break a fresh install: config, secret, content dirs, Git. */
+async function doctor(cwd, env) {
+	const lines = [];
+	let failed = false;
+	const check = (ok, label, hint = "") => {
+		if (!ok) failed = true;
+		lines.push(`${ok ? "ok  " : "FAIL"} ${label}${ok ? "" : ` - ${hint}`}`);
+	};
+	try {
+		const config = await loadConfig(cwd);
+		check(true, "wuppy.config loads");
+		for (const c of config.collections) check(await exists(join(cwd, c.dir)), `content dir ${c.dir}`, "directory is missing");
+		check(!config.git || await exists(join(cwd, ".git")), "Git repository", "run `git init` (created on first sign-up otherwise)");
+	} catch (e) {
+		check(false, "wuppy.config loads", e.message);
+	}
+	check((env.WUPPY_SECRET ?? "").length >= 32, "WUPPY_SECRET", "set 32+ random characters in .env");
+	return {
+		code: failed ? 1 : 0,
+		stdout: lines.join("\n") + "\n",
+		stderr: ""
+	};
+}
+async function run(argv, cwd, env = process.env) {
+	const [cmd, sub, dir] = argv;
+	if (cmd === "doctor") return doctor(cwd, env);
+	if (cmd === "init") return init(cwd, { force: argv.includes("--force") });
+	if (cmd === "mdx-to-md") return convertMdx(cwd, sub);
+	if (cmd === "import") return importRepo(sub ?? "", dir ?? "", cwd);
+	if (cmd === "upgrade") {
+		const r = await upgrade(cwd, { force: argv.includes("--force") });
+		return r.code === 0 ? {
+			code: 0,
+			stdout: r.message + "\n",
+			stderr: ""
+		} : {
+			code: r.code,
+			stdout: "",
+			stderr: r.message
+		};
+	}
+	if (cmd === "types") try {
+		const { collections } = await loadConfig(cwd);
+		await writeFile(join(cwd, "wuppy-env.d.ts"), generateTypes(collections));
+		return {
+			code: 0,
+			stdout: `Wrote wuppy-env.d.ts (${collections.length} collections)\n`,
+			stderr: ""
+		};
+	} catch (e) {
+		return {
+			code: 1,
+			stdout: "",
+			stderr: e.message
+		};
+	}
+	if (cmd === "plugin" && sub === "hash") {
+		if (!dir) return {
+			code: 1,
+			stdout: "",
+			stderr: USAGE
+		};
+		try {
+			const manifest = manifestSchema.parse(JSON.parse(await readFile(join(cwd, dir, "manifest.json"), "utf8")));
+			const filters = manifest.hooks.filter(isFilter);
+			return {
+				code: 0,
+				stderr: "",
+				stdout: `Capabilities requested by "${manifest.id}":\n${JSON.stringify(manifest.capabilities, null, 2)}\n${filters.length ? `\nBefore-hooks (can refuse, and some can change, changes before they are made): ${filters.join(", ")}\n` : ""}\nIf you accept them, add to wuppy.config:\n  { dir: "${dir}", approve: "${capabilityHash$1(manifest)}" }\n`
+			};
+		} catch (e) {
+			return {
+				code: 1,
+				stdout: "",
+				stderr: `Cannot read ${dir}/manifest.json: ${e.message}`
+			};
+		}
+	}
+	return {
+		code: 1,
+		stdout: "",
+		stderr: USAGE
+	};
+}
+
+//#endregion
+//#region src/cli/main.ts
+const { code, stdout, stderr } = await run(process.argv.slice(2), process.cwd());
+if (stdout) process.stdout.write(stdout);
+if (stderr) process.stderr.write(stderr + "\n");
+process.exit(code);
+
+//#endregion
+export {  };

package/dist/components-BrGAEPly.mjs

@@ -0,0 +1,39 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+//#region src/themes/components.ts
+const NAME = /^[A-Z][A-Za-z0-9]*$/;
+/**
+* Components under `src/components` (recursively). They are design code, not content: the active theme's components are
+* trusted, so they are added to the MDX allowlist automatically. Nested folders are flattened by filename; a duplicate
+* name keeps the first path so two components can never silently shadow each other in the map.
+*/
+async function listThemeComponents(root) {
+	const found = (await readdir(join(root, "src", "components"), { recursive: true }).catch(() => [])).map((name) => name.split("\\").join("/")).filter((name) => name.endsWith(".astro") && !name.split("/").some((part) => part.startsWith("_"))).toSorted();
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const relative of found) {
+		const name = relative.split("/").pop().replace(/\.astro$/, "");
+		if (!NAME.test(name) || seen.has(name)) continue;
+		seen.add(name);
+		out.push({
+			name,
+			path: `src/components/${relative}`
+		});
+	}
+	return out;
+}
+/** The component tag names from one or more roots, in the order the roots are given. */
+async function themeComponentNames(...roots) {
+	const names = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const root of roots) for (const component of await listThemeComponents(root)) {
+		if (seen.has(component.name)) continue;
+		seen.add(component.name);
+		names.push(component.name);
+	}
+	return names;
+}
+
+//#endregion
+export { themeComponentNames as n, listThemeComponents as t };