kizlo 0.8.2 → 0.8.4

package/dist/cli/commands/_setup.js

@@ -321,11 +321,11 @@ async function syncRemote(conn) {
 	});
 	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.`);
 }
-/** The shared "Next steps" note, branched on whether a local dev stack was set up. */
-function nextStepsNote(mode, prefix = "") {
-	p.note([
+/** The "Next steps" lines, branched on whether a local dev stack was set up. */
+function nextStepsLines(mode, prefix = "") {
+	return [
 		...mode === "local" ? [
-			`Start your local WordPress dev stack (also watches your extensions):`,
+			`Start your local WordPress dev stack:`,
 			`  ${prefix}npx kizlo dev`,
 			``
 		] : [
@@ -335,8 +335,12 @@ function nextStepsNote(mode, prefix = "") {
 		],
 		`Generate the contract once for production builds:`,
 		`  ${prefix}npx kizlo generate`
-	].join("\n"), "Next steps");
+	];
+}
+/** The shared "Next steps" note, branched on whether a local dev stack was set up. */
+function nextStepsNote(mode, prefix = "") {
+	p.note(nextStepsLines(mode, prefix).join("\n"), "Next steps");
 }
 
 //#endregion
-export { collectConnectionFromEnv, collectConnectionInteractively, dirPath, nextStepsNote, orCancel, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv };
+export { collectConnectionFromEnv, collectConnectionInteractively, dirPath, nextStepsLines, nextStepsNote, orCancel, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv };

package/dist/cli/commands/_wiring.js

@@ -0,0 +1,116 @@
+import { resolveModuleImport, writeFileIfAbsent } from "../utils.js";
+import { applyPatchToSource, patchChanged, renderPatchCode } from "../presets/patch.js";
+import { findRootLayout, patchEntries, resolvePatch } from "../presets/template.js";
+import { orCancel } from "./_setup.js";
+import { CONTRACT_BARREL } from "../daemon/generate.js";
+import path from "node:path";
+import fs from "node:fs";
+import * as p from "@clack/prompts";
+
+//#region src/cli/commands/_wiring.ts
+/** The kizlo.config.ts a scaffolded project gets: the Kizlo directory, optional import alias, and —
+*  for a local dev setup — the WordPress install folder so `kizlo dev` knows where it lives. */
+function kizloConfigTemplate(dir, alias, devPath) {
+	return `import { defineConfig } from "kizlo/config"
+
+export default defineConfig({
+	dir: "${dir}",${alias ? `\n\talias: "${alias}",` : ""}${devPath ? `\n\tdev: { path: "${devPath}" },` : ""}
+})
+`;
+}
+/**
+* Build the {@link ScaffoldContext} that adapts a template's tokenized paths and imports to a real
+* project. `dirRel` is the Kizlo home directory, `appDir` the App Router directory, and `alias` the
+* import-alias prefix (empty for relative imports). The server-entry import is resolved per calling
+* file so each scaffolded file references the server through the right specifier.
+*/
+function buildScaffoldContext(cwd, { dirRel, appDir, alias, clientUrl }) {
+	const serverDirRel = path.join(dirRel, "server");
+	return {
+		kizloDir: dirRel,
+		serverDirName: path.basename(serverDirRel),
+		serverEntryPath: path.join(serverDirRel, "index.ts"),
+		clientPath: path.join(dirRel, "client.ts"),
+		appDir,
+		serverImport: (fromDir) => resolveModuleImport(cwd, serverDirRel, fromDir, alias),
+		clientUrl
+	};
+}
+/**
+* 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
+* declines or when running non-interactively with `--yes`). Every scaffolded file routes through
+* here rather than deciding for itself, so new files inherit the same behavior for free.
+*/
+async function scaffoldFile(cwd, file, opts) {
+	const absPath = path.join(cwd, file.relPath);
+	const existed = fs.existsSync(absPath);
+	if (existed) {
+		let overwrite = opts.force;
+		if (!opts.force && !opts.yes) {
+			p.log.warn(`${file.label} already exists at ${file.relPath}`);
+			overwrite = orCancel(await p.confirm({
+				message: "Overwrite it?",
+				initialValue: true
+			}));
+		}
+		if (!overwrite) return "kept";
+	}
+	fs.mkdirSync(path.dirname(absPath), { recursive: true });
+	fs.writeFileSync(absPath, file.contents);
+	return existed ? "overwritten" : "created";
+}
+/** Report a {@link scaffoldFile} outcome in the setup commands' usual voice. */
+function reportScaffold(file, result, yes) {
+	if (result === "kept") p.log.info(`Kept existing ${file.label} (${file.relPath})${yes ? " — pass --force to overwrite" : ""}`);
+	else p.log.success(`${result === "overwritten" ? "Overwrote" : "Created"} ${file.label} (${file.relPath})`);
+}
+/** Seed the generated-contract directory so imports resolve before the first `kizlo watch`/`generate`. */
+function writeGeneratedContract(cwd, serverDirRel) {
+	const generatedDirRel = path.join(serverDirRel, "generated");
+	writeFileIfAbsent(path.join(cwd, generatedDirRel, "contract.json"), "{}\n");
+	writeFileIfAbsent(path.join(cwd, generatedDirRel, "index.ts"), CONTRACT_BARREL);
+}
+/**
+* Merge Kizlo wiring into files the project already owns (the root layout's SEO exports). Never
+* aborts: the target is resolved by identity (the layout that renders `<html>`), and on any doubt —
+* not found, not parseable — the resolved payload is printed at the end with placement instructions
+* rather than written to a guessed-at file. A confident apply is an idempotent upsert: it replaces
+* our exports if present, adds them if not.
+*/
+function applyLayoutPatches(cwd, manifest, scaffold) {
+	const manualSteps = [];
+	for (const entry of patchEntries(manifest)) {
+		const resolved = resolvePatch(entry, manifest.tokens, scaffold);
+		const target = findRootLayout(cwd, scaffold.appDir, resolved.relPath);
+		if (!target) {
+			manualSteps.push(resolved);
+			p.log.info(`Couldn't find your ${resolved.label} to wire Kizlo into — see the code to add below`);
+			continue;
+		}
+		const relTarget = path.relative(cwd, target);
+		const src = fs.readFileSync(target, "utf8");
+		let applied;
+		try {
+			applied = applyPatchToSource(src, resolved);
+		} catch {
+			manualSteps.push(resolved);
+			p.log.warn(`Couldn't parse your ${resolved.label} (${relTarget}) — see the code to add below`);
+			continue;
+		}
+		const { text, changes } = applied;
+		if (patchChanged(changes)) {
+			fs.writeFileSync(target, 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(", ")}`);
+		} else p.log.info(`Your ${resolved.label} is already wired (${relTarget})`);
+	}
+	for (const resolved of manualSteps) p.note(renderPatchCode(resolved), `Add these to your ${resolved.label} (the layout that renders <html>)`);
+}
+
+//#endregion
+export { applyLayoutPatches, buildScaffoldContext, kizloConfigTemplate, reportScaffold, scaffoldFile, writeGeneratedContract };

package/dist/cli/commands/create.js

@@ -1,10 +1,11 @@
 import { dockerAvailable } from "../wp/docker.js";
-import { detectPackageManager, getVersion } from "../utils.js";
+import { availablePackageManagers, detectInvokingPackageManager, ensureGitignored, frameworkCreateArgs, getVersion, installArgs, runCommandAsync, runCommandCaptured } from "../utils.js";
 import { printBanner } from "../banner.js";
 import { getPreset } from "../presets/index.js";
 import { fetchTemplate } from "../presets/source.js";
-import { readManifest } from "../presets/template.js";
-import { collectConnectionInteractively, nextStepsNote, orCancel, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv } from "./_setup.js";
+import { adaptOwnFile, ownEntries, readManifest } from "../presets/template.js";
+import { collectConnectionInteractively, nextStepsLines, orCancel, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv } from "./_setup.js";
+import { applyLayoutPatches, buildScaffoldContext, kizloConfigTemplate, reportScaffold, scaffoldFile, writeGeneratedContract } from "./_wiring.js";
 import z from "zod/v4";
 import path from "node:path";
 import fs from "node:fs";
@@ -14,54 +15,77 @@ import * as p from "@clack/prompts";
 //#region src/cli/commands/create.ts
 /**
 * The templates `create` can scaffold from. Each id is both the `templates/<id>` folder and the
-* preset that drives its WordPress setup.
+* preset that drives its WordPress setup and framework bootstrap.
 */
 const TEMPLATES = ["nextjs"];
 function isTemplate(value) {
 	return TEMPLATES.includes(value);
 }
 const projectName = validate(z.string().trim().min(1, "Required").refine((value) => !value.startsWith(".") && !value.includes("/") && !value.includes("\\"), "Enter a folder name (letters, numbers, dashes)"));
-/** Directory entries never copied into a scaffolded project — the internal manifest and build junk. */
-const SKIP_COPY = new Set([
-	"template.json",
-	"node_modules",
-	".next",
-	".turbo",
-	".git"
-]);
+/** Package managers `create` can wire the getting-started steps for, in display order. */
+const PACKAGE_MANAGERS = [
+	"pnpm",
+	"npm",
+	"yarn",
+	"bun"
+];
 /**
-* Copy the template into `dir`, then make it a standalone project: name the package after the
-* project folder and resolve the monorepo-only `workspace:*` Kizlo dependency to the version the
-* template declares (`kizloVersion` in its manifest, stamped at release), falling back to the running
-* CLI's version. The version the project runs is the template's to decide, not a moving `latest` tag.
-* The template's `template.json` is an internal input, so it's left out of the copy — as is
-* local build junk (`node_modules`, `.next`, …) that only exists on the `KIZLO_TEMPLATE_LOCAL_DIR` path.
+* Pin the `kizlo` dependency in the freshly bootstrapped `package.json`. The template is
+* authoritative for the version (`kizloVersion` in its manifest, stamped at release), falling back to
+* the running CLI's version in-repo before the first stamp. The dependency is only recorded, not
+* installed — the getting-started note tells the user to run install.
 */
-async function scaffoldTemplate(template, dir, name) {
-	const { dir: src, cleanup } = await fetchTemplate(template);
-	let kizloVersion;
-	try {
-		kizloVersion = readManifest(src).kizloVersion ?? `^${getVersion()}`;
-		fs.cpSync(src, dir, {
-			recursive: true,
-			filter: (from) => !SKIP_COPY.has(path.basename(from))
-		});
-	} finally {
-		cleanup();
-	}
+function recordKizloDependency(dir, manifest) {
 	const pkgPath = path.join(dir, "package.json");
-	if (!fs.existsSync(pkgPath)) {
-		fs.rmSync(dir, {
-			recursive: true,
-			force: true
-		});
-		throw new Error(`Template "${template}" wasn't found. Check the template name and your network connection, then try again.`);
-	}
 	const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-	pkg.name = name;
-	if (pkg.dependencies?.kizlo === "workspace:*") pkg.dependencies.kizlo = kizloVersion;
+	pkg.dependencies ??= {};
+	pkg.dependencies.kizlo = manifest.kizloVersion ?? `^${getVersion()}`;
 	fs.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, "	")}\n`);
 }
+/**
+* The argv `create` runs to bootstrap a fresh base app with the framework's own official CLI, built
+* from the template manifest's `bootstrap` (initializer + flags) — the template is the single source
+* of truth for the framework. The CLI owns only the package-manager mechanics: {@link frameworkCreateArgs}
+* assembles the `<pm> create …` invocation, and the `{{pm}}` token in the flags is substituted with the
+* chosen manager (e.g. `--use-{{pm}}` → `--use-pnpm`).
+*/
+function bootstrapArgs(manifest, pm, name) {
+	if (!manifest.bootstrap) return void 0;
+	const flags = manifest.bootstrap.flags.map((flag) => flag.replaceAll("{{pm}}", pm));
+	return frameworkCreateArgs(pm, manifest.bootstrap.initializer, name, flags);
+}
+/**
+* Layer Kizlo's wiring onto a freshly bootstrapped app in `dir`, from an already-fetched template
+* directory + manifest. The framework CLI has produced the base project (package.json, config,
+* tsconfig, the root layout); this drives the manifest — the same engine `init` uses — to record the
+* `kizlo` dependency, write `kizlo.config.ts`, scaffold the manifest's own files (wiring plus the demo
+* starter pages), seed the generated contract, ignore `.env`, and patch the root layout's SEO exports.
+* The target directory layout comes straight from the manifest tokens, which the bootstrap flags are
+* chosen to match, so files land where the manifest expects. Fresh files are written with `force`,
+* silently replacing the framework defaults.
+*/
+async function applyManifestWiring(dir, templateDir, manifest, opts) {
+	const { kizloDir, appDir, alias } = manifest.tokens;
+	const scaffold = buildScaffoldContext(dir, {
+		dirRel: kizloDir,
+		appDir,
+		alias,
+		clientUrl: void 0
+	});
+	recordKizloDependency(dir, manifest);
+	const files = [{
+		label: "Kizlo config",
+		relPath: "kizlo.config.ts",
+		contents: kizloConfigTemplate(kizloDir, alias, opts.devPath)
+	}, ...ownEntries(manifest, { includeStarter: opts.includeStarter }).map((entry) => adaptOwnFile(templateDir, entry, manifest.tokens, scaffold))];
+	for (const file of files) reportScaffold(file, await scaffoldFile(dir, file, {
+		force: true,
+		yes: false
+	}), false);
+	writeGeneratedContract(dir, path.join(kizloDir, "server"));
+	ensureGitignored(dir, ".env");
+	applyLayoutPatches(dir, manifest, scaffold);
+}
 const create = defineCommand({
 	meta: {
 		name: "create",
@@ -120,21 +144,67 @@ const create = defineCommand({
 			p.cancel(`No preset for template "${template}".`);
 			process.exit(1);
 		}
+		const installed = availablePackageManagers(PACKAGE_MANAGERS);
+		const invokingPm = detectInvokingPackageManager();
+		const defaultPm = invokingPm && installed.includes(invokingPm) ? invokingPm : installed[0];
+		const pm = orCancel(await p.select({
+			message: "Package manager",
+			options: installed.map((id) => ({
+				value: id,
+				label: id
+			})),
+			initialValue: defaultPm
+		}));
+		const includeStarter = orCancel(await p.confirm({
+			message: "Add example pages?",
+			initialValue: true
+		}));
 		const conn = await collectConnectionInteractively(preset);
 		if (preset.apiPath && conn.baseUrl) conn.baseUrl = withApiPath(conn.baseUrl, preset.apiPath);
 		if (conn.mode === "local" && !await dockerAvailable()) {
 			p.cancel("Docker isn't available — start Docker (or install it) and re-run, or choose “Use my own WordPress”.");
 			process.exit(1);
 		}
+		const fetched = await fetchTemplate(template);
+		const fail = (message) => {
+			fetched.cleanup();
+			p.cancel(message);
+			process.exit(1);
+		};
+		const manifest = readManifest(fetched.dir);
+		const bootstrap = bootstrapArgs(manifest, pm, name);
+		if (!bootstrap) {
+			fetched.cleanup();
+			p.cancel(`Template "${template}" can't be scaffolded — its manifest declares no framework bootstrap.`);
+			process.exit(1);
+		}
 		const s = p.spinner();
-		s.start(`Creating ${name} from the ${template} template`);
+		s.start(`Creating ${name} with the ${preset.label} CLI`);
+		const scaffold = runCommandCaptured(bootstrap, cwd);
+		s.stop(scaffold.ok ? `Created ${name} with the ${preset.label} CLI` : `${preset.label} setup failed`);
+		if (!scaffold.ok) {
+			if (scaffold.output) p.log.error(scaffold.output);
+			fail(`${preset.label} setup failed — see the output above and try again.`);
+		}
 		try {
-			await scaffoldTemplate(template, dir, name);
-			s.stop(`Created ${name}`);
+			await applyManifestWiring(dir, fetched.dir, manifest, {
+				devPath: conn.devPath,
+				includeStarter
+			});
 		} catch (error) {
-			s.stop("Could not create the project");
-			p.cancel(error instanceof Error ? error.message : String(error));
-			process.exit(1);
+			fail(error instanceof Error ? error.message : String(error));
+		}
+		fetched.cleanup();
+		let depsInstalled = false;
+		if (orCancel(await p.confirm({
+			message: "Install dependencies now?",
+			initialValue: true
+		}))) {
+			const is = p.spinner();
+			is.start(`Installing dependencies with ${pm}`);
+			depsInstalled = await runCommandAsync(installArgs(pm), dir, "ignore");
+			is.stop(depsInstalled ? "Installed dependencies" : "Could not install dependencies");
+			if (!depsInstalled) p.log.warn(`Install them yourself: cd ${name} && ${installArgs(pm).join(" ")}`);
 		}
 		await setupLocalWordPress(dir, conn);
 		await writeEnv(dir, preset, conn, {
@@ -142,9 +212,12 @@ const create = defineCommand({
 			yes: false
 		});
 		await syncRemote(conn);
-		const pm = detectPackageManager(dir);
-		p.note([`cd ${name}`, `${pm} install`].join("\n"), "Get started");
-		nextStepsNote(conn.mode);
+		p.note([
+			`cd ${name}`,
+			...depsInstalled ? [] : [`${pm} install`],
+			``,
+			...nextStepsLines(conn.mode)
+		].join("\n"), "Next steps");
 		p.outro("Kizlo is ready 🎉");
 	}
 });

package/dist/cli/commands/init.js

@@ -1,12 +1,11 @@
 import { dockerAvailable } from "../wp/docker.js";
-import { addDependencyArgs, detectImportAlias, detectPackageManager, ensureGitignored, getVersion, loadEnvFiles, resolveModuleImport, runCommand, writeFileIfAbsent } from "../utils.js";
+import { addDependencyArgs, detectImportAlias, detectPackageManager, ensureGitignored, getVersion, loadEnvFiles, runCommandAsync } from "../utils.js";
 import { printBanner } from "../banner.js";
 import { PRESETS, detectPreset, getPreset } from "../presets/index.js";
 import { fetchTemplate } from "../presets/source.js";
-import { applyPatchToSource, patchChanged, renderPatchCode } from "../presets/patch.js";
-import { adaptOwnFile, findRootLayout, ownEntries, patchEntries, readManifest, resolvePatch } from "../presets/template.js";
+import { adaptOwnFile, ownEntries, readManifest } from "../presets/template.js";
 import { collectConnectionFromEnv, collectConnectionInteractively, dirPath, nextStepsNote, orCancel, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv } from "./_setup.js";
-import { CONTRACT_BARREL } from "../daemon/generate.js";
+import { applyLayoutPatches, buildScaffoldContext, kizloConfigTemplate, reportScaffold, scaffoldFile, writeGeneratedContract } from "./_wiring.js";
 import path from "node:path";
 import fs from "node:fs";
 import { defineCommand } from "citty";
@@ -20,14 +19,6 @@ function defaultDir(hasSrcDir) {
 function aliasWithSlash(alias) {
 	return alias ? `${alias.replace(/\/+$/, "")}/` : "";
 }
-function kizloConfigTemplate(dir, alias, devPath) {
-	return `import { defineConfig } from "kizlo/config"
-
-export default defineConfig({
-	dir: "${dir}",${alias ? `\n\talias: "${alias}",` : ""}${devPath ? `\n\tdev: { path: "${devPath}" },` : ""}
-})
-`;
-}
 /** Whether two URLs share an origin (scheme + host + port); false when either can't be parsed. */
 function sameOrigin(a, b) {
 	try {
@@ -41,35 +32,6 @@ function detectAppDir(cwd, hasSrcDir) {
 	if (fs.existsSync(path.join(cwd, "app"))) return "app";
 	return hasSrcDir ? "src/app" : "app";
 }
-/**
-* 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
-* declines or when running non-interactively with `--yes`). Every scaffolded file routes through
-* here rather than deciding for itself, so new files inherit the same behavior for free.
-*/
-async function scaffoldFile(cwd, file, opts) {
-	const absPath = path.join(cwd, file.relPath);
-	const existed = fs.existsSync(absPath);
-	if (existed) {
-		let overwrite = opts.force;
-		if (!opts.force && !opts.yes) {
-			p.log.warn(`${file.label} already exists at ${file.relPath}`);
-			overwrite = orCancel(await p.confirm({
-				message: "Overwrite it?",
-				initialValue: true
-			}));
-		}
-		if (!overwrite) return "kept";
-	}
-	fs.mkdirSync(path.dirname(absPath), { recursive: true });
-	fs.writeFileSync(absPath, file.contents);
-	return existed ? "overwritten" : "created";
-}
-/** Report a {@link scaffoldFile} outcome in init's usual voice. */
-function reportScaffold(file, result, yes) {
-	if (result === "kept") p.log.info(`Kept existing ${file.label} (${file.relPath})${yes ? " — pass --force to overwrite" : ""}`);
-	else p.log.success(`${result === "overwritten" ? "Overwrote" : "Created"} ${file.label} (${file.relPath})`);
-}
 async function collectInteractively(ctx) {
 	const conn = await collectConnectionInteractively(ctx.preset);
 	const dir = orCancel(await p.text({
@@ -136,13 +98,13 @@ function isOlder(have, want) {
 * When the project's kizlo is older, upgrade the project up to it and say so — a deliberate pin is
 * never changed silently. Never downgrades.
 */
-function alignKizloVersion(cwd, pm, pkg, manifest) {
+async function alignKizloVersion(cwd, pm, pkg, manifest) {
 	const want = manifest.kizloVersion ?? `^${getVersion()}`;
 	const have = kizloDep(pkg);
 	if (!have || !isOlder(have, want)) return;
 	const s = p.spinner();
 	s.start(`Upgrading kizlo from ${have} to ${want}`);
-	const ok = runCommand(addDependencyArgs(pm, `kizlo@${want}`), cwd, "ignore");
+	const ok = await runCommandAsync(addDependencyArgs(pm, `kizlo@${want}`), cwd, "ignore");
 	s.stop(ok ? `Upgraded kizlo to ${want}` : `Could not upgrade kizlo automatically — install kizlo@${want} yourself`);
 }
 const init = defineCommand({
@@ -221,6 +183,10 @@ const init = defineCommand({
 		});
 		if (args.alias !== void 0) setup.alias = String(args.alias).trim();
 		setup.alias = aliasWithSlash(setup.alias);
+		const includeStarter = preset.template ? yes || orCancel(await p.confirm({
+			message: "Add example pages?",
+			initialValue: true
+		})) : false;
 		if (setup.mode === "local" && !await dockerAvailable()) {
 			p.cancel("Docker isn't available — start Docker (or install it) and re-run, or choose “Use my own WordPress”.");
 			process.exit(1);
@@ -229,7 +195,7 @@ const init = defineCommand({
 			const spec = `kizlo@^${getVersion()}`;
 			const s = p.spinner();
 			s.start(`Installing kizlo with ${pm}`);
-			const ok = runCommand(addDependencyArgs(pm, spec), cwd, "ignore");
+			const ok = await runCommandAsync(addDependencyArgs(pm, spec), cwd, "ignore");
 			s.stop(ok ? "Installed kizlo" : "Could not install kizlo automatically");
 			if (!ok) p.log.warn(`Install it yourself: ${addDependencyArgs(pm, spec).join(" ")}`);
 		}
@@ -243,15 +209,12 @@ const init = defineCommand({
 		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"),
+		const scaffold = buildScaffoldContext(cwd, {
+			dirRel,
 			appDir: detectAppDir(cwd, hasSrcDir),
-			serverImport: (fromDir) => resolveModuleImport(cwd, serverDirRel, fromDir, setup.alias),
+			alias: setup.alias,
 			clientUrl
-		};
+		});
 		const files = [{
 			label: "Kizlo config",
 			relPath: "kizlo.config.ts",
@@ -262,8 +225,8 @@ const init = defineCommand({
 			const fetched = await fetchTemplate(preset.template);
 			try {
 				manifest = readManifest(fetched.dir);
-				alignKizloVersion(cwd, pm, pkg, manifest);
-				for (const entry of ownEntries(manifest)) files.push(adaptOwnFile(fetched.dir, entry, manifest.tokens, scaffold));
+				await alignKizloVersion(cwd, pm, pkg, manifest);
+				for (const entry of ownEntries(manifest, { includeStarter })) files.push(adaptOwnFile(fetched.dir, entry, manifest.tokens, scaffold));
 			} finally {
 				fetched.cleanup();
 			}
@@ -276,42 +239,10 @@ const init = defineCommand({
 				yes
 			})
 		});
-		const generatedDirRel = path.join(serverDirRel, "generated");
-		writeFileIfAbsent(path.join(cwd, generatedDirRel, "contract.json"), "{}\n");
-		writeFileIfAbsent(path.join(cwd, generatedDirRel, "index.ts"), CONTRACT_BARREL);
+		writeGeneratedContract(cwd, serverDirRel);
 		const gitignore = ensureGitignored(cwd, ".env");
 		for (const { file, result } of scaffolded) reportScaffold(file, result, yes);
-		const manualSteps = [];
-		for (const entry of manifest ? patchEntries(manifest) : []) {
-			const resolved = resolvePatch(entry, manifest.tokens, scaffold);
-			const target = findRootLayout(cwd, scaffold.appDir, resolved.relPath);
-			if (!target) {
-				manualSteps.push(resolved);
-				p.log.info(`Couldn't find your ${resolved.label} to wire Kizlo into — see the code to add below`);
-				continue;
-			}
-			const relTarget = path.relative(cwd, target);
-			const src = fs.readFileSync(target, "utf8");
-			let applied;
-			try {
-				applied = applyPatchToSource(src, resolved);
-			} catch {
-				manualSteps.push(resolved);
-				p.log.warn(`Couldn't parse your ${resolved.label} (${relTarget}) — see the code to add below`);
-				continue;
-			}
-			const { text, changes } = applied;
-			if (patchChanged(changes)) {
-				fs.writeFileSync(target, 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(", ")}`);
-			} else p.log.info(`Your ${resolved.label} is already wired (${relTarget})`);
-		}
-		for (const resolved of manualSteps) p.note(renderPatchCode(resolved), `Add these to your ${resolved.label} (the layout that renders <html>)`);
+		if (manifest) applyLayoutPatches(cwd, manifest, scaffold);
 		if (gitignore !== "present") p.log.success(`${gitignore === "created" ? "Created" : "Updated"} .gitignore (ignoring .env)`);
 		nextStepsNote(setup.mode);
 		p.outro("Kizlo is ready 🎉");

package/dist/cli/presets/template.js

@@ -5,15 +5,17 @@ import fs from "node:fs";
 
 //#region src/cli/presets/template.ts
 /**
-* The template's `template.json`. It is the single declaration of which files are Kizlo wiring
-* and how each is applied. Every entry is one of a small closed set — deliberately no "patch an
-* arbitrary source file" kind, so a dangerous strategy is unrepresentable:
+* The template's `template.json`. It is the single declaration of which files Kizlo lays onto a
+* project and how each is applied — the same engine drives both `create` (onto a fresh app the
+* framework CLI just bootstrapped) and `init` (onto the user's existing project). Every entry is one
+* of a small closed set — deliberately no "patch an arbitrary source file" kind, so a dangerous
+* strategy is unrepresentable:
 *
-* - `own` — a whole file Kizlo writes. Its path is authoritative; `create` copies it and `init`
-*   adapts + writes it through the overwrite policy.
-* - `patch` — a partial injection into a file the user owns (the root layout's SEO exports). `init`
-*   tries a confident apply, otherwise prints the payload with placement instructions. `create` never
-*   patches — its own template files already carry the wiring.
+* - `own` — a whole file Kizlo writes, adapted to the project's directories and written through the
+*   overwrite policy. `wiring`-scope files (the default) are laid down by both commands; `starter`
+*   demo files are laid down only by `create` (see {@link ownEntries}).
+* - `patch` — a partial injection into a file the framework owns (the root layout's SEO exports).
+*   Both commands try a confident apply, otherwise print the payload with placement instructions.
 */
 const tokensSchema = z.object({
 	kizloDir: z.string(),
@@ -23,7 +25,8 @@ const tokensSchema = z.object({
 const ownSchema = z.object({
 	kind: z.literal("own"),
 	role: z.string(),
-	path: z.string()
+	path: z.string(),
+	scope: z.enum(["wiring", "starter"]).optional()
 });
 const patchSchema = z.object({
 	kind: z.literal("patch"),
@@ -39,9 +42,14 @@ const patchSchema = z.object({
 		value: z.string()
 	}))
 });
+const bootstrapSchema = z.object({
+	initializer: z.string(),
+	flags: z.array(z.string()).default([])
+});
 const manifestSchema = z.object({
 	framework: z.string(),
 	kizloVersion: z.string().optional(),
+	bootstrap: bootstrapSchema.optional(),
 	tokens: tokensSchema,
 	files: z.array(z.discriminatedUnion("kind", [ownSchema, patchSchema]))
 });
@@ -53,7 +61,10 @@ const ROLE_LABELS = {
 	robots: "robots.txt route",
 	sitemap: "sitemap route",
 	"sitemap-redirect": "sitemap.xml redirect route",
-	manifest: "web manifest route"
+	manifest: "web manifest route",
+	"home-page": "home page",
+	"blog-post": "blog post page",
+	styles: "global styles"
 };
 /** Read and validate the template's manifest from a fetched template directory. */
 function readManifest(templateDir) {
@@ -61,8 +72,13 @@ function readManifest(templateDir) {
 	if (!fs.existsSync(manifestPath)) throw new Error(`Template manifest not found at ${manifestPath}`);
 	return manifestSchema.parse(JSON.parse(fs.readFileSync(manifestPath, "utf8")));
 }
-function ownEntries(manifest) {
-	return manifest.files.filter((file) => file.kind === "own");
+/**
+* The `own` files to scaffold. By default only `wiring` files (the Kizlo plumbing) — this is what
+* `init` lays onto an existing project, so it never touches the user's own pages. With
+* `includeStarter`, demo `starter` files are added too, which is what `create` lays onto a fresh app.
+*/
+function ownEntries(manifest, opts = {}) {
+	return manifest.files.filter((file) => file.kind === "own" && (opts.includeStarter || file.scope !== "starter"));
 }
 function patchEntries(manifest) {
 	return manifest.files.filter((file) => file.kind === "patch");

package/dist/cli/utils.js

@@ -2,7 +2,7 @@ import { log } from "./daemon/logger.js";
 import { PortInUseError, resolveHostPort } from "./wp/ports.js";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import fs from "node:fs";
 import * as p from "@clack/prompts";
 
@@ -107,6 +107,31 @@ function detectPackageManager(cwd) {
 	if (fs.existsSync(path.join(cwd, "bun.lockb")) || fs.existsSync(path.join(cwd, "bun.lock"))) return "bun";
 	return "npm";
 }
+/**
+* The package manager that invoked the current process, read from `npm_config_user_agent`
+* (e.g. `pnpm/9.0.0 npm/? node/v20`). Used to pre-select the most likely choice when a fresh
+* project has no lockfile to detect from. Returns undefined when the agent is absent or unknown.
+*/
+function detectInvokingPackageManager() {
+	const name = process.env.npm_config_user_agent?.split("/")[0];
+	return name === "pnpm" || name === "yarn" || name === "bun" || name === "npm" ? name : void 0;
+}
+/**
+* Whether `command` resolves to a runnable executable, probed with `--version`. Used to hide or
+* disable package-manager choices the user can't actually run. A non-zero exit or a spawn error
+* (the binary isn't on PATH) both count as unavailable.
+*/
+function isCommandAvailable(command) {
+	const result = spawnSync(command, ["--version"], {
+		stdio: "ignore",
+		shell: process.platform === "win32"
+	});
+	return !result.error && result.status === 0;
+}
+/** The package managers currently installed on the host, in the given display order. */
+function availablePackageManagers(order) {
+	return order.filter((pm) => isCommandAvailable(pm));
+}
 function addDependencyArgs(pm, pkg) {
 	if (pm === "npm") return [
 		"npm",
@@ -119,14 +144,80 @@ function addDependencyArgs(pm, pkg) {
 		pkg
 	];
 }
-function runCommand(args, cwd, stdio = "inherit") {
+/** The argv to install a project's dependencies with `pm` — every supported manager spells it `<pm> install`. */
+function installArgs(pm) {
+	return [pm, "install"];
+}
+/**
+* The argv to run a framework's `create-*` initializer through a package manager, e.g.
+* `pnpm create next-app@latest my-app --ts …`. The mechanics differ per manager: npm forwards
+* flags to the initializer only after a `--` separator, and `yarn create` resolves the latest
+* version itself so the `@latest` tag is dropped. `flags` are the initializer's own options.
+*/
+function frameworkCreateArgs(pm, initializer, name, flags) {
+	switch (pm) {
+		case "npm": return [
+			"npm",
+			"create",
+			initializer,
+			name,
+			"--",
+			...flags
+		];
+		case "yarn": return [
+			"yarn",
+			"create",
+			initializer.replace(/@latest$/, ""),
+			name,
+			...flags
+		];
+		default: return [
+			pm,
+			"create",
+			initializer,
+			name,
+			...flags
+		];
+	}
+}
+/**
+* Async sibling of {@link runCommand}: runs a command without blocking the event loop, so a clack
+* spinner can keep animating while it works (a synchronous `spawnSync` would freeze it on the first
+* frame). Resolves whether it exited cleanly; a spawn error (binary off PATH) resolves false.
+*/
+function runCommandAsync(args, cwd, stdio = "inherit") {
 	const [command, ...rest] = args;
-	if (!command) return false;
-	return spawnSync(command, rest, {
+	if (!command) return Promise.resolve(false);
+	return new Promise((resolve$1) => {
+		const child = spawn(command, rest, {
+			cwd,
+			stdio,
+			shell: process.platform === "win32"
+		});
+		child.on("error", () => resolve$1(false));
+		child.on("close", (code) => resolve$1(code === 0));
+	});
+}
+/**
+* Run a command capturing its combined output instead of streaming it, for a step that should stay
+* quiet on success but whose logs are worth surfacing when it fails (e.g. the framework's scaffolder
+* behind a spinner). Returns whether it succeeded and the trimmed stdout+stderr.
+*/
+function runCommandCaptured(args, cwd) {
+	const [command, ...rest] = args;
+	if (!command) return {
+		ok: false,
+		output: ""
+	};
+	const result = spawnSync(command, rest, {
 		cwd,
-		stdio,
+		encoding: "utf8",
 		shell: process.platform === "win32"
-	}).status === 0;
+	});
+	return {
+		ok: result.status === 0,
+		output: `${result.stdout ?? ""}${result.stderr ?? ""}`.trim()
+	};
 }
 function writeFileIfAbsent(filePath, contents) {
 	if (fs.existsSync(filePath)) return false;
@@ -263,4 +354,4 @@ function groupDefault(subCommandNames, run) {
 }
 
 //#endregion
-export { addDependencyArgs, detectImportAlias, detectPackageManager, ensureGitignored, envGroups, envKeysPresent, getVersion, groupDefault, loadEnvFiles, mergeEnv, pickStackPort, resolveModuleImport, runCommand, withSpinner, writeFileIfAbsent };
+export { addDependencyArgs, availablePackageManagers, detectImportAlias, detectInvokingPackageManager, detectPackageManager, ensureGitignored, envGroups, envKeysPresent, frameworkCreateArgs, getVersion, groupDefault, installArgs, loadEnvFiles, mergeEnv, pickStackPort, resolveModuleImport, runCommandAsync, runCommandCaptured, withSpinner, writeFileIfAbsent };

package/dist/cli/wp/dev.js

@@ -1,6 +1,6 @@
 import { WordPressService } from "../../wordpress/service.js";
 import { DEFAULT_PLUGINS, TEST_ADMIN } from "./constants.js";
-import { compose, composeUp, wpCli } from "./docker.js";
+import { compose, composePull, composeUp, wpCli } from "./docker.js";
 import { ensurePlugins } from "./utils.js";
 import { createAdminAppPassword, seedUsers } from "./bootstrap.js";
 import { prepareByo } from "./byo.js";
@@ -74,7 +74,9 @@ async function seedDevFixtures(cfg, url) {
 */
 async function bootstrapDev(cfg) {
 	const url = devUrl(cfg.port);
-	const byo = !existsSync(join(cfg.wordpressDir, "wp-includes", "version.php")) && cfg.byo ? await prepareByo(cfg.byo, cfg.wordpressDir, cfg.configDir) : void 0;
+	const fresh = !existsSync(join(cfg.wordpressDir, "wp-includes", "version.php"));
+	const byo = fresh && cfg.byo ? await prepareByo(cfg.byo, cfg.wordpressDir, cfg.configDir) : void 0;
+	if (fresh && !byo) await composePull(["wordpress", "wp-cli"]).catch(() => void 0);
 	await composeUp();
 	const installed = (await compose([
 		"exec",

package/dist/cli/wp/docker.d.ts

@@ -22,6 +22,8 @@ interface Stack {
 /** Stack-bound docker helpers. */
 interface DockerStack {
   compose(args: string[], opts?: RunInput): Promise<RunResult>;
+  /** Pull the latest images for the named services (all when omitted) — refreshes a cached tag like `wordpress:latest`. */
+  composePull(services?: string[]): Promise<RunResult>;
   composeUp(): Promise<void>;
   composeStop(opts?: {
     detached?: boolean;
@@ -48,6 +50,8 @@ declare function dockerAvailable(): Promise<boolean>;
 declare function createStack(stack: Stack): DockerStack;
 /** `docker compose <args>` against the active stack. */
 declare const compose: DockerStack["compose"];
+/** Pull the latest images for the active stack's named services (all when omitted). */
+declare const composePull: (services?: string[]) => Promise<RunResult>;
 /** Bring the active stack's services up detached and wait for health checks. */
 declare const composeUp: () => Promise<void>;
 /** Tear the active stack down, optionally removing volumes. */
@@ -61,4 +65,4 @@ declare const composeStop: (opts?: {
 /** Run a wp-cli command against the active stack's warm `wp-cli` container. */
 declare const wpCli: (args: string[]) => Promise<string>;
 //#endregion
-export { DockerStack, RunResult, Stack, compose, composeDown, composeStop, composeUp, createStack, dockerAvailable, wpCli };
+export { DockerStack, RunResult, Stack, compose, composeDown, composePull, composeStop, composeUp, createStack, dockerAvailable, wpCli };

package/dist/cli/wp/docker.js

@@ -56,6 +56,7 @@ function bind(stack) {
 		WP_PORT: String(stack.port)
 	};
 	const compose$1 = (args, opts) => run("docker", [...base, ...args], env, opts);
+	const composePull$1 = (services = []) => compose$1(["pull", ...services]);
 	const composeUp$1 = async () => {
 		const res = await compose$1([
 			"up",
@@ -93,6 +94,7 @@ function bind(stack) {
 	};
 	return {
 		compose: compose$1,
+		composePull: composePull$1,
 		composeUp: composeUp$1,
 		composeStop: composeStop$1,
 		composeDown: composeDown$1,
@@ -117,6 +119,8 @@ function activeStack() {
 }
 /** `docker compose <args>` against the active stack. */
 const compose = (args, opts) => activeStack().compose(args, opts);
+/** Pull the latest images for the active stack's named services (all when omitted). */
+const composePull = (services) => activeStack().composePull(services);
 /** Bring the active stack's services up detached and wait for health checks. */
 const composeUp = () => activeStack().composeUp();
 /** Tear the active stack down, optionally removing volumes. */
@@ -127,4 +131,4 @@ const composeStop = (opts) => activeStack().composeStop(opts);
 const wpCli = (args) => activeStack().wpCli(args);
 
 //#endregion
-export { compose, composeDown, composeStop, composeUp, createStack, dockerAvailable, wpCli };
+export { compose, composeDown, composePull, composeStop, composeUp, createStack, dockerAvailable, wpCli };

package/dist/package.js

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "0.8.2";
+var version = "0.8.4";
 
 //#endregion
 export { version };

package/dist/router.d.ts

@@ -179,7 +179,7 @@ declare const ROUTER_MAP: {
         include?: string | number | (string | number)[] | undefined;
         offset?: string | number | undefined;
         order?: "asc" | "desc" | undefined;
-        orderby?: "id" | "date" | "slug" | "parent" | "title" | "author" | "include" | "modified" | "relevance" | "include_slugs" | undefined;
+        orderby?: "date" | "id" | "slug" | "parent" | "title" | "author" | "include" | "modified" | "relevance" | "include_slugs" | undefined;
         searchColumns?: ("post_title" | "post_content" | "post_excerpt")[] | undefined;
         slug?: string | string[] | undefined;
         taxRelation?: "AND" | "OR" | undefined;
@@ -507,7 +507,7 @@ declare const ROUTER_MAP: {
         include?: string | number | (string | number)[] | undefined;
         offset?: string | number | undefined;
         order?: "asc" | "desc" | undefined;
-        orderby?: "id" | "date" | "slug" | "parent" | "title" | "author" | "include" | "modified" | "relevance" | "include_slugs" | "menu_order" | undefined;
+        orderby?: "date" | "id" | "slug" | "parent" | "title" | "author" | "include" | "modified" | "relevance" | "include_slugs" | "menu_order" | undefined;
         searchColumns?: ("post_title" | "post_content" | "post_excerpt")[] | undefined;
         slug?: string | string[] | undefined;
         parent?: string | number | (string | number)[] | undefined;
@@ -1186,7 +1186,7 @@ declare const ROUTER_MAP: {
           include?: string | number | (string | number)[] | undefined;
           offset?: string | number | undefined;
           order?: "asc" | "desc" | undefined;
-          orderby?: "id" | "date" | "slug" | "parent" | "title" | "author" | "include" | "relevance" | "include_slugs" | "menu_order" | undefined;
+          orderby?: "date" | "id" | "slug" | "parent" | "title" | "author" | "include" | "relevance" | "include_slugs" | "menu_order" | undefined;
           searchColumns?: ("post_title" | "post_content" | "post_excerpt")[] | undefined;
           slug?: string | string[] | undefined;
           taxRelation?: "AND" | "OR" | undefined;
@@ -1265,7 +1265,7 @@ declare const ROUTER_MAP: {
           include?: string | number | (string | number)[] | undefined;
           offset?: string | number | undefined;
           order?: "asc" | "desc" | undefined;
-          orderby?: "id" | "date" | "slug" | "parent" | "title" | "author" | "include" | "relevance" | "include_slugs" | "menu_order" | undefined;
+          orderby?: "date" | "id" | "slug" | "parent" | "title" | "author" | "include" | "relevance" | "include_slugs" | "menu_order" | undefined;
           searchColumns?: ("post_title" | "post_content" | "post_excerpt")[] | undefined;
           slug?: string | string[] | undefined;
           taxRelation?: "AND" | "OR" | undefined;
@@ -1414,7 +1414,7 @@ declare const ROUTER_MAP: {
         include?: string | number | (string | number)[] | undefined;
         offset?: string | number | undefined;
         order?: "asc" | "desc" | undefined;
-        orderby?: "id" | "date" | "parent" | "post" | "include" | undefined;
+        orderby?: "date" | "id" | "parent" | "post" | "include" | undefined;
         parent?: string | number | (string | number)[] | undefined;
         parentExclude?: string | number | (string | number)[] | undefined;
         post?: string | number | (string | number)[] | undefined;

package/dist/test.d.ts

@@ -1,6 +1,6 @@
 import { DevPluginSource, Fixture, FixtureCleanupFn, FixtureSeedFn, JsonValue, LocalPlugin, PluginSource, SeedContext, TestAdminUser, TestCredentials, TestUser, defineFixture, isLocalPlugin } from "./cli/wp/types.js";
 import { COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, githubRelease, kizloRelease } from "./cli/wp/constants.js";
-import { DockerStack, RunResult, Stack, compose, composeDown, composeStop, composeUp, createStack, dockerAvailable, wpCli } from "./cli/wp/docker.js";
+import { DockerStack, RunResult, Stack, compose, composeDown, composePull, composeStop, composeUp, createStack, dockerAvailable, wpCli } from "./cli/wp/docker.js";
 import { activateLocalPlugin, credentialsPath, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, isSeeded, recordedPort, resolvePluginSource } from "./cli/wp/utils.js";
 import { TestAuthAdapterUser, toTestUser } from "./test/users.js";
 import { testAuthAdapter } from "./test/auth.js";
@@ -10,4 +10,4 @@ import { KizloClientTestInstance, getKizloClientTestInstance } from "./test/clie
 import { menuFixture } from "./menu/fixture.js";
 import { postFixture } from "./post/fixture.js";
 import { coreFixtures } from "./test/fixtures.js";
-export { CAPTCHA_TEST_TOKEN_PASS, COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DevPluginSource, DockerStack, Fixture, FixtureCleanupFn, FixtureSeedFn, JsonValue, KizloClientTestInstance, KizloTestInstance, LocalPlugin, OPCACHE_INI, PluginSource, REMAP_ENTRYPOINT, RunResult, SEED_MARKER_OPTION, SEED_VERSION, SeedContext, Stack, TEST_ADMIN, TEST_USER, TestAdminUser, TestAuthAdapterUser, TestCredentials, TestUser, activateLocalPlugin, captchaMock, compose, composeDown, composeStop, composeUp, coreFixtures, createStack, credentialsPath, defineFixture, dockerAvailable, ensurePlugin, ensurePlugins, findConfigDir, getKizloClientTestInstance, getKizloTestInstance, getTestCredentials, githubRelease, isLocalPlugin, isSeeded, kizloRelease, menuFixture, postFixture, recordedPort, resolvePluginSource, testAuthAdapter, toTestUser, wpCli };
+export { CAPTCHA_TEST_TOKEN_PASS, COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, DevPluginSource, DockerStack, Fixture, FixtureCleanupFn, FixtureSeedFn, JsonValue, KizloClientTestInstance, KizloTestInstance, LocalPlugin, OPCACHE_INI, PluginSource, REMAP_ENTRYPOINT, RunResult, SEED_MARKER_OPTION, SEED_VERSION, SeedContext, Stack, TEST_ADMIN, TEST_USER, TestAdminUser, TestAuthAdapterUser, TestCredentials, TestUser, activateLocalPlugin, captchaMock, compose, composeDown, composePull, composeStop, composeUp, coreFixtures, createStack, credentialsPath, defineFixture, dockerAvailable, ensurePlugin, ensurePlugins, findConfigDir, getKizloClientTestInstance, getKizloTestInstance, getTestCredentials, githubRelease, isLocalPlugin, isSeeded, kizloRelease, menuFixture, postFixture, recordedPort, resolvePluginSource, testAuthAdapter, toTestUser, wpCli };

package/dist/test.js

@@ -1,6 +1,6 @@
 import { defineFixture, isLocalPlugin } from "./cli/wp/types.js";
 import { COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, githubRelease, kizloRelease } from "./cli/wp/constants.js";
-import { compose, composeDown, composeStop, composeUp, createStack, dockerAvailable, wpCli } from "./cli/wp/docker.js";
+import { compose, composeDown, composePull, composeStop, composeUp, createStack, dockerAvailable, wpCli } from "./cli/wp/docker.js";
 import { activateLocalPlugin, credentialsPath, ensurePlugin, ensurePlugins, findConfigDir, getTestCredentials, isSeeded, recordedPort, resolvePluginSource } from "./cli/wp/utils.js";
 import { testAuthAdapter } from "./test/auth.js";
 import { CAPTCHA_TEST_TOKEN_PASS, captchaMock } from "./test/captcha.js";
@@ -11,4 +11,4 @@ import { coreFixtures } from "./test/fixtures.js";
 import { toTestUser } from "./test/users.js";
 import { getKizloTestInstance } from "./test/server.js";
 
-export { CAPTCHA_TEST_TOKEN_PASS, COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, activateLocalPlugin, captchaMock, compose, composeDown, composeStop, composeUp, coreFixtures, createStack, credentialsPath, defineFixture, dockerAvailable, ensurePlugin, ensurePlugins, findConfigDir, getKizloClientTestInstance, getKizloTestInstance, getTestCredentials, githubRelease, isLocalPlugin, isSeeded, kizloRelease, menuFixture, postFixture, recordedPort, resolvePluginSource, testAuthAdapter, toTestUser, wpCli };
+export { CAPTCHA_TEST_TOKEN_PASS, COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER, activateLocalPlugin, captchaMock, compose, composeDown, composePull, composeStop, composeUp, coreFixtures, createStack, credentialsPath, defineFixture, dockerAvailable, ensurePlugin, ensurePlugins, findConfigDir, getKizloClientTestInstance, getKizloTestInstance, getTestCredentials, githubRelease, isLocalPlugin, isSeeded, kizloRelease, menuFixture, postFixture, recordedPort, resolvePluginSource, testAuthAdapter, toTestUser, wpCli };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kizlo",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "type": "module",
   "description": "A headless WordPress framework for TypeScript.",
   "keywords": [