@pyreon/create-zero 0.13.1 → 0.15.0

package/lib/index.js

@@ -1,9 +1,172 @@
-import { existsSync, readFileSync } from "node:fs";
-import { cp, readFile, writeFile } from "node:fs/promises";
-import { basename, join, resolve } from "node:path";
 import * as p from "@clack/prompts";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { cp, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
 
-//#region src/index.ts
+//#region src/args.ts
+const TEMPLATE_VALUES = [
+	"app",
+	"blog",
+	"dashboard"
+];
+const ADAPTER_VALUES = [
+	"vercel",
+	"cloudflare",
+	"netlify",
+	"node",
+	"bun",
+	"static"
+];
+const MODE_VALUES = [
+	"ssr-stream",
+	"ssr-string",
+	"ssg",
+	"spa"
+];
+const INTEGRATION_VALUES = ["supabase", "email"];
+const AI_VALUES = [
+	"mcp",
+	"claude",
+	"cursor",
+	"copilot",
+	"agents"
+];
+const COMPAT_VALUES = [
+	"none",
+	"react",
+	"vue",
+	"solid",
+	"preact"
+];
+const PKG_STRATEGY_VALUES = ["meta", "individual"];
+function parseArgs(argv) {
+	const out = {
+		name: void 0,
+		yes: false,
+		help: false,
+		template: void 0,
+		adapter: void 0,
+		mode: void 0,
+		features: void 0,
+		integrations: void 0,
+		ai: void 0,
+		compat: void 0,
+		packageStrategy: void 0,
+		lint: void 0
+	};
+	for (let i = 0; i < argv.length; i++) {
+		const a = argv[i];
+		if (a === void 0) continue;
+		if (a.startsWith("--") || a === "-h") {
+			const eq = a.indexOf("=");
+			const key = eq >= 0 ? a.slice(2, eq) : a.startsWith("--") ? a.slice(2) : "h";
+			const inlineValue = eq >= 0 ? a.slice(eq + 1) : void 0;
+			const consumeValue = () => {
+				if (inlineValue !== void 0) return inlineValue;
+				const next = argv[i + 1];
+				if (next === void 0 || next.startsWith("--")) return void 0;
+				i++;
+				return next;
+			};
+			switch (key) {
+				case "help":
+				case "h":
+					out.help = true;
+					break;
+				case "yes":
+					out.yes = true;
+					break;
+				case "lint":
+					out.lint = true;
+					break;
+				case "no-lint":
+					out.lint = false;
+					break;
+				case "template":
+					out.template = pickEnum(consumeValue(), TEMPLATE_VALUES, "--template");
+					break;
+				case "adapter":
+					out.adapter = pickEnum(consumeValue(), ADAPTER_VALUES, "--adapter");
+					break;
+				case "mode":
+					out.mode = pickEnum(consumeValue(), MODE_VALUES, "--mode");
+					break;
+				case "features":
+					out.features = parseCsv(consumeValue());
+					break;
+				case "integrations":
+					out.integrations = parseEnumCsv(consumeValue(), INTEGRATION_VALUES, "--integrations");
+					break;
+				case "ai":
+					out.ai = parseEnumCsv(consumeValue(), AI_VALUES, "--ai");
+					break;
+				case "compat":
+					out.compat = pickEnum(consumeValue(), COMPAT_VALUES, "--compat");
+					break;
+				case "pm":
+				case "packages":
+				case "package-strategy":
+					out.packageStrategy = pickEnum(consumeValue(), PKG_STRATEGY_VALUES, "--packages");
+					break;
+				default: throw new Error(`Unknown flag: ${a}. Run with --help for usage.`);
+			}
+			continue;
+		}
+		if (out.name === void 0) out.name = a;
+		else throw new Error(`Unexpected extra positional argument: ${a}`);
+	}
+	return out;
+}
+function parseCsv(raw) {
+	if (raw === void 0) return void 0;
+	return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function parseEnumCsv(raw, allowed, flag) {
+	const parts = parseCsv(raw);
+	if (parts === void 0) return void 0;
+	for (const p of parts) if (!allowed.includes(p)) throw new Error(`Invalid value "${p}" for ${flag}. Expected one of: ${allowed.join(", ")}.`);
+	return parts;
+}
+function pickEnum(raw, allowed, flag) {
+	if (raw === void 0) return void 0;
+	if (!allowed.includes(raw)) throw new Error(`Invalid value "${raw}" for ${flag}. Expected one of: ${allowed.join(", ")}.`);
+	return raw;
+}
+function helpText(invokedAs) {
+	return `Usage: ${invokedAs} [name] [flags]
+
+Scaffold a new Pyreon Zero project.
+
+Templates:
+  --template <id>          app | blog | dashboard
+
+Deployment:
+  --adapter <id>           vercel | cloudflare | netlify | node | bun | static
+
+Rendering:
+  --mode <id>              ssr-stream | ssr-string | ssg | spa
+
+Features (csv):
+  --features <list>        store,query,forms,table,virtual,i18n,charts,…
+  --integrations <list>    supabase,email
+  --ai <list>              mcp,claude,cursor,copilot,agents
+
+Other:
+  --compat <id>            none | react | vue | solid | preact
+  --packages <id>          meta | individual
+  --lint / --no-lint       toggle @pyreon/lint
+  --yes                    skip prompts, accept defaults
+  --help, -h               show this help
+
+Examples:
+  ${invokedAs} my-app
+  ${invokedAs} my-app --template dashboard --adapter vercel --integrations supabase,email --yes
+  ${invokedAs} my-blog --template blog --adapter cloudflare --yes
+`;
+}
+
+//#endregion
+//#region src/templates.ts
 const FEATURES = {
 	store: {
 		label: "State Management (@pyreon/store)",
@@ -85,151 +248,1070 @@ const FEATURES = {
 	code: {
 		label: "Code Editor (@pyreon/code — CodeMirror 6)",
 		deps: ["@pyreon/code"]
+	},
+	toast: {
+		label: "Toast Notifications (@pyreon/toast)",
+		deps: ["@pyreon/toast"]
+	},
+	permissions: {
+		label: "Permissions (@pyreon/permissions — RBAC, feature flags)",
+		deps: ["@pyreon/permissions"]
+	},
+	"url-state": {
+		label: "URL State (@pyreon/url-state — URL-synced params)",
+		deps: ["@pyreon/url-state"]
+	},
+	rx: {
+		label: "Reactive Transforms (@pyreon/rx — filter, map, sortBy, groupBy)",
+		deps: ["@pyreon/rx"]
 	}
 };
-const TEMPLATE_DIR = resolve(import.meta.dirname, "../templates/default");
-async function main() {
-	const argName = process.argv.slice(2)[0];
-	if (argName === "--help" || argName === "-h") {
-		console.log("Usage: create-zero [project-name]");
-		process.exit(0);
+const TEMPLATES = {
+	app: {
+		id: "app",
+		label: "App",
+		hint: "full-featured starter — counter, posts, layout, admin route group",
+		defaultMode: "ssr-stream",
+		defaultFeatures: [
+			"store",
+			"query",
+			"forms"
+		],
+		forcesMode: false,
+		adapters: [
+			"vercel",
+			"cloudflare",
+			"netlify",
+			"node",
+			"bun",
+			"static"
+		],
+		defaultAdapter: "vercel",
+		defaultIntegrations: []
+	},
+	blog: {
+		id: "blog",
+		label: "Blog",
+		hint: "SSG markdown blog with RSS feed and SEO",
+		defaultMode: "ssg",
+		defaultFeatures: [],
+		forcesMode: true,
+		adapters: [
+			"static",
+			"vercel",
+			"cloudflare",
+			"netlify"
+		],
+		defaultAdapter: "static",
+		defaultIntegrations: []
+	},
+	dashboard: {
+		id: "dashboard",
+		label: "Dashboard",
+		hint: "SaaS-shape SSR app — auth-gated routes, full integration suite available",
+		defaultMode: "ssr-stream",
+		defaultFeatures: [
+			"store",
+			"query",
+			"forms",
+			"table"
+		],
+		forcesMode: true,
+		adapters: [
+			"vercel",
+			"cloudflare",
+			"netlify",
+			"node",
+			"bun"
+		],
+		defaultAdapter: "vercel",
+		defaultIntegrations: ["supabase", "email"]
+	}
+};
+const TEMPLATES_ROOT = resolve(import.meta.dirname, "../templates");
+function templateDir(id) {
+	return resolve(TEMPLATES_ROOT, id);
+}
+
+//#endregion
+//#region src/prompts.ts
+const ADAPTER_LABELS = {
+	vercel: {
+		label: "Vercel",
+		hint: "serverless / edge — vercel.json + one-click deploy badge"
+	},
+	cloudflare: {
+		label: "Cloudflare Pages",
+		hint: "workers — wrangler.toml + _routes.json"
+	},
+	netlify: {
+		label: "Netlify",
+		hint: "netlify functions — netlify.toml"
+	},
+	node: {
+		label: "Node.js",
+		hint: "Dockerfile + start script for self-hosting"
+	},
+	bun: {
+		label: "Bun",
+		hint: "Dockerfile (bun-based) for self-hosting on Bun runtimes"
+	},
+	static: {
+		label: "Static (no server)",
+		hint: "works with any static host (GitHub Pages, S3, …)"
 	}
-	p.intro("Create a new Pyreon Zero project");
-	const name = argName ?? await p.text({
-		message: "Project name",
-		placeholder: "my-zero-app",
-		validate: (v) => {
-			if (!v?.trim()) return "Project name is required";
-			if (existsSync(resolve(process.cwd(), v))) return `Directory "${v}" already exists`;
+};
+/**
+* Run the interactive prompt flow. Every prompt is skipped when its
+* corresponding CLI flag is set or when `--yes` was passed; in that
+* case the template-default (or flag-supplied) value is used.
+*
+* Cancellation at any prompt aborts via `process.exit(0)`.
+*/
+async function runPrompts(args) {
+	const yes = args.yes;
+	let name;
+	if (args.name !== void 0) name = args.name;
+	else if (yes) {
+		p.cancel("Project name is required when using --yes (pass it as the first argument).");
+		process.exit(2);
+	} else {
+		const value = await p.text({
+			message: "Project name",
+			placeholder: "my-zero-app",
+			validate: (v) => {
+				if (!v?.trim()) return "Project name is required";
+				if (existsSync(resolve(process.cwd(), v))) return `Directory "${v}" already exists`;
+			}
+		});
+		if (p.isCancel(value)) {
+			p.cancel("Cancelled.");
+			process.exit(0);
 		}
-	});
-	if (p.isCancel(name)) {
-		p.cancel("Cancelled.");
-		process.exit(0);
+		name = value;
 	}
 	const targetDir = resolve(process.cwd(), name);
 	if (existsSync(targetDir)) {
 		p.cancel(`Directory "${name}" already exists.`);
 		process.exit(1);
 	}
-	const renderMode = await p.select({
-		message: "Rendering mode",
-		options: [
-			{
-				value: "ssr-stream",
-				label: "SSR Streaming",
-				hint: "recommended — progressive HTML with Suspense"
-			},
-			{
-				value: "ssr-string",
-				label: "SSR String",
-				hint: "buffered HTML, simpler but slower TTFB"
-			},
-			{
-				value: "ssg",
-				label: "Static (SSG)",
-				hint: "pre-rendered at build time"
-			},
-			{
-				value: "spa",
-				label: "SPA",
-				hint: "client-only, no server rendering"
-			}
-		]
-	});
-	if (p.isCancel(renderMode)) {
-		p.cancel("Cancelled.");
-		process.exit(0);
+	let template;
+	if (args.template) template = args.template;
+	else if (yes) template = "app";
+	else {
+		const value = await p.select({
+			message: "Template",
+			options: Object.values(TEMPLATES).map((t) => ({
+				value: t.id,
+				label: t.label,
+				hint: t.hint
+			}))
+		});
+		if (p.isCancel(value)) {
+			p.cancel("Cancelled.");
+			process.exit(0);
+		}
+		template = value;
 	}
-	const features = await p.multiselect({
-		message: "Select features (space to toggle, enter to confirm)",
-		options: Object.entries(FEATURES).map(([key, { label }]) => ({
-			value: key,
-			label
-		})),
-		initialValues: [
-			"store",
-			"query",
-			"forms"
-		],
-		required: false
-	});
-	if (p.isCancel(features)) {
-		p.cancel("Cancelled.");
-		process.exit(0);
+	const tmpl = TEMPLATES[template];
+	let renderMode;
+	if (tmpl.forcesMode) renderMode = tmpl.defaultMode;
+	else if (args.mode) renderMode = args.mode;
+	else if (yes) renderMode = tmpl.defaultMode;
+	else {
+		const value = await p.select({
+			message: "Rendering mode",
+			options: [
+				{
+					value: "ssr-stream",
+					label: "SSR Streaming",
+					hint: "recommended — progressive HTML with Suspense"
+				},
+				{
+					value: "ssr-string",
+					label: "SSR String",
+					hint: "buffered HTML, simpler but slower TTFB"
+				},
+				{
+					value: "ssg",
+					label: "Static (SSG)",
+					hint: "pre-rendered at build time"
+				},
+				{
+					value: "spa",
+					label: "SPA",
+					hint: "client-only, no server rendering"
+				}
+			],
+			initialValue: tmpl.defaultMode
+		});
+		if (p.isCancel(value)) {
+			p.cancel("Cancelled.");
+			process.exit(0);
+		}
+		renderMode = value;
 	}
-	const packageStrategy = await p.select({
-		message: "Package imports",
-		options: [{
-			value: "meta",
-			label: "@pyreon/meta (single barrel)",
-			hint: "one import for everything — simpler, tree-shaken at build"
-		}, {
-			value: "individual",
-			label: "Individual packages",
-			hint: "only install what you selected — smaller node_modules"
-		}]
-	});
-	if (p.isCancel(packageStrategy)) {
-		p.cancel("Cancelled.");
-		process.exit(0);
+	let adapter;
+	if (args.adapter) {
+		if (!tmpl.adapters.includes(args.adapter)) {
+			p.cancel(`Adapter "${args.adapter}" is not supported by template "${template}". Allowed: ${tmpl.adapters.join(", ")}.`);
+			process.exit(2);
+		}
+		adapter = args.adapter;
+	} else if (yes) adapter = tmpl.defaultAdapter;
+	else {
+		const value = await p.select({
+			message: "Deployment target",
+			options: tmpl.adapters.map((id) => ({
+				value: id,
+				label: ADAPTER_LABELS[id].label,
+				hint: ADAPTER_LABELS[id].hint
+			})),
+			initialValue: tmpl.defaultAdapter
+		});
+		if (p.isCancel(value)) {
+			p.cancel("Cancelled.");
+			process.exit(0);
+		}
+		adapter = value;
 	}
-	const aiToolchain = await p.confirm({
-		message: "Include AI toolchain? (MCP server, CLAUDE.md, doctor)",
-		initialValue: true
-	});
-	if (p.isCancel(aiToolchain)) {
-		p.cancel("Cancelled.");
-		process.exit(0);
+	let features;
+	if (args.features !== void 0) features = args.features;
+	else if (yes) features = [...tmpl.defaultFeatures];
+	else {
+		const value = await p.multiselect({
+			message: "Select features (space to toggle, enter to confirm)",
+			options: Object.entries(FEATURES).map(([key, { label }]) => ({
+				value: key,
+				label
+			})),
+			initialValues: [...tmpl.defaultFeatures],
+			required: false
+		});
+		if (p.isCancel(value)) {
+			p.cancel("Cancelled.");
+			process.exit(0);
+		}
+		features = value;
+	}
+	let packageStrategy;
+	if (args.packageStrategy) packageStrategy = args.packageStrategy;
+	else if (yes) packageStrategy = "meta";
+	else {
+		const value = await p.select({
+			message: "Package imports",
+			options: [{
+				value: "meta",
+				label: "@pyreon/meta (single barrel)",
+				hint: "one import for everything — simpler, tree-shaken at build"
+			}, {
+				value: "individual",
+				label: "Individual packages",
+				hint: "only install what you selected — smaller node_modules"
+			}]
+		});
+		if (p.isCancel(value)) {
+			p.cancel("Cancelled.");
+			process.exit(0);
+		}
+		packageStrategy = value;
+	}
+	let integrations;
+	if (args.integrations !== void 0) integrations = args.integrations;
+	else if (yes) integrations = [...tmpl.defaultIntegrations];
+	else {
+		const value = await p.multiselect({
+			message: "Backend integrations (space to toggle)",
+			options: [{
+				value: "supabase",
+				label: "Supabase",
+				hint: "Postgres + auth + storage — replaces dashboard auth/db stubs"
+			}, {
+				value: "email",
+				label: "Email (Resend)",
+				hint: "Resend transport + document-primitives email templates"
+			}],
+			initialValues: [...tmpl.defaultIntegrations],
+			required: false
+		});
+		if (p.isCancel(value)) {
+			p.cancel("Cancelled.");
+			process.exit(0);
+		}
+		integrations = value;
+	}
+	let aiTools;
+	if (args.ai !== void 0) aiTools = args.ai;
+	else if (yes) aiTools = ["mcp", "claude"];
+	else {
+		const value = await p.multiselect({
+			message: "AI tooling (space to toggle, enter to confirm)",
+			options: [
+				{
+					value: "mcp",
+					label: "MCP server",
+					hint: ".mcp.json — Claude Code, Continue.dev"
+				},
+				{
+					value: "claude",
+					label: "CLAUDE.md",
+					hint: "Claude Code project rules"
+				},
+				{
+					value: "cursor",
+					label: "Cursor rules",
+					hint: ".cursor/rules/pyreon.md"
+				},
+				{
+					value: "copilot",
+					label: "GitHub Copilot",
+					hint: ".github/copilot-instructions.md"
+				},
+				{
+					value: "agents",
+					label: "AGENTS.md",
+					hint: "Aider, Continue, editor agents"
+				}
+			],
+			initialValues: ["mcp", "claude"],
+			required: false
+		});
+		if (p.isCancel(value)) {
+			p.cancel("Cancelled.");
+			process.exit(0);
+		}
+		aiTools = value;
+	}
+	let compat;
+	if (args.compat) compat = args.compat;
+	else if (yes) compat = "none";
+	else {
+		const value = await p.select({
+			message: "Migrating from another framework?",
+			options: [
+				{
+					value: "none",
+					label: "No — native Pyreon",
+					hint: "recommended"
+				},
+				{
+					value: "react",
+					label: "React",
+					hint: "use useState, useEffect, etc."
+				},
+				{
+					value: "vue",
+					label: "Vue",
+					hint: "use ref, computed, watch, etc."
+				},
+				{
+					value: "solid",
+					label: "Solid",
+					hint: "use createSignal, createEffect, etc."
+				},
+				{
+					value: "preact",
+					label: "Preact",
+					hint: "use useState, signals, etc."
+				}
+			]
+		});
+		if (p.isCancel(value)) {
+			p.cancel("Cancelled.");
+			process.exit(0);
+		}
+		compat = value;
 	}
-	const config = {
+	let lint;
+	if (args.lint !== void 0) lint = args.lint;
+	else if (yes) lint = true;
+	else {
+		const value = await p.confirm({
+			message: "Include @pyreon/lint? (59 Pyreon-specific rules)",
+			initialValue: true
+		});
+		if (p.isCancel(value)) {
+			p.cancel("Cancelled.");
+			process.exit(0);
+		}
+		lint = value;
+	}
+	return {
 		name,
 		targetDir,
+		template,
 		renderMode,
+		adapter,
 		features,
 		packageStrategy,
-		aiToolchain
+		integrations,
+		aiTools,
+		compat,
+		lint
 	};
-	const s = p.spinner();
-	s.start("Scaffolding project...");
-	await scaffold(config);
-	s.stop("Project created!");
-	p.note([
-		`cd ${config.name}`,
-		"bun install",
-		"bun run dev"
-	].join("\n"), "Next steps");
-	p.outro("Happy building!");
 }
+
+//#endregion
+//#region src/adapters.ts
+const vercel = {
+	id: "vercel",
+	viteFactory: "vercelAdapter",
+	async apply(config) {
+		await writeFile(join(config.targetDir, "vercel.json"), JSON.stringify({
+			$schema: "https://openapi.vercel.sh/vercel.json",
+			buildCommand: "bun run build",
+			outputDirectory: "dist",
+			framework: null
+		}, null, 2) + "\n");
+	},
+	badge() {
+		return "[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=)";
+	},
+	envKeys() {
+		return [];
+	}
+};
+const cloudflare = {
+	id: "cloudflare",
+	viteFactory: "cloudflareAdapter",
+	async apply(config) {
+		const wranglerToml = `name = "${slug(config.name)}"
+compatibility_date = "2026-01-01"
+compatibility_flags = ["nodejs_compat"]
+pages_build_output_dir = "dist"
+
+[vars]
+# NODE_ENV = "production"
+`;
+		await writeFile(join(config.targetDir, "wrangler.toml"), wranglerToml);
+		await writeFile(join(config.targetDir, "_routes.json"), JSON.stringify({
+			version: 1,
+			include: ["/*"],
+			exclude: ["/build/*"]
+		}, null, 2) + "\n");
+	},
+	badge() {
+		return "[![Deploy to Cloudflare](https://deploy.workers.cloudflare.com/button)](https://deploy.workers.cloudflare.com/?url=)";
+	},
+	envKeys() {
+		return [];
+	}
+};
+const netlify = {
+	id: "netlify",
+	viteFactory: "netlifyAdapter",
+	async apply(config) {
+		await writeFile(join(config.targetDir, "netlify.toml"), `[build]
+  command = "bun run build"
+  publish = "dist"
+
+[functions]
+  directory = "dist/.netlify/functions"
+  node_bundler = "esbuild"
+
+[[redirects]]
+  from = "/*"
+  to = "/.netlify/functions/server/:splat"
+  status = 200
+  force = false
+`);
+	},
+	badge() {
+		return "[![Deploy to Netlify](https://www.netlify.com/img/deploy/button.svg)](https://app.netlify.com/start/deploy?repository=)";
+	},
+	envKeys() {
+		return [];
+	}
+};
+const node = {
+	id: "node",
+	viteFactory: "nodeAdapter",
+	async apply(config) {
+		await writeFile(join(config.targetDir, "Dockerfile"), `FROM node:22-alpine AS build
+WORKDIR /app
+COPY package.json bun.lock* ./
+RUN corepack enable && corepack prepare bun@latest --activate && bun install --frozen-lockfile
+COPY . .
+RUN bun run build
+
+FROM node:22-alpine
+WORKDIR /app
+COPY --from=build /app/dist ./dist
+COPY --from=build /app/package.json ./
+COPY --from=build /app/node_modules ./node_modules
+EXPOSE 3000
+CMD ["node", "dist/server.js"]
+`);
+		await writeFile(join(config.targetDir, ".dockerignore"), "node_modules\ndist\n.git\n.env\n.env.*\n");
+	},
+	badge() {
+		return "";
+	},
+	envKeys() {
+		return ["PORT"];
+	}
+};
+const bun = {
+	id: "bun",
+	viteFactory: "bunAdapter",
+	async apply(config) {
+		await writeFile(join(config.targetDir, "Dockerfile"), `FROM oven/bun:1 AS build
+WORKDIR /app
+COPY package.json bun.lock* ./
+RUN bun install --frozen-lockfile
+COPY . .
+RUN bun run build
+
+FROM oven/bun:1
+WORKDIR /app
+COPY --from=build /app/dist ./dist
+COPY --from=build /app/package.json ./
+COPY --from=build /app/node_modules ./node_modules
+EXPOSE 3000
+CMD ["bun", "run", "dist/server.js"]
+`);
+		await writeFile(join(config.targetDir, ".dockerignore"), "node_modules\ndist\n.git\n.env\n.env.*\n");
+	},
+	badge() {
+		return "";
+	},
+	envKeys() {
+		return ["PORT"];
+	}
+};
+const staticAdapter = {
+	id: "static",
+	viteFactory: null,
+	async apply() {},
+	badge() {
+		return "";
+	},
+	envKeys() {
+		return [];
+	}
+};
+const ADAPTERS = {
+	vercel,
+	cloudflare,
+	netlify,
+	node,
+	bun,
+	static: staticAdapter
+};
+function adapterFor(id) {
+	return ADAPTERS[id];
+}
+function slug(name) {
+	return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/^-+|-+$/g, "");
+}
+
+//#endregion
+//#region src/ai-tools.ts
+/**
+* Pyreon-specific guidance shared across every AI-tool rule file. Each tool
+* wraps this in its own preamble (frontmatter, header, etc.) so the styling
+* matches the tool's conventions, but the substance is identical: this is
+* Pyreon, not React; here is how reactivity, JSX, and routing actually work.
+*
+* `doctorLine` is appended to the Commands section when the consumer is the
+* primary "knows about doctor" file (CLAUDE.md). Other tools omit it.
+*/
+function pyreonPrinciples(opts) {
+	return `## Reactivity (Pyreon, not React)
+
+- \`signal()\` not \`useState\`; \`computed()\` not \`useMemo\`; \`effect()\` not \`useEffect\`.
+- Write signals via \`signal.set(value)\` or \`signal.update(fn)\`. Calling \`signal(value)\` does NOT write — it reads.
+- Components run **once** at mount. Reactivity comes from signals reading themselves at use sites; the framework subscribes the surrounding DOM node, not the whole component.
+- In JSX, signals auto-call: \`{count}\` (compiler inserts \`()\`). Outside JSX, call explicitly: \`count()\`.
+- Don't destructure props (\`const { x } = props\` captures getters once and loses reactivity). Read \`props.x\` directly, or use \`splitProps(props, ['x'])\`.
+
+## JSX
+
+- \`class=\` not \`className\`; \`for=\` not \`htmlFor\`; camelCase events (\`onClick\`, \`onMouseEnter\`).
+- Lists: \`<For each={items} by={r => r.id}>{r => <li>...</li>}</For>\`. The prop is \`by\` (not \`key\`) — JSX extracts \`key\` for VNode reconciliation.
+- Conditionals: \`<Show when={cond}>...</Show>\` or accessor form \`{() => cond() ? <A /> : null}\`.
+- \`onChange\` → \`onInput\` for keypress-by-keypress text updates.
+
+## File-Based Routing
+
+- \`src/routes/index.tsx\` → \`/\`
+- \`src/routes/about.tsx\` → \`/about\`
+- \`src/routes/[id].tsx\` → \`/:id\`
+- \`src/routes/_layout.tsx\` → layout wrapper
+- \`(group)/\` → route group (no URL segment)
+
+Per-route exports: \`default\` (component), \`loader\` (server data), \`guard\` (nav guard), \`middleware\`, \`meta\`, \`renderMode\`.
+
+## Don't reach for raw DOM APIs
+
+- Use \`useEventListener\` / \`useClickOutside\` / \`useScrollLock\` from \`@pyreon/hooks\` instead of \`addEventListener\` / \`removeEventListener\`. The hook handles cleanup on unmount.
+- For controlled state in primitives, use \`useControllableState({ value, defaultValue, onChange })\`.
+
+## Don't paste React patterns
+
+- No \`useState\` / \`useEffect\` / \`useMemo\` / \`useCallback\` / \`useRef\`. None of those exist.
+- No \`React.Fragment\` — just \`<></>\`.
+- No "children as function" trick — Pyreon supports JSX children directly.
+
+## Commands
+
+- \`bun run dev\` — dev server with HMR (signals preserve across reload)
+- \`bun run build\` — production build
+- \`bun run preview\` — serve build${opts.doctorLine ? "\n- `bun run doctor` — checks for React patterns and other anti-patterns" : ""}
+`;
+}
+const RULE_FILES = [
+	{
+		id: "claude",
+		path: "CLAUDE.md",
+		render: () => `# Project
+
+This project uses Pyreon Zero, a signal-based full-stack meta-framework. Do NOT use React patterns.
+
+${pyreonPrinciples({ doctorLine: true })}`
+	},
+	{
+		id: "cursor",
+		path: ".cursor/rules/pyreon.md",
+		render: () => `---
+description: Pyreon Zero project rules
+globs:
+  - "**/*.{ts,tsx}"
+alwaysApply: true
+---
+
+# Pyreon Zero
+
+This is a Pyreon Zero project — a signal-based full-stack meta-framework. **Do not use React patterns** (useState, useEffect, className, etc.).
+
+${pyreonPrinciples({ doctorLine: false })}
+
+## When in doubt
+
+The MCP server at \`.mcp.json\` exposes a \`validate\` tool that statically catches React→Pyreon mistakes. Run it on suspicious snippets before committing.
+`
+	},
+	{
+		id: "copilot",
+		path: ".github/copilot-instructions.md",
+		render: () => `# Copilot Instructions
+
+This repository uses **Pyreon Zero** — a signal-based meta-framework. Do not generate React code.
+
+${pyreonPrinciples({ doctorLine: false })}
+
+## Quick reference
+
+| Need | Use |
+|---|---|
+| Reactive value | \`signal()\` |
+| Derived value | \`computed()\` |
+| Side effect | \`effect()\` or \`onMount(() => { … return cleanup })\` |
+| Form state | \`useForm()\` from \`@pyreon/form\` |
+| Server data | \`useQuery()\` from \`@pyreon/query\` |
+| Global state | \`defineStore()\` from \`@pyreon/store\` |
+`
+	},
+	{
+		id: "agents",
+		path: "AGENTS.md",
+		render: () => `# AGENTS.md
+
+A generic AI-agent instruction file picked up by Aider, Continue.dev, and various editor agents that read \`AGENTS.md\` at the project root.
+
+This is a Pyreon Zero project. Do not use React patterns (no useState / useEffect / className).
+
+${pyreonPrinciples({ doctorLine: false })}`
+	}
+];
+async function applyAiTools(config) {
+	const selected = new Set(config.aiTools);
+	for (const gen of RULE_FILES) if (selected.has(gen.id)) {
+		const target = join(config.targetDir, gen.path);
+		await mkdir(dirname(target), { recursive: true });
+		await writeFile(target, gen.render(config));
+	}
+	if (!selected.has("claude")) await removeIfExists$1(join(config.targetDir, "CLAUDE.md"));
+	if (!selected.has("mcp")) await removeIfExists$1(join(config.targetDir, ".mcp.json"));
+}
+async function removeIfExists$1(path) {
+	if (!existsSync(path)) return;
+	await unlink(path);
+}
+
+//#endregion
+//#region src/integrations.ts
+const REGISTRY = {
+	supabase: {
+		id: "supabase",
+		deps() {
+			return { "@supabase/supabase-js": "^2.49.0" };
+		},
+		envKeys() {
+			return ["SUPABASE_URL", "SUPABASE_ANON_KEY"];
+		},
+		async apply(config) {
+			await writeFileEnsuringDir(join(config.targetDir, "src/lib/supabase.ts"), supabaseClient());
+			if (config.template === "dashboard") {
+				await writeFile(join(config.targetDir, "src/lib/auth.ts"), supabaseAuth());
+				await writeFile(join(config.targetDir, "src/lib/db.ts"), supabaseDb());
+			}
+		}
+	},
+	email: {
+		id: "email",
+		deps() {
+			return {
+				resend: "^4.0.0",
+				"@pyreon/document-primitives": "workspace:^",
+				"@pyreon/document": "workspace:^",
+				"@pyreon/connector-document": "workspace:^"
+			};
+		},
+		envKeys() {
+			return ["RESEND_API_KEY", "EMAIL_FROM"];
+		},
+		async apply(config) {
+			await writeFileEnsuringDir(join(config.targetDir, "src/lib/email.ts"), emailLib());
+			await writeFileEnsuringDir(join(config.targetDir, "src/emails/welcome.tsx"), welcomeEmailTemplate());
+			await writeFileEnsuringDir(join(config.targetDir, "src/routes/api/email/welcome.ts"), welcomeEmailEndpoint());
+		}
+	}
+};
+async function applyIntegrations(config) {
+	for (const id of config.integrations) await REGISTRY[id].apply(config);
+	await appendEnvExample(config);
+}
+function integrationDeps(config) {
+	const out = {};
+	for (const id of config.integrations) Object.assign(out, REGISTRY[id].deps());
+	return out;
+}
+async function appendEnvExample(config) {
+	if (config.integrations.length === 0) return;
+	const lines = [];
+	for (const id of config.integrations) {
+		const keys = REGISTRY[id].envKeys();
+		if (keys.length === 0) continue;
+		lines.push(`# ─── ${id} ───`);
+		for (const k of keys) lines.push(`${k}=`);
+		lines.push("");
+	}
+	const envPath = join(config.targetDir, ".env.example");
+	const existing = existsSync(envPath) ? await readFile(envPath, "utf-8") : "";
+	await writeFile(envPath, existing ? `${existing.trimEnd()}\n\n${lines.join("\n")}` : lines.join("\n"));
+}
+async function writeFileEnsuringDir(path, content) {
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, content);
+}
+function supabaseClient() {
+	return `import { createClient, type SupabaseClient } from '@supabase/supabase-js'
+
+/**
+ * Server-side Supabase client. Uses the anon key by default; swap for the
+ * service-role key inside trusted server contexts (route loaders that
+ * need to bypass RLS) and pair with row-level policies in your Postgres
+ * schema.
+ *
+ * The server reads SUPABASE_URL / SUPABASE_ANON_KEY from \`process.env\`.
+ * For the browser bundle, expose the SAME values via \`publicEnv()\` so
+ * client-side fetch / realtime subscriptions can connect.
+ */
+export const supabase: SupabaseClient = createClient(
+  process.env.SUPABASE_URL ?? '',
+  process.env.SUPABASE_ANON_KEY ?? '',
+  { auth: { persistSession: false, detectSessionInUrl: false } },
+)
+`;
+}
+function supabaseAuth() {
+	return `import { supabase } from './supabase'
+
+/**
+ * Supabase-backed auth implementation. Mirrors the in-memory stub's
+ * exported surface (signIn / signUp / getSession / signOut / SessionInfo)
+ * so route guards don't change when swapping backends.
+ */
+
+export interface SessionInfo {
+  userId: string
+  email: string
+}
+
+export async function signUp(
+  email: string,
+  password: string,
+): Promise<{ sessionId: string } | { error: string }> {
+  const { data, error } = await supabase.auth.signUp({ email, password })
+  if (error) return { error: error.message }
+  if (!data.session) return { error: 'Email confirmation required — check your inbox.' }
+  return { sessionId: data.session.access_token }
+}
+
+export async function signIn(
+  email: string,
+  password: string,
+): Promise<{ sessionId: string } | { error: string }> {
+  const { data, error } = await supabase.auth.signInWithPassword({ email, password })
+  if (error) return { error: error.message }
+  return { sessionId: data.session.access_token }
+}
+
+export async function getSession(sessionId: string | undefined): Promise<SessionInfo | null> {
+  if (!sessionId) return null
+  const { data, error } = await supabase.auth.getUser(sessionId)
+  if (error || !data.user) return null
+  return { userId: data.user.id, email: data.user.email ?? '' }
+}
+
+export async function signOut(sessionId: string): Promise<void> {
+  // Supabase tokens are JWTs; revocation is server-mediated. We invalidate
+  // the access token by calling \`supabase.auth.admin.signOut(sessionId)\`
+  // when the service-role key is available; otherwise fall back to a
+  // client-side cookie clear (handled by the route).
+  if (process.env.SUPABASE_SERVICE_ROLE_KEY) {
+    await supabase.auth.admin.signOut(sessionId)
+  }
+}
+`;
+}
+function supabaseDb() {
+	return `import { supabase } from './supabase'
+
+/**
+ * Supabase-backed data layer. Mirrors the in-memory stub's exported
+ * surface (User / Invoice / listUsers / listInvoices / invoiceById /
+ * invoiceTotal) so dashboard routes don't change when swapping backends.
+ *
+ * Schema expected in your Supabase Postgres:
+ *
+ *   create table public.users (
+ *     id uuid primary key,
+ *     email text not null,
+ *     name text not null,
+ *     role text not null check (role in ('admin','member')),
+ *     created_at timestamptz not null default now()
+ *   );
+ *
+ *   create table public.invoices (
+ *     id text primary key,
+ *     number text not null,
+ *     customer jsonb not null,
+ *     items jsonb not null,
+ *     status text not null check (status in ('draft','pending','paid')),
+ *     issued_at timestamptz not null default now()
+ *   );
+ */
+
+export interface User {
+  id: string
+  email: string
+  name: string
+  role: 'admin' | 'member'
+  createdAt: Date
+}
+
+export interface InvoiceItem {
+  description: string
+  qty: number
+  unitPrice: number
+}
+
+export interface Invoice {
+  id: string
+  number: string
+  customer: { name: string; email: string; address: string }
+  items: InvoiceItem[]
+  status: 'draft' | 'pending' | 'paid'
+  issuedAt: Date
+}
+
+export async function listUsers(): Promise<User[]> {
+  const { data, error } = await supabase.from('users').select('*')
+  if (error) throw error
+  return data.map((row) => ({
+    id: row.id,
+    email: row.email,
+    name: row.name,
+    role: row.role,
+    createdAt: new Date(row.created_at),
+  }))
+}
+
+export async function listInvoices(): Promise<Invoice[]> {
+  const { data, error } = await supabase.from('invoices').select('*')
+  if (error) throw error
+  return data.map(rowToInvoice)
+}
+
+export async function invoiceById(id: string): Promise<Invoice | undefined> {
+  const { data, error } = await supabase.from('invoices').select('*').eq('id', id).maybeSingle()
+  if (error) throw error
+  return data ? rowToInvoice(data) : undefined
+}
+
+export function invoiceTotal(inv: Invoice): number {
+  return inv.items.reduce((sum, i) => sum + i.qty * i.unitPrice, 0)
+}
+
+function rowToInvoice(row: any): Invoice {
+  return {
+    id: row.id,
+    number: row.number,
+    customer: row.customer,
+    items: row.items,
+    status: row.status,
+    issuedAt: new Date(row.issued_at),
+  }
+}
+`;
+}
+function emailLib() {
+	return `import { Resend } from 'resend'
+import { extractDocNode } from '@pyreon/document-primitives'
+import { render } from '@pyreon/document'
+import type { ComponentFn } from '@pyreon/core'
+
+const resend = new Resend(process.env.RESEND_API_KEY)
+const FROM = process.env.EMAIL_FROM ?? 'noreply@example.com'
+
+/**
+ * Send an email rendered from a Pyreon \`@pyreon/document-primitives\`
+ * template. The same template renders in the browser preview AND exports
+ * to email HTML — that is the headline Pyreon angle: one component tree,
+ * many output formats.
+ */
+export async function sendEmail<TProps>(opts: {
+  to: string | string[]
+  subject: string
+  template: ComponentFn<TProps>
+  data: TProps
+}): Promise<{ id: string } | { error: string }> {
+  const node = extractDocNode(() => opts.template(opts.data))
+  const html = (await render(node, 'email')) as string
+
+  const { data, error } = await resend.emails.send({
+    from: FROM,
+    to: opts.to,
+    subject: opts.subject,
+    html,
+  })
+
+  if (error) return { error: error.message }
+  return { id: data?.id ?? 'unknown' }
+}
+`;
+}
+function welcomeEmailTemplate() {
+	return `import {
+  DocDocument,
+  DocPage,
+  DocSection,
+  DocHeading,
+  DocText,
+  DocSpacer,
+} from '@pyreon/document-primitives'
+
+export interface WelcomeEmailProps {
+  name: string
+  appUrl: string
+}
+
+/**
+ * Welcome email template. Renders in the browser AND exports to email
+ * HTML via \`@pyreon/document-primitives\` — the SAME component tree.
+ *
+ * Try it: in dev, visit \`/api/email/welcome?to=you@example.com\`. In
+ * production, call \`sendEmail({ to, subject, template: WelcomeEmail,
+ * data: { name, appUrl } })\` from any server route.
+ */
+export default function WelcomeEmail(props: WelcomeEmailProps) {
+  return (
+    <DocDocument title="Welcome" subject="Welcome to your new account">
+      <DocPage>
+        <DocSection>
+          <DocHeading level="h1">Welcome, {props.name}.</DocHeading>
+        </DocSection>
+
+        <DocSpacer />
+
+        <DocSection>
+          <DocText>
+            Your account is ready. The dashboard is the fastest way to get started — log
+            in any time at:
+          </DocText>
+          <DocText>{props.appUrl}</DocText>
+        </DocSection>
+
+        <DocSpacer />
+
+        <DocSection>
+          <DocText>If you didn't create this account, ignore this email.</DocText>
+        </DocSection>
+      </DocPage>
+    </DocDocument>
+  )
+}
+`;
+}
+function welcomeEmailEndpoint() {
+	return `import { sendEmail } from '../../../lib/email'
+import WelcomeEmail from '../../../emails/welcome'
+
+export async function GET(request: Request) {
+  const url = new URL(request.url)
+  const to = url.searchParams.get('to')
+  if (!to) {
+    return new Response(JSON.stringify({ error: 'Missing ?to=' }), {
+      status: 400,
+      headers: { 'content-type': 'application/json' },
+    })
+  }
+
+  const appUrl = url.origin
+
+  const result = await sendEmail({
+    to,
+    subject: 'Welcome',
+    template: WelcomeEmail,
+    data: { name: to.split('@')[0] ?? 'friend', appUrl },
+  })
+
+  return new Response(JSON.stringify(result), {
+    headers: { 'content-type': 'application/json' },
+  })
+}
+`;
+}
+
+//#endregion
+//#region src/scaffold.ts
 async function scaffold(config) {
-	await cp(TEMPLATE_DIR, config.targetDir, { recursive: true });
+	await cp(templateDir(config.template), config.targetDir, { recursive: true });
 	await writeFile(join(config.targetDir, "package.json"), generatePackageJson(config));
 	await writeFile(join(config.targetDir, "vite.config.ts"), generateViteConfig(config));
+	await adapterFor(config.adapter).apply(config);
 	await writeFile(join(config.targetDir, "src/entry-server.ts"), generateEntryServer(config));
 	await writeFile(join(config.targetDir, "env.d.ts"), generateEnvDts(config));
 	await writeFile(join(config.targetDir, ".gitignore"), "node_modules\ndist\n.DS_Store\n*.local\n.pyreon\n");
-	if (config.aiToolchain) await writeFile(join(config.targetDir, ".mcp.json"), JSON.stringify({ mcpServers: { pyreon: {
-		command: "bunx",
-		args: ["@pyreon/mcp"]
-	} } }, null, 2));
-	else for (const f of [".mcp.json", "CLAUDE.md"]) {
-		const path = join(config.targetDir, f);
-		if (existsSync(path)) {
-			const { unlink } = await import("node:fs/promises");
-			await unlink(path);
-		}
-	}
-	if (!config.features.includes("feature") && !config.features.includes("forms")) {
-		await removeIfExists(join(config.targetDir, "src/routes/posts/new.tsx"));
-		await removeIfExists(join(config.targetDir, "src/features"));
-	}
-	if (!config.features.includes("store")) await removeIfExists(join(config.targetDir, "src/stores"));
-	if (!config.features.includes("store")) {
-		const layoutPath = join(config.targetDir, "src/routes/_layout.tsx");
-		if (existsSync(layoutPath)) {
-			let layout = await readFile(layoutPath, "utf-8");
-			layout = layout.replace(/import .* from '\.\.\/stores\/app'\n/g, "").replace(/.*useAppStore.*\n/g, "").replace(/\s*<button[\s\S]*?sidebar-toggle[\s\S]*?<\/button>\n/g, "");
-			await writeFile(layoutPath, layout);
+	if (config.lint) await writeFile(join(config.targetDir, ".pyreonlintrc.json"), JSON.stringify({
+		$schema: "node_modules/@pyreon/lint/schema/pyreonlintrc.schema.json",
+		preset: "recommended"
+	}, null, 2) + "\n");
+	await applyAiTools(config);
+	await applyIntegrations(config);
+	if (config.template === "app") {
+		if (!config.features.includes("feature")) await removeIfExists(join(config.targetDir, "src/features"));
+		if (!config.features.includes("feature") || !config.features.includes("forms")) await removeIfExists(join(config.targetDir, "src/routes/posts/new.tsx"));
+		if (!config.features.includes("store")) {
+			await removeIfExists(join(config.targetDir, "src/stores"));
+			const layoutPath = join(config.targetDir, "src/routes/_layout.tsx");
+			if (existsSync(layoutPath)) {
+				let layout = await readFile(layoutPath, "utf-8");
+				layout = layout.replace(/import .* from '\.\.\/stores\/app'\n/g, "").replace(/.*useAppStore.*\n/g, "").replace(/\s*<button[\s\S]*?sidebar-toggle[\s\S]*?<\/button>\n/g, "");
+				await writeFile(layoutPath, layout);
+			}
 		}
 	}
 }
@@ -248,67 +1330,81 @@ function generatePackageJson(config) {
 		"@pyreon/server": pyreonVersion("@pyreon/server"),
 		"@pyreon/zero": pyreonVersion("@pyreon/zero")
 	};
-	if (config.packageStrategy === "meta") {
-		deps["@pyreon/meta"] = pyreonVersion("@pyreon/meta");
-		for (const key of config.features) {
-			const feature = FEATURES[key];
-			if (feature) {
-				for (const dep of feature.deps) if (!dep.startsWith("@pyreon/")) {
-					if (dep.startsWith("@tanstack/")) deps[dep] = dep.includes("query") ? "^5.90.0" : dep.includes("table") ? "^8.21.0" : "^3.13.0";
-					else if (dep === "zod") deps[dep] = "^4.0.0";
-				}
-			}
-		}
-	} else {
-		const allDeps = /* @__PURE__ */ new Set();
-		for (const key of config.features) {
-			const feature = FEATURES[key];
-			if (feature) for (const dep of feature.deps) allDeps.add(dep);
-		}
-		for (const dep of allDeps) if (dep.startsWith("@pyreon/")) deps[dep] = pyreonVersion(dep);
-		else if (dep.startsWith("@tanstack/")) deps[dep] = dep.includes("query") ? "^5.90.0" : dep.includes("table") ? "^8.21.0" : "^3.13.0";
-		else if (dep === "zod") deps[dep] = "^4.0.0";
+	const allFeatureDeps = /* @__PURE__ */ new Set();
+	for (const key of config.features) {
+		const feature = FEATURES[key];
+		if (feature) for (const dep of feature.deps) allFeatureDeps.add(dep);
+	}
+	if (config.template === "app") {
+		allFeatureDeps.add("@pyreon/query");
+		allFeatureDeps.add("@tanstack/query-core");
+		allFeatureDeps.add("@pyreon/store");
 	}
+	if (config.template === "dashboard") {
+		allFeatureDeps.add("@pyreon/document-primitives");
+		allFeatureDeps.add("@pyreon/document");
+		allFeatureDeps.add("@pyreon/connector-document");
+	}
+	for (const dep of allFeatureDeps) if (dep.startsWith("@pyreon/")) deps[dep] = pyreonVersion(dep);
+	else if (dep.startsWith("@tanstack/")) deps[dep] = dep.includes("query") ? "^5.90.0" : dep.includes("table") ? "^8.21.0" : "^3.13.0";
+	else if (dep === "zod") deps[dep] = "^4.0.0";
+	if (config.packageStrategy === "meta") deps["@pyreon/meta"] = pyreonVersion("@pyreon/meta");
 	const devDeps = {
 		"@pyreon/vite-plugin": pyreonVersion("@pyreon/vite-plugin"),
 		"@pyreon/zero-cli": pyreonVersion("@pyreon/zero-cli"),
 		typescript: "^6.0.2",
 		vite: "^8.0.3"
 	};
-	if (config.aiToolchain) devDeps["@pyreon/mcp"] = pyreonVersion("@pyreon/mcp");
+	if (config.aiTools.includes("mcp")) devDeps["@pyreon/mcp"] = pyreonVersion("@pyreon/mcp");
+	const compatPkgMap = {
+		react: "@pyreon/react-compat",
+		vue: "@pyreon/vue-compat",
+		solid: "@pyreon/solid-compat",
+		preact: "@pyreon/preact-compat"
+	};
+	if (config.compat !== "none" && compatPkgMap[config.compat]) deps[compatPkgMap[config.compat]] = pyreonVersion(compatPkgMap[config.compat]);
+	if (config.lint) devDeps["@pyreon/lint"] = pyreonVersion("@pyreon/lint");
+	for (const [name, version] of Object.entries(integrationDeps(config))) deps[name] = version === "workspace:^" ? pyreonVersion(name) : version;
+	const scripts = {
+		dev: "zero dev",
+		build: "zero build",
+		preview: "zero preview",
+		doctor: "zero doctor",
+		"doctor:fix": "zero doctor --fix",
+		"doctor:ci": "zero doctor --ci"
+	};
+	if (config.lint) scripts.lint = "pyreon-lint .";
 	const pkg = {
 		name: basename(config.name),
 		version: "0.0.1",
 		private: true,
 		type: "module",
-		scripts: {
-			dev: "zero dev",
-			build: "zero build",
-			preview: "zero preview",
-			doctor: "zero doctor",
-			"doctor:fix": "zero doctor --fix",
-			"doctor:ci": "zero doctor --ci"
-		},
+		scripts,
 		dependencies: Object.fromEntries(Object.entries(deps).sort(([a], [b]) => a.localeCompare(b))),
 		devDependencies: Object.fromEntries(Object.entries(devDeps).sort(([a], [b]) => a.localeCompare(b)))
 	};
 	return `${JSON.stringify(pkg, null, 2)}\n`;
 }
 function generateViteConfig(config) {
+	const modeMap = {
+		"ssr-stream": `mode: 'ssr', ssr: { mode: 'stream' }`,
+		"ssr-string": `mode: 'ssr'`,
+		ssg: `mode: 'ssg'`,
+		spa: `mode: 'spa'`
+	};
+	const pyreonOpts = config.compat !== "none" ? `{ compat: '${config.compat}' }` : "";
+	const adapter = adapterFor(config.adapter);
+	const adapterImport = adapter.viteFactory ? `\nimport { ${adapter.viteFactory} } from '@pyreon/zero/server'` : "";
+	const adapterArg = adapter.viteFactory ? `, adapter: ${adapter.viteFactory}()` : "";
 	return `import pyreon from '@pyreon/vite-plugin'
-import zero from '@pyreon/zero/server'
+import zero from '@pyreon/zero/server'${adapterImport}
 import { fontPlugin } from '@pyreon/zero/font'
 import { seoPlugin } from '@pyreon/zero/seo'
 
 export default {
   plugins: [
-    pyreon(),
-    zero({ ${{
-		"ssr-stream": `mode: 'ssr', ssr: { mode: 'stream' }`,
-		"ssr-string": `mode: 'ssr'`,
-		ssg: `mode: 'ssg'`,
-		spa: `mode: 'spa'`
-	}[config.renderMode]} }),
+    pyreon(${pyreonOpts}),
+    zero({ ${modeMap[config.renderMode]}${adapterArg} }),
 
     // Google Fonts — self-hosted at build time, CDN in dev
     fontPlugin({
@@ -387,6 +1483,47 @@ async function removeIfExists(path) {
 	const { rm } = await import("node:fs/promises");
 	await rm(path, { recursive: true });
 }
+
+//#endregion
+//#region src/index.ts
+/**
+* Detect which bin alias the user invoked. The same package ships two
+* entry points: `create-pyreon-app` (canonical, discoverable via
+* `bunx create-pyreon-app`) and `create-zero` (back-compat alias for
+* users following older docs / `bun create @pyreon/zero` flow).
+*
+* The --help text echoes the alias the user actually typed so docs
+* links and copy-paste invocations stay consistent.
+*/
+function detectInvocation() {
+	return (process.argv[1] ?? "").includes("create-pyreon-app") ? "create-pyreon-app" : "create-zero";
+}
+async function main() {
+	const invokedAs = detectInvocation();
+	let args;
+	try {
+		args = parseArgs(process.argv.slice(2));
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : err);
+		process.exit(2);
+	}
+	if (args.help) {
+		console.log(helpText(invokedAs));
+		process.exit(0);
+	}
+	p.intro(invokedAs === "create-pyreon-app" ? "Create a new Pyreon project" : "Pyreon Zero");
+	const config = await runPrompts(args);
+	const s = p.spinner();
+	s.start("Scaffolding project...");
+	await scaffold(config);
+	s.stop("Project created!");
+	p.note([
+		`cd ${config.name}`,
+		"bun install",
+		"bun run dev"
+	].join("\n"), "Next steps");
+	p.outro("Happy building!");
+}
 main().catch((err) => {
 	console.error(err);
 	process.exit(1);