kizlo 0.7.0 → 0.8.1

package/dist/cli/commands/init.js

@@ -1,65 +1,16 @@
-import { composeStop, createStack, dockerAvailable } from "../wp/docker.js";
-import { addDependencyArgs, detectImportAlias, detectPackageManager, ensureGitignored, envGroups, envKeysPresent, getVersion, loadEnvFiles, mergeEnv, pickStackPort, resolveModuleImport, runCommand, writeFileIfAbsent } from "../utils.js";
+import { dockerAvailable } from "../wp/docker.js";
+import { addDependencyArgs, detectImportAlias, detectPackageManager, ensureGitignored, getVersion, loadEnvFiles, resolveModuleImport, runCommand, writeFileIfAbsent } from "../utils.js";
 import { printBanner } from "../banner.js";
-import { DEFAULT_DEV_DB_PORT, DEFAULT_DEV_PORT, resolveStackName } from "../daemon/config.js";
-import { CONTRACT_BARREL } from "../daemon/generate.js";
-import { createAdminAppPassword } from "../wp/bootstrap.js";
-import { bootstrapDev } from "../wp/dev.js";
-import { removeProjectContainers } from "../wp/session.js";
-import { syncSiteSettings } from "../wp/settings.js";
-import { devStack } from "../wp/stack.js";
 import { PRESETS, detectPreset, getPreset } from "../presets/index.js";
-import z from "zod/v4";
+import { collectConnectionFromEnv, collectConnectionInteractively, dirPath, nextStepsNote, orCancel, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv } from "./_setup.js";
+import { CONTRACT_BARREL } from "../daemon/generate.js";
+import { applyPatchToSource, patchChanged, resolvePatch, resolvePatchTargetPath, templatePatches } from "../presets/patch.js";
 import path from "node:path";
 import fs from "node:fs";
 import { defineCommand } from "citty";
 import * as p from "@clack/prompts";
-import { randomBytes } from "node:crypto";
 
 //#region src/cli/commands/init.ts
-/** Production connection keys — what a real deploy needs, and what `.env.example` always lists. */
-const PROD_WP_ENV_KEYS = [
-	"KIZLO_SITE_SECRET",
-	"KIZLO_WORDPRESS_URL",
-	"KIZLO_WORDPRESS_USERNAME",
-	"KIZLO_WORDPRESS_APPLICATION_PASSWORD"
-];
-/**
-* The `.env` keys init manages and the values to write, branched on the connection mode. A local
-* dev stack writes the `KIZLO_DEV_WORDPRESS_*` / `KIZLO_DEV_SITE_SECRET` set plus `KIZLO_TARGET=dev`, so it
-* never touches the production keys (a user can point those at a real site). A remote site writes the
-* bare production keys exactly as before — no `KIZLO_TARGET`, since `"production"` is the default target.
-*/
-function managedEnv(preset, setup) {
-	if (setup.mode === "local") return {
-		keys: [
-			preset.baseUrlEnvKey,
-			"KIZLO_TARGET",
-			"KIZLO_DEV_SITE_SECRET",
-			"KIZLO_DEV_WORDPRESS_URL",
-			"KIZLO_DEV_WORDPRESS_USERNAME",
-			"KIZLO_DEV_WORDPRESS_APPLICATION_PASSWORD"
-		],
-		values: {
-			[preset.baseUrlEnvKey]: setup.baseUrl,
-			KIZLO_TARGET: "dev",
-			KIZLO_DEV_SITE_SECRET: setup.siteSecret,
-			KIZLO_DEV_WORDPRESS_URL: setup.wpUrl,
-			KIZLO_DEV_WORDPRESS_USERNAME: setup.wpUsername,
-			KIZLO_DEV_WORDPRESS_APPLICATION_PASSWORD: setup.wpPassword
-		}
-	};
-	return {
-		keys: [preset.baseUrlEnvKey, ...PROD_WP_ENV_KEYS],
-		values: {
-			[preset.baseUrlEnvKey]: setup.baseUrl,
-			KIZLO_SITE_SECRET: setup.siteSecret,
-			KIZLO_WORDPRESS_URL: setup.wpUrl,
-			KIZLO_WORDPRESS_USERNAME: setup.wpUsername,
-			KIZLO_WORDPRESS_APPLICATION_PASSWORD: setup.wpPassword
-		}
-	};
-}
 function defaultDir(hasSrcDir) {
 	return hasSrcDir ? "src/lib/kizlo" : "lib/kizlo";
 }
@@ -75,18 +26,6 @@ export default defineConfig({
 })
 `;
 }
-/** Appends the API path to the base URL so the client and route handler agree. */
-function withApiPath(baseUrl, apiPath) {
-	try {
-		const url = new URL(baseUrl);
-		const current = url.pathname.replace(/\/+$/, "");
-		if (current.endsWith(apiPath)) return url.toString().replace(/\/+$/, "");
-		url.pathname = `${current}${apiPath}`;
-		return url.toString().replace(/\/+$/, "");
-	} catch {
-		return baseUrl;
-	}
-}
 /** Whether two URLs share an origin (scheme + host + port); false when either can't be parsed. */
 function sameOrigin(a, b) {
 	try {
@@ -100,22 +39,6 @@ function detectAppDir(cwd, hasSrcDir) {
 	if (fs.existsSync(path.join(cwd, "app"))) return "app";
 	return hasSrcDir ? "src/app" : "app";
 }
-const requiredString = z.string().trim().min(1, "Required");
-const urlString = requiredString.pipe(z.url("Must be a valid URL (e.g. https://example.com)"));
-const dirPath = requiredString.refine((value) => !value.endsWith(".ts"), "Enter a directory, not a file");
-function validate(schema) {
-	return (value) => {
-		const result = schema.safeParse(value ?? "");
-		return result.success ? void 0 : result.error.issues[0]?.message;
-	};
-}
-function orCancel(value) {
-	if (p.isCancel(value)) {
-		p.cancel("Setup cancelled.");
-		process.exit(0);
-	}
-	return value;
-}
 /**
 * The single overwrite policy for every scaffolded file: create it when absent, overwrite on
 * `--force`, and otherwise ask before clobbering an existing file (keeping it when the user
@@ -146,76 +69,7 @@ function reportScaffold(file, result, yes) {
 	else p.log.success(`${result === "overwritten" ? "Overwrote" : "Created"} ${file.label} (${file.relPath})`);
 }
 async function collectInteractively(ctx) {
-	let siteUrl;
-	let baseUrl;
-	if (ctx.preset.apiPath) baseUrl = orCancel(await p.text({
-		message: "Public app URL",
-		placeholder: "https://your-app.com",
-		validate: validate(urlString)
-	}));
-	else {
-		siteUrl = orCancel(await p.text({
-			message: "Public site URL",
-			placeholder: "https://your-app.com",
-			validate: validate(urlString)
-		}));
-		baseUrl = orCancel(await p.text({
-			message: "Kizlo backend URL (where the handler is mounted)",
-			placeholder: "https://your-app.com/kizlo",
-			validate: validate(urlString)
-		}));
-	}
-	const siteSecret = orCancel(await p.select({
-		message: "Site secret (webhook signing key)",
-		initialValue: "generate",
-		options: [{
-			value: "generate",
-			label: "Generate a secure secret automatically",
-			hint: "recommended"
-		}, {
-			value: "enter",
-			label: "Enter my own"
-		}]
-	})) === "enter" ? orCancel(await p.password({
-		message: "Enter the site secret",
-		validate: validate(requiredString)
-	})) : randomBytes(32).toString("hex");
-	const mode = orCancel(await p.select({
-		message: "WordPress connection",
-		initialValue: "local",
-		options: [{
-			value: "local",
-			label: "Set up a local dev environment",
-			hint: "runs WordPress in Docker"
-		}, {
-			value: "remote",
-			label: "Use my own WordPress",
-			hint: "connect to an existing site"
-		}]
-	}));
-	let wpUrl = "";
-	let wpUsername = "";
-	let wpPassword = "";
-	let devPath;
-	if (mode === "remote") {
-		wpUrl = orCancel(await p.text({
-			message: "WordPress URL",
-			placeholder: "https://wp.your-app.com",
-			validate: validate(urlString)
-		}));
-		wpUsername = orCancel(await p.text({
-			message: "WordPress username",
-			validate: validate(requiredString)
-		}));
-		wpPassword = orCancel(await p.password({
-			message: "WordPress application password",
-			validate: validate(requiredString)
-		}));
-	} else devPath = orCancel(await p.text({
-		message: "Local WordPress folder",
-		initialValue: "wordpress",
-		validate: validate(dirPath)
-	}));
+	const conn = await collectConnectionInteractively(ctx.preset);
 	const dir = orCancel(await p.text({
 		message: "Kizlo directory",
 		initialValue: defaultDir(ctx.hasSrcDir),
@@ -232,14 +86,7 @@ async function collectInteractively(ctx) {
 		})).trim();
 	}
 	return {
-		mode,
-		baseUrl,
-		siteUrl,
-		siteSecret,
-		wpUrl,
-		wpUsername,
-		wpPassword,
-		devPath,
+		...conn,
 		dir,
 		alias
 	};
@@ -250,14 +97,10 @@ async function collectInteractively(ctx) {
 * later. Never fails — `--yes` always scaffolds a fillable project.
 */
 function collectFromEnv(ctx) {
+	const conn = collectConnectionFromEnv(ctx.preset);
 	const dir = defaultDir(ctx.hasSrcDir);
 	return {
-		mode: "remote",
-		baseUrl: process.env[ctx.preset.baseUrlEnvKey]?.trim() ?? "",
-		siteSecret: process.env.KIZLO_SITE_SECRET?.trim() || randomBytes(32).toString("hex"),
-		wpUrl: process.env.KIZLO_WORDPRESS_URL?.trim() ?? "",
-		wpUsername: process.env.KIZLO_WORDPRESS_USERNAME?.trim() ?? "",
-		wpPassword: process.env.KIZLO_WORDPRESS_APPLICATION_PASSWORD?.trim() ?? "",
+		...conn,
 		dir,
 		alias: ctx.preset.apiPath ? aliasWithSlash(detectImportAlias(ctx.cwd, path.join(dir, "server"))?.prefix) : ""
 	};
@@ -265,66 +108,6 @@ function collectFromEnv(ctx) {
 function readPkg(pkgPath) {
 	return JSON.parse(fs.readFileSync(pkgPath, "utf8"));
 }
-/** Build a {@link ResolvedDevConfig} from the chosen install folder, matching `resolveDevConfig`'s
-* defaults — built directly so init never has to round-trip through the config file it's writing. */
-function devConfigFor(cwd, devPath) {
-	return {
-		configDir: cwd,
-		project: `${resolveStackName(cwd)}-dev`,
-		port: DEFAULT_DEV_PORT,
-		portExplicit: false,
-		dbPort: DEFAULT_DEV_DB_PORT,
-		dbPortExplicit: false,
-		fixtures: [],
-		wordpressPath: devPath,
-		wordpressDir: path.resolve(cwd, devPath)
-	};
-}
-/**
-* Boot the local dev stack once to produce working credentials, then stop it (volumes
-* persist, so a later `kizlo dev` resumes instantly). The dev stack mints no application
-* password — that's a test-stack concern — so we create one here for REST auth in `.env`.
-* While the stack is still up, push the dev site settings (`siteSecret` plus the Kizlo server's
-* `url`/`backend_url`, derived from `baseUrl`) into the plugin so webhook signing and event delivery
-* work.
-*/
-async function provisionLocalStack(cfg, siteSecret, baseUrl) {
-	await removeProjectContainers(cfg.project);
-	const port = await pickStackPort(cfg.port, {
-		fixed: cfg.portExplicit,
-		configKey: "dev.port"
-	});
-	const dbPort = await pickStackPort(cfg.dbPort, {
-		fixed: cfg.dbPortExplicit,
-		host: "127.0.0.1",
-		configKey: "dev.dbPort"
-	});
-	const ready = {
-		...cfg,
-		port,
-		dbPort
-	};
-	createStack(devStack(ready));
-	const info = await bootstrapDev(ready);
-	const appPassword = info.appPassword ?? await createAdminAppPassword("kizlo");
-	const sync = await syncSiteSettings({
-		url: info.url,
-		username: info.username,
-		password: appPassword
-	}, {
-		secret: siteSecret,
-		backendUrl: baseUrl,
-		containerized: true
-	});
-	await composeStop();
-	return {
-		url: info.url,
-		username: info.username,
-		appPassword,
-		adminPassword: info.secrets?.password,
-		secretSyncError: sync.ok ? void 0 : sync.error
-	};
-}
 const init = defineCommand({
 	meta: {
 		name: "init",
@@ -409,63 +192,17 @@ const init = defineCommand({
 			if (!ok) p.log.warn(`Install it yourself: ${addDependencyArgs(pm, "kizlo@latest").join(" ")}`);
 		}
 		if (preset.apiPath && setup.baseUrl) setup.baseUrl = withApiPath(setup.baseUrl, preset.apiPath);
-		let adminPassword;
-		if (setup.mode === "local" && setup.devPath) {
-			ensureGitignored(cwd, setup.devPath);
-			const s = p.spinner();
-			s.start("Setting up local WordPress (first run downloads images, this can take a while)");
-			try {
-				const local = await provisionLocalStack(devConfigFor(cwd, setup.devPath), setup.siteSecret, setup.baseUrl);
-				setup.wpUrl = local.url;
-				setup.wpUsername = local.username;
-				setup.wpPassword = local.appPassword;
-				adminPassword = local.adminPassword;
-				s.stop("Local WordPress ready");
-				if (local.secretSyncError) p.log.warn(`Could not sync KIZLO_DEV_SITE_SECRET to the local plugin (${local.secretSyncError})`);
-			} catch (error) {
-				s.stop("Local WordPress setup failed");
-				p.cancel(error instanceof Error ? error.message : String(error));
-				process.exit(1);
-			}
-		}
-		const { keys, values: envValues } = managedEnv(preset, setup);
-		const envPath = path.join(cwd, ".env");
-		const envExisted = fs.existsSync(envPath);
-		const existingEnv = envExisted ? fs.readFileSync(envPath, "utf8") : "";
-		const conflicts = envKeysPresent(existingEnv, keys);
-		let overwriteKeys = new Set(keys);
-		if (conflicts.length && !force) if (yes) {
-			overwriteKeys = /* @__PURE__ */ new Set();
-			p.log.info("Keeping existing .env values (pass --force to overwrite)");
-		} else {
-			p.log.warn("Some environment variables already exist in .env");
-			if (!orCancel(await p.confirm({
-				message: "Overwrite their existing values?",
-				initialValue: true
-			}))) overwriteKeys = /* @__PURE__ */ new Set();
-		}
-		const merge = mergeEnv(existingEnv, envValues, overwriteKeys, envGroups(preset.baseUrlEnvKey));
-		fs.writeFileSync(envPath, merge.content);
-		if (setup.mode === "remote" && setup.wpUrl && setup.wpUsername && setup.wpPassword) {
-			const sync = await syncSiteSettings({
-				url: setup.wpUrl,
-				username: setup.wpUsername,
-				password: setup.wpPassword
-			}, {
-				secret: setup.siteSecret,
-				siteUrl: setup.siteUrl,
-				backendUrl: setup.baseUrl
-			});
-			if (!sync.ok) p.log.warn(`Could not sync the site settings to WordPress (${sync.error}) — make sure the kizlo plugin is active, then set them from the Kizlo settings.`);
-		}
-		const exampleKeys = [preset.baseUrlEnvKey, ...PROD_WP_ENV_KEYS];
-		const { content: exampleEnv } = mergeEnv("", Object.fromEntries(exampleKeys.map((key) => [key, ""])), new Set(exampleKeys), envGroups(preset.baseUrlEnvKey));
-		const exampleBody = `${exampleEnv}\n# Point the app at a local dev stack (managed by \`kizlo dev\`) instead of the keys above:\n# KIZLO_TARGET=dev\n`;
-		const exampleCreated = writeFileIfAbsent(path.join(cwd, ".env.example"), exampleBody);
+		await setupLocalWordPress(cwd, setup);
+		await writeEnv(cwd, preset, setup, {
+			force,
+			yes
+		});
+		await syncRemote(setup);
 		const dirRel = setup.dir.replace(/^\.\//, "").replace(/\/+$/, "");
 		const serverDirRel = path.join(dirRel, "server");
 		const clientUrl = setup.siteUrl && !sameOrigin(setup.siteUrl, setup.baseUrl) ? setup.baseUrl : void 0;
 		const scaffold = {
+			kizloDir: dirRel,
 			serverDirName: path.basename(serverDirRel),
 			serverEntryPath: path.join(serverDirRel, "index.ts"),
 			clientPath: path.join(dirRel, "client.ts"),
@@ -490,29 +227,45 @@ const init = defineCommand({
 		writeFileIfAbsent(path.join(cwd, generatedDirRel, "contract.json"), "{}\n");
 		writeFileIfAbsent(path.join(cwd, generatedDirRel, "index.ts"), CONTRACT_BARREL);
 		const gitignore = ensureGitignored(cwd, ".env");
-		if (!envExisted) p.log.success("Created .env");
-		else if (merge.updated.length || merge.added.length) p.log.success("Updated .env");
-		else p.log.info("Left .env unchanged");
-		p.log.success(exampleCreated ? "Created .env.example" : "Skipped .env.example (exists)");
 		for (const { file, result } of scaffolded) reportScaffold(file, result, yes);
-		if (gitignore !== "present") p.log.success(`${gitignore === "created" ? "Created" : "Updated"} .gitignore (ignoring .env)`);
-		if (setup.mode === "local") {
-			p.log.success(`Local WordPress configured (${setup.devPath}) — .env points at ${setup.wpUrl}`);
-			if (adminPassword) p.log.warn(`wp-admin login: ${setup.wpUsername} / ${adminPassword} — save it, it's shown only once`);
+		for (const patch of templatePatches(preset.id)) {
+			const resolved = resolvePatch(patch, scaffold);
+			const abs = resolvePatchTargetPath(cwd, resolved.relPath);
+			if (!abs) {
+				p.log.info(`Skipped ${resolved.label} wiring — ${resolved.relPath} not found (add it yourself)`);
+				continue;
+			}
+			const relTarget = path.relative(cwd, abs);
+			const src = fs.readFileSync(abs, "utf8");
+			let text;
+			let changes;
+			try {
+				({text, changes} = applyPatchToSource(src, resolved, { replaceConflicts: force }));
+			} catch (err) {
+				p.log.error(`Could not parse ${resolved.label} (${relTarget}) to wire Kizlo into it: ${err instanceof Error ? err.message : String(err)}`);
+				throw err;
+			}
+			if (!force && !yes && changes.keptExports.length) {
+				p.log.warn(`${resolved.label} (${relTarget}) already defines ${changes.keptExports.join(", ")}`);
+				if (orCancel(await p.confirm({
+					message: "Replace with Kizlo's version?",
+					initialValue: true
+				}))) ({text, changes} = applyPatchToSource(src, resolved, { replaceConflicts: true }));
+			}
+			if (patchChanged(changes)) {
+				fs.writeFileSync(abs, text);
+				const parts = [
+					...changes.replacedExports.length ? [`replaced ${changes.replacedExports.join(", ")}`] : [],
+					...changes.addedExports.length ? [`added ${changes.addedExports.join(", ")}`] : [],
+					...changes.addedImports.length ? ["imports"] : []
+				];
+				p.log.success(`Wired Kizlo into your ${resolved.label} (${relTarget}) — ${parts.join(", ")}`);
+			}
+			if (changes.keptExports.length) p.log.info(`Kept your existing ${changes.keptExports.join(", ")} in ${resolved.label} — pass --force to replace`);
+			else if (!patchChanged(changes)) p.log.info(`Your ${resolved.label} is already wired (${relTarget})`);
 		}
-		p.note([
-			...setup.mode === "local" ? [
-				`Start your local WordPress dev stack (also watches your extensions):`,
-				`  npx kizlo dev`,
-				``
-			] : [
-				`Watch your extensions and regenerate the contract during development:`,
-				`  npx kizlo watch`,
-				``
-			],
-			`Generate the contract once for production builds:`,
-			`  npx kizlo generate`
-		].join("\n"), "Next steps");
+		if (gitignore !== "present") p.log.success(`${gitignore === "created" ? "Created" : "Updated"} .gitignore (ignoring .env)`);
+		nextStepsNote(setup.mode);
 		p.outro("Kizlo is ready 🎉");
 	}
 });

package/dist/cli/index.js

@@ -7,9 +7,10 @@ runMain(defineCommand({
 	meta: {
 		name: "kizlo",
 		version: getVersion(),
-		description: "Kizlo CLI — headless WordPress toolkit"
+		description: "Kizlo CLI — headless WordPress framework"
 	},
 	subCommands: {
+		create: () => import("./commands/create.js").then((m) => m.create),
 		init: () => import("./commands/init.js").then((m) => m.init),
 		watch: () => import("./commands/watch.js").then((m) => m.watch),
 		generate: () => import("./commands/generate.js").then((m) => m.generate),

package/dist/cli/presets/generated/templates.js

@@ -0,0 +1,59 @@
+//#region src/cli/presets/generated/templates.ts
+const TEMPLATE_SUBSETS = { "nextjs": [
+	{
+		"role": "server-entry",
+		"tokenizedPath": "{{kizloDir}}/server/index.ts",
+		"body": "import { createKizlo } from \"kizlo/nextjs/server\"\n\nexport const { router, client, context, handler } = createKizlo()\n"
+	},
+	{
+		"role": "client",
+		"tokenizedPath": "{{kizloDir}}/client.ts",
+		"body": "import { createKizloClient } from \"kizlo/nextjs\"\nimport { contract } from \"./server/generated\"\n\nexport const client = createKizloClient(contract)\n"
+	},
+	{
+		"role": "api-route",
+		"tokenizedPath": "{{appDir}}/api/kizlo/[[...rest]]/route.ts",
+		"body": "import { handler } from \"{{serverImport}}\"\n\nexport { handler as GET, handler as POST, handler as PUT, handler as PATCH, handler as DELETE, handler as OPTIONS }\n"
+	},
+	{
+		"role": "robots",
+		"tokenizedPath": "{{appDir}}/robots.txt/route.ts",
+		"body": "import { createRobotsRoute } from \"kizlo/nextjs/server\"\nimport { client } from \"{{serverImport}}\"\n\n// Run on the edge: cheaper and faster than Node for a response this small.\nexport const runtime = \"edge\"\n\n// Vercel treats special metadata files like robots.txt and sitemap.xml as completely static\n// files at build time, bypassing normal Incremental Static Regeneration (ISR) and on-demand\n// revalidatePath rules.\n//\n// While your revalidation logic executes perfectly in a local Node.js server, Vercel uploads\n// these routes directly to its Edge CDN as immutable assets. Subsequent on-demand revalidation\n// triggers will successfully clear the Data Cache but fail to purge the CDN-level Edge cache\n// for that file.\n//\n// force-dynamic opts out of that static treatment so CMS edits show up; the WordPress call is\n// cached, so requests stay cheap.\nexport const dynamic = \"force-dynamic\"\n\nexport const GET = createRobotsRoute(client)\n"
+	},
+	{
+		"role": "sitemap",
+		"tokenizedPath": "{{appDir}}/sitemaps/[sitemap]/route.ts",
+		"body": "import { createSitemapRoute } from \"kizlo/nextjs/server\"\nimport { client } from \"{{serverImport}}\"\n\n// Run on the edge: cheaper and faster than Node for a response this small.\nexport const runtime = \"edge\"\n\n// Like robots.txt, Vercel bakes sitemap routes into immutable Edge CDN assets at build time,\n// bypassing ISR and on-demand revalidatePath. The index gets frozen with whatever WordPress\n// returned at build (often nothing, since the self-referential backend isn't reachable yet),\n// and revalidation can't purge that CDN copy.\n//\n// force-dynamic opts out of that static treatment. createSitemapRoute caches the WordPress calls\n// per sitemap and refreshes them on content changes (via revalidateTag), so requests stay cheap.\nexport const dynamic = \"force-dynamic\"\n\nexport const GET = createSitemapRoute(client)\n"
+	},
+	{
+		"role": "sitemap-redirect",
+		"tokenizedPath": "{{appDir}}/sitemap.xml/route.ts",
+		"body": "import { createSitemapRedirectRoute } from \"kizlo/nextjs/server\"\n\n// Many crawlers ignore robots.txt and probe the well-known /sitemap.xml directly. This route\n// permanently redirects (308) to the generated index at /sitemaps/index.xml. The response is a\n// fixed constant with no WordPress call or request input, so Next statically generates it at\n// build time (no runtime/edge function invoked per request).\nexport const GET = createSitemapRedirectRoute()\n"
+	},
+	{
+		"role": "manifest",
+		"tokenizedPath": "{{appDir}}/site.webmanifest/route.ts",
+		"body": "import { createManifestRoute } from \"kizlo/nextjs/server\"\nimport { client } from \"{{serverImport}}\"\n\n// Run on the edge: cheaper and faster than Node for a response this small.\nexport const runtime = \"edge\"\n\n// Like robots.txt, Vercel bakes this route into an immutable Edge CDN asset at build time,\n// bypassing ISR and on-demand revalidatePath. force-dynamic opts out of that static treatment\n// so brand-settings edits show up; createManifestRoute caches the WordPress call, so requests\n// stay cheap.\nexport const dynamic = \"force-dynamic\"\n\nexport const GET = createManifestRoute(client)\n"
+	}
+] };
+const TEMPLATE_PATCHES = { "nextjs": [{
+	"label": "root layout",
+	"tokenizedFile": "{{appDir}}/layout.tsx",
+	"imports": [{
+		"module": "kizlo/nextjs/server",
+		"names": ["createRootMetadata", "createRootViewport"]
+	}, {
+		"module": "{{serverImport}}",
+		"names": ["client"]
+	}],
+	"exports": [{
+		"name": "generateMetadata",
+		"value": "createRootMetadata(client)"
+	}, {
+		"name": "generateViewport",
+		"value": "createRootViewport(client)"
+	}]
+}] };
+
+//#endregion
+export { TEMPLATE_PATCHES, TEMPLATE_SUBSETS };

package/dist/cli/presets/nextjs.js

@@ -1,3 +1,5 @@
+import { materializeTemplate } from "./template.js";
+
 //#region src/cli/presets/nextjs.ts
 const nextjs = {
 	id: "nextjs",
@@ -11,101 +13,7 @@ const nextjs = {
 	baseUrlEnvKey: "NEXT_PUBLIC_KIZLO_BACKEND_URL",
 	apiPath: "/api/kizlo",
 	scaffolds(ctx) {
-		const apiDir = `${ctx.appDir}/api/kizlo/[[...rest]]`;
-		const robotsDir = `${ctx.appDir}/robots.txt`;
-		const sitemapDir = `${ctx.appDir}/sitemaps/[sitemap]`;
-		const manifestDir = `${ctx.appDir}/site.webmanifest`;
-		return [
-			{
-				label: "Kizlo server instance",
-				relPath: ctx.serverEntryPath,
-				contents: `import { createKizlo } from "kizlo/nextjs/server"
-
-export const { router, client, context, handler } = createKizlo()
-`
-			},
-			{
-				label: "Browser client",
-				relPath: ctx.clientPath,
-				contents: `import { createKizloClient } from "kizlo/nextjs"
-import { contract } from "./${ctx.serverDirName}/generated"
-
-export const client = createKizloClient(contract)
-`
-			},
-			{
-				label: "API route",
-				relPath: `${apiDir}/route.ts`,
-				contents: `import { handler } from "${ctx.serverImport(apiDir)}"
-
-export { handler as GET, handler as POST, handler as PUT, handler as PATCH, handler as DELETE, handler as OPTIONS }
-`
-			},
-			{
-				label: "robots.txt route",
-				relPath: `${robotsDir}/route.ts`,
-				contents: `import { createRobotsRoute } from "kizlo/nextjs/server"
-import { client } from "${ctx.serverImport(robotsDir)}"
-
-// Run on the edge: cheaper and faster than Node for a response this small.
-export const runtime = "edge"
-
-// Vercel treats special metadata files like robots.txt and sitemap.xml as completely static
-// files at build time, bypassing normal Incremental Static Regeneration (ISR) and on-demand
-// revalidatePath rules.
-//
-// While your revalidation logic executes perfectly in a local Node.js server, Vercel uploads
-// these routes directly to its Edge CDN as immutable assets. Subsequent on-demand revalidation
-// triggers will successfully clear the Data Cache but fail to purge the CDN-level Edge cache
-// for that file.
-//
-// force-dynamic opts out of that static treatment so CMS edits show up; the WordPress call is
-// cached, so requests stay cheap.
-export const dynamic = "force-dynamic"
-
-export const GET = createRobotsRoute(client)
-`
-			},
-			{
-				label: "sitemap route",
-				relPath: `${sitemapDir}/route.ts`,
-				contents: `import { createSitemapRoute } from "kizlo/nextjs/server"
-import { client } from "${ctx.serverImport(sitemapDir)}"
-
-// Run on the edge: cheaper and faster than Node for a response this small.
-export const runtime = "edge"
-
-// Like robots.txt, Vercel bakes sitemap routes into immutable Edge CDN assets at build time,
-// bypassing ISR and on-demand revalidatePath. The index gets frozen with whatever WordPress
-// returned at build (often nothing, since the self-referential backend isn't reachable yet),
-// and revalidation can't purge that CDN copy.
-//
-// force-dynamic opts out of that static treatment. createSitemapRoute caches the WordPress calls
-// per sitemap and refreshes them on content changes (via revalidateTag), so requests stay cheap.
-export const dynamic = "force-dynamic"
-
-export const GET = createSitemapRoute(client)
-`
-			},
-			{
-				label: "web manifest route",
-				relPath: `${manifestDir}/route.ts`,
-				contents: `import { createManifestRoute } from "kizlo/nextjs/server"
-import { client } from "${ctx.serverImport(manifestDir)}"
-
-// Run on the edge: cheaper and faster than Node for a response this small.
-export const runtime = "edge"
-
-// Like robots.txt, Vercel bakes this route into an immutable Edge CDN asset at build time,
-// bypassing ISR and on-demand revalidatePath. force-dynamic opts out of that static treatment
-// so brand-settings edits show up; createManifestRoute caches the WordPress call, so requests
-// stay cheap.
-export const dynamic = "force-dynamic"
-
-export const GET = createManifestRoute(client)
-`
-			}
-		];
+		return materializeTemplate("nextjs", ctx);
 	}
 };