@plitzi/cli 0.37.9 → 0.37.10

package/dist/index.js

@@ -1,21 +1,236 @@
 #!/usr/bin/env node
-import { Option, program } from "commander";
+import { InvalidArgumentError, Option, program } from "commander";
+import fs, { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { builtinModules, createRequire } from "node:module";
+import path, { dirname, join, relative, sep } from "node:path";
+import { pathToFileURL } from "node:url";
 import chalk from "chalk";
-import fs from "node:fs/promises";
+import { execFile, spawn, spawnSync } from "node:child_process";
 import os from "node:os";
-import path, { dirname, join, relative, sep } from "node:path";
-import { spawn, spawnSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import { createServer } from "node:http";
 import tls from "node:tls";
 import readline from "node:readline/promises";
-import { builtinModules, createRequire } from "node:module";
 import { readFileSync, readdirSync, watch } from "node:fs";
-import { actionSpecFromEntry, actionToSource, blankSpaceSource, elementTypeNames } from "@plitzi/sdk-authoring";
-import { pathToFileURL } from "node:url";
+import { EXPLAIN_KINDS, actionSpecFromEntry, actionToSource, authorSpace, blankSpaceSource, catalogTemplateFiles, comparePictures, darkScheme, elementTriggers, elementTypeNames, emptySpaceSource, explain, explainKindOf, explainList, explanationText, failedFlowText, importProbe, importedFiles, inspectDocument, inspectPage, pageRegions, planFixes, readDevTools, refusalOf } from "@plitzi/sdk-authoring";
+import { promisify } from "node:util";
+import { lookup } from "node:dns/promises";
 import { build } from "esbuild";
 import { unzipSync, zipSync } from "fflate";
 import { gzipSync } from "node:zlib";
+//#region ../../packages/sdk-shared/dist/helpers/isRecord.mjs
+var e$1 = (e) => typeof e == "object" && !!e && !Array.isArray(e);
+//#endregion
+//#region src/browser/index.ts
+/**
+* A browser on the project's own Playwright, and the project's own server to point it at — what `plitzi check`,
+* `plitzi shot` and `plitzi import` look at a page with (`import` at a site of the person's, not the project's server).
+*
+* Playwright is the project's: `create` installs it for the visual tests, and a second copy in the CLI would be a
+* second set of browsers to download. It is described here by the little that is used of it, and checked to be that
+* when it loads, so the CLI depends on no driver.
+*/
+var SCHEMES = ["light", "dark"];
+var isChromium = (value) => e$1(value) && typeof value.launch === "function";
+/** A property of an object or of a function, which a module's exports can be either of. */
+var propertyOf = (value, key) => (typeof value === "object" || typeof value === "function") && value !== null ? Reflect.get(value, key) : void 0;
+/** The project's `@playwright/test`'s Chromium, launched — or why there is none. */
+var launchBrowser = async (root) => {
+	let loaded;
+	try {
+		const resolved = createRequire(path.join(root, "package.json")).resolve("@playwright/test");
+		loaded = await import(pathToFileURL(resolved).href);
+	} catch {
+		return { problem: "This project has no @playwright/test installed: npm install -D @playwright/test" };
+	}
+	const chromium = [propertyOf(loaded, "chromium"), propertyOf(propertyOf(loaded, "default"), "chromium")].find(isChromium);
+	if (!isChromium(chromium)) return { problem: "The @playwright/test installed here has no Chromium to launch." };
+	try {
+		return await chromium.launch();
+	} catch (error) {
+		return { problem: `Chromium did not start (${error instanceof Error ? error.message.split("\n")[0] : String(error)}): npx playwright install chromium` };
+	}
+};
+/** What `npm start` wrote down when it took a port: the port, and the name its `/health` answers with. */
+var recorded = async (root) => {
+	try {
+		const value = JSON.parse(await readFile(path.join(root, ".plitzi/dev-server.json"), "utf8"));
+		if (!e$1(value)) return {};
+		return {
+			...typeof value.port === "number" ? { port: value.port } : {},
+			...typeof value.name === "string" ? { name: value.name } : {}
+		};
+	} catch {
+		return {};
+	}
+};
+/**
+* Where the project's server answers: `PORT` when set, the port `npm start` took otherwise, else the mode's default —
+* and, when `npm start` named itself, that what answers there is this project. Something else on the port answers too,
+* with a page and a `200`, and a picture of the wrong server looks like one of the right one.
+*/
+var projectOrigin = async (root, project) => {
+	const server = await recorded(root);
+	const port = Number(process.env.PORT ?? server.port ?? (project?.mode === "client" ? 5173 : 8080));
+	const origin = `http://127.0.0.1:${String(port)}`;
+	if (!server.name) return { origin };
+	const health = await fetch(`${origin}/health`).then((response) => response.json()).catch(() => null);
+	const answered = e$1(health) && typeof health.Server === "string" ? health.Server : "";
+	if (answered !== server.name) return { problem: answered ? `Port ${String(port)} answers as "${answered}", not this project ("${server.name}"). Start it: npm start` : `Nothing of this project answers on port ${String(port)}. Start it: npm start` };
+	return { origin };
+};
+/** A picture as a data URL, which is how a page in the browser is handed one to read. */
+var dataUrl = (png) => `data:image/png;base64,${Buffer.from(png).toString("base64")}`;
+/** A data URL's picture back as bytes, to write to a file. */
+var fromDataUrl = (url) => Buffer.from(url.slice(url.indexOf(",") + 1), "base64");
+//#endregion
+//#region src/commands/terminal.ts
+/**
+* What every command shares with the person running it: whether anybody is there, how a choice is put to them, and
+* what happens when nobody is.
+*/
+/** Why a command stopped, to stderr, and the exit code that says it did. */
+var fail = (problem) => {
+	console.error(chalk.red(problem));
+	process.exitCode = 1;
+};
+/** Somebody who can answer a prompt. An agent's shell, CI and a pipe are nobody, whatever they were asked to do. */
+var atTerminal = () => process.stdin.isTTY && process.stdout.isTTY;
+/**
+* Nobody to ask, so the questions go to whoever ran this — in practice an agent — to put to the person.
+*
+* It offers no way around them. It used to end with "or with --yes to take the defaults", and an agent keen to finish
+* took that exit every time: the person was never asked, which is the whole failure this stop exists to prevent.
+*/
+var refuseWithoutTerminal = (what, questions, stopped = `plitzi create stopped before writing anything: these choices shape the whole ${what}`) => {
+	console.error(chalk.red(`\n${stopped}, they belong to the person it is for, and nobody is at this terminal to make them.`));
+	console.error(chalk.bold("\nIf you are an AI agent: ask the user each question below, show them the options, and wait for their answers. Do not choose for them and do not fall back to a default.\n"));
+	questions.forEach(({ flag, choices, question }, index) => {
+		console.error(`  ${index + 1}. ${question}`);
+		console.error(`     ${flag} ${choices.join(" | ")}`);
+	});
+	const flags = questions.map(({ flag }) => `${flag} <their answer>`).join(" ");
+	console.error(`\nThen run the same command again with their answers: ${flags}`);
+	process.exitCode = 1;
+};
+/** One choice at the terminal: Enter takes the default, anything off the list is refused rather than guessed at. */
+var ask = async (rl, question) => {
+	const reply = (await rl.question(`\n${question.question}\n${question.flag} (${question.choices.join("/")}) [${question.fallback}] > `)).trim();
+	const chosen = question.choices.find((choice) => choice === (reply || question.fallback));
+	if (!chosen) console.error(chalk.red(`"${reply}" is not one of ${question.choices.join(", ")}.`));
+	return chosen;
+};
+/**
+* A free answer at the terminal, with the likely one offered. `check` answers what is wrong with a reply, if anything:
+* a refused reply is said and asked again, since a name or a path is typed rather than picked and a typo is the
+* usual reason for one.
+*/
+var askText = async (rl, question, fallback, check = () => void 0) => {
+	for (;;) {
+		const offered = fallback ? `[${fallback}]` : "(optional)";
+		const reply = (await rl.question(`\n${question}\n${offered} > `)).trim() || fallback;
+		const problem = check(reply);
+		if (!problem) return reply;
+		console.error(chalk.red(problem));
+	}
+};
+/**
+* One of a numbered list, or something else typed out. Enter takes the first entry. `other` is the question for the
+* typed answer, offered as the last number.
+*/
+var askChoice = async (rl, question, options, other) => {
+	const menu = [...options.map((option) => option.label), other.label].map((label, index) => `  ${index + 1}. ${label}`).join("\n");
+	for (;;) {
+		const reply = (await rl.question(`\n${question}\n${menu}\n[1] > `)).trim() || "1";
+		const index = Number(reply) - 1;
+		if (Number.isInteger(index) && index >= 0 && index < options.length) return options[index].value;
+		if (index === options.length) return askText(rl, other.question, other.fallback, other.check);
+		console.error(chalk.red(`"${reply}" is not a number from 1 to ${options.length + 1}.`));
+	}
+};
+/** One of a numbered list and nothing else. Enter takes the first entry. */
+var askPick = async (rl, question, options) => {
+	const menu = options.map(({ label }, index) => `  ${index + 1}. ${label}`).join("\n");
+	for (;;) {
+		const reply = (await rl.question(`\n${question}\n${menu}\n[1] > `)).trim() || "1";
+		const index = Number(reply) - 1;
+		if (Number.isInteger(index) && index >= 0 && index < options.length) return options[index].value;
+		console.error(chalk.red(`"${reply}" is not a number from 1 to ${options.length}.`));
+	}
+};
+/** A directory that does not exist yet is as empty as one can be, which is the answer this question wants. */
+var isEmpty = async (target) => {
+	try {
+		return (await fs.readdir(target)).length === 0;
+	} catch {
+		return true;
+	}
+};
+var isDirectory$1 = async (candidate) => {
+	try {
+		return (await fs.stat(candidate)).isDirectory();
+	} catch {
+		return false;
+	}
+};
+/** The closest directory that already exists: the project's own does not until its files are written. */
+var nearestExisting = async (target) => {
+	let dir = target;
+	while (!await isDirectory$1(dir) && path.dirname(dir) !== dir) dir = path.dirname(dir);
+	return dir;
+};
+/** Every file, by the path under `target` it is written to. */
+var writeFiles = async (target, files) => {
+	await Promise.all(Object.entries(files).map(async ([file, contents]) => {
+		const destination = path.join(target, file);
+		await fs.mkdir(path.dirname(destination), { recursive: true });
+		return fs.writeFile(destination, contents);
+	}));
+};
+/**
+* What a first install is most likely refused over, and what to do about it.
+*
+* The scaffold already exempts what it ships, but not the rest of the tree: a third-party dependency published in
+* the last day is held back by the same age gates, and says so in a code that means nothing to somebody who has
+* not touched the project yet.
+*/
+var INSTALL_HINTS = {
+	npm: "A peer-dependency conflict (ERESOLVE) is a bug in this scaffold: please report it. `npm install --legacy-peer-deps` gets past it meanwhile.",
+	yarn: "YN0016 (\"quarantined\") means a dependency was published less than a day ago. Wait, or add it to `npmPreapprovedPackages` in .yarnrc.yml.",
+	pnpm: "A dependency published too recently is added to `minimumReleaseAgeExclude` in pnpm-workspace.yaml; a skipped build script is approved with `pnpm approve-builds`."
+};
+var install = (manager, cwd) => new Promise((resolve) => {
+	const child = spawn(manager, ["install"], {
+		cwd,
+		stdio: "inherit",
+		shell: process.platform === "win32"
+	});
+	child.on("error", () => resolve(false));
+	child.on("close", (code) => resolve(code === 0));
+});
+/**
+* One of the project's own scripts, run quietly: what it prints is the project's business, and whether it worked is
+* all this needs. `run` is understood by all three managers alike.
+*/
+var runScript = (manager, script, cwd) => new Promise((resolve) => {
+	const child = spawn(manager, ["run", script], {
+		cwd,
+		stdio: "ignore",
+		shell: process.platform === "win32"
+	});
+	child.on("error", () => resolve(false));
+	child.on("close", (code) => resolve(code === 0));
+});
+/**
+* How to get to `target` from here, in whichever form is shorter.
+*
+* A relative path out of a temp directory is six `../` and unreadable; an absolute one to a sibling folder is noise.
+* These lines are meant to be pasted, so they are printed the way somebody would have typed them.
+*/
+var cdPrefix = (target) => {
+	const relative = path.relative(process.cwd(), target);
+	return target === process.cwd() ? "" : `cd ${relative.length < target.length ? relative : target} && `;
+};
 /** `$XDG_CONFIG_HOME/plitzi`, `%APPDATA%\plitzi` on Windows, `~/.config/plitzi` otherwise. */
 var configDir = () => {
 	if (process.env.XDG_CONFIG_HOME) return path.join(process.env.XDG_CONFIG_HOME, "plitzi");
@@ -395,7 +610,7 @@ var spaceOfGrant = async (api, grant) => {
 * A new connection, made in the browser, REPLACING whatever connection there was — another space, another account,
 * another platform. The old grant is revoked rather than left alive in nobody's hands.
 */
-var connect$2 = async (api, { scope, open }) => {
+var connect = async (api, { scope, open }) => {
 	const signedIn = await signInThroughBrowser(api, {
 		scope,
 		open
@@ -518,24 +733,20 @@ var authorizedRequest = async (connection, pathname, init = {}) => {
 };
 //#endregion
 //#region src/commands/account.ts
-/** The address to open, printed as well: over SSH, or with no browser to start, it is opened by hand. */
+/**
+* The address to open, printed as well: over SSH, or with no browser to start, it is opened by hand. To stderr, like
+* every prompt on the way to a command's answer, so `--json` output stays only the answer.
+*/
 var openInBrowser = (url) => {
-	console.log(`\nContinue in your browser. If it did not open, go to:\n  ${chalk.cyan(url)}`);
+	console.error(`\nContinue in your browser. If it did not open, go to:\n  ${chalk.cyan(url)}`);
 	openBrowser(url);
 };
 /** The platform this command talks to, or undefined — said — when `--api` or `PLITZI_API_URL` is not an address. */
 var apiFor = async (options) => {
 	const api = resolveApi(options.api, await readConnection());
-	if (!api) {
-		console.error(chalk.red(`"${options.api ?? process.env.PLITZI_API_URL ?? ""}" is not an address.`));
-		process.exitCode = 1;
-	}
+	if (!api) fail(`"${options.api ?? process.env.PLITZI_API_URL ?? ""}" is not an address.`);
 	return api;
 };
-var fail = (error) => {
-	console.error(chalk.red(error));
-	process.exitCode = 1;
-};
 /** Who the connection signs in as, asked of the platform — which also proves the session still works. */
 var whoIs = async (connection) => {
 	const answered = await authorizedRequest(connection, "/auth/session");
@@ -564,7 +775,7 @@ var login = async (options) => {
 		}
 	}
 	const previous = await readConnection();
-	const connected = await connect$2(api, { open: openInBrowser });
+	const connected = await connect(api, { open: openInBrowser });
 	if (!connected.ok) {
 		fail(connected.error);
 		return;
@@ -595,6 +806,19 @@ var whoami = async (options) => {
 		fail(who.error);
 		return;
 	}
+	if (options.json) {
+		const { space: chosen } = current.value;
+		console.log(JSON.stringify({
+			api,
+			user: who.value,
+			space: chosen ? {
+				id: chosen.id,
+				name: chosen.name,
+				permanentUrl: chosen.permanentUrl
+			} : null
+		}));
+		return;
+	}
 	console.log(`\nSigned in to ${api} as ${chalk.bold(who.value)}.`);
 	console.log(`${spaceLine(current.value)}\n`);
 };
@@ -603,7 +827,7 @@ var whoami = async (options) => {
 * works in one space at a time, and the space it worked in before is no longer reachable from it.
 */
 var chooseSpace = async (api) => {
-	const connected = await connect$2(api, {
+	const connected = await connect(api, {
 		scope: "space",
 		open: openInBrowser
 	});
@@ -635,7 +859,7 @@ var connectionWithSpace = async (api, doing = "to work in") => {
 		return;
 	}
 	if (current.value?.space) return current.value;
-	console.log(current.value ? `\nChoose the space ${doing}.` : `\nSign in, and choose the space ${doing}.`);
+	console.error(current.value ? `\nChoose the space ${doing}.` : `\nSign in, and choose the space ${doing}.`);
 	const chosen = await chooseSpace(api);
 	if (!chosen.ok) {
 		fail(chosen.error);
@@ -651,14 +875,19 @@ var connectionWithSpace = async (api, doing = "to work in") => {
 var signedIn = async (api, doing) => {
 	const current = await currentConnection(api);
 	if (current.ok && current.value) return current.value;
-	console.log(`\nSign in ${doing}.`);
-	const connected = await connect$2(api, { open: openInBrowser });
+	console.error(`\nSign in ${doing}.`);
+	const connected = await connect(api, { open: openInBrowser });
 	if (!connected.ok) {
 		fail(connected.error);
 		return;
 	}
 	return connected.value;
 };
+/** The platform the options name, then the connection to its chosen space: how a command that works in it starts. */
+var connectToSpace = async (options, doing) => {
+	const api = await apiFor(options);
+	return api ? connectionWithSpace(api, doing) : void 0;
+};
 //#endregion
 //#region src/scaffold/client.ts
 /**
@@ -1054,11 +1283,10 @@ to author — and \`YourThing/index.ts\` with an \`export default\`.
 
 ## Three things that bite
 
-**Render \`RootElement\`, not a \`div\`.** It is what makes a plugin an *element*: the id and classes the space
+**Render \`RootElement\`, not a \`div\`.** It is what makes a plugin an _element_: the id and classes the space
 gave it land on what you render, so the CSS authored on the element applies, the builder can select it, and a test
 can find it by name. A plain tag renders the same pixels and none of that.
 
-
 **Do not render anything that differs between the server and the first client render** — a clock, a random number,
 anything read out of \`window\`. React answers a hydration mismatch by discarding the whole tree, so it does not
 break the plugin, it blanks the page. Put live values in an effect.
@@ -1086,8 +1314,10 @@ ${list.length <= 120 ? list : `export const declarations: PluginDeclarationData[
 `;
 };
 var pluginFiles = (answers) => ({
-	"src/plugins/StatCard/StatCard.tsx": component$1(),
-	"src/plugins/StatCard/index.ts": barrel(),
+	...(answers.template ?? "welcome") === "welcome" ? {
+		"src/plugins/StatCard/StatCard.tsx": component$1(),
+		"src/plugins/StatCard/index.ts": barrel()
+	} : {},
 	"src/plugins/README.md": readme$2(answers),
 	...answers.source === "local" ? { "src/plugins/declarations.ts": projectDeclarations([]) } : {}
 });
@@ -1232,6 +1462,7 @@ var dependencies = ({ mode, source }) => ({
 /** A server-mode project runs no bundler of its own: the page server builds the plugins, and Node runs the rest. */
 var devDependencies = ({ mode }) => ({
 	...SHARED_DEV_DEPENDENCIES,
+	"@plitzi/cli": SDK_VERSION,
 	...mode === "server" ? {} : { vite: VITE_VERSION }
 });
 /**
@@ -1274,11 +1505,12 @@ var scripts = ({ mode, source }) => ({
 		preview: "vite preview"
 	},
 	...source === "local" ? { author: "node src/author.ts" } : {},
-	typecheck: "tsc -p tsconfig.json --noEmit",
+	typecheck: "tsc -p tsconfig.json --noEmit --pretty false",
 	lint: "eslint .",
 	format: "prettier --write .",
 	visual: "playwright test",
-	shot: "node scripts/shot.ts"
+	shot: "plitzi shot",
+	check: "plitzi check"
 });
 /**
 * `extra` is what a project made from a space needs besides (`plitzi create --from`): the packages its plugins and
@@ -1341,7 +1573,6 @@ var tsconfig$1 = ({ mode }) => `${JSON.stringify({
 	},
 	include: [
 		"src",
-		"scripts",
 		"visual",
 		"playwright.config.ts",
 		...mode === "client" ? ["vite.config.ts"] : []
@@ -1353,9 +1584,9 @@ var tsconfig$1 = ({ mode }) => `${JSON.stringify({
 */
 var YARN_IGNORES$1 = "\n.yarn/*\n!.yarn/patches\n!.yarn/plugins\n!.yarn/releases\n!.yarn/versions\n";
 /** Where the page server writes the plugin bundles it builds. A build output, and rebuilt whenever it is missing. */
-var SERVER_IGNORES = ".sdk-plugins\n";
+var SERVER_IGNORES = ".sdk-plugins\n.plitzi\n";
 var gitignore$1 = ({ mode, packageManager }) => `node_modules\ndist\n.env\nvisual/.results\nvisual/screenshots\n${mode === "server" ? SERVER_IGNORES : ""}${packageManager === "yarn" ? YARN_IGNORES$1 : ""}`;
-var startLine = ({ mode, packageManager }) => mode === "server" ? `\`${runCommand(packageManager, "start")}\` serves pages on http://127.0.0.1:8080. \`${runCommand(packageManager, "start:dev")}\` restarts on save. In production, \`${runCommand(packageManager, "build")}\` once and run \`${runCommand(packageManager, "start:prod")}\` with \`NODE_ENV=production\`: the compiled server, with no TypeScript in the process.` : `\`${runCommand(packageManager, "start")}\` runs Vite on http://127.0.0.1:5173, with hot module replacement.`;
+var startLine = ({ mode, packageManager }) => mode === "server" ? `\`${runCommand(packageManager, "start")}\` serves pages on http://127.0.0.1:8080 — or, when something else holds 8080, the next free port, which it prints and writes to \`.plitzi/dev-server.json\` (set \`PORT\` to choose one). \`${runCommand(packageManager, "start:dev")}\` restarts on save. In production, \`${runCommand(packageManager, "build")}\` once and run \`${runCommand(packageManager, "start:prod")}\` with \`NODE_ENV=production\`: the compiled server, with no TypeScript in the process.` : `\`${runCommand(packageManager, "start")}\` runs Vite on http://127.0.0.1:5173, with hot module replacement.`;
 var spaceSection = (answers) => {
 	if (answers.source === "cloud") return `## Where the space comes from
 
@@ -1413,10 +1644,14 @@ var agentsFile = (answers) => {
 	const commands = [
 		`| ${code(installCommand(answers.packageManager))} | install |`,
 		`| ${run("start")} | serve it |`,
-		...local ? [`| ${run("author")} | author the space and print its warnings |`] : [],
+		...local ? [`| ${run("author")} | author the space and print its warnings and suggestions |`] : [],
 		`| ${run("visual")} | open the page in a browser and check it rendered |`
 	];
 	const zeroWarnings = local ? `Zero warnings from ${run("author")}.` : "Zero warnings from authoring.";
+	const port = answers.mode === "server" ? `${run("start")} serves on 8080, or on the next free port when something else holds it — printed, and written to ${code(".plitzi/dev-server.json")}, where ${code("check")}, ${code("shot")} and ${code("visual")} read it. ${code("PORT")} chooses one.` : `${run("start")} runs Vite on 5173.`;
+	const pictures = answers.mode === "server" ? `- **Pictures from other sites** are resized by this server once ${code("src/main.ts")} names their hosts — ${code("images: { domains }")} in ${code("createServer")}, a list of hosts like ${code("images.example.com")} — and ${code("sharp")} is installed: an ${code("image")} then offers a ${code("srcset")} (give it ${code("sizes")}, and ${code("width")}/${code("height")} so nothing jumps).\n` : "";
+	const serverData = answers.mode === "server" ? `; one whose ${code("runtime")} is ${code("server")} is read by the server, and the page arrives with it` : "";
+	const generated = [...local ? [`- ${code("space/offline-data.json")} — what ${run("author")} writes out; the space is ${code("src/space.ts")}.`] : [], ...answers.mode === "server" ? [`- ${code(".sdk-plugins/")} and ${code(".plitzi/")} — built and written by the server.`] : []];
 	return `# ${answers.name} — notes for agents
 
 A Plitzi space, rendered ${answers.mode === "server" ? "by the server in this project (SSR + RSC)" : "in the browser by a Vite app"}.
@@ -1428,6 +1663,21 @@ ${where}
 | --- | --- |
 ${commands.join("\n")}
 
+## This project
+
+- **Port.** ${port}
+- **Data with no backend** goes in ${code("public/data/*.json")}, served as it is and read by an ${code("apiContainer")} whose ${code("query")} is ${code("/data/products.json")}${serverData}.
+${pictures}- **Check a page in text first:** ${code(`${runCommand(answers.packageManager, "check")} -- / --width 1440,390`)} says whether every element is on screen, nothing overflows and the console is clean — a picture only when it says something is wrong: ${code(`${runCommand(answers.packageManager, "shot")} -- / --width 390`)} (add ${code("--scheme dark")}; ${code("--frames 4")} to see what moves; ${code("--compare <url>")} against another site, by section). ${run("visual")} runs the checks as tests.
+- **What the page holds, in text:** ${code(`${runCommand(answers.packageManager, "check")} -- /products --state --element <id>`)} adds its state, every source by name and one element (what it reads, its own state, whether it is on screen); every check already lists the flows that failed. Read it instead of guessing from classes in the DOM.
+
+## Do not read
+
+${[
+		...generated,
+		`- A large ${code("public/data/*.json")} — ${code("npx plitzi data describe public/data/<file>.json")} prints its fields, their types and one row.`,
+		`- The bundles in ${code("node_modules/@plitzi/*/dist/*.js")}. ${code("npx plitzi explain <name>")} says what an element, a step or a problem's code is; the ${code(".d.ts")} beside them documents the rest — search it, never read it whole.`
+	].join("\n")}
+
 ## Before anything else
 
 Read ${code(".claude/skills/plitzi-authoring/SKILL.md")} — how a space is written, and the references it links to for
@@ -1437,10 +1687,12 @@ ${code(".claude/skills/plitzi-cli/SKILL.md")} first: ${code("plitzi add plugin")
 
 ## The rules that go wrong most
 
-- Never write schema/style JSON by hand; author it. A refusal names the fix — fix the declaration.
+- Never write schema/style JSON by hand; author it. A refusal names the fix — fix the declaration; ${code("npx plitzi fix --write")} writes the ones with a single reading.
 - ${zeroWarnings}
 - Chrome shared by pages is a layout; a look used twice is a class; a repeated block is a function or a ${code("map")}.
-- Ids are one namespace for the whole space: name what is referred to, prefix ids made by a helper.
+- Ids are one namespace for the whole space: name what is referred to; a helper that runs more than once builds inside ${code("scope()")}.
+- A file per part — the tokens, the layout, each component, each page — short enough to read whole; ${code("src/space.ts")} assembles them. ${code("npx plitzi create <dir> --template catalog")} is a complete example of the shape.
+- Rebuilding a page the user owns: ${code("npx plitzi import <url>")} writes its tokens, outline and lists as a start — then split it into parts and write the content. It reads only a site whose domain the user verified on one of their spaces.
 - Elements are visible by default. One the logic REVEALS starts hidden (${code("visible")}, or ${code("visible: false")} plus a computed binding) so nothing flashes while loading; one a flag HIDES stays shown while the flag is unset.
 - Inside a template a source is spelled in full (${code("apiContainer_stats")}); an attribute only resolves ${code("{{ name|filter }}")}.
 - Colours are tokens with light and dark values; times carry an explicit zone and say it.
@@ -1512,7 +1764,16 @@ var PROJECT_OUTPUTS = [
 	"visual/.results",
 	"visual/screenshots"
 ];
-var prettierignore = (outputs) => `${["node_modules", ...outputs.filter((output) => output !== ".sdk-plugins")].join("\n")}\n`;
+/**
+* What is the agents' and not the project's: the skills copied in, whose recipes are TypeScript no program of the
+* project includes — linted with types, they would stop the lint before its first file.
+*/
+var AGENT_FILES = ".claude";
+var prettierignore = (outputs) => `${[
+	"node_modules",
+	AGENT_FILES,
+	...outputs.filter((output) => output !== ".sdk-plugins")
+].join("\n")}\n`;
 /**
 * Flat config, and only what earns its place.
 *
@@ -1528,7 +1789,7 @@ import tsEslint from 'typescript-eslint';
 import eslintConfigPrettier from 'eslint-config-prettier';
 
 export default tsEslint.config(
-  { ignores: [${outputs.map((output) => `'${output}'`).join(", ")}] },
+  { ignores: [${[AGENT_FILES, ...outputs].map((output) => `'${output}'`).join(", ")}] },
   js.configs.recommended,
   {
     /**
@@ -1608,19 +1869,44 @@ const plugins = Object.fromEntries(
  * no error anywhere, which is a long afternoon.
  */
 const pluginNames = Object.keys(plugins);`;
-var localMain = () => `import { readdirSync } from 'node:fs';
+/**
+* Which port the server takes. `PORT` set: that one, and a clear error if something else has it. Not set, while
+* developing: 8080, or the next free one — so a second project, or anything else on 8080, does not stop this one.
+*/
+var PORT_SNIPPET = `// Loopback unless told otherwise: a container publishes a port only from an address it listens on (\`HOST=0.0.0.0\`).
+const HOST = process.env.HOST ?? '127.0.0.1';
+// \`PORT\` set: that port. Not set, while developing: 8080 or the next free one, written down below for the scripts.
+const PORT = process.env.PORT
+  ? Number(process.env.PORT)
+  : process.env.NODE_ENV === 'production'
+    ? 8080
+    : await freePort(8080, HOST);`;
+/** Where the server says it is: the port it took, for `npm run shot` and the visual tests to find. */
+var LISTEN_SNIPPET = `server.listen(PORT, HOST);
+mkdirSync(path.join(PROJECT_ROOT, '.plitzi'), { recursive: true });
+writeFileSync(
+  path.join(PROJECT_ROOT, '.plitzi/dev-server.json'),
+  \`\${JSON.stringify({ name: SERVER_NAME, port: PORT, url: \`http://127.0.0.1:\${PORT}\` }, null, 2)}\\n\`
+);
+console.log(\`pages on http://127.0.0.1:\${PORT}/\`);`;
+var localMain = () => `import { mkdirSync, readdirSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 
-import { closeOnSignals, consoleLogger, createJsonAdapters, createServer, loadFunctions } from '@plitzi/sdk-server';
+import {
+  closeOnSignals,
+  consoleLogger,
+  createJsonAdapters,
+  createServer,
+  freePort,
+  loadFunctions
+} from '@plitzi/sdk-server';
 
 import { authorSpace } from '@plitzi/sdk-authoring';
 
 import { declarations } from './plugins/declarations.ts';
 import { space } from './space.ts';
 
-const PORT = Number(process.env.PORT ?? 8080);
-// Loopback unless told otherwise: a container publishes a port only from an address it listens on (\`HOST=0.0.0.0\`).
-const HOST = process.env.HOST ?? '127.0.0.1';
+${PORT_SNIPPET}
 
 /**
  * The space, held in this project.
@@ -1653,20 +1939,26 @@ const functions = await loadFunctions(new URL('../functions/', import.meta.url))
  * page server makes. A real deployment swaps this for adapters onto its own database, or for
  * \`createCloudAdapters\` to read the live space out of Plitzi — the server never learns the difference.
  */
+// What \`/health\` answers with, and \`.plitzi/dev-server.json\` records: how a tool knows it reached THIS project.
+const SERVER_NAME = schema.definition.permanentUrl;
 const server = createServer({
   port: PORT,
   devMode: process.env.NODE_ENV !== 'production',
+  health: { name: SERVER_NAME },
   adapters: createJsonAdapters({
     offlineData,
     deployment: { spaceId: 1, environment: 'main', revision: 0, pluginNames }
   }),
   plugins,
+  // \`public/\` served as it is: the data an apiContainer reads (\`/data/home.json\`), images, a favicon.
+  publicDir: path.join(PROJECT_ROOT, 'public'),
   functions: { native: functions },
+  // What went wrong and nothing else: \`npm start -- --verbose\` adds a line for every request.
+  logLevel: process.argv.includes('--verbose') ? 'info' : 'warn',
   logger: consoleLogger
 });
 
-server.listen(PORT, HOST);
-console.log(\`pages on http://127.0.0.1:\${PORT}/\`);
+${LISTEN_SNIPPET}
 
 /**
  * A deploy, a restart or ^C closes the server instead of dropping it: requests in flight are answered, and once the
@@ -1675,14 +1967,19 @@ console.log(\`pages on http://127.0.0.1:\${PORT}/\`);
  */
 closeOnSignals(server);
 `;
-var cloudMain = () => `import { readdirSync } from 'node:fs';
+var cloudMain = (name) => `import { mkdirSync, readdirSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 
-import { closeOnSignals, consoleLogger, createCloudAdapters, createServer, loadFunctions } from '@plitzi/sdk-server';
+import {
+  closeOnSignals,
+  consoleLogger,
+  createCloudAdapters,
+  createServer,
+  freePort,
+  loadFunctions
+} from '@plitzi/sdk-server';
 
-const PORT = Number(process.env.PORT ?? 8080);
-// Loopback unless told otherwise: a container publishes a port only from an address it listens on (\`HOST=0.0.0.0\`).
-const HOST = process.env.HOST ?? '127.0.0.1';
+${PORT_SNIPPET}
 
 ${PLUGINS}
 
@@ -1718,9 +2015,12 @@ const functions = await loadFunctions(new URL('../functions/', import.meta.url))
  * on every request; a published environment with no \`revision\` serves the latest and releases itself; with a
  * \`revision\` it serves exactly that version, for a deployment that rolls forward on its own schedule.
  */
+// What \`/health\` answers with, and \`.plitzi/dev-server.json\` records: how a tool knows it reached THIS project.
+const SERVER_NAME = ${JSON.stringify(name)};
 const server = createServer({
   port: PORT,
   devMode: process.env.NODE_ENV !== 'production',
+  health: { name: SERVER_NAME },
   adapters: createCloudAdapters({
     webKey: HOST_KEY,
     ...(process.env.PLITZI_SERVER_URL ? { serverUrl: process.env.PLITZI_SERVER_URL } : {}),
@@ -1729,12 +2029,15 @@ const server = createServer({
     deployment: { pluginNames }
   }),
   plugins,
+  // \`public/\` served as it is: the data an apiContainer reads (\`/data/home.json\`), images, a favicon.
+  publicDir: path.join(PROJECT_ROOT, 'public'),
   functions: { native: functions },
+  // What went wrong and nothing else: \`npm start -- --verbose\` adds a line for every request.
+  logLevel: process.argv.includes('--verbose') ? 'info' : 'warn',
   logger: consoleLogger
 });
 
-server.listen(PORT, HOST);
-console.log(\`pages on http://127.0.0.1:\${PORT}/\`);
+${LISTEN_SNIPPET}
 
 /**
  * A deploy, a restart or ^C closes the server instead of dropping it: requests in flight are answered, and once the
@@ -1743,7 +2046,10 @@ console.log(\`pages on http://127.0.0.1:\${PORT}/\`);
  */
 closeOnSignals(server);
 `;
-var serverFiles = (answers) => ({ "src/main.ts": answers.source === "cloud" ? cloudMain() : localMain() });
+var serverFiles = (answers) => ({
+	"src/main.ts": answers.source === "cloud" ? cloudMain(answers.name) : localMain(),
+	"public/data/.gitkeep": ""
+});
 //#endregion
 //#region src/scaffold/skills.ts
 /**
@@ -1759,19 +2065,43 @@ var serverFiles = (answers) => ({ "src/main.ts": answers.source === "cloud" ? cl
 * other one Plitzi ships, and it is deliberately left out: it drives the `plitzi_render` MCP tool, so in a project with
 * no MCP connection it would be an instruction to use something that is not there.
 */
-var require = createRequire(import.meta.url);
+var cliRequire = createRequire(import.meta.url);
+var SKILL_NAMES = ["plitzi-authoring", "plitzi-cli"];
+/** The package each skill is published in, and copied from. */
 var SKILLS = {
 	"plitzi-authoring": "@plitzi/sdk-authoring",
 	"plitzi-cli": "@plitzi/cli"
 };
 /**
+* How a package is found: the project's own install first — the SDK it renders with is the one its skill has to match —
+* then this CLI's. `@plitzi/cli` is usually run with npx and installed nowhere in the project, so it falls through.
+*/
+var resolversFor = (root) => root ? [createRequire(join(root, "package.json")), cliRequire] : [cliRequire];
+/**
 * Where a skill file sits, resolved through the package's own export map rather than guessed from a path.
 *
 * `<package>/skills/*` is an export of the packages that ship one, which is what makes this work under Yarn PnP —
 * there is no `node_modules` directory to walk there, and a file the package does not export is unreachable
 * however present it is on disk.
 */
-var skillPath = (packageName, skill) => require.resolve(`${packageName}/skills/${skill}/SKILL.md`);
+var resolveFrom = (resolvers, request) => {
+	for (const resolver of resolvers) try {
+		return resolver.resolve(request);
+	} catch {
+		continue;
+	}
+};
+/** The version of the package a skill came from, written into its frontmatter — `version: 0.38.0`. */
+var versionOf = (resolvers, packageName) => {
+	const manifest = resolveFrom(resolvers, `${packageName}/package.json`);
+	if (!manifest) return;
+	const parsed = JSON.parse(readFileSync(manifest, "utf-8"));
+	return e$1(parsed) && typeof parsed.version === "string" ? parsed.version : void 0;
+};
+/** The frontmatter's `version:`, said once: after the skill's `name:`, replacing any already there. */
+var stampVersion = (skill, version) => skill.replace(/^version: .*\n/m, "").replace(/^(name: .*)$/m, `$1\nversion: ${version}`);
+/** The version a copied `SKILL.md` says it came from. */
+var skillVersion = (skill) => /^version: (.+)$/m.exec(skill)?.[1]?.trim();
 /**
 * Every file under a skill's folder, by its path inside it.
 *
@@ -1779,19 +2109,23 @@ var skillPath = (packageName, skill) => require.resolve(`${packageName}/skills/$
 * sit beside it and are opened when the task needs them. Copying \`SKILL.md\` alone left every one of those links
 * pointing at nothing.
 */
-var filesUnder = (root, folder = root) => readdirSync(folder, { withFileTypes: true }).flatMap((entry) => {
+var filesUnder$1 = (root, folder = root) => readdirSync(folder, { withFileTypes: true }).flatMap((entry) => {
 	const path = join(folder, entry.name);
-	if (entry.isDirectory()) return filesUnder(root, path);
+	if (entry.isDirectory()) return filesUnder$1(root, path);
 	return entry.isFile() ? [[relative(root, path).split(sep).join("/"), readFileSync(path, "utf-8")]] : [];
 });
-/** The skills a project carries: both for a project that renders a space, the CLI's alone for a plugin package. */
-var skillFiles = (names = ["plitzi-authoring", "plitzi-cli"]) => {
+/**
+* The skills a project carries: both for a project that renders a space, the CLI's alone for a plugin package. With
+* `root`, from the packages that project installed — what `plitzi skills update` brings it up to.
+*/
+var skillFiles = (names = SKILL_NAMES, root) => {
+	const resolvers = resolversFor(root);
 	const files = {};
-	for (const name of names) try {
-		const root = dirname(skillPath(SKILLS[name], name));
-		for (const [path, content] of filesUnder(root)) files[`.claude/skills/${name}/${path}`] = content;
-	} catch {
-		continue;
+	for (const name of names) {
+		const entry = resolveFrom(resolvers, `${SKILLS[name]}/skills/${name}/SKILL.md`);
+		if (!entry) continue;
+		const version = versionOf(resolvers, SKILLS[name]);
+		for (const [path, content] of filesUnder$1(dirname(entry))) files[`.claude/skills/${name}/${path}`] = path === "SKILL.md" && version ? stampVersion(content, version) : content;
 	}
 	return files;
 };
@@ -1815,23 +2149,105 @@ var skillFiles = (names = ["plitzi-authoring", "plitzi-cli"]) => {
 * the space has to go somewhere else: imported into Plitzi, handed to another server, or checked into a
 * repository with no TypeScript in it.
 */
-var authorScript = () => `import { mkdirSync, writeFileSync } from 'node:fs';
+var authorScript = () => `import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 
-import { authorSpace } from '@plitzi/sdk-authoring';
+import { authorSpace, planFixes, refusalOf, SpaceRefusedError } from '@plitzi/sdk-authoring';
 
 import { declarations } from './plugins/declarations.ts';
 import { space } from './space.ts';
 
-const { schema, style, warnings } = authorSpace(space, { plugins: declarations });
+// \`--json\` answers in one object, for a tool or an agent; otherwise one line on success, the problems on failure.
+const json = process.argv.includes('--json');
 
-mkdirSync('space', { recursive: true });
-writeFileSync('space/offline-data.json', \`\${JSON.stringify({ schema, style }, null, 2)}\\n\`);
+/** How many of the problems said have one fix \`plitzi fix\` can write in this source — and the line that says so. */
+const fixableHint = (): string | undefined => {
+  let count: number;
+  try {
+    count = planFixes(space, { plugins: declarations }).fixes.length;
+  } catch {
+    return undefined;
+  }
 
-for (const warning of warnings) {
-  console.warn(\`[author] \${warning.message}\`);
-}
+  return count === 0 ? undefined : \`[fix] \${count} of these have one fix: npx plitzi fix shows it in your source, --write writes it\`;
+};
 
-console.log('space/offline-data.json');
+/**
+ * The skill an agent reads was copied from the SDK at one version: a newer SDK has what the older skill never taught.
+ * Both versions, when they differ — \`npx @plitzi/cli skills update\` brings the skill up to the SDK.
+ */
+const outdatedSkill = (): { skill: string; sdk: string } | undefined => {
+  let skill: string | undefined;
+  try {
+    skill = /^version: (.+)$/m.exec(readFileSync('.claude/skills/plitzi-authoring/SKILL.md', 'utf-8'))?.[1]?.trim();
+  } catch {
+    return undefined;
+  }
+
+  const manifest: unknown = JSON.parse(
+    readFileSync(createRequire(import.meta.url).resolve('@plitzi/sdk-authoring/package.json'), 'utf-8')
+  );
+  const sdk =
+    typeof manifest === 'object' && manifest !== null && 'version' in manifest && typeof manifest.version === 'string'
+      ? manifest.version
+      : undefined;
+
+  return skill && sdk && skill !== sdk ? { skill, sdk } : undefined;
+};
+
+try {
+  const { schema, style, warnings, suggestions } = authorSpace(space, { plugins: declarations });
+  mkdirSync('space', { recursive: true });
+  writeFileSync('space/offline-data.json', \`\${JSON.stringify({ schema, style }, null, 2)}\\n\`);
+
+  const outdated = outdatedSkill();
+  if (json) {
+    console.log(
+      JSON.stringify({ ok: true, pages: schema.pages.length, warnings, suggestions, ...(outdated ? { outdated } : {}) })
+    );
+  } else {
+    for (const warning of warnings) {
+      console.warn(\`[author] \${warning.code} · \${warning.message}\`);
+    }
+
+    const hint = warnings.length > 0 ? fixableHint() : undefined;
+    if (hint) {
+      console.warn(hint);
+    }
+
+    // Not problems: a shorter way to the same page, the one that saves the most elements first.
+    for (const suggestion of suggestions) {
+      const at = suggestion.at ? \` · \${suggestion.at}\` : '';
+      console.warn(\`[suggest] \${suggestion.code} · \${suggestion.message} (saves \${suggestion.saves})\${at}\`);
+    }
+
+    if (outdated) {
+      console.warn(
+        \`[skills] the authoring skill is \${outdated.skill} and @plitzi/sdk-authoring is \${outdated.sdk}: npx @plitzi/cli skills update\`
+      );
+    }
+
+    console.log(
+      \`ok · \${schema.pages.length} pages · \${warnings.length} warnings · \${suggestions.length} suggestions · space/offline-data.json\`
+    );
+  }
+} catch (error) {
+  // The message is the whole report — every problem, where it was written and what to change. The stack would only
+  // point inside @plitzi/sdk-authoring.
+  const refusals = error instanceof SpaceRefusedError ? error.refusals : undefined;
+  const message = error instanceof Error ? error.message : String(error);
+  if (json) {
+    console.log(JSON.stringify({ ok: false, refusals: refusals ?? [{ place: '', ...refusalOf(error) }] }));
+  } else {
+    console.error(message);
+    const hint = fixableHint();
+    if (hint) {
+      console.error(hint);
+    }
+  }
+
+  process.exitCode = 1;
+}
 `;
 /** The numbers the example shows: in a data file where one is served, on the element where none is. */
 var STATS = {
@@ -1879,13 +2295,25 @@ var pluginHost = ({ mode }) => mode === "client" ? {
 		...STATS
 	}
 };
-var spaceFiles = (answers) => answers.source === "cloud" ? {} : {
-	"src/space.ts": blankSpaceSource({
-		name: answers.name,
-		plugin: pluginHost(answers)
-	}),
-	"src/author.ts": authorScript(),
-	...answers.mode === "client" ? { "public/data/stats.json": `${JSON.stringify(STATS, null, 2)}\n` } : {}
+var spaceFiles = (answers) => {
+	if (answers.source === "cloud") return {};
+	if (answers.template === "catalog") return {
+		...catalogTemplateFiles({ name: answers.name }),
+		"src/author.ts": authorScript()
+	};
+	if (answers.template === "blank") return {
+		"src/space.ts": emptySpaceSource({ name: answers.name }),
+		"src/author.ts": authorScript(),
+		"public/data/.gitkeep": ""
+	};
+	return {
+		"src/space.ts": blankSpaceSource({
+			name: answers.name,
+			plugin: pluginHost(answers)
+		}),
+		"src/author.ts": authorScript(),
+		...answers.mode === "client" ? { "public/data/stats.json": `${JSON.stringify(STATS, null, 2)}\n` } : {}
+	};
 };
 //#endregion
 //#region src/scaffold/visual.ts
@@ -1896,9 +2324,30 @@ var spaceFiles = (answers) => answers.source === "cloud" ? {} : {
 * a space renders through a stack — schema, style, plugins, hydration — where a mistake shows up as a blank page
 * rather than as an exception, and nobody writes the first test for a project that already looks fine.
 */
-var playwrightConfig$1 = ({ mode, packageManager }) => `import { defineConfig } from '@playwright/test';
-
-const PORT = ${mode === "server" ? "8080" : "5173"};
+var RECORDED = `/** What \`npm start\` wrote down when it took a port: the port, and the name its \`/health\` answers with. */
+const recorded = (): { port?: number; name?: string } => {
+  try {
+    const value: unknown = JSON.parse(readFileSync('.plitzi/dev-server.json', 'utf8'));
+    if (typeof value !== 'object' || value === null) {
+      return {};
+    }
+
+    return {
+      ...('port' in value && typeof value.port === 'number' ? { port: value.port } : {}),
+      ...('name' in value && typeof value.name === 'string' ? { name: value.name } : {})
+    };
+  } catch {
+    return {};
+  }
+};`;
+var playwrightConfig$1 = ({ mode, packageManager }) => `import { readFileSync } from 'node:fs';
+
+import { defineConfig } from '@playwright/test';
+
+${RECORDED}
+
+// \`PORT\` when set; otherwise the port \`npm start\` took; otherwise the default.
+const PORT = Number(process.env.PORT ?? recorded().port ?? ${mode === "server" ? "8080" : "5173"});
 
 export default defineConfig({
   testDir: './visual',
@@ -1909,6 +2358,7 @@ export default defineConfig({
   webServer: {
     command: '${runCommand(packageManager, "start")}',
     url: \`http://127.0.0.1:\${PORT}\`,
+    env: { PORT: String(PORT) },
     reuseExistingServer: true,
     timeout: 120_000
   }
@@ -1974,53 +2424,8 @@ test('renders the space without errors', async ({ page }) => {
   expect(errors).toEqual([]);
 });
 `;
-var shotScript = ({ mode }) => `import { mkdir } from 'node:fs/promises';
-import { dirname } from 'node:path';
-
-import { chromium } from '@playwright/test';
-
-/**
- * A screenshot of one page, to look at a change without writing a test for it.
- *
- *   npm run shot -- /about --width 390 --scheme dark
- *   npm run shot -- / --out shots/home.png --height 900
- *
- * The whole page, not one screen of it. The dev server has to be running (npm start).
- */
-const PORT = ${mode === "server" ? "8080" : "5173"};
-
-const args = process.argv.slice(2);
-const option = (name: string, fallback: string): string => {
-  const index = args.indexOf('--' + name);
-
-  return index === -1 ? fallback : (args[index + 1] ?? fallback);
-};
-
-const path = args.find(arg => arg.startsWith('/')) ?? '/';
-const width = Number(option('width', '1280'));
-const height = Number(option('height', '800'));
-const scheme = option('scheme', 'light') === 'dark' ? 'dark' : 'light';
-const name = path === '/' ? 'home' : path.replace(/[^a-z0-9]+/gi, '-').replace(/^-|-$/g, '');
-const out = option('out', 'visual/.shots/' + name + '-' + width + '-' + scheme + '.png');
-
-const browser = await chromium.launch();
-try {
-  const page = await browser.newPage({ viewport: { width, height }, colorScheme: scheme });
-  const response = await page.goto('http://127.0.0.1:' + PORT + path, { waitUntil: 'networkidle' }).catch(() => null);
-  if (!response) {
-    throw new Error('Nothing answers on port ' + PORT + '. Start the project first: npm start');
-  }
-
-  await mkdir(dirname(out), { recursive: true });
-  await page.screenshot({ path: out, fullPage: true });
-  console.log(out);
-} finally {
-  await browser.close();
-}
-`;
 var visualFiles$1 = (answers) => ({
 	"playwright.config.ts": playwrightConfig$1(answers),
-	"scripts/shot.ts": shotScript(answers),
 	"visual/home.spec.ts": answers.source === "local" ? authoredSpec() : documentSpec()
 });
 //#endregion
@@ -2251,7 +2656,7 @@ var packageJson = ({ packageName, base }, { packageManager, owner }) => `${JSON.
 	},
 	scripts: {
 		start: "vite",
-		typecheck: "tsc -p tsconfig.json --noEmit",
+		typecheck: "tsc -p tsconfig.json --noEmit --pretty false",
 		lint: "eslint .",
 		format: "prettier --write .",
 		visual: "playwright test"
@@ -2435,6 +2840,497 @@ var previewFiles = ([main, ...others]) => ({
 	})
 });
 //#endregion
+//#region ../../packages/sdk-shared/dist/helpers/scroll.mjs
+var e = ["smooth", "auto"];
+var t = [
+	"start",
+	"center",
+	"end",
+	"nearest"
+];
+//#endregion
+//#region ../../packages/sdk-shared/dist/authoring/elementCallbacks.mjs
+var r$2 = {
+	type: "select",
+	description: "How it moves: \"smooth\" glides there, \"auto\" jumps.",
+	default: "smooth",
+	options: [...e]
+};
+var a$1 = {
+	setState: {
+		title: "Update Element (set attribute / state)",
+		type: "callback",
+		strictParams: !0,
+		params: {
+			category: {
+				type: "select",
+				description: "What to change on the element: \"attribute\" sets one of its props (the common case — e.g. content, disabled); \"state\" sets element state (visibility or a style selector). REQUIRED — always set it.",
+				default: "attribute",
+				options: ["attribute", "state"],
+				required: !0
+			},
+			key: {
+				type: "text",
+				description: "The field to set. When category=\"attribute\", an attribute/prop key of THIS element (e.g. \"content\", \"disabled\"). When category=\"state\", \"visibility\" or \"styleSelectors.<selector>\". REQUIRED.",
+				required: !0
+			},
+			value: {
+				type: "scalar",
+				description: "The value to set — its type follows the target attribute: a real boolean (true/false) for a boolean attribute, a number for a numeric one, otherwise a string (the strings \"true\"/\"false\" also coerce). There is NO separate `type` param (that belongs to the global state setState, not this one). REQUIRED.",
+				when: (e) => !!e.category,
+				required: !0
+			},
+			revertOnFinish: {
+				type: "boolean",
+				description: "When true, this change is UNDONE automatically when the whole flow finishes. Use it for a TEMPORARY change (a \"loading…\" label, disabling a button while it works) instead of adding manual restore steps at the end of the flow.",
+				default: !1,
+				label: "Revert changes after interaction"
+			}
+		}
+	},
+	toggleState: {
+		title: "Toggle Element (flip attribute / state)",
+		type: "callback",
+		strictParams: !0,
+		params: {
+			category: {
+				type: "select",
+				description: "What to flip on the element: \"attribute\" flips one of its props (e.g. disabled); \"state\" flips element state (\"visibility\", or \"styleSelectors.<selector>\" for an expanded/collapsed look). REQUIRED.",
+				default: "state",
+				options: ["attribute", "state"],
+				required: !0
+			},
+			key: {
+				type: "text",
+				description: "The field to flip. When category=\"attribute\", an attribute/prop key of THIS element. When category=\"state\", \"visibility\" or \"styleSelectors.<selector>\". Anything not already true counts as false, so a field that has never been set flips ON first. REQUIRED.",
+				required: !0
+			},
+			revertOnFinish: {
+				type: "boolean",
+				description: "When true, the flip is UNDONE automatically when the whole flow finishes — a change that lasts only as long as the flow does.",
+				default: !1,
+				label: "Revert changes after interaction"
+			}
+		}
+	},
+	scrollBy: {
+		title: "Scroll By",
+		type: "callback",
+		strictParams: !0,
+		params: {
+			x: {
+				type: "text",
+				description: "How far across: pixels (\"240\") or a share of what the box shows (\"80%\"); negative goes back.",
+				default: ""
+			},
+			y: {
+				type: "text",
+				description: "How far down, the same way; negative goes up.",
+				default: ""
+			},
+			behavior: r$2
+		}
+	},
+	scrollTo: {
+		title: "Scroll To",
+		type: "callback",
+		strictParams: !0,
+		params: {
+			x: {
+				type: "text",
+				description: "Where across: \"start\", \"end\", pixels from the start, or a share of the way (\"50%\"). Empty stays.",
+				default: ""
+			},
+			y: {
+				type: "text",
+				description: "Where down, the same way. Empty stays.",
+				default: ""
+			},
+			behavior: r$2
+		}
+	},
+	scrollIntoView: {
+		title: "Scroll Into View",
+		type: "callback",
+		strictParams: !0,
+		params: {
+			block: {
+				type: "select",
+				description: "Where the element lands, top to bottom.",
+				default: "start",
+				options: [...t]
+			},
+			inline: {
+				type: "select",
+				description: "Where it lands, side to side.",
+				default: "nearest",
+				options: [...t]
+			},
+			behavior: r$2
+		}
+	}
+};
+//#endregion
+//#region src/scaffold/pluginPackage/shape.ts
+/**
+* An element written in its final shape, from what `plitzi add plugin` was told: its props with their types and
+* defaults, the events it fires and what each hands a flow, the actions it answers to, and whether it draws anything.
+*
+* The counter `add plugin` writes without them shows the three ways an element talks to a space, and is rewritten on
+* day one; told the shape, it writes that shape — four files with nothing to delete.
+*/
+var PROP_TYPES = [
+	"string",
+	"number",
+	"boolean"
+];
+var IDENTIFIER = /^[a-z][A-Za-z0-9]*$/;
+var EVENT = /^on[A-Z][A-Za-z0-9]*$/;
+/** What the runtime hands every element already, so a prop of that name would never be the author's. */
+var RESERVED_PROPS = [
+	"className",
+	"children",
+	"ref",
+	"key",
+	"id",
+	"style"
+];
+var parseProp = (flag) => {
+	const match = /^([^:=]+):([^=]+)(?:=(.*))?$/.exec(flag);
+	if (!match) return `--prop ${flag}: write it name:type or name:type=default — interval:number=5000, paused:boolean, label:string=Hi.`;
+	const [, name, type] = match;
+	const given = match.at(3);
+	if (!IDENTIFIER.test(name) || RESERVED_PROPS.includes(name)) return `--prop ${flag}: "${name}" is not a prop name of its own — camelCase, starting with a lowercase letter, and none of ${RESERVED_PROPS.join(", ")}.`;
+	const propType = PROP_TYPES.find((candidate) => candidate === type);
+	if (!propType) return `--prop ${flag}: the type is ${PROP_TYPES.join(", ")}, not "${type}".`;
+	if (propType === "number") {
+		const value = given === void 0 ? 0 : Number(given);
+		return Number.isFinite(value) && given !== "" ? {
+			name,
+			type: propType,
+			value
+		} : `--prop ${flag}: "${given ?? ""}" is not a number.`;
+	}
+	if (propType === "boolean") {
+		if (given !== void 0 && given !== "true" && given !== "false") return `--prop ${flag}: a boolean's default is true or false, not "${given}".`;
+		return {
+			name,
+			type: propType,
+			value: given === "true"
+		};
+	}
+	return {
+		name,
+		type: propType,
+		value: given ?? ""
+	};
+};
+var parseTrigger = (flag) => {
+	const [name, ...rest] = flag.split(":");
+	const fields = rest.join(":").split(",").map((field) => field.trim()).filter(Boolean);
+	if (!EVENT.test(name)) return `--trigger ${flag}: an event is named on + what happened, in camelCase — onTick, onPick.`;
+	if (Object.hasOwn(elementTriggers, "custom") && elementTriggers.custom.includes(name)) return `--trigger ${flag}: every element already fires "${name}"; name the event after what this one does.`;
+	const wrong = fields.find((field) => !IDENTIFIER.test(field));
+	return wrong ? `--trigger ${flag}: "${wrong}" is not a field name — camelCase, starting with a lowercase letter.` : {
+		name,
+		fields
+	};
+};
+var parseCallback = (name) => {
+	if (!IDENTIFIER.test(name)) return { problem: `--callback ${name}: an action is named in camelCase, starting with a lowercase letter — reset, play.` };
+	return Object.hasOwn(a$1, name) ? { problem: `--callback ${name}: every element already answers to "${name}"; name the action after what this one does.` } : name;
+};
+var repeated = (names) => names.find((name, index) => names.indexOf(name) !== index);
+/**
+* The shape the flags describe — `undefined` when none was given, which keeps the example — or the first thing wrong
+* with them, said so it can be fixed in one go.
+*/
+var shapeFromFlags = (flags) => {
+	if (!([
+		flags.prop,
+		flags.trigger,
+		flags.callback
+	].some((list) => list && list.length > 0) || flags.headless)) return {};
+	const props = [];
+	for (const flag of flags.prop ?? []) {
+		const prop = parseProp(flag);
+		if (typeof prop === "string") return { problem: prop };
+		props.push(prop);
+	}
+	const triggers = [];
+	for (const flag of flags.trigger ?? []) {
+		const trigger = parseTrigger(flag);
+		if (typeof trigger === "string") return { problem: trigger };
+		triggers.push(trigger);
+	}
+	const callbacks = [];
+	for (const flag of flags.callback ?? []) {
+		const callback = parseCallback(flag);
+		if (typeof callback !== "string") return { problem: callback.problem };
+		callbacks.push(callback);
+	}
+	const twice = repeated([
+		...props.map((prop) => prop.name),
+		...triggers.map((trigger) => trigger.name),
+		...callbacks
+	]);
+	if (twice) return { problem: `"${twice}" is named twice: a prop, an event and an action each need a name of their own.` };
+	return { shape: {
+		props,
+		triggers,
+		callbacks,
+		headless: flags.headless === true
+	} };
+};
+/** `onTick` → `On Tick`, `pausedOnHover` → `Paused On Hover`: what the builder shows for a name. */
+var titleOf = (name) => {
+	const words = name.replace(/([a-z0-9])([A-Z])/g, "$1 $2");
+	return `${words.charAt(0).toUpperCase()}${words.slice(1)}`;
+};
+var literal = (value) => typeof value === "string" ? tsString(value) : String(value);
+var shapedDeclaration = ({ component: name, type }, { title, description, owner }, shape) => `import type { ${name}Props } from './${name}';
+import type { PluginDeclaration } from '@plitzi/plitzi-sdk';
+
+/** What this element can be authored with — its component's own props, minus what the runtime supplies. */
+export type ${name}Attributes = Omit<${name}Props, 'className'>;
+
+/**
+ * Static declaration for ${name}: its type, the events it fires and the actions it answers to, and the element the
+ * builder adds when somebody drops it on a page. Data only, no React — the build reads it to write the manifest.
+ */
+const declaration = {
+  /** What a space names it by: the \`renderType\` of the \`custom\` element that hosts it. Renaming it orphans every one. */
+  type: '${type}',
+  /** The events it fires; \`preview\` names what a flow started by one reads — shown in the builder, never sent. */
+  triggers: {${shape.triggers.map((trigger) => `
+    ${trigger.name}: {
+      action: '${trigger.name}',
+      title: ${tsString(titleOf(trigger.name))},
+      type: 'trigger',
+      params: {},
+      preview: { ${trigger.fields.map((field) => `${field}: ''`).join(", ")} }
+    }`).join(",")}${shape.triggers.length > 0 ? "\n  " : ""}},
+  /** The actions it answers to, static half: the component adds the function that does each. */
+  callbacks: {${shape.callbacks.map((callback) => `
+    ${callback}: { action: '${callback}', title: ${tsString(titleOf(callback))}, type: 'callback', params: {} }`).join(",")}${shape.callbacks.length > 0 ? "\n  " : ""}},
+  content: {
+    /** The starting attributes — the component's defaults, written where the builder can show them. */
+    attributes: { ${shape.props.map((prop) => `${prop.name}: ${literal(prop.value)}`).join(", ")} },
+    definition: {
+      label: ${tsString(title)},
+      type: '${type}',
+      /** What it is for: the builder shows it, and an agent connected over MCP reads it to choose the element. */
+      description: ${tsString(description)},
+      items: [],
+      bindings: {},
+      styleSelectors: { base: '' },
+      initialState: { visibility: true }
+    },
+    builder: {
+      canDelete: true,
+      canSelect: true,
+      canDragDrop: true,
+      canMove: true,
+      canSnippet: true,
+      itemsAllowed: [],
+      itemsNotAllowed: []
+    },
+    market: {
+      category: ${tsString(title)},
+      owner: ${tsString(owner)},
+      license: 'MIT',
+      website: '',
+      backgroundColor: '#4422ee',
+      icon: ''
+    },
+    defaultStyle: {
+      name: ${tsString(title)},
+      displayMode: 'desktop',
+      style: { base: { default: {} } },
+      /** The attributes a data source may be pointed at — what the builder offers when somebody connects data to it. */
+      bindingsAllowed: {
+        attributes: [${shape.props.map((prop) => `{ path: '${prop.name}', label: ${tsString(titleOf(prop.name))} }`).join(", ")}],
+        initialState: []
+      }
+    },
+    settings: {}
+  }
+} satisfies PluginDeclaration<${name}Attributes>;
+
+export default declaration;
+`;
+var eventsSource = (name, triggers) => triggers.length === 0 ? "" : `
+/** What a flow started by each event reads — \`{{ <step>.${triggers[0].fields[0] ?? "field"} }}\`. */
+export type ${name}Events = {
+${triggers.map((trigger) => `  ${trigger.name}: ${trigger.fields.length > 0 ? `{ ${trigger.fields.map((field) => `${field}: unknown`).join("; ")} }` : "Record<string, never>"};`).join("\n")}
+};
+
+/**
+ * Fires one of the element's events: \`fire('${triggers[0].name}', { ${triggers[0].fields.map((field) => `${field}: …`).join(", ")} })\`. A flow on that event
+ * runs, and reads what it was handed.
+ */
+export const use${name}Events = () => {
+  const { id } = useElement();
+  const {
+    contexts: { InteractionsContext }
+  } = usePlitziServiceContext();
+  const { interactionsManager } = use(InteractionsContext);
+
+  return useCallback(
+    <Event extends keyof ${name}Events>(event: Event, payload: ${name}Events[Event]) => {
+      void interactionsManager.interactionTrigger(id, event, payload);
+    },
+    [interactionsManager, id]
+  );
+};
+`;
+var callbacksSource = (callbacks) => callbacks.length === 0 ? "" : `
+  /** The declared actions, with what only a mounted element has: the function that does each. */
+  const interactionCallbacks = useMemo<Record<string, InteractionCallback>>(
+    () => ({${callbacks.map((callback) => `
+      ${callback}: {
+        ...declaration.callbacks.${callback},
+        callback: () => {
+          // What \`${callback}\` does when a flow calls it.
+        }
+      }`).join(",")}
+    }),
+    []
+  );
+`;
+var shapedComponent = ({ component: name, title }, shape) => {
+	const { props, triggers, callbacks, headless } = shape;
+	const reactImports = [...triggers.length > 0 ? ["use", "useCallback"] : [], ...callbacks.length > 0 ? ["useMemo"] : []];
+	const sdkImports = [
+		"RootElement",
+		...triggers.length > 0 ? ["useElement"] : [],
+		...triggers.length > 0 || headless ? ["usePlitziServiceContext"] : []
+	];
+	const imports = [
+		...reactImports.length > 0 ? [`import { ${reactImports.join(", ")} } from 'react';`, ""] : [],
+		`import { ${sdkImports.join(", ")} } from '@plitzi/plitzi-sdk';`,
+		"",
+		"import declaration from './declaration';",
+		"",
+		...callbacks.length > 0 ? ["import type { InteractionCallback } from '@plitzi/plitzi-sdk';"] : [],
+		"import type { CSSProperties } from 'react';"
+	];
+	const params = [...props.map((prop) => `${prop.name} = ${literal(prop.value)}`), "className"].join(", ");
+	const rootProps = [
+		"className={className}",
+		"style={style}",
+		...triggers.length > 0 ? ["interactionTriggers={declaration.triggers}"] : [],
+		...callbacks.length > 0 ? ["interactionCallbacks={interactionCallbacks}"] : []
+	];
+	const shown = (line) => headless ? `{!previewMode && ${line}}` : line;
+	const body = [shown(`<span style={LABEL}>${title}</span>`), ...props.map((prop) => shown(`<span>${titleOf(prop.name)}: {String(${prop.name})}</span>`))].map((line) => `      ${line}`).join("\n");
+	const look = headless ? `
+  const {
+    settings: { previewMode }
+  } = usePlitziServiceContext();
+  const style = previewMode ? HIDDEN : BADGE;
+` : `
+  const style = CARD;
+`;
+	const styles = headless ? `const HIDDEN: CSSProperties = { display: 'none' };
+
+/** In the builder: small, and in the colours of whatever page it is on. */
+const BADGE: CSSProperties = {
+  display: 'inline-flex',
+  gap: '8px',
+  padding: '4px 10px',
+  borderRadius: '999px',
+  fontSize: '12px',
+  border: '1px dashed color-mix(in srgb, currentColor 35%, transparent)'
+};` : `/** Colours borrowed rather than chosen: a plugin does not know the palette of the page it is dropped on. */
+const CARD: CSSProperties = {
+  display: 'inline-flex',
+  flexDirection: 'column',
+  gap: '4px',
+  padding: '12px 16px',
+  borderRadius: '12px',
+  border: '1px solid color-mix(in srgb, currentColor 15%, transparent)'
+};`;
+	return `${imports.join("\n")}
+
+/**
+ * The props ARE the element's attributes: whatever a space writes on the element arrives here by the same name, and so
+ * does whatever a binding writes later. Everything is optional with a default — an attribute nobody has authored yet,
+ * or a binding whose source has not answered, is \`undefined\`.
+ */
+export interface ${name}Props {
+${props.map((prop) => `  ${prop.name}?: ${prop.type};\n`).join("")}  /** Supplied by the runtime, not authored: the classes the element's own style rules are written against. */
+  className?: string;
+}
+${eventsSource(name, triggers)}
+/**
+ * ${headless ? "Nothing to see on a page: it is there for what it does. In the builder it shows as a badge with its attributes, so it can be selected; on a page it renders hidden — still an element, so its events and actions are its own." : "What it draws — for now its attributes, to be replaced by what it is. Deterministic on its first render (the same markup on a server and in the browser); anything live goes in an effect."}
+ */
+const ${name} = ({ ${params} }: ${name}Props) => {${look}${callbacksSource(callbacks)}
+  return (
+    <RootElement
+${rootProps.map((prop) => `      ${prop}`).join("\n")}
+    >
+${body}
+    </RootElement>
+  );
+};
+
+${styles}
+
+const LABEL: CSSProperties = { fontSize: '12px', opacity: 0.65 };
+
+export default ${name};
+`;
+};
+var settingsControl = (prop) => {
+	const label = titleOf(prop.name);
+	if (prop.type === "boolean") return `    <label style={FIELD}>
+      <input type="checkbox" checked={${prop.name}} onChange={event => onUpdate?.('${prop.name}', event.target.checked)} />
+      ${label}
+    </label>`;
+	return `    <label style={FIELD}>
+      ${label}
+      <input style={INPUT} ${prop.type === "number" ? `type="number" value={${prop.name}} onChange={event => onUpdate?.('${prop.name}', Number(event.target.value))}` : `value={${prop.name}} onChange={event => onUpdate?.('${prop.name}', event.target.value)}`} />
+    </label>`;
+};
+var shapedSettings = ({ component: name }, shape) => {
+	const { props } = shape;
+	const typed = props.some((prop) => prop.type !== "boolean");
+	return `import type { ${name}Attributes } from './declaration';
+import type { CSSProperties } from 'react';
+
+/**
+ * The builder's panel for the element: one control per attribute, writing back through \`onUpdate\` the attributes the
+ * component reads. Only the builder loads it.
+ */
+export type SettingsProps = ${name}Attributes & {
+  onUpdate?: (attribute: string, value: string | number | boolean) => void;
+};
+
+${props.length === 0 ? "const Settings = () => <div style={PANEL}>It has no attributes to set.</div>;" : `const Settings = ({ ${[...props.map((prop) => `${prop.name} = ${literal(prop.value)}`), "onUpdate"].join(", ")} }: SettingsProps) => (
+  <div style={PANEL}>
+${props.map(settingsControl).join("\n")}
+  </div>
+);`}
+
+const PANEL: CSSProperties = { display: 'flex', flexDirection: 'column', gap: '12px', padding: '8px 0' };
+${props.length > 0 ? `
+const FIELD: CSSProperties = { display: 'flex', flexDirection: 'column', gap: '4px', fontSize: '12px' };
+` : ""}${typed ? `
+const INPUT: CSSProperties = {
+  font: 'inherit',
+  color: 'inherit',
+  padding: '6px 8px',
+  borderRadius: '6px',
+  border: '1px solid color-mix(in srgb, currentColor 25%, transparent)',
+  background: 'transparent'
+};
+` : ""}
+export default Settings;
+`;
+};
+//#endregion
 //#region src/scaffold/pluginPackage/source.ts
 var declarationFile = ({ component: name, type }, { title, description, owner }) => `import type { ${name}Props } from './${name}';
 import type { PluginDeclaration } from '@plitzi/plitzi-sdk';
@@ -2476,7 +3372,7 @@ const declaration = {
       canSelect: true,
       canDragDrop: true,
       canMove: true,
-      canTemplate: true,
+      canSnippet: true,
       itemsAllowed: [],
       itemsNotAllowed: []
     },
@@ -2758,10 +3654,10 @@ export { elements };
 export default main;
 `;
 /** The element alone: its folder's files, by their path inside it. */
-var elementFiles = (names, text) => ({
-	[`${names.component}.tsx`]: component(names),
-	"declaration.ts": declarationFile(names, text),
-	"Settings.tsx": settings(names),
+var elementFiles = (names, text, shape) => ({
+	[`${names.component}.tsx`]: shape ? shapedComponent(names, shape) : component(names),
+	"declaration.ts": shape ? shapedDeclaration(names, text, shape) : declarationFile(names, text),
+	"Settings.tsx": shape ? shapedSettings(names, shape) : settings(names),
 	"index.ts": elementIndex(names)
 });
 /** Every element of a plugin package in its own folder, the two lists that gather them, and the entry. */
@@ -2889,10 +3785,17 @@ var scaffoldPlugin = (answers) => {
 * One element, for a folder of a project that already exists: paths relative to the element's own folder. `title` is
 * the label it renders until an attribute says otherwise.
 */
-var scaffoldElement = (name, text) => elementFiles({
+var scaffoldElement = (name, text, shape) => elementFiles({
 	...pluginNames(name),
 	title: text.title
-}, text);
+}, text, shape);
+//#endregion
+//#region src/scaffold/types.ts
+var CREATE_TEMPLATES = [
+	"welcome",
+	"blank",
+	"catalog"
+];
 //#endregion
 //#region src/scaffold/index.ts
 /**
@@ -3043,144 +3946,49 @@ var findProject = async (from) => {
 };
 /** Whether `dir` is one of the workspace's packages — a folder its globs cover — so an install there installs it. */
 var coveredByWorkspace = (project, dir) => project.workspaceRoot !== void 0 && project.workspaceFolders.some((folder) => path.dirname(dir) === path.join(project.workspaceRoot ?? "", folder));
-//#endregion
-//#region src/commands/terminal.ts
-/** Somebody who can answer a prompt. An agent's shell, CI and a pipe are nobody, whatever they were asked to do. */
-var atTerminal = () => process.stdin.isTTY && process.stdout.isTTY;
-/**
-* Nobody to ask, so the questions go to whoever ran this — in practice an agent — to put to the person.
-*
-* It offers no way around them. It used to end with "or with --yes to take the defaults", and an agent keen to finish
-* took that exit every time: the person was never asked, which is the whole failure this stop exists to prevent.
-*/
-var refuseWithoutTerminal = (what, questions, stopped = `plitzi create stopped before writing anything: these choices shape the whole ${what}`) => {
-	console.error(chalk.red(`\n${stopped}, they belong to the person it is for, and nobody is at this terminal to make them.`));
-	console.error(chalk.bold("\nIf you are an AI agent: ask the user each question below, show them the options, and wait for their answers. Do not choose for them and do not fall back to a default.\n"));
-	questions.forEach(({ flag, choices, question }, index) => {
-		console.error(`  ${index + 1}. ${question}`);
-		console.error(`     ${flag} ${choices.join(" | ")}`);
-	});
-	const flags = questions.map(({ flag }) => `${flag} <their answer>`).join(" ");
-	console.error(`\nThen run the same command again with their answers: ${flags}`);
-	process.exitCode = 1;
-};
-/** One choice at the terminal: Enter takes the default, anything off the list is refused rather than guessed at. */
-var ask = async (rl, question) => {
-	const reply = (await rl.question(`\n${question.question}\n${question.flag} (${question.choices.join("/")}) [${question.fallback}] > `)).trim();
-	const chosen = question.choices.find((choice) => choice === (reply || question.fallback));
-	if (!chosen) console.error(chalk.red(`"${reply}" is not one of ${question.choices.join(", ")}.`));
-	return chosen;
-};
 /**
-* A free answer at the terminal, with the likely one offered. `check` answers what is wrong with a reply, if anything:
-* a refused reply is said and asked again, since a name or a path is typed rather than picked and a typo is the
-* usual reason for one.
+* The project the command runs in, or `undefined` — said — when there is none: every command that works on a project
+* refuses outside one rather than writing into whatever folder it was run from. `what` ends the sentence: "whose page
+* to check".
 */
-var askText = async (rl, question, fallback, check = () => void 0) => {
-	for (;;) {
-		const offered = fallback ? `[${fallback}]` : "(optional)";
-		const reply = (await rl.question(`\n${question}\n${offered} > `)).trim() || fallback;
-		const problem = check(reply);
-		if (!problem) return reply;
-		console.error(chalk.red(problem));
-	}
+var projectHere = async (what) => {
+	const project = await findProject(process.cwd());
+	if (!project) fail(`There is no package.json here or above: run this in the project ${what}.`);
+	return project;
 };
-/**
-* One of a numbered list, or something else typed out. Enter takes the first entry. `other` is the question for the
-* typed answer, offered as the last number.
-*/
-var askChoice = async (rl, question, options, other) => {
-	const menu = [...options.map((option) => option.label), other.label].map((label, index) => `  ${index + 1}. ${label}`).join("\n");
-	for (;;) {
-		const reply = (await rl.question(`\n${question}\n${menu}\n[1] > `)).trim() || "1";
-		const index = Number(reply) - 1;
-		if (Number.isInteger(index) && index >= 0 && index < options.length) return options[index].value;
-		if (index === options.length) return askText(rl, other.question, other.fallback, other.check);
-		console.error(chalk.red(`"${reply}" is not a number from 1 to ${options.length + 1}.`));
-	}
-};
-/** One of a numbered list and nothing else. Enter takes the first entry. */
-var askPick = async (rl, question, options) => {
-	const menu = options.map(({ label }, index) => `  ${index + 1}. ${label}`).join("\n");
-	for (;;) {
-		const reply = (await rl.question(`\n${question}\n${menu}\n[1] > `)).trim() || "1";
-		const index = Number(reply) - 1;
-		if (Number.isInteger(index) && index >= 0 && index < options.length) return options[index].value;
-		console.error(chalk.red(`"${reply}" is not a number from 1 to ${options.length}.`));
-	}
-};
-/** A directory that does not exist yet is as empty as one can be, which is the answer this question wants. */
-var isEmpty = async (target) => {
-	try {
-		return (await fs.readdir(target)).length === 0;
-	} catch {
-		return true;
-	}
-};
-var isDirectory$1 = async (candidate) => {
+//#endregion
+//#region src/commands/projectFormatter.ts
+var isPrettier = (value) => e$1(value) && [
+	"format",
+	"resolveConfig",
+	"getFileInfo"
+].every((name) => typeof value[name] === "function");
+var unformatted = (_file, text) => Promise.resolve(text);
+/** Loads the project's Prettier once. A project without one formats nothing. */
+var projectFormatter = async (root) => {
+	let loaded;
 	try {
-		return (await fs.stat(candidate)).isDirectory();
+		const resolved = createRequire(path.join(root, "package.json")).resolve("prettier");
+		loaded = await import(pathToFileURL(resolved).href);
 	} catch {
-		return false;
+		return unformatted;
 	}
-};
-/** The closest directory that already exists: the project's own does not until its files are written. */
-var nearestExisting = async (target) => {
-	let dir = target;
-	while (!await isDirectory$1(dir) && path.dirname(dir) !== dir) dir = path.dirname(dir);
-	return dir;
-};
-/** Every file, by the path under `target` it is written to. */
-var writeFiles = async (target, files) => {
-	await Promise.all(Object.entries(files).map(async ([file, contents]) => {
-		const destination = path.join(target, file);
-		await fs.mkdir(path.dirname(destination), { recursive: true });
-		return fs.writeFile(destination, contents);
-	}));
-};
-/**
-* What a first install is most likely refused over, and what to do about it.
-*
-* The scaffold already exempts what it ships, but not the rest of the tree: a third-party dependency published in
-* the last day is held back by the same age gates, and says so in a code that means nothing to somebody who has
-* not touched the project yet.
-*/
-var INSTALL_HINTS = {
-	npm: "A peer-dependency conflict (ERESOLVE) is a bug in this scaffold: please report it. `npm install --legacy-peer-deps` gets past it meanwhile.",
-	yarn: "YN0016 (\"quarantined\") means a dependency was published less than a day ago. Wait, or add it to `npmPreapprovedPackages` in .yarnrc.yml.",
-	pnpm: "A dependency published too recently is added to `minimumReleaseAgeExclude` in pnpm-workspace.yaml; a skipped build script is approved with `pnpm approve-builds`."
-};
-var install = (manager, cwd) => new Promise((resolve) => {
-	const child = spawn(manager, ["install"], {
-		cwd,
-		stdio: "inherit",
-		shell: process.platform === "win32"
-	});
-	child.on("error", () => resolve(false));
-	child.on("close", (code) => resolve(code === 0));
-});
-/**
-* One of the project's own scripts, run quietly: what it prints is the project's business, and whether it worked is
-* all this needs. `run` is understood by all three managers alike.
-*/
-var runScript = (manager, script, cwd) => new Promise((resolve) => {
-	const child = spawn(manager, ["run", script], {
-		cwd,
-		stdio: "ignore",
-		shell: process.platform === "win32"
-	});
-	child.on("error", () => resolve(false));
-	child.on("close", (code) => resolve(code === 0));
-});
-/**
-* How to get to `target` from here, in whichever form is shorter.
-*
-* A relative path out of a temp directory is six `../` and unreadable; an absolute one to a sibling folder is noise.
-* These lines are meant to be pasted, so they are printed the way somebody would have typed them.
-*/
-var cdPrefix = (target) => {
-	const relative = path.relative(process.cwd(), target);
-	return target === process.cwd() ? "" : `cd ${relative.length < target.length ? relative : target} && `;
+	const prettier = isPrettier(loaded) ? loaded : e$1(loaded) ? loaded.default : void 0;
+	if (!isPrettier(prettier)) return unformatted;
+	const api = prettier;
+	const ignorePath = [".prettierignore", ".gitignore"].map((file) => path.join(root, file));
+	return async (file, text) => {
+		const filepath = path.join(root, file);
+		const info = await api.getFileInfo(filepath, {
+			ignorePath,
+			resolveConfig: true
+		});
+		if (info.ignored || !info.inferredParser) return text;
+		return api.format(text, {
+			...await api.resolveConfig(filepath),
+			filepath
+		});
+	};
 };
 //#endregion
 //#region src/commands/addPlugin.ts
@@ -3295,7 +4103,7 @@ src/plugins/declarations.ts is missing or not the list the CLI wrote, so it is y
 /** A project the CLI did not write: how to register, and the one dependency the elements import. */
 var registerElsewhere = async (root, added) => {
 	console.log(`\nRegister ${added.length > 1 ? "them" : "it"} where the project renders its space:\n\n${chalk.dim(registration(added))}`);
-	const { dependencies = {}, devDependencies = {} } = JSON.parse(await fs.readFile(path.join(root, "package.json"), "utf-8"));
+	const { dependencies = {}, devDependencies = {} } = await readPackageJson(root) ?? {};
 	if (!("@plitzi/plitzi-sdk" in {
 		...dependencies,
 		...devDependencies
@@ -3304,19 +4112,21 @@ var registerElsewhere = async (root, added) => {
 var addPlugin = async (namesGiven, options) => {
 	const project = await findProject(process.cwd());
 	if (!project) {
-		console.error(chalk.red("plitzi add plugin adds an element to a project, and there is no package.json here or above. For a plugin of its own, run plitzi create <folder> --plugin."));
-		process.exitCode = 1;
+		fail("plitzi add plugin adds an element to a project, and there is no package.json here or above. For a plugin of its own, run plitzi create <folder> --plugin.");
 		return;
 	}
 	if (namesGiven.length > 1 && (options.title !== void 0 || options.description !== void 0)) {
-		console.error(chalk.red("--title and --description describe one element: add several without them, or one at a time."));
-		process.exitCode = 1;
+		fail("--title and --description describe one element: add several without them, or one at a time.");
+		return;
+	}
+	const { shape, problem: shapeProblem } = shapeFromFlags(options);
+	if (shapeProblem ?? (shape && namesGiven.length > 1)) {
+		fail(shapeProblem ?? "--prop, --trigger, --callback and --headless shape one element: add them one at a time.");
 		return;
 	}
 	const givenProblem = namesGiven.length > 0 ? namesProblem(namesGiven) : void 0;
 	if (givenProblem) {
-		console.error(chalk.red(givenProblem));
-		process.exitCode = 1;
+		fail(givenProblem);
 		return;
 	}
 	const folderKnown = options.dir !== void 0 || project.plitzi !== void 0;
@@ -3351,21 +4161,23 @@ var addPlugin = async (namesGiven, options) => {
 			};
 		});
 		for (const { target } of planned) if (!options.force && !await isEmpty(target)) {
-			console.error(chalk.red(`${target} is not empty. Pass --force to write into it anyway.`));
-			process.exitCode = 1;
+			fail(`${target} is not empty. Pass --force to write into it anyway.`);
 			return;
 		}
+		const format = await projectFormatter(project.root);
 		const single = planned.length === 1;
 		const answer = async (question, given, fallback) => given ?? (rl ? askText(rl, question, fallback) : fallback);
 		const added = [];
 		for (const { name, names: elementNames, target } of planned) {
 			const called = single ? "it" : name;
 			const title = await answer(`What does the builder call ${called}?`, single ? options.title : void 0, elementNames.title);
-			await writeFiles(target, scaffoldElement(name, {
+			const files = scaffoldElement(name, {
 				title,
 				description: await answer(`What is ${called} for, in a sentence? The builder shows it, and an agent reads it to choose the element.`, single ? options.description : void 0, ""),
 				owner: ""
-			}));
+			}, shape);
+			const formatted = await Promise.all(Object.entries(files).map(async ([file, text]) => [file, await format(path.relative(project.root, path.join(target, file)), text)]));
+			await writeFiles(target, Object.fromEntries(formatted));
 			added.push({
 				names: {
 					...elementNames,
@@ -3393,6 +4205,166 @@ This project lists its plugins in src/main.ts (projects created since find them
 	}
 };
 //#endregion
+//#region src/commands/projectSpace.ts
+/**
+* What the module exports as `space`, taken as a declaration when it has the shape of one. `authorSpace` checks the
+* rest of it, field by field, and says what is wrong — so this only has to tell a space from anything else.
+*/
+var isSpaceSpec = (value) => e$1(value) && typeof value.name === "string" && typeof value.permanentUrl === "string" && Array.isArray(value.pages);
+var isDeclarations = (value) => Array.isArray(value) && value.every((entry) => e$1(entry) && typeof entry.type === "string");
+var importProject = async (file) => import(pathToFileURL(file).href);
+/**
+* The project's own declaration, loaded as its `author` script loads it — `src/space.ts`, and the plugins in
+* `src/plugins/declarations.ts` — for a command that authors it in this process.
+*/
+var loadProjectSpace = async (root) => {
+	const module = await importProject(path.join(root, "src/space.ts"));
+	const space = e$1(module) ? module.space : void 0;
+	if (!isSpaceSpec(space)) return { problem: "src/space.ts exports no `space`." };
+	const registry = await importProject(path.join(root, "src/plugins/declarations.ts")).catch(() => void 0);
+	const declarations = e$1(registry) ? registry.declarations : void 0;
+	return {
+		space,
+		plugins: isDeclarations(declarations) ? declarations : []
+	};
+};
+//#endregion
+//#region src/commands/check.ts
+/** The space the project declares, authored — the handles say what each page owes. Only for one written here. */
+var projectHandles = async (root) => {
+	const project = await loadProjectSpace(root);
+	if ("problem" in project) return { problem: `${project.problem} There is nothing to check the page against.` };
+	try {
+		return authorSpace(project.space, { plugins: project.plugins }).handles;
+	} catch (error) {
+		return { problem: `The space does not author — npm run author says why: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}` };
+	}
+};
+/** The page a path is, `:slug` and `{{slug}}` matching any segment. */
+var pageFor = (handles, pathname) => {
+	const wanted = pathname.replace(/\/$/, "").split("/");
+	return Object.values(handles.pages).find((page) => {
+		const segments = page.path.replace(/\/$/, "").split("/");
+		return segments.length === wanted.length && segments.every((segment, index) => segment.startsWith(":") || /^\{\{.*\}\}$/.test(segment) || segment === wanted[index]);
+	})?.id;
+};
+var checkAt = async (browser, origin, pathname, width, scheme, handles, asked) => {
+	const page = await browser.newPage({
+		viewport: {
+			width,
+			height: 900
+		},
+		colorScheme: scheme,
+		reducedMotion: "no-preference"
+	});
+	const consoleErrors = [];
+	const failedRequests = [];
+	page.on("pageerror", (error) => consoleErrors.push(error.message));
+	page.on("console", (message) => {
+		if (message.type() === "error") consoleErrors.push(message.text());
+	});
+	page.on("response", (response) => {
+		if (response.status() >= 400 && response.url().startsWith(origin)) failedRequests.push(`${String(response.status())} ${response.url().slice(origin.length)}`);
+	});
+	if (!await page.goto(`${origin}${pathname}`, { waitUntil: "networkidle" }).catch(() => null)) return {
+		path: pathname,
+		width,
+		ok: false,
+		checked: 0,
+		problems: [`nothing answers at ${origin}${pathname}`],
+		consoleErrors,
+		failedRequests,
+		devTools: false
+	};
+	const pageId = handles ? pageFor(handles, pathname) : void 0;
+	const report = handles && pageId ? await inspectPage(page, handles, { page: pageId }) : await inspectDocument(page);
+	const devTools = await readDevTools(page, asked);
+	const problems = [
+		...handles && !pageId ? [`no page of the space answers at ${pathname}`] : [],
+		...report.problems,
+		...devTools.flows.filter((flow) => flow.status === "failed").map(failedFlowText)
+	];
+	return {
+		path: pathname,
+		width,
+		ok: problems.length === 0 && consoleErrors.length === 0 && failedRequests.length === 0,
+		checked: report.checked,
+		problems,
+		consoleErrors,
+		failedRequests,
+		devTools: devTools.available,
+		...devTools.state === void 0 ? {} : { state: devTools.state },
+		...devTools.sources === void 0 ? {} : { sources: devTools.sources },
+		...devTools.element === void 0 ? {} : { element: devTools.element }
+	};
+};
+/** What the page holds, when it was asked for: one compact line each, the shape of a source rather than its rows. */
+var heldText = (report, asked) => {
+	if (!asked.state && asked.element === void 0) return [];
+	if (!report.devTools) return ["  · the page has no dev tools on (debug mode), so its state and elements cannot be read"];
+	return [
+		...report.state === void 0 ? [] : [`  · state ${JSON.stringify(report.state)}`],
+		...Object.entries(report.sources ?? {}).map(([name, value]) => `  · source ${name}: ${shapeOf(value)}`),
+		...asked.element === void 0 ? [] : [`  · element ${asked.element}: ${JSON.stringify(report.element ?? null)}`]
+	];
+};
+/** A value's shape in a few words: a list's length, an object's keys, a short value as it is. */
+var shapeOf = (value) => {
+	if (Array.isArray(value)) return `a list of ${String(value.length)}`;
+	if (e$1(value)) {
+		const keys = Object.keys(value);
+		return `{ ${keys.slice(0, 8).join(", ")}${keys.length > 8 ? ", …" : ""} }`;
+	}
+	const text = value === void 0 ? "undefined" : JSON.stringify(value);
+	return text.length > 60 ? `${text.slice(0, 57)}…` : text;
+};
+var reportText = (report, asked) => {
+	const head = `${report.path} at ${String(report.width)} px`;
+	const held = heldText(report, asked);
+	if (report.ok) return [chalk.green(`✓ ${head} — ${report.checked > 0 ? `${String(report.checked)} elements on screen, ` : ""}nothing wrong`), ...held].join("\n");
+	return [
+		chalk.red(`✗ ${head}`),
+		...report.problems.map((problem) => `  - ${problem}`),
+		...report.consoleErrors.map((error) => `  - console: ${error}`),
+		...report.failedRequests.map((request) => `  - request refused: ${request}`),
+		...held
+	].join("\n");
+};
+var check = async (route, options) => {
+	const project = await projectHere("whose page to check");
+	if (!project) return;
+	const plitzi = project.plitzi?.kind === "project" ? project.plitzi : void 0;
+	const where = await projectOrigin(project.root, plitzi);
+	if ("problem" in where) {
+		fail(where.problem);
+		return;
+	}
+	const handles = plitzi?.source === "local" ? await projectHandles(project.root) : void 0;
+	if (handles && "problem" in handles) {
+		fail(handles.problem);
+		return;
+	}
+	const browser = await launchBrowser(project.root);
+	if ("problem" in browser) {
+		fail(browser.problem);
+		return;
+	}
+	try {
+		const widths = options.width ?? [1440, 390];
+		const scheme = options.scheme ?? "light";
+		const asked = {
+			state: Boolean(options.state),
+			...options.element ? { element: options.element } : {}
+		};
+		const reports = [];
+		for (const width of widths) reports.push(await checkAt(browser, where.origin, route ?? "/", width, scheme, handles, asked));
+		console.log(options.json ? JSON.stringify(reports) : reports.map((report) => reportText(report, asked)).join("\n"));
+		if (reports.some((report) => !report.ok)) process.exitCode = 1;
+	} finally {
+		await browser.close();
+	}
+};
+//#endregion
 //#region ../../packages/sdk-shared/dist/actions/functions.mjs
 var r$1 = (e) => /^[A-Za-z0-9_][A-Za-z0-9_./-]*\.(ts|js|mjs|json)$/.test(e) && !e.split("/").some((e) => e === ".." || e === "." || e === "");
 var i$1 = async (e, t) => {
@@ -3414,9 +4386,8 @@ var i$1 = async (e, t) => {
 //#region src/commands/functions.ts
 var FUNCTIONS_DIR = "functions";
 var STATE_FILE = path.join(".plitzi", "functions.json");
-var isRecord$6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-/** The project's root: where `functions/` and `.plitzi/` go. */
-var rootOf = async () => (await findProject(process.cwd()))?.root ?? process.cwd();
+/** The project's root: where `functions/` and `.plitzi/` go. Undefined — said — outside a project. */
+var rootOf = async () => (await projectHere("whose functions these are"))?.root;
 /** Every source file under `functions/`, by its path there — read by the one rule of what a source is. */
 var readLocal = (root) => i$1(path.join(root, FUNCTIONS_DIR), {
 	list: async (dir) => (await fs.readdir(dir, { withFileTypes: true })).map((entry) => ({
@@ -3428,7 +4399,7 @@ var readLocal = (root) => i$1(path.join(root, FUNCTIONS_DIR), {
 var readState = async (root) => {
 	try {
 		const value = JSON.parse(await fs.readFile(path.join(root, STATE_FILE), "utf8"));
-		if (!isRecord$6(value) || typeof value.space !== "number" || typeof value.version !== "string" || !isRecord$6(value.files)) return;
+		if (!e$1(value) || typeof value.space !== "number" || typeof value.version !== "string" || !e$1(value.files)) return;
 		const files = Object.fromEntries(Object.entries(value.files).flatMap(([name, text]) => typeof text === "string" ? [[name, text]] : []));
 		return {
 			space: value.space,
@@ -3446,10 +4417,6 @@ var writeFunctionsState = async (root, state) => {
 /** The files that differ between two copies — added, removed or changed — sorted. */
 var changedFiles = (a, b) => [.../* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])].filter((file) => a[file] !== b[file]).sort();
 var taskList = (draft) => draft.manifest?.tasks.length ? draft.manifest.tasks.map((task) => `${task.namespace}.${task.action}`).join(", ") : "no tasks";
-var connect$1 = async (options, doing) => {
-	const api = await apiFor(options);
-	return api ? connectionWithSpace(api, doing) : void 0;
-};
 var readDraft = async (connection, spaceId) => {
 	const answered = await authorizedRequest(connection, `/spaces/${spaceId}/functions`);
 	if (!answered.ok) {
@@ -3464,9 +4431,9 @@ var readDraft = async (connection, spaceId) => {
 	return reply.data;
 };
 var pullFunctions = async (options) => {
-	const connection = await connect$1(options, "to pull from");
-	if (!connection?.space) return;
 	const root = await rootOf();
+	const connection = root && await connectToSpace(options, "to pull from");
+	if (!root || !connection || !connection.space) return;
 	const [local, state] = await Promise.all([readLocal(root), readState(root)]);
 	const unpushed = state ? changedFiles(local, state.files) : Object.keys(local);
 	if (!options.force && (state?.space ?? connection.space.id) !== connection.space.id) {
@@ -3491,7 +4458,7 @@ var pullFunctions = async (options) => {
 		files: draft.files
 	});
 	const count = Object.keys(draft.files).length;
-	console.log(count ? `Pulled ${count} file${count === 1 ? "" : "s"} of ${chalk.bold(connection.space.name)}’s functions into functions/ — ${taskList(draft)}.` : `${chalk.bold(connection.space.name)} has no functions yet. Write functions/index.ts and plitzi functions push.`);
+	console.log(count ? chalk.green(`Pulled ${count} file${count === 1 ? "" : "s"} of ${connection.space.name}’s functions into functions/ — ${taskList(draft)}.`) : `${chalk.bold(connection.space.name)} has no functions yet. Write functions/index.ts and plitzi functions push.`);
 };
 var printProblems = (problems) => {
 	console.error(chalk.red("The functions were not saved:"));
@@ -3502,9 +4469,9 @@ var printProblems = (problems) => {
 	process.exitCode = 1;
 };
 var pushFunctions = async (options) => {
-	const connection = await connect$1(options, "to push to");
-	if (!connection?.space) return;
 	const root = await rootOf();
+	const connection = root && await connectToSpace(options, "to push to");
+	if (!root || !connection || !connection.space) return;
 	const [local, state] = await Promise.all([readLocal(root), readState(root)]);
 	if (!Object.hasOwn(local, "index.ts")) {
 		fail("There is no functions/index.ts here: it is where a space’s functions start. Pull them, or write it.");
@@ -3554,7 +4521,7 @@ var pushFunctions = async (options) => {
 		version: reply.data.version,
 		files: local
 	});
-	console.log(`Pushed to ${chalk.bold(connection.space.name)}’s draft — ${taskList({ manifest: reply.data.manifest ?? null })}. ` + chalk.dim("The live site runs them once the space is published."));
+	console.log(chalk.green(`Pushed to ${connection.space.name}’s draft — ${taskList({ manifest: reply.data.manifest ?? null })}.`) + chalk.dim(" The live site runs them once the space is published."));
 };
 /** What one run of a task did: its logs, then its value — or why it failed, as a failure of the command. */
 var printRun = (task, report) => {
@@ -3572,14 +4539,14 @@ var printRun = (task, report) => {
 var paramsOf = (given) => {
 	try {
 		const params = given ? JSON.parse(given) : {};
-		if (isRecord$6(params)) return params;
+		if (e$1(params)) return params;
 	} catch {}
 	fail("--params is a JSON object of the task’s params, by name: --params '{\"name\":\"Ada\"}'");
 };
 var tryFunction = async (task, options) => {
 	const params = paramsOf(options.params);
 	if (!params) return;
-	const connection = await connect$1(options, "to try it in");
+	const connection = await connectToSpace(options, "to try it in");
 	if (!connection?.space) return;
 	const answered = await authorizedRequest(connection, `/spaces/${connection.space.id}/functions/try`, {
 		method: "POST",
@@ -3600,7 +4567,7 @@ var tryFunction = async (task, options) => {
 	}
 	printRun(task, reply.data);
 };
-var isLocalRunner = (value) => isRecord$6(value) && typeof value.createLocalFunctions === "function";
+var isLocalRunner = (value) => e$1(value) && typeof value.createLocalFunctions === "function";
 /**
 * This project's own runner: `dev` runs the functions with the `@plitzi/sdk-server` the project installed, so the build,
 * the checks, the isolates and the limits are the platform's own, at the version the project is on.
@@ -3618,7 +4585,7 @@ var localCredentials = () => {
 	const raw = process.env.PLITZI_FUNCTIONS_CREDENTIALS;
 	try {
 		const value = raw ? JSON.parse(raw) : {};
-		return isRecord$6(value) ? Object.fromEntries(Object.entries(value).flatMap(([id, keys]) => isRecord$6(keys) ? [[id, Object.fromEntries(Object.entries(keys).filter((pair) => typeof pair[1] === "string"))]] : [])) : {};
+		return e$1(value) ? Object.fromEntries(Object.entries(value).flatMap(([id, keys]) => e$1(keys) ? [[id, Object.fromEntries(Object.entries(keys).filter((pair) => typeof pair[1] === "string"))]] : [])) : {};
 	} catch {
 		return {};
 	}
@@ -3649,9 +4616,9 @@ var devFunction = async (task, options) => {
 		return;
 	}
 	const params = paramsOf(options.params);
-	const root = await rootOf();
-	const runner = params ? await projectRunner(root) : void 0;
-	if (!params || !runner) return;
+	const root = params && await rootOf();
+	const runner = root ? await projectRunner(root) : void 0;
+	if (!root || !runner) return;
 	const local = runner.createLocalFunctions({ credentials: localCredentials() });
 	const run = async () => {
 		const loaded = await local.load(await readLocal(root));
@@ -3679,41 +4646,6 @@ var devFunction = async (task, options) => {
 	});
 };
 //#endregion
-//#region src/commands/projectFormatter.ts
-var isRecord$5 = (value) => typeof value === "object" && value !== null;
-var isPrettier = (value) => isRecord$5(value) && [
-	"format",
-	"resolveConfig",
-	"getFileInfo"
-].every((name) => typeof value[name] === "function");
-var unformatted = (_file, text) => Promise.resolve(text);
-/** Loads the project's Prettier once. A project without one formats nothing. */
-var projectFormatter = async (root) => {
-	let loaded;
-	try {
-		const resolved = createRequire(path.join(root, "package.json")).resolve("prettier");
-		loaded = await import(pathToFileURL(resolved).href);
-	} catch {
-		return unformatted;
-	}
-	const prettier = isPrettier(loaded) ? loaded : isRecord$5(loaded) ? loaded.default : void 0;
-	if (!isPrettier(prettier)) return unformatted;
-	const api = prettier;
-	const ignorePath = [".prettierignore", ".gitignore"].map((file) => path.join(root, file));
-	return async (file, text) => {
-		const filepath = path.join(root, file);
-		const info = await api.getFileInfo(filepath, {
-			ignorePath,
-			resolveConfig: true
-		});
-		if (info.ignored || !info.inferredParser) return text;
-		return api.format(text, {
-			...await api.resolveConfig(filepath),
-			filepath
-		});
-	};
-};
-//#endregion
 //#region src/scaffold/fromSpace.ts
 var TEXT = /\.((m|c)?(t|j)sx?|json|css|scss|sass|less|md|txt|html|svg|ya?ml|xml|csv|graphql)$/i;
 /** Whether a file of the project is text — written, compared and formatted as such — rather than bytes. */
@@ -4102,8 +5034,7 @@ var projectFromSpace = (exported, spaceSource) => {
 * copy of the whole project beside the project would be the second source of it nobody keeps in step.
 */
 var ORIGIN_FILE = path.join(".plitzi", "space.json");
-var isRecord$4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var isStrings = (value) => isRecord$4(value) && Object.values(value).every((entry) => typeof entry === "string");
+var isStrings = (value) => e$1(value) && Object.values(value).every((entry) => typeof entry === "string");
 var digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
 /**
 * A file of the project as a pull compares it: the digest of what the project's formatter makes of it — so a file only
@@ -4127,7 +5058,7 @@ var digestsOf = async (root, file, format) => {
 var readOrigin = async (root) => {
 	try {
 		const value = JSON.parse(await fs.readFile(path.join(root, ORIGIN_FILE), "utf-8"));
-		if (!isRecord$4(value) || value.format !== 1 || typeof value.api !== "string" || !isRecord$4(value.space) || typeof value.space.id !== "number" || typeof value.space.name !== "string" || typeof value.space.permanentUrl !== "string" || value.source !== "local" && value.source !== "cloud" || !isRecord$4(value.version) || typeof value.version.environment !== "string" || value.version.revision !== void 0 && typeof value.version.revision !== "number" || !isStrings(value.files) || !isStrings(value.downloads) || !isStrings(value.dependencies)) return;
+		if (!e$1(value) || value.format !== 1 || typeof value.api !== "string" || !e$1(value.space) || typeof value.space.id !== "number" || typeof value.space.name !== "string" || typeof value.space.permanentUrl !== "string" || value.source !== "local" && value.source !== "cloud" || !e$1(value.version) || typeof value.version.environment !== "string" || value.version.revision !== void 0 && typeof value.version.revision !== "number" || !isStrings(value.files) || !isStrings(value.downloads) || !isStrings(value.dependencies)) return;
 		return {
 			format: 1,
 			api: value.api,
@@ -4171,9 +5102,8 @@ var digestsOnDisk = async (root, files, format) => {
 * `plitzi create --from <space>`: the space as Plitzi keeps it (docs/en/projects-from-spaces.md), asked for as the person — who must be able
 * to change it — and the files of it the project serves itself, fetched once.
 */
-var isRecord$3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** What the platform answered is an export: of the format this CLI writes, with every part it reads. */
-var isExport = (value) => isRecord$3(value) && value.format === 1 && isRecord$3(value.space) && isRecord$3(value.version) && isRecord$3(value.source) && isRecord$3(value.builtOnly) && isRecord$3(value.report) && isRecord$3(value.functions) && Array.isArray(value.actions) && Array.isArray(value.assets) && Array.isArray(value.visitorRoles);
+var isExport = (value) => e$1(value) && value.format === 1 && e$1(value.space) && e$1(value.version) && e$1(value.source) && e$1(value.builtOnly) && e$1(value.report) && e$1(value.functions) && Array.isArray(value.actions) && Array.isArray(value.assets) && Array.isArray(value.visitorRoles);
 /** How a version is said: `the draft`, `production (latest)`, `production r3`. */
 var versionLabel = ({ environment, revision }) => {
 	if (environment === "main") return "the draft";
@@ -4194,19 +5124,16 @@ var fetchExport = async (api, from, { source, version, name = from }) => {
 	});
 	const answered = await authorizedRequest(connection, `/spaces/${encodeURIComponent(from)}/export?${query.toString()}`);
 	if (!answered.ok) {
-		console.error(chalk.red(answered.error));
-		process.exitCode = 1;
+		fail(answered.error);
 		return;
 	}
 	const { status, data } = answered.value.reply;
 	if (status === 200 && isExport(data)) return data;
-	const said = isRecord$3(data) && typeof data.error === "string" ? data.error : void 0;
-	const why = {
+	const said = e$1(data) && typeof data.error === "string" ? data.error : void 0;
+	fail({
 		403: `You may not take ${from} out: it takes being able to change it — its owner, an administrator or a writer.`,
 		404: said ?? `There is no space ${from} you can reach.`
-	};
-	console.error(chalk.red(why[status] ?? said ?? `The platform would not hand ${from} over (${String(status)}).`));
-	process.exitCode = 1;
+	}[status] ?? said ?? `The platform would not hand ${from} over (${String(status)}).`);
 };
 /** A file of the space's CDN, fetched. */
 var download = async (url) => {
@@ -4352,20 +5279,17 @@ var create = async (directory, options) => {
 	const name = path.basename(target);
 	const wasEmpty = await isEmpty(target);
 	if (!options.force && !wasEmpty) {
-		console.error(chalk.red(`${target} is not empty. Pass --force to write into it anyway.`));
-		process.exitCode = 1;
+		fail(`${target} is not empty. Pass --force to write into it anyway.`);
 		return;
 	}
 	if (options.from && options.mode === "client") {
-		console.error(chalk.red("A project made from a space runs its own server: leave out --mode, or pass --mode server."));
-		process.exitCode = 1;
+		fail("A project made from a space runs its own server: leave out --mode, or pass --mode server.");
 		return;
 	}
 	const environment = options.environment ?? "main";
 	const revision = options.revision === void 0 ? void 0 : Number(options.revision);
 	if (revision !== void 0 && (!Number.isInteger(revision) || revision < 1 || environment === "main")) {
-		console.error(chalk.red(environment === "main" ? "The draft (main) has no revisions: name a published environment with --environment, then --revision." : `--revision takes a revision number from 1, not "${options.revision ?? ""}".`));
-		process.exitCode = 1;
+		fail(environment === "main" ? "The draft (main) has no revisions: name a published environment with --environment, then --revision." : `--revision takes a revision number from 1, not "${options.revision ?? ""}".`);
 		return;
 	}
 	const decisions = await resolveDecisions(options.from ? {
@@ -4374,9 +5298,13 @@ var create = async (directory, options) => {
 	} : options);
 	if (!decisions) return;
 	const { packageManager, mode, source } = decisions;
+	const template = CREATE_TEMPLATES.find((candidate) => candidate === (options.template ?? "welcome"));
+	if (!template || options.template !== void 0 && (source === "cloud" || options.from)) {
+		fail(template ? "--template is what a space written in the project starts as: it goes with --source local, without --from." : `--template is ${CREATE_TEMPLATES.join(" or ")}, not "${options.template ?? ""}".`);
+		return;
+	}
 	if (revision !== void 0 && !options.from && source === "local") {
-		console.error(chalk.red("--revision pins a published version: it goes with --from, or with --source cloud."));
-		process.exitCode = 1;
+		fail("--revision pins a published version: it goes with --from, or with --source cloud.");
 		return;
 	}
 	if (source === "cloud" && !options.key && !atTerminal()) {
@@ -4389,14 +5317,14 @@ var create = async (directory, options) => {
 	}
 	const key = source === "cloud" ? options.key ?? await askForKey(mode) : "";
 	if (source === "cloud" && !key) {
-		console.error(chalk.red("\nNo key. Mint one under Credentials in the builder, then run this again."));
-		process.exitCode = 1;
+		fail("\nNo key. Mint one under Credentials in the builder, then run this again.");
 		return;
 	}
 	const answers = {
 		name,
 		mode,
 		source,
+		...template === "welcome" ? {} : { template },
 		key,
 		environment,
 		...revision ? { revision } : {},
@@ -4431,9 +5359,8 @@ var create = async (directory, options) => {
 	* `node_modules`.
 	*/
 	if (wantsInstall && !installed) {
-		console.error(chalk.red(`\n\`${installCommand(packageManager)}\` failed. The project is written; the reason is in the output above.`));
+		fail(`\n\`${installCommand(packageManager)}\` failed. The project is written; the reason is in the output above.`);
 		console.error(chalk.dim(INSTALL_HINTS[packageManager]));
-		process.exitCode = 1;
 	}
 	/**
 	* Formatted by the project's own Prettier, once, so the first commit is already in its style — the scaffold writes
@@ -4483,173 +5410,967 @@ var QUESTIONS = {
 		choices: ["<folder>"],
 		question: "Which folder should the plugin be written to?"
 	}
-};
-var splitNames = (list) => list.split(",").map((name) => name.trim()).filter(Boolean);
-/**
-* What is wrong with the other elements asked for, if anything: a name that makes no element, or two elements — the
-* package's own among them — that would share a type, which a space could not tell apart.
-*/
-var elementListProblem = (main, others) => {
-	for (const name of others) {
-		const problem = pluginNameProblem(name);
-		if (problem) return problem;
+};
+var splitNames = (list) => list.split(",").map((name) => name.trim()).filter(Boolean);
+/**
+* What is wrong with the other elements asked for, if anything: a name that makes no element, or two elements — the
+* package's own among them — that would share a type, which a space could not tell apart.
+*/
+var elementListProblem = (main, others) => {
+	for (const name of others) {
+		const problem = pluginNameProblem(name);
+		if (problem) return problem;
+	}
+	const types = [pluginNames(main).type, ...others.map((name) => pluginNames(name).type)];
+	const repeated = types.find((type, index) => types.indexOf(type) !== index);
+	return repeated ? `Two elements would both be "${repeated}": give each a name of its own.` : void 0;
+};
+/** The folders a repository keeps its packages in, as places for this one — or `./<name>` outside of any. */
+var folderOptions = (project, base) => {
+	if (!project) return [];
+	const root = project.workspaceRoot ?? project.root;
+	return [.../* @__PURE__ */ new Set([...project.workspaceFolders, "plugins"])].map((folder) => {
+		const value = path.join(root, folder, base);
+		return {
+			label: path.relative(process.cwd(), value) || ".",
+			value
+		};
+	});
+};
+var askDirectory = async (rl, project, base) => {
+	const typed = {
+		question: "Which folder? (relative to here)",
+		fallback: `./${base}`
+	};
+	if (!project) return path.resolve(await askText(rl, "Which folder should the plugin be written to?", typed.fallback));
+	const chosen = await askChoice(rl, `Which folder of ${path.relative(process.cwd(), project.workspaceRoot ?? project.root) || "this project"} should the plugin go in?`, folderOptions(project, base), {
+		label: "Somewhere else",
+		...typed
+	});
+	return path.resolve(chosen);
+};
+/**
+* The manager: the one the repository already installs with, when it is written into one — asking would only offer a
+* second lockfile — and otherwise asked, as a project's is.
+*/
+var resolveManager = async (rl, options, project) => {
+	const given = PACKAGE_MANAGERS.find((manager) => manager === options.packageManager);
+	if (given ?? project?.packageManager) return given ?? project?.packageManager;
+	const detected = detectPackageManager();
+	if (!rl || options.yes) return options.yes ? detected : void 0;
+	return ask(rl, {
+		flag: "--package-manager",
+		choices: PACKAGE_MANAGERS,
+		question: `Which package manager will you work in? (this was run through ${detected})`,
+		fallback: detected
+	});
+};
+var createPlugin = async (directory, options) => {
+	const nameGiven = options.name ?? (directory ? path.basename(path.resolve(directory)) : void 0);
+	const othersGiven = options.elements === void 0 ? void 0 : splitNames(options.elements);
+	const nameProblem = nameGiven === void 0 ? void 0 : pluginNameProblem(nameGiven) ?? elementListProblem(pluginNames(nameGiven).base, othersGiven ?? []);
+	if (nameProblem) {
+		fail(nameProblem);
+		return;
+	}
+	const here = await findProject(process.cwd());
+	const terminal = atTerminal();
+	if (!terminal && (nameGiven === void 0 || directory === void 0)) {
+		refuseWithoutTerminal("plugin", [...nameGiven === void 0 ? [QUESTIONS.name] : [], ...directory === void 0 ? [QUESTIONS.directory] : []]);
+		return;
+	}
+	const rl = terminal ? readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	}) : void 0;
+	try {
+		/**
+		* Everything the plugin is called and says about itself, asked before a file is written — the package name, what
+		* the builder's catalogue shows, what an agent reads to choose it, who publishes it. Each has a default, taken
+		* whole with Enter; only the name and the folder are ever refused for want of an answer.
+		*/
+		const name = nameGiven ?? (rl ? await askText(rl, QUESTIONS.name.question, DEFAULT_NAME, pluginNameProblem) : DEFAULT_NAME);
+		const names = pluginNames(name);
+		const answer = async (question, given, fallback) => given ?? (rl && !options.yes ? askText(rl, question, fallback) : fallback);
+		const title = await answer("What does the builder call the element?", options.title, names.title);
+		const description = await answer("What is it for, in a sentence? The builder shows it, and an agent reads it to choose the element.", options.description, "");
+		const owner = await answer("Who publishes it?", options.owner, "");
+		const others = othersGiven ?? (rl && !options.yes ? splitNames(await askText(rl, "Any other elements in this package? Their names, separated by commas.", "", (reply) => elementListProblem(names.base, splitNames(reply)))) : []);
+		const otherElements = [];
+		for (const other of others) {
+			const otherNames = pluginNames(other);
+			otherElements.push({
+				name: other,
+				title: await answer(`What does the builder call ${other}?`, void 0, otherNames.title),
+				description: await answer(`What is ${other} for, in a sentence?`, void 0, "")
+			});
+		}
+		const target = directory ? path.resolve(directory) : rl ? await askDirectory(rl, here, names.base) : void 0;
+		if (!target) return;
+		const wasEmpty = await isEmpty(target);
+		if (!options.force && !wasEmpty) {
+			fail(`${target} is not empty. Pass --force to write into it anyway.`);
+			return;
+		}
+		const project = await findProject(path.dirname(target));
+		const packageManager = await resolveManager(rl, options, project);
+		if (!packageManager) {
+			if (!rl) refuseWithoutTerminal("plugin", [{
+				flag: "--package-manager",
+				choices: PACKAGE_MANAGERS,
+				question: "Which package manager will you work in?"
+			}]);
+			process.exitCode = 1;
+			return;
+		}
+		await writeFiles(target, scaffoldPlugin({
+			packageName: name,
+			elements: [{
+				name: names.base,
+				title,
+				description
+			}, ...otherElements],
+			owner,
+			packageManager,
+			managerVersion: detectManagerVersion(packageManager, await nearestExisting(target)),
+			inProject: project !== void 0
+		}));
+		/**
+		* Installed where it will be installed from. Inside a workspace that covers the folder, installing there installs
+		* the workspace; inside a repository that does not list it, Yarn refuses to install a package it does not know —
+		* so that is said, with the fix, rather than failed at.
+		*/
+		const unlisted = project?.workspaceRoot !== void 0 && !coveredByWorkspace(project, target);
+		const wantsInstall = options.install !== false && !unlisted;
+		const installed = wantsInstall && await install(packageManager, target);
+		if (wantsInstall && !installed) {
+			fail(`\n\`${installCommand(packageManager)}\` failed. The plugin is written; the reason is in the output above.`);
+			console.error(chalk.dim(INSTALL_HINTS[packageManager]));
+		}
+		if (installed && wasEmpty) await runScript(packageManager, "format", target);
+		const where = cdPrefix(target);
+		console.log(chalk.green(`\n${name} — the ${names.type} element, as a package any space can load.`));
+		if (unlisted) console.log(chalk.yellow(`\n${path.relative(process.cwd(), target)} is not one of the workspace's packages: add it to \`workspaces\`, then install.`));
+		console.log("");
+		if (!installed) console.log(`  ${where}${installCommand(packageManager)}`);
+		console.log(`  ${where}${runCommand(packageManager, "start")}   # the plugin inside a space`);
+		console.log(`  ${where}${runCommand(packageManager, "zip")}     # what the builder takes, under Resources`);
+		console.log("");
+	} finally {
+		rl?.close();
+	}
+};
+//#endregion
+//#region src/commands/data.ts
+var emptyShape = () => ({ primitives: /* @__PURE__ */ new Set() });
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var merge = (shape, value) => {
+	if (value === null) {
+		shape.primitives.add("null");
+		return;
+	}
+	if (Array.isArray(value)) {
+		shape.array ??= {
+			occurrences: 0,
+			lengths: /* @__PURE__ */ new Set(),
+			item: emptyShape()
+		};
+		shape.array.occurrences += 1;
+		shape.array.lengths.add(value.length);
+		for (const item of value) merge(shape.array.item, item);
+		return;
+	}
+	if (isPlainObject(value)) {
+		shape.object ??= {
+			count: 0,
+			fields: /* @__PURE__ */ new Map()
+		};
+		shape.object.count += 1;
+		for (const [key, field] of Object.entries(value)) {
+			const entry = shape.object.fields.get(key) ?? {
+				count: 0,
+				shape: emptyShape()
+			};
+			entry.count += 1;
+			merge(entry.shape, field);
+			shape.object.fields.set(key, entry);
+		}
+		return;
+	}
+	shape.primitives.add(typeof value);
+};
+/** Past this many fields an object is summarised: a map keyed by ids is data, not a shape. */
+var MAX_FIELDS = 40;
+var PAD = "  ";
+var KEY = /^[A-Za-z_$][\w$]*$/;
+var render = (shape, depth) => {
+	const parts = [...shape.primitives].sort();
+	if (shape.object) parts.push(renderObject(shape.object, depth));
+	if (shape.array) parts.push(renderArray(shape.array, depth));
+	return parts.length > 0 ? parts.join(" | ") : "never";
+};
+var renderArray = ({ occurrences, lengths, item }, depth) => {
+	const inner = render(item, depth);
+	if (occurrences === 1) {
+		const [length] = lengths;
+		return length === 0 ? "Array(0)" : `Array(${String(length)}) of ${inner}`;
+	}
+	return inner.includes(" | ") ? `(${inner})[]` : `${inner}[]`;
+};
+var renderObject = ({ count, fields }, depth) => {
+	if (fields.size === 0) return "{}";
+	const indent = PAD.repeat(depth + 1);
+	const entries = [...fields].slice(0, MAX_FIELDS).map(([key, field]) => {
+		const name = KEY.test(key) ? key : JSON.stringify(key);
+		const optional = field.count < count;
+		const seen = optional && count > 1 ? `  (in ${String(field.count)} of ${String(count)})` : "";
+		return `${indent}${name}${optional ? "?" : ""}: ${render(field.shape, depth + 1)}${seen}`;
+	});
+	const more = fields.size > MAX_FIELDS ? [`${indent}… ${String(fields.size - MAX_FIELDS)} more keys`] : [];
+	return [
+		"{",
+		...entries,
+		...more,
+		`${PAD.repeat(depth)}}`
+	].join("\n");
+};
+/** The longest list of objects in the document, and where it is — the rows a page most likely renders. */
+var rowsOf = (value) => {
+	const candidates = [];
+	const visit = (node, at) => {
+		if (Array.isArray(node)) {
+			if (node.some(isPlainObject)) candidates.push({
+				path: at,
+				rows: node
+			});
+			node.forEach((item, index) => visit(item, `${at}[${String(index)}]`));
+			return;
+		}
+		if (isPlainObject(node)) for (const [key, field] of Object.entries(node)) visit(field, at ? `${at}.${key}` : key);
+	};
+	visit(value, "");
+	return candidates.sort((a, b) => b.rows.length - a.rows.length)[0];
+};
+/** One row, shortened: long text cut, long lists cut to their first items. */
+var shorten = (value) => {
+	if (typeof value === "string") return value.length > 80 ? `${value.slice(0, 77)}…` : value;
+	if (Array.isArray(value)) return value.length > 3 ? [...value.slice(0, 3).map(shorten), `… ${String(value.length - 3)} more`] : value.map(shorten);
+	if (isPlainObject(value)) return Object.fromEntries(Object.entries(value).map(([key, field]) => [key, shorten(field)]));
+	return value;
+};
+var describeData = (value) => {
+	const shape = emptyShape();
+	merge(shape, value);
+	const rows = rowsOf(value);
+	const first = rows?.rows.find(isPlainObject);
+	return {
+		shape: render(shape, 0),
+		...rows && first ? { example: {
+			path: rows.path || "(the document)",
+			row: shorten(first)
+		} } : {}
+	};
+};
+var dataDescribe = async (file, options) => {
+	let value;
+	try {
+		value = JSON.parse(await fs.readFile(file, "utf-8"));
+	} catch (error) {
+		fail(`${file} is not a JSON file this can read: ${error instanceof Error ? error.message : String(error)}`);
+		return;
+	}
+	const description = describeData(value);
+	if (options.json) {
+		console.log(JSON.stringify(description));
+		return;
+	}
+	console.log(description.shape);
+	if (description.example) {
+		console.log(`\n${chalk.dim(`One row of ${description.example.path}:`)}`);
+		console.log(JSON.stringify(description.example.row, null, 2));
+	}
+};
+//#endregion
+//#region src/commands/explain.ts
+var kinds = Object.values(EXPLAIN_KINDS).join(", ");
+var explainCommand = (name, options) => {
+	if (options.list !== void 0) {
+		const kind = explainKindOf(options.list);
+		if (!kind) {
+			fail(`--list takes ${kinds}, not "${options.list}".`);
+			return;
+		}
+		const entries = explainList(kind);
+		console.log(options.json ? JSON.stringify(entries) : entries.map((entry) => `${entry.name.padEnd(32)} ${chalk.dim(entry.summary)}`).join("\n"));
+		return;
+	}
+	if (!name) {
+		fail(`Name what to explain — plitzi explain container — or list a kind: --list ${kinds}.`);
+		return;
+	}
+	const explanations = explain(name);
+	if (explanations.length === 0) {
+		fail(`"${name}" is no element, step, trigger, code or transformer. See what there is: --list ${kinds}.`);
+		return;
+	}
+	console.log(options.json ? JSON.stringify(explanations) : explanations.map(explanationText).join("\n\n"));
+};
+//#endregion
+//#region src/fix/diff.ts
+/** A line diff of a file, as `diff -u` prints it: the changed lines and two of context around each run of them. */
+var unifiedDiff = (file, before, after, context = 2) => {
+	const a = before.split("\n");
+	const b = after.split("\n");
+	const common = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+	for (let i = a.length - 1; i >= 0; i -= 1) for (let j = b.length - 1; j >= 0; j -= 1) common[i][j] = a[i] === b[j] ? common[i + 1][j + 1] + 1 : Math.max(common[i + 1][j], common[i][j + 1]);
+	const lines = [];
+	let i = 0;
+	let j = 0;
+	while (i < a.length || j < b.length) if (i < a.length && j < b.length && a[i] === b[j]) {
+		lines.push({
+			kind: " ",
+			text: a[i],
+			at: i + 1
+		});
+		i += 1;
+		j += 1;
+	} else if (i < a.length && (j === b.length || common[i + 1][j] >= common[i][j + 1])) {
+		lines.push({
+			kind: "-",
+			text: a[i],
+			at: i + 1
+		});
+		i += 1;
+	} else {
+		lines.push({
+			kind: "+",
+			text: b[j],
+			at: i + 1
+		});
+		j += 1;
+	}
+	const keep = lines.map((_line, index) => lines.slice(Math.max(0, index - context), index + context + 1).some((near) => near.kind !== " "));
+	const hunks = [];
+	let open = false;
+	lines.forEach((line, index) => {
+		if (!keep[index]) {
+			open = false;
+			return;
+		}
+		if (!open) {
+			hunks.push(`@@ line ${String(line.at)} @@`);
+			open = true;
+		}
+		hunks.push(`${line.kind}${line.text}`);
+	});
+	return hunks.length === 0 ? "" : [
+		`--- ${file}`,
+		`+++ ${file}`,
+		...hunks
+	].join("\n");
+};
+//#endregion
+//#region src/fix/format.ts
+/**
+* The edited text formatted as the project formats it — when the file was formatted that way before the edit. One the
+* project does not keep formatted is written as it is, so the change is the edit and nothing else.
+*/
+var formatLikeBefore = async (format, file, before, after) => {
+	try {
+		return await format(file, before) === before ? await format(file, after) : after;
+	} catch {
+		return after;
+	}
+};
+//#endregion
+//#region src/fix/plan.ts
+/** A fix by what it is, to tell whether it is still to be made after the source was edited. */
+var fixKey = (fix) => `${fix.code} ${fix.elementId ?? ""} ${fix.message}`;
+/** A problem by its code and its element: the message may change with a fix, the problem is the same problem. */
+var problemKey = (problem) => `${problem.code} ${problem.elementId ?? ""}`;
+var projectPlan = ({ space, plugins }) => {
+	try {
+		return planFixes(space, { plugins });
+	} catch (error) {
+		return { problem: `the space is not written as far as its documents — ${refusalOf(error).message.split("\n")[0]}` };
+	}
+};
+/**
+* Why the fixes written are not to be kept, by element: a fix still there to make, a problem that was not there
+* before. An element named is one whose fixes go back to the author; a reason with no element blames them all.
+*/
+var verdict = (before, written, after) => {
+	if ("problem" in after) return {
+		reasons: [`the space no longer authors: ${after.problem}`],
+		elements: /* @__PURE__ */ new Set([null])
+	};
+	const still = new Set(after.fixes.map(fixKey));
+	const known = new Set(before.problems.map(problemKey));
+	const stuck = written.filter((fix) => still.has(fixKey(fix)));
+	const added = after.problems.filter((problem) => !known.has(problemKey(problem)));
+	return {
+		reasons: [...stuck.map((fix) => `still to fix: [${fix.code}] ${fix.message}`), ...added.map((problem) => `new problem: [${problem.code}] ${problem.message}`)],
+		elements: /* @__PURE__ */ new Set([...stuck.map((fix) => fix.elementId), ...added.map((problem) => problem.elementId)])
+	};
+};
+//#endregion
+//#region src/fix/sourceEdits.ts
+var SINGLE = "'";
+var quoted = (text) => `${SINGLE}${text.replace(/\\/g, "\\\\").replaceAll(SINGLE, `\\${SINGLE}`)}${SINGLE}`;
+var literalText = (value) => typeof value === "string" ? quoted(value) : String(value);
+var keyText = (key) => /^[A-Za-z_$][\w$]*$/.test(key) ? key : quoted(key);
+/** A property's name as written: `mode`, `'aria-label'`. */
+var nameOf = (ts, property) => {
+	const name = property.name;
+	if (!name) return;
+	return ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name) ? name.text : void 0;
+};
+var findProperty = (ts, object, key) => object.properties.find((property) => nameOf(ts, property) === key);
+/** The object literal a property holds, when it holds one: `attributes: { … }`, `params: { … }`. */
+var objectAt = (ts, object, key) => {
+	const property = findProperty(ts, object, key);
+	return property && ts.isPropertyAssignment(property) && ts.isObjectLiteralExpression(property.initializer) ? property.initializer : void 0;
+};
+/** One item of a comma list taken out, with the comma that went with it. */
+var removeFromList = (sourceFile, items, index) => {
+	const item = items[index];
+	if (index < items.length - 1) return {
+		start: item.getStart(sourceFile),
+		end: items[index + 1].getStart(sourceFile),
+		text: ""
+	};
+	if (index > 0) return {
+		start: items[index - 1].getEnd(),
+		end: item.getEnd(),
+		text: ""
+	};
+	return {
+		start: item.getStart(sourceFile),
+		end: item.getEnd(),
+		text: ""
+	};
+};
+/** The call written at the factory's name: `container(` at that line and column, from 1. */
+var callAt = (ts, sourceFile, line, column) => {
+	let found;
+	const visit = (node) => {
+		if (found) return;
+		if (ts.isCallExpression(node)) {
+			const callee = ts.isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression;
+			const at = sourceFile.getLineAndCharacterOfPosition(callee.getStart(sourceFile));
+			if (at.line + 1 === line && at.character + 1 === column) {
+				found = node;
+				return;
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return found;
+};
+/** The props a factory call was handed: its last object literal — `text('Hi', { … })`, `container({ … })`. */
+var propsOf = (ts, call) => call.arguments.filter(ts.isObjectLiteralExpression).at(-1);
+/**
+* The object a step was written with: itself when it is a literal, a builder's own props (`setState({ … })`), or —
+* through a wrapper (`named('x', …)`, `when(rule, …)`) — the step it wraps, which is its last argument.
+*/
+var stepObject = (ts, expression) => {
+	if (ts.isObjectLiteralExpression(expression)) return expression;
+	if (!ts.isCallExpression(expression)) return;
+	const last = expression.arguments.at(-1);
+	if (last && ts.isCallExpression(last)) return stepObject(ts, last);
+	return expression.arguments.filter(ts.isObjectLiteralExpression).at(-1);
+};
+var stepIn = (ts, props, flow, index) => {
+	const flows = findProperty(ts, props, "flows");
+	if (!flows || !ts.isPropertyAssignment(flows) || !ts.isArrayLiteralExpression(flows.initializer)) return;
+	const steps = flows.initializer.elements.at(flow);
+	const step = steps && ts.isArrayLiteralExpression(steps) ? steps.elements.at(index) : void 0;
+	return step ? stepObject(ts, step) : void 0;
+};
+var isLiteral = (ts, node) => ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) || ts.isNumericLiteral(node) || node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword || node.kind === ts.SyntaxKind.NullKeyword;
+/** `key: value` added to an object literal, after what it already holds. */
+var insertInto = (sourceFile, object, key, value) => {
+	const last = object.properties.at(-1);
+	if (!last) return {
+		start: object.getStart(sourceFile),
+		end: object.getEnd(),
+		text: `{ ${keyText(key)}: ${value} }`
+	};
+	return {
+		start: last.getEnd(),
+		end: last.getEnd(),
+		text: `, ${keyText(key)}: ${value}`
+	};
+};
+/** An edit to one key of `object` — or of what it nests the key in (`attributes`, `params`). */
+var editKey = (ts, sourceFile, object, nested, edit) => {
+	const inner = nested === void 0 ? void 0 : objectAt(ts, object, nested);
+	const holder = findProperty(ts, object, edit.key) ? object : inner && findProperty(ts, inner, edit.key) ? inner : void 0;
+	const property = holder ? findProperty(ts, holder, edit.key) : void 0;
+	if (edit.op === "set") {
+		if (edit.value === void 0) return { unplaced: "there is no value to write" };
+		if (!holder || !property) return { change: insertInto(sourceFile, inner ?? object, edit.key, literalText(edit.value)) };
+		if (!ts.isPropertyAssignment(property) || !isLiteral(ts, property.initializer)) return { unplaced: `\`${edit.key}\` is not written as a value there` };
+		return { change: {
+			start: property.initializer.getStart(sourceFile),
+			end: property.initializer.getEnd(),
+			text: literalText(edit.value)
+		} };
+	}
+	if (!holder || !property) return { unplaced: `\`${edit.key}\` is not written in that call` };
+	if (edit.op === "remove") return { change: removeFromList(sourceFile, holder.properties, holder.properties.indexOf(property)) };
+	if (edit.op === "rename" && edit.to !== void 0) {
+		if (ts.isShorthandPropertyAssignment(property)) return { change: {
+			start: property.getStart(sourceFile),
+			end: property.getEnd(),
+			text: `${keyText(edit.to)}: ${property.name.text}`
+		} };
+		if (ts.isPropertyAssignment(property)) return { change: {
+			start: property.name.getStart(sourceFile),
+			end: property.name.getEnd(),
+			text: keyText(edit.to)
+		} };
+	}
+	return { unplaced: `\`${edit.key}\` is not a property that edit applies to` };
+};
+/** A binding by its target: a key of `bind: { … }`, or the entry of `bind: [ … ]` whose `to` it is. */
+var editBinding = (ts, sourceFile, props, edit) => {
+	const bind = findProperty(ts, props, "bind");
+	if (!bind || !ts.isPropertyAssignment(bind)) return { unplaced: "the binding is not written in that call" };
+	const list = bind.initializer;
+	if (edit.op === "replace" && edit.to !== void 0) {
+		let found;
+		const visit = (node) => {
+			if (!found && ts.isStringLiteral(node) && node.text === edit.key && ts.isPropertyAssignment(node.parent) && nameOf(ts, node.parent) === "action") found = node;
+			ts.forEachChild(node, visit);
+		};
+		visit(list);
+		return found ? { change: {
+			start: found.getStart(sourceFile),
+			end: found.getEnd(),
+			text: quoted(edit.to)
+		} } : { unplaced: `"${edit.key}" is not written as a transformer there` };
+	}
+	if (edit.op !== "remove") return { unplaced: "that change to a binding has no one way to be written" };
+	const dropBind = () => ({ change: removeFromList(sourceFile, props.properties, props.properties.indexOf(bind)) });
+	if (ts.isObjectLiteralExpression(list)) {
+		const property = findProperty(ts, list, edit.key);
+		if (!property) return { unplaced: `the binding onto "${edit.key}" is not written there` };
+		return list.properties.length === 1 ? dropBind() : { change: removeFromList(sourceFile, list.properties, list.properties.indexOf(property)) };
+	}
+	if (ts.isArrayLiteralExpression(list)) {
+		const index = list.elements.findIndex((entry) => {
+			if (!ts.isObjectLiteralExpression(entry)) return false;
+			const to = findProperty(ts, entry, "to");
+			return to !== void 0 && ts.isPropertyAssignment(to) && ts.isStringLiteral(to.initializer) && to.initializer.text === edit.key;
+		});
+		if (index === -1) return { unplaced: `the binding onto "${edit.key}" is not written there` };
+		return list.elements.length === 1 ? dropBind() : { change: removeFromList(sourceFile, list.elements, index) };
+	}
+	return { unplaced: "`bind` is not written as a literal there" };
+};
+/**
+* What an edit planned on a spec changes in the source that wrote it: the call at its position, the props it was
+* handed, and in them only what is written as a literal. Anything else — a value computed, props spread from a
+* variable, a flow built elsewhere — is left as it was and said, for the author.
+*/
+var sourceEdit = (ts, sourceFile, position, edit) => {
+	const call = callAt(ts, sourceFile, position.line, position.column);
+	if (!call) return { unplaced: "the call that wrote it is not where it was" };
+	const props = propsOf(ts, call);
+	if (!props) return { unplaced: "the call that wrote it was handed no props to edit" };
+	if (edit.on === "binding") return editBinding(ts, sourceFile, props, edit);
+	if (edit.on === "step") {
+		const step = edit.step ? stepIn(ts, props, edit.step.flow, edit.step.index) : void 0;
+		return step ? editKey(ts, sourceFile, step, "params", edit) : { unplaced: "the step is not written in that call" };
+	}
+	return editKey(ts, sourceFile, props, edit.on === "attribute" ? "attributes" : void 0, edit);
+};
+/** The text with every change made — from the end back, so each span is where it was found. Overlaps are refused. */
+var applyChanges = (text, changes) => {
+	const ordered = [...changes].toSorted((a, b) => b.start - a.start);
+	for (let index = 1; index < ordered.length; index += 1) if (ordered[index].end > ordered[index - 1].start) return;
+	return ordered.reduce((result, change) => result.slice(0, change.start) + change.text + result.slice(change.end), text);
+};
+//#endregion
+//#region src/projectTypeScript.ts
+/**
+* The TypeScript a project (or a plugin package) installs, resolved from its own folder rather than the CLI's: its
+* version is the one its source is written for. Absent when it installs none.
+*/
+var loadTypeScript = (root) => {
+	try {
+		return createRequire(path.join(root, "package.json"))("typescript");
+	} catch {
+		return;
+	}
+};
+//#endregion
+//#region src/commands/fix.ts
+var run = promisify(execFile);
+var editSources = async (root, fixes) => {
+	const ts = loadTypeScript(root);
+	const placed = [];
+	const left = [];
+	const sources = /* @__PURE__ */ new Map();
+	for (const fix of fixes) {
+		if (!fix.edit || !fix.position) {
+			left.push({
+				fix,
+				why: fix.position ? "it has no one way to be written" : "no call of the project wrote it"
+			});
+			continue;
+		}
+		if (!ts) {
+			left.push({
+				fix,
+				why: "the project has no TypeScript to read its source with"
+			});
+			continue;
+		}
+		const file = path.resolve(process.cwd(), fix.position.file);
+		let source = sources.get(file);
+		if (!source) {
+			const text = await fs.readFile(file, "utf-8");
+			source = {
+				text,
+				sourceFile: ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+			};
+			sources.set(file, source);
+		}
+		const outcome = sourceEdit(ts, source.sourceFile, fix.position, fix.edit);
+		if ("unplaced" in outcome) left.push({
+			fix,
+			why: outcome.unplaced
+		});
+		else placed.push({
+			fix,
+			file,
+			change: outcome.change
+		});
+	}
+	const format = await projectFormatter(root);
+	const files = [];
+	const written = [];
+	for (const [file, { text }] of sources) {
+		const mine = placed.filter((entry) => entry.file === file);
+		const changed = applyChanges(text, mine.map((entry) => entry.change));
+		if (changed === void 0) {
+			left.push(...mine.map((entry) => ({
+				fix: entry.fix,
+				why: "it overlaps another fix in the same place"
+			})));
+			continue;
+		}
+		if (mine.length > 0) {
+			files.push({
+				file,
+				before: text,
+				after: await formatLikeBefore(format, path.relative(root, file), text, changed)
+			});
+			written.push(...mine.map((entry) => entry.fix));
+		}
+	}
+	return {
+		files,
+		written,
+		left
+	};
+};
+/** A plan as `plitzi fix --json` prints it. */
+var planFromJson = (stdout) => {
+	const parsed = JSON.parse(stdout);
+	if (!e$1(parsed)) return { problem: "the space did not answer as a plan" };
+	if (typeof parsed.problem === "string") return { problem: parsed.problem };
+	const entries = (value) => Array.isArray(value) ? value.filter(e$1) : [];
+	const elementOf = (entry) => typeof entry.elementId === "string" ? entry.elementId : null;
+	return {
+		fixes: entries(parsed.fixes).map((entry) => ({
+			code: String(entry.code),
+			elementId: elementOf(entry),
+			message: String(entry.message)
+		})),
+		problems: entries(parsed.problems).map((entry) => ({
+			code: String(entry.code),
+			elementId: elementOf(entry),
+			message: String(entry.message)
+		}))
+	};
+};
+/** The plan, made in a process of its own: the edited files are imported fresh, never from this one's module cache. */
+var planAfresh = async () => {
+	try {
+		const { stdout } = await run(process.execPath, [
+			process.argv[1],
+			"fix",
+			"--json"
+		], {
+			cwd: process.cwd(),
+			maxBuffer: 16777216
+		});
+		return planFromJson(stdout);
+	} catch (error) {
+		const printed = e$1(error) && typeof error.stdout === "string" ? error.stdout.trim() : "";
+		if (printed.startsWith("{")) return planFromJson(printed);
+		return { problem: error instanceof Error ? error.message.split("\n").slice(0, 3).join(" ") : String(error) };
+	}
+};
+var leftText = (left) => left.length === 0 ? [] : [chalk.yellow(`${String(left.length)} left for you:`), ...left.map(({ fix, why }) => `  - ${fix.at ? `${fix.at} ` : ""}[${fix.code}] ${fix.message} (${why})`)];
+var fix = async (options) => {
+	const project = await findProject(process.cwd());
+	if (!project || project.plitzi?.kind !== "project" || project.plitzi.source !== "local") {
+		fail("Run this in a project whose space is written in it (`src/space.ts`): one kept on Plitzi is fixed in the builder.");
+		return;
+	}
+	const loaded = await loadProjectSpace(project.root);
+	if ("problem" in loaded) {
+		fail(loaded.problem);
+		return;
+	}
+	const plan = projectPlan(loaded);
+	if (options.json) {
+		console.log(JSON.stringify(plan));
+		if ("problem" in plan) process.exitCode = 1;
+		return;
+	}
+	if ("problem" in plan) {
+		fail(`Nothing to plan: ${plan.problem}. \`npm run author\` says what to change first.`);
+		return;
+	}
+	if (plan.fixes.length === 0) {
+		console.log(chalk.green("Nothing to fix."));
+		return;
+	}
+	const edited = await editSources(project.root, plan.fixes);
+	const diffs = edited.files.map(({ file, before, after }) => unifiedDiff(path.relative(process.cwd(), file), before, after));
+	if (!options.write) {
+		console.log([
+			...diffs,
+			...edited.written.length > 0 ? [chalk.green(`${String(edited.written.length)} to write: plitzi fix --write`)] : [],
+			...leftText(edited.left)
+		].join("\n"));
+		return;
+	}
+	let attempt = edited;
+	const refused = [];
+	for (;;) {
+		await Promise.all(attempt.files.map(({ file, after }) => fs.writeFile(file, after)));
+		const { reasons, elements } = verdict(plan, attempt.written, await planAfresh());
+		if (reasons.length === 0) break;
+		await Promise.all(attempt.files.map(({ file, before }) => fs.writeFile(file, before)));
+		const blamed = attempt.written.filter((entry) => elements.has(null) || elements.has(entry.elementId));
+		const why = `writing it would leave the space with ${reasons.join("; ")}`;
+		refused.push(...blamed.map((entry) => ({
+			fix: entry,
+			why
+		})));
+		const rest = attempt.written.filter((entry) => !blamed.includes(entry));
+		if (blamed.length === 0 || rest.length === 0) {
+			fail(["Nothing was written — the source is as it was:", ...reasons.map((reason) => `  - ${reason}`)].join("\n"));
+			console.log(leftText([...edited.left, ...refused]).join("\n"));
+			return;
+		}
+		attempt = await editSources(project.root, rest);
 	}
-	const types = [pluginNames(main).type, ...others.map((name) => pluginNames(name).type)];
-	const repeated = types.find((type, index) => types.indexOf(type) !== index);
-	return repeated ? `Two elements would both be "${repeated}": give each a name of its own.` : void 0;
+	console.log([
+		...attempt.files.map(({ file, before, after }) => unifiedDiff(path.relative(process.cwd(), file), before, after)),
+		chalk.green(`Wrote ${String(attempt.written.length)} ${attempt.written.length === 1 ? "fix" : "fixes"} in ${String(attempt.files.length)} ${attempt.files.length === 1 ? "file" : "files"}; the space authors with them gone. Typecheck the project before calling it done.`),
+		...leftText([...edited.left, ...refused])
+	].join("\n"));
 };
-/** The folders a repository keeps its packages in, as places for this one — or `./<name>` outside of any. */
-var folderOptions = (project, base) => {
-	if (!project) return [];
-	const root = project.workspaceRoot ?? project.root;
-	return [.../* @__PURE__ */ new Set([...project.workspaceFolders, "plugins"])].map((folder) => {
-		const value = path.join(root, folder, base);
-		return {
-			label: path.relative(process.cwd(), value) || ".",
-			value
-		};
-	});
+//#endregion
+//#region src/commands/siteOwnership.ts
+var LOOPBACK = /^(127\.|::1$|::ffff:127\.)/;
+/** Served from this machine: `localhost`, or a name that resolves only to loopback addresses (a `/etc/hosts` entry). */
+var isThisMachine = async (host) => {
+	const name = host.replace(/^\[|\]$/g, "").toLowerCase();
+	if (name === "localhost" || name.endsWith(".localhost")) return true;
+	try {
+		const addresses = await lookup(name, { all: true });
+		return addresses.length > 0 && addresses.every(({ address }) => LOOPBACK.test(address));
+	} catch {
+		return false;
+	}
 };
-var askDirectory = async (rl, project, base) => {
-	const typed = {
-		question: "Which folder? (relative to here)",
-		fallback: `./${base}`
+var NOT_YOURS = (host) => `${host} is not a verified domain of any space of yours, so it is not imported. If the site is yours: add its domain to one of your spaces under Domains in the dashboard, publish the \`_plitzi\` TXT record it shows, verify it, and import again.`;
+var siteOwnership = async (url, options) => {
+	if (await isThisMachine(url.hostname)) return {
+		ok: true,
+		said: "served from this machine"
+	};
+	const api = await apiFor(options);
+	const connection = api && await signedIn(api, `to show ${url.hostname} is yours`);
+	if (!connection) return { ok: false };
+	const answered = await authorizedRequest(connection, `/account/domains/covering?host=${encodeURIComponent(url.hostname)}`);
+	if (!answered.ok) return {
+		ok: false,
+		problem: answered.error
+	};
+	const { status, data } = answered.value.reply;
+	const space = e$1(data) && e$1(data.space) && typeof data.space.name === "string" ? data.space.name : "";
+	if (status === 200 && e$1(data) && typeof data.domain === "string") return {
+		ok: true,
+		said: `${data.domain}, verified for ${space || "one of your spaces"}`
+	};
+	if (status === 404) return {
+		ok: false,
+		problem: NOT_YOURS(url.hostname)
+	};
+	return {
+		ok: false,
+		problem: `The platform could not say whether ${url.hostname} is yours (${String(status)}).`
 	};
-	if (!project) return path.resolve(await askText(rl, "Which folder should the plugin be written to?", typed.fallback));
-	const chosen = await askChoice(rl, `Which folder of ${path.relative(process.cwd(), project.workspaceRoot ?? project.root) || "this project"} should the plugin go in?`, folderOptions(project, base), {
-		label: "Somewhere else",
-		...typed
-	});
-	return path.resolve(chosen);
 };
-/**
-* The manager: the one the repository already installs with, when it is written into one — asking would only offer a
-* second lockfile — and otherwise asked, as a project's is.
-*/
-var resolveManager = async (rl, options, project) => {
-	const given = PACKAGE_MANAGERS.find((manager) => manager === options.packageManager);
-	if (given ?? project?.packageManager) return given ?? project?.packageManager;
-	const detected = detectPackageManager();
-	if (!rl || options.yes) return options.yes ? detected : void 0;
-	return ask(rl, {
-		flag: "--package-manager",
-		choices: PACKAGE_MANAGERS,
-		question: `Which package manager will you work in? (this was run through ${detected})`,
-		fallback: detected
+//#endregion
+//#region src/commands/importPage.ts
+var OUTLINE_DEPTH = 4;
+/** Scrolls to the end and back, so pictures and sections that load as they come into view are there to measure. */
+var revealLazyContent = async (page) => {
+	await page.evaluate(async () => {
+		const step = window.innerHeight;
+		for (let y = 0; y < Math.min(document.body.scrollHeight, 3e4); y += step) {
+			window.scrollTo(0, y);
+			await new Promise((resolve) => setTimeout(resolve, 60));
+		}
+		window.scrollTo(0, 0);
+	}, void 0);
+	await page.waitForTimeout(300);
+};
+var measure = async (browser, url, width, scheme, read = []) => {
+	const page = await browser.newPage({
+		viewport: {
+			width,
+			height: 900
+		},
+		colorScheme: scheme,
+		reducedMotion: "reduce"
 	});
+	const answered = await page.goto(url, { waitUntil: "networkidle" }).catch((error) => error);
+	if (answered instanceof Error) return { problem: `${url} did not load at ${String(width)} px: ${answered.message.split("\n")[0] ?? ""}` };
+	await revealLazyContent(page);
+	return {
+		probe: await page.evaluate(importProbe, {
+			depth: OUTLINE_DEPTH,
+			read
+		}),
+		screen: await page.screenshot({ fullPage: true })
+	};
 };
-var createPlugin = async (directory, options) => {
-	const nameGiven = options.name ?? (directory ? path.basename(path.resolve(directory)) : void 0);
-	const othersGiven = options.elements === void 0 ? void 0 : splitNames(options.elements);
-	const nameProblem = nameGiven === void 0 ? void 0 : pluginNameProblem(nameGiven) ?? elementListProblem(pluginNames(nameGiven).base, othersGiven ?? []);
-	if (nameProblem) {
-		console.error(chalk.red(nameProblem));
-		process.exitCode = 1;
+/** Every file under a folder, by its path inside it — none when there is no such folder. */
+var filesUnder = async (folder) => {
+	return (await readdir(folder, {
+		recursive: true,
+		withFileTypes: true
+	}).catch(() => [])).filter((entry) => entry.isFile()).map((entry) => path.relative(folder, path.join(entry.parentPath, entry.name)));
+};
+var count = (amount, one, many = `${one}s`) => `${String(amount)} ${amount === 1 ? one : many}`;
+var summaryText = (summary, out, stale) => [
+	chalk.green(`Imported ${summary.url} into ${out}`),
+	`  tokens   ${count(summary.colours, "colour")} (${summary.dark ? "light and dark" : "no dark scheme: dark repeats light"}), ${count(summary.shadows, "shadow")}, ${count(summary.radii, "radius", "radii")}${summary.fonts.length > 0 ? `, fonts ${summary.fonts.join(", ")}` : ""}`,
+	`  outline  ${count(summary.blocks, "block")} at ${summary.widths.join(", ")} px`,
+	...summary.lists.length > 0 ? [`  lists    ${summary.lists.map((list) => `${list.file} (${count(list.rows, "row")})`).join(", ")}`] : [],
+	`  pictures ${String(summary.pictures)} in assets.json`,
+	...stale.length > 0 ? [chalk.yellow(`  earlier  ${stale.join(", ")} ${stale.length === 1 ? "was" : "were"} there before and not written this time: delete what is stale`)] : [],
+	`  next     ${path.join(out, "IMPORT.md")} says what was not carried over`
+].join("\n");
+var importPage = async (address, options) => {
+	let url;
+	try {
+		url = new URL(address);
+	} catch {
+		fail(`${address} is not a URL: give the whole address, https://example.com/page.`);
 		return;
 	}
-	const here = await findProject(process.cwd());
-	const terminal = atTerminal();
-	if (!terminal && (nameGiven === void 0 || directory === void 0)) {
-		refuseWithoutTerminal("plugin", [...nameGiven === void 0 ? [QUESTIONS.name] : [], ...directory === void 0 ? [QUESTIONS.directory] : []]);
+	if (url.protocol !== "https:" && url.protocol !== "http:") {
+		fail(`${address} is not a web page: only http and https addresses are imported.`);
+		return;
+	}
+	const project = await projectHere("to import into");
+	if (!project) return;
+	const out = options.out ?? "src/imported";
+	const target = path.resolve(project.root, out);
+	if (path.relative(project.root, target).startsWith("..")) {
+		fail(`${out} is outside the project: the import is written inside it.`);
+		return;
+	}
+	const existing = await filesUnder(target);
+	if (existing.length > 0 && !options.force) {
+		fail(`${out} already has files: choose another --out, or --force to write over them.`);
+		return;
+	}
+	const widths = options.width ?? [
+		1440,
+		768,
+		390
+	];
+	const ownership = await siteOwnership(url, options);
+	if (!ownership.ok) {
+		if (ownership.problem) fail(ownership.problem);
+		return;
+	}
+	if (!options.json) console.log(chalk.dim(`${url.hostname} is yours: ${ownership.said}.`));
+	const browser = await launchBrowser(project.root);
+	if ("problem" in browser) {
+		fail(browser.problem);
 		return;
 	}
-	const rl = terminal ? readline.createInterface({
-		input: process.stdin,
-		output: process.stdout
-	}) : void 0;
 	try {
-		/**
-		* Everything the plugin is called and says about itself, asked before a file is written — the package name, what
-		* the builder's catalogue shows, what an agent reads to choose it, who publishes it. Each has a default, taken
-		* whole with Enter; only the name and the folder are ever refused for want of an answer.
-		*/
-		const name = nameGiven ?? (rl ? await askText(rl, QUESTIONS.name.question, DEFAULT_NAME, pluginNameProblem) : DEFAULT_NAME);
-		const names = pluginNames(name);
-		const answer = async (question, given, fallback) => given ?? (rl && !options.yes ? askText(rl, question, fallback) : fallback);
-		const title = await answer("What does the builder call the element?", options.title, names.title);
-		const description = await answer("What is it for, in a sentence? The builder shows it, and an agent reads it to choose the element.", options.description, "");
-		const owner = await answer("Who publishes it?", options.owner, "");
-		const others = othersGiven ?? (rl && !options.yes ? splitNames(await askText(rl, "Any other elements in this package? Their names, separated by commas.", "", (reply) => elementListProblem(names.base, splitNames(reply)))) : []);
-		const otherElements = [];
-		for (const other of others) {
-			const otherNames = pluginNames(other);
-			otherElements.push({
-				name: other,
-				title: await answer(`What does the builder call ${other}?`, void 0, otherNames.title),
-				description: await answer(`What is ${other} for, in a sentence?`, void 0, "")
-			});
-		}
-		const target = directory ? path.resolve(directory) : rl ? await askDirectory(rl, here, names.base) : void 0;
-		if (!target) return;
-		const wasEmpty = await isEmpty(target);
-		if (!options.force && !wasEmpty) {
-			console.error(chalk.red(`${target} is not empty. Pass --force to write into it anyway.`));
-			process.exitCode = 1;
-			return;
+		const measured = [];
+		for (const width of widths) {
+			const result = await measure(browser, url.href, width, "light");
+			if ("problem" in result) {
+				fail(result.problem);
+				return;
+			}
+			measured.push(result);
 		}
-		const project = await findProject(path.dirname(target));
-		const packageManager = await resolveManager(rl, options, project);
-		if (!packageManager) {
-			if (!rl) refuseWithoutTerminal("plugin", [{
-				flag: "--package-manager",
-				choices: PACKAGE_MANAGERS,
-				question: "Which package manager will you work in?"
-			}]);
-			process.exitCode = 1;
-			return;
+		const widest = measured.reduce((wide, next) => next.probe.width > wide.probe.width ? next : wide).probe;
+		const darkResult = await measure(browser, url.href, widest.width, "dark", Object.values(widest.colors.samples));
+		const dark = "probe" in darkResult ? darkScheme(widest, darkResult.probe) : void 0;
+		const { files, summary } = importedFiles({
+			probes: measured.map(({ probe }) => probe),
+			...dark ? { dark } : {}
+		});
+		const format = await projectFormatter(project.root);
+		await mkdir(path.join(target, "screens"), { recursive: true });
+		for (const file of files) {
+			const destination = path.join(target, file.path);
+			await mkdir(path.dirname(destination), { recursive: true });
+			const relative = path.relative(project.root, destination);
+			await writeFile(destination, file.path.endsWith(".ts") ? await format(relative, file.content) : file.content);
 		}
-		await writeFiles(target, scaffoldPlugin({
-			packageName: name,
-			elements: [{
-				name: names.base,
-				title,
-				description
-			}, ...otherElements],
-			owner,
-			packageManager,
-			managerVersion: detectManagerVersion(packageManager, await nearestExisting(target)),
-			inProject: project !== void 0
+		const screens = measured.map(({ probe, screen }) => ({
+			path: `screens/${String(probe.width)}.png`,
+			screen
 		}));
-		/**
-		* Installed where it will be installed from. Inside a workspace that covers the folder, installing there installs
-		* the workspace; inside a repository that does not list it, Yarn refuses to install a package it does not know —
-		* so that is said, with the fix, rather than failed at.
-		*/
-		const unlisted = project?.workspaceRoot !== void 0 && !coveredByWorkspace(project, target);
-		const wantsInstall = options.install !== false && !unlisted;
-		const installed = wantsInstall && await install(packageManager, target);
-		if (wantsInstall && !installed) {
-			console.error(chalk.red(`\n\`${installCommand(packageManager)}\` failed. The plugin is written; the reason is in the output above.`));
-			console.error(chalk.dim(INSTALL_HINTS[packageManager]));
-			process.exitCode = 1;
-		}
-		if (installed && wasEmpty) await runScript(packageManager, "format", target);
-		const where = cdPrefix(target);
-		console.log(chalk.green(`\n${name} — the ${names.type} element, as a package any space can load.`));
-		if (unlisted) console.log(chalk.yellow(`\n${path.relative(process.cwd(), target)} is not one of the workspace's packages: add it to \`workspaces\`, then install.`));
-		console.log("");
-		if (!installed) console.log(`  ${where}${installCommand(packageManager)}`);
-		console.log(`  ${where}${runCommand(packageManager, "start")}   # the plugin inside a space`);
-		console.log(`  ${where}${runCommand(packageManager, "zip")}     # what the builder takes, under Resources`);
-		console.log("");
+		for (const { path: file, screen } of screens) await writeFile(path.join(target, file), screen);
+		const written = /* @__PURE__ */ new Set([...files.map((file) => file.path), ...screens.map((screen) => screen.path)]);
+		const stale = existing.filter((file) => !written.has(file.split(path.sep).join("/")));
+		console.log(options.json ? JSON.stringify({
+			...summary,
+			out,
+			files: [...written],
+			stale
+		}) : summaryText(summary, out, stale));
 	} finally {
-		rl?.close();
+		await browser.close();
 	}
 };
 //#endregion
 //#region ../../packages/sdk-shared/dist/source/snapshot.mjs
-var t = {
+var n = {
 	files: 2e3,
 	fileBytes: 4194304,
 	totalBytes: 25165824
 };
-var n = ["plugin", "runtime"];
-var r = [
+var r = ["plugin", "runtime"];
+var i = [
 	/(^|\/)\.env(\.|$)/,
 	/\.(pem|key|p12|pfx)$/i,
 	/(^|\/)id_(rsa|dsa|ecdsa|ed25519)$/
 ];
-var i = [
+var a = [
 	{
 		what: "a private key",
 		pattern: /-----BEGIN (?:[A-Z]+ )?PRIVATE KEY-----/
@@ -4671,55 +6392,54 @@ var i = [
 		pattern: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/
 	}
 ];
-var a = (e) => {
+var o = (e) => {
 	let t = e.split("/");
 	if (!e || e.startsWith("/") || /^[a-zA-Z]:/.test(e) || e.includes("\\")) return `"${e}" is not a path relative to the project, with forward slashes`;
 	if (t.some((e) => e === "" || e === "." || e === "..")) return `"${e}" climbs out of the project, or has an empty part`;
 	if (t.some((e) => e === "node_modules" || e === ".git")) return `"${e}" is in node_modules or .git: a package is a dependency, not a file of the project`;
-	if (r.some((t) => t.test(e))) return `"${e}" is a file of credentials: they stay where the project runs, never in what Plitzi keeps`;
-};
-var o = (e) => i.find(({ pattern: t }) => t.test(e))?.what;
-var s = (e) => typeof e == "string" && n.some((t) => t === e);
-var c = (e) => typeof e == "string" && /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(e);
-var l = (e) => Array.isArray(e) && e.length > 0 && e.every((e) => typeof e == "string");
-var u = (e) => typeof e == "object" && !!e && !Array.isArray(e);
-var d = (e) => u(e) && Object.values(e).every((e) => typeof e == "string");
+	if (i.some((t) => t.test(e))) return `"${e}" is a file of credentials: they stay where the project runs, never in what Plitzi keeps`;
+};
+var s = (e) => a.find(({ pattern: t }) => t.test(e))?.what;
+var c = (e) => typeof e == "string" && r.some((t) => t === e);
+var l = (e) => typeof e == "string" && /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(e);
+var u = (e) => Array.isArray(e) && e.length > 0 && e.every((e) => typeof e == "string");
+var d = (t) => e$1(t) && Object.values(t).every((e) => typeof e == "string");
 var f = (e) => Math.floor(e.length * 3 / 4) - (e.endsWith("==") ? 2 : +!!e.endsWith("="));
-var p = (e, r) => {
-	if (!u(e) || e.format !== 1) return {
+var p = (t, i) => {
+	if (!e$1(t) || t.format !== 1) return {
 		ok: !1,
 		problems: ["Not a source snapshot of format 1"]
 	};
-	let { kind: i, name: p, entries: m, files: h, dependencies: g } = e, _ = [];
-	if (s(i) || _.push(`Its kind is one of ${n.join(", ")}`), c(p) || _.push("Its name is a plugin type or \"runtime\": letters, digits, dashes and underscores"), !d(h) || !d(g)) return {
+	let { kind: a, name: p, entries: m, files: h, dependencies: g } = t, _ = [];
+	if (c(a) || _.push(`Its kind is one of ${r.join(", ")}`), l(p) || _.push("Its name is a plugin type or \"runtime\": letters, digits, dashes and underscores"), !d(h) || !d(g)) return {
 		ok: !1,
 		problems: [..._, "Its files and dependencies are maps of text"]
 	};
-	l(m) ? m.filter((e) => !Object.hasOwn(h, e)).forEach((e) => _.push(`Its entry "${e}" is not among its files`)) : _.push("It names at least one entry");
+	u(m) ? m.filter((e) => !Object.hasOwn(h, e)).forEach((e) => _.push(`Its entry "${e}" is not among its files`)) : _.push("It names at least one entry");
 	let v = Object.keys(h);
-	v.length > t.files && _.push(`It holds ${String(v.length)} files; a snapshot holds at most ${String(t.files)}`);
+	v.length > n.files && _.push(`It holds ${String(v.length)} files; a snapshot holds at most ${String(n.files)}`);
 	let y = 0;
 	return v.forEach((e) => {
-		let n = a(e);
-		if (n) {
-			_.push(n);
+		let t = o(e);
+		if (t) {
+			_.push(t);
 			return;
 		}
-		let i = f(h[e]);
-		if (y += i, i > t.fileBytes) {
-			_.push(`"${e}" is ${(i / 1024 / 1024).toFixed(1)} MB; a file of source is at most 4 MB`);
+		let r = f(h[e]);
+		if (y += r, r > n.fileBytes) {
+			_.push(`"${e}" is ${(r / 1024 / 1024).toFixed(1)} MB; a file of source is at most 4 MB`);
 			return;
 		}
-		let s = o(r(h[e]));
-		s && _.push(`"${e}" holds ${s}: take it out of the code and give it to the project as a variable`);
-	}), y > t.totalBytes && _.push(`It holds ${(y / 1024 / 1024).toFixed(1)} MB of files; a snapshot holds at most 24 MB`), _.length > 0 || !s(i) || !c(p) || !l(m) ? {
+		let a = s(i(h[e]));
+		a && _.push(`"${e}" holds ${a}: take it out of the code and give it to the project as a variable`);
+	}), y > n.totalBytes && _.push(`It holds ${(y / 1024 / 1024).toFixed(1)} MB of files; a snapshot holds at most 24 MB`), _.length > 0 || !c(a) || !l(p) || !u(m) ? {
 		ok: !1,
 		problems: _
 	} : {
 		ok: !0,
 		snapshot: {
 			format: 1,
-			kind: i,
+			kind: a,
 			name: p,
 			entries: m,
 			files: h,
@@ -4746,13 +6466,6 @@ var EXTENSIONS = [
 	".scss"
 ];
 var BUILTINS = new Set(builtinModules);
-var loadTypeScript$1 = (root) => {
-	try {
-		return createRequire(path.join(root, "package.json"))("typescript");
-	} catch {
-		return;
-	}
-};
 var isFile = async (file) => {
 	try {
 		return (await fs.stat(file)).isFile();
@@ -4803,7 +6516,7 @@ var dependencyOf = async (root, name) => {
 * reaches holds a credential.
 */
 var packSource = async ({ root, kind, name, entries }) => {
-	const ts = loadTypeScript$1(root);
+	const ts = loadTypeScript(root);
 	if (!ts) throw new Error("Packing the source reads its imports with the project’s own TypeScript:\n  npm install -D typescript");
 	const problems = [];
 	const files = {};
@@ -4859,13 +6572,6 @@ var packSource = async ({ root, kind, name, entries }) => {
 };
 //#endregion
 //#region src/pack/typeDeclarations.ts
-var loadTypeScript = (root) => {
-	try {
-		return createRequire(path.join(root, "package.json"))("typescript");
-	} catch {
-		return;
-	}
-};
 var emitTypeDeclarations = (root, outDir) => {
 	const ts = loadTypeScript(root);
 	if (!ts) return "no-typescript";
@@ -4929,21 +6635,20 @@ var INLINED = [
 ];
 /** A plugin that cannot be packed, with what to change — never a stack trace out of esbuild. */
 var PackError = class extends Error {};
-var isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** The declaration, or what is missing from it — named, so the fix is one edit away. */
 var checkDeclaration = (value, where) => {
 	const missing = (field) => new PackError(`${where}: the declaration has no ${field}. Write it the way \`plitzi add plugin\` does.`);
-	if (!isRecord$2(value) || typeof value.type !== "string" || !value.type) throw missing("`type`");
+	if (!e$1(value) || typeof value.type !== "string" || !value.type) throw missing("`type`");
 	const { content } = value;
-	if (!isRecord$2(content)) throw missing("`content`");
+	if (!e$1(content)) throw missing("`content`");
 	for (const field of [
 		"attributes",
 		"definition",
 		"builder",
 		"market",
 		"defaultStyle"
-	]) if (!isRecord$2(content[field])) throw missing(`\`content.${field}\``);
-	if (!isRecord$2(content.definition) || typeof content.definition.label !== "string") throw missing("`content.definition.label`");
+	]) if (!e$1(content[field])) throw missing(`\`content.${field}\``);
+	if (!e$1(content.definition) || typeof content.definition.label !== "string") throw missing("`content.definition.label`");
 	return value;
 };
 var toImportPath = (file) => file.split(path.sep).join("/");
@@ -5125,10 +6830,6 @@ var elementFolders = async (project) => {
 	const packable = await Promise.all(folders.map(hasElement));
 	return folders.filter((_folder, index) => packable[index]);
 };
-var readVersion = async (root) => {
-	const { version } = JSON.parse(await fs.readFile(path.join(root, "package.json"), "utf-8"));
-	return version ?? "0.0.0";
-};
 /** The `-kebab-` spelling of a type, for the files it names: `seatPicker` writes `seat-picker.mjs`. */
 var fileNameOf = (folder) => path.basename(folder).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
 /** Which folders to pack, when none were named: asked for at a terminal, from the ones the project has. */
@@ -5154,8 +6855,7 @@ var chosenFolders = async (project, foldersGiven) => {
 	if (foldersGiven.length > 0) return foldersGiven.map((folder) => path.resolve(folder));
 	const candidates = await elementFolders(project);
 	if (candidates.length === 0) {
-		console.error(chalk.red("No element to pack: name its folder (plitzi pack plugin src/components/SeatPicker), or add one with plitzi add plugin."));
-		process.exitCode = 1;
+		fail("No element to pack: name its folder (plitzi pack plugin src/components/SeatPicker), or add one with plitzi add plugin.");
 		return;
 	}
 	if (!atTerminal()) {
@@ -5171,16 +6871,15 @@ var chosenFolders = async (project, foldersGiven) => {
 var packPluginCommand = async (foldersGiven, options) => {
 	const project = await findProject(process.cwd());
 	if (!project) {
-		console.error(chalk.red("plitzi pack plugin packs a plugin of a project, and there is no package.json here or above."));
-		process.exitCode = 1;
+		fail("plitzi pack plugin packs a plugin of a project, and there is no package.json here or above.");
 		return;
 	}
 	const inPackage = project.plitzi?.kind === "plugin" && foldersGiven.length === 0;
 	const folders = inPackage ? [] : await chosenFolders(project, foldersGiven);
 	if (!folders) return;
-	const packageName = JSON.parse(await fs.readFile(path.join(project.root, "package.json"), "utf-8"));
-	const base = inPackage ? pluginNames(packageName.name ?? path.basename(project.root)).base : fileNameOf(folders[0]);
-	const version = options.pluginVersion ?? await readVersion(project.root);
+	const manifest = await readPackageJson(project.root);
+	const base = inPackage ? pluginNames(manifest?.name ?? path.basename(project.root)).base : fileNameOf(folders[0]);
+	const version = options.pluginVersion ?? manifest?.version ?? "0.0.0";
 	const source = inPackage ? {
 		kind: "package",
 		entry: path.join(project.root, "src/index.ts"),
@@ -5218,8 +6917,7 @@ var packPluginCommand = async (foldersGiven, options) => {
 		console.log("");
 	} catch (error) {
 		if (!(error instanceof PackError)) throw error;
-		console.error(chalk.red(error.message));
-		process.exitCode = 1;
+		fail(error.message);
 	}
 };
 //#endregion
@@ -5231,8 +6929,7 @@ var packPluginCommand = async (foldersGiven, options) => {
 var packSourceCommand = async (entries, options) => {
 	const root = options.root ? path.resolve(options.root) : (await findProject(process.cwd()))?.root;
 	if (!root) {
-		console.error(chalk.red("plitzi pack source packs a project’s source, and there is no package.json here or above."));
-		process.exitCode = 1;
+		fail("plitzi pack source packs a project’s source, and there is no package.json here or above.");
 		return;
 	}
 	try {
@@ -5247,8 +6944,7 @@ var packSourceCommand = async (entries, options) => {
 		await fs.writeFile(out, bytes);
 		console.log(chalk.green(`${options.name}: ${String(Object.keys(snapshot.files).length)} files`) + chalk.dim(` — ${path.relative(process.cwd(), out)} (${(bytes.byteLength / 1024).toFixed(0)} KB)`));
 	} catch (error) {
-		console.error(chalk.red(error instanceof Error ? error.message : String(error)));
-		process.exitCode = 1;
+		fail(error instanceof Error ? error.message : String(error));
 	}
 };
 //#endregion
@@ -5297,13 +6993,12 @@ var verdictOf = ({ given, was, here }) => {
 	if (here === was) return "write";
 	return given === was ? "keep" : "conflict";
 };
-var isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /**
 * The packages the space's code asks for, added to the project's `package.json`: a package it does not list is added,
 * one still at the range the space last asked for follows the space, and one the project changed stays as it is.
 */
 var mergeDependencies = (manifest, asked, before) => {
-	const current = isRecord$1(manifest.dependencies) ? manifest.dependencies : {};
+	const current = e$1(manifest.dependencies) ? manifest.dependencies : {};
 	const dependencies = { ...current };
 	const changed = [];
 	const kept = [];
@@ -5400,7 +7095,7 @@ var pull = async (options) => {
 	await Promise.all(removed.map((file) => fs.rm(path.join(root, file), { force: true })));
 	const packageFile = path.join(root, "package.json");
 	const manifest = JSON.parse(await fs.readFile(packageFile, "utf-8"));
-	const dependencies = mergeDependencies(isRecord$1(manifest) ? manifest : {}, next.dependencies, origin.dependencies);
+	const dependencies = mergeDependencies(e$1(manifest) ? manifest : {}, next.dependencies, origin.dependencies);
 	if (dependencies.changed.length > 0) await fs.writeFile(packageFile, `${JSON.stringify(dependencies.manifest, null, 2)}\n`);
 	const files = Object.fromEntries([...[...given].map(([file, bytes]) => [file, digest(bytes)]), ...[...untouched].flatMap((file) => origin.files[file] ? [[file, origin.files[file]]] : [])]);
 	await writeOrigin(root, {
@@ -5469,8 +7164,7 @@ var keepSource = async (connection, spaceId, bytes) => {
 //#endregion
 //#region src/commands/runtime.ts
 var DEFAULT_ENTRY = path.join("src", "runtime.ts");
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var isPacker = (value) => isRecord(value) && typeof value.packRuntime === "function";
+var isPacker = (value) => e$1(value) && typeof value.packRuntime === "function";
 /** This project's own packer — read, since it is the project's. */
 var projectPacker = async (root) => {
 	try {
@@ -5480,15 +7174,11 @@ var projectPacker = async (root) => {
 	} catch {}
 	fail("plitzi runtime packs it with this project’s own @plitzi/sdk-server:\n  npm install @plitzi/sdk-server");
 };
-var connect = async (options, doing) => {
-	const api = await apiFor(options);
-	return api ? connectionWithSpace(api, doing) : void 0;
-};
 /** Packs the project's runtime module and keeps it as the space's draft runtime — which a publish takes live. */
 var pushRuntime = async (options) => {
-	const connection = await connect(options, "to push to");
-	if (!connection?.space) return;
-	const root = (await findProject(process.cwd()))?.root ?? process.cwd();
+	const root = (await projectHere("whose runtime to push"))?.root;
+	const connection = root && await connectToSpace(options, "to push to");
+	if (!root || !connection || !connection.space) return;
 	const entry = path.resolve(root, options.entry ?? DEFAULT_ENTRY);
 	try {
 		await fs.access(entry);
@@ -5519,7 +7209,7 @@ var pushRuntime = async (options) => {
 		fail(reply.data.error ?? `The runtime was not kept (${String(reply.status)}).`);
 		return;
 	}
-	console.log(`${chalk.green("✓")} ${connection.space.name}’s draft runtime is ${reply.data.digest.slice(0, 12)} (${(bytes.byteLength / 1024).toFixed(0)} KB). It starts in a moment; publish the space to take it live.`);
+	console.log(chalk.green(`${connection.space.name}’s draft runtime is ${reply.data.digest.slice(0, 12)} (${(bytes.byteLength / 1024).toFixed(0)} KB).`) + chalk.dim(" It starts in a moment; publish the space to take it live."));
 	try {
 		const source = await packSource({
 			root,
@@ -5552,10 +7242,20 @@ var readRuntime = async (connection, spaceId) => {
 };
 /** How each environment's runtime is, and the names of its variables. */
 var runtimeStatus = async (options) => {
-	const connection = await connect(options, "to read");
+	const connection = await connectToSpace(options, "to read");
 	if (!connection?.space) return;
 	const runtime = await readRuntime(connection, connection.space.id);
 	if (!runtime) return;
+	if (options.json) {
+		console.log(JSON.stringify({
+			space: {
+				id: connection.space.id,
+				name: connection.space.name
+			},
+			...runtime
+		}));
+		return;
+	}
 	if (!runtime.environments.length) console.log(`${connection.space.name} has no runtime. Push one: plitzi runtime push.`);
 	const spendOf = (name) => {
 		const size = runtime.sizes.find((option) => option.name === name);
@@ -5578,7 +7278,7 @@ var runtimeStatus = async (options) => {
 };
 /** Starts an environment's runtime again, or stops it — kept stopped until started. */
 var powerRuntime = async (power, options) => {
-	const connection = await connect(options, "to configure");
+	const connection = await connectToSpace(options, "to configure");
 	if (!connection?.space) return;
 	const environment = options.environment ?? "main";
 	const answered = await authorizedRequest(connection, `/spaces/${String(connection.space.id)}/runtime/${power}`, {
@@ -5595,11 +7295,11 @@ var powerRuntime = async (power, options) => {
 		fail(reply.data.error ?? `The runtime was not ${power === "start" ? "started" : "stopped"} (${String(reply.status)}).`);
 		return;
 	}
-	console.log(`${chalk.green("✓")} ${environment} ${power === "start" ? "starts in a moment" : "stops, and stays stopped until started"}.`);
+	console.log(chalk.green(`${environment} ${power === "start" ? "starts in a moment" : "stops, and stays stopped until started"}.`));
 };
 /** Chooses the size an environment's runtime runs at — one the space's plan includes — and it starts again at it. */
 var setRuntimeSize = async (size, options) => {
-	const connection = await connect(options, "to configure");
+	const connection = await connectToSpace(options, "to configure");
 	if (!connection?.space) return;
 	const environment = options.environment ?? "main";
 	const answered = await authorizedRequest(connection, `/spaces/${String(connection.space.id)}/runtime/size`, {
@@ -5619,7 +7319,7 @@ var setRuntimeSize = async (size, options) => {
 		fail(reply.data.error ?? `The size was not changed (${String(reply.status)}).`);
 		return;
 	}
-	console.log(`${chalk.green("✓")} ${environment} runs at ${size} — the runtime starts again at it.`);
+	console.log(chalk.green(`${environment} runs at ${size} — the runtime starts again at it.`));
 };
 /** Everything sent on standard input: a value piped in rather than typed where the shell history keeps it. */
 var readStdin = async () => {
@@ -5632,7 +7332,7 @@ var readStdin = async () => {
 * input (`printf %s "$URL" | plitzi runtime vars set REDIS_URL`), which keeps a secret out of the shell's history.
 */
 var setRuntimeVariable = async (name, value, options) => {
-	const connection = await connect(options, "to configure");
+	const connection = await connectToSpace(options, "to configure");
 	if (!connection?.space) return;
 	const given = value ?? await readStdin();
 	const answered = await authorizedRequest(connection, `/spaces/${String(connection.space.id)}/runtime/variables/${encodeURIComponent(name)}`, {
@@ -5649,17 +7349,190 @@ var setRuntimeVariable = async (name, value, options) => {
 		fail(reply.data.error ?? `${name} was not set (${String(reply.status)}).`);
 		return;
 	}
-	console.log(`${chalk.green("✓")} ${name} set — the runtime starts again with it.`);
+	console.log(chalk.green(`${name} set — the runtime starts again with it.`));
 };
 var unsetRuntimeVariable = async (name, options) => {
-	const connection = await connect(options, "to configure");
+	const connection = await connectToSpace(options, "to configure");
 	if (!connection?.space) return;
 	const answered = await authorizedRequest(connection, `/spaces/${String(connection.space.id)}/runtime/variables/${encodeURIComponent(name)}`, { method: "DELETE" });
 	if (!answered.ok) {
 		fail(answered.error);
 		return;
 	}
-	console.log(`${chalk.green("✓")} ${name} removed — the runtime starts again without it.`);
+	console.log(chalk.green(`${name} removed — the runtime starts again without it.`));
+};
+//#endregion
+//#region src/commands/shot.ts
+/** A region moves when more than this share of it changed between two frames: below is anti-aliasing and carets. */
+var MOVING_PERCENT = .5;
+/** A selector, or an element's name — what `data-plitzi-el` carries. */
+var selectorOf = (target) => /^[#.[]/.test(target) ? target : `[data-plitzi-el="${target}"]`;
+var pictureOf = async (browser, url, view) => {
+	const page = await browser.newPage({
+		viewport: {
+			width: view.width,
+			height: view.height
+		},
+		colorScheme: view.scheme,
+		reducedMotion: view.reducedMotion ? "reduce" : "no-preference"
+	});
+	if (!await page.goto(url, { waitUntil: "networkidle" }).catch(() => null)) return { problem: `Nothing answers at ${url}.` };
+	if (view.waitFor) {
+		if (!await page.waitForSelector(selectorOf(view.waitFor), { timeout: 1e4 }).catch(() => null)) return { problem: `${view.waitFor} did not appear on ${url} within 10 s.` };
+	}
+	return {
+		page,
+		png: await page.screenshot({ fullPage: true })
+	};
+};
+var regionsText = (regions) => regions.map((region) => `${region.name} ${String(region.changed)}%`).join(", ");
+/** Compared frame to frame: the most each region changed between two that follow each other. */
+var framesMoved = (diffs) => {
+	const most = /* @__PURE__ */ new Map();
+	for (const diff of diffs) for (const region of diff.regions) most.set(region.name, Math.max(most.get(region.name) ?? 0, region.changed));
+	return [...most].map(([name, changed]) => ({
+		name,
+		changed
+	}));
+};
+var shot = async (route, options) => {
+	const project = await projectHere("whose page to picture");
+	if (!project) return;
+	const where = await projectOrigin(project.root, project.plitzi?.kind === "project" ? project.plitzi : void 0);
+	if ("problem" in where) {
+		fail(where.problem);
+		return;
+	}
+	const browser = await launchBrowser(project.root);
+	if ("problem" in browser) {
+		fail(browser.problem);
+		return;
+	}
+	try {
+		const pathname = route ?? "/";
+		const view = {
+			width: options.width ?? 1280,
+			height: options.height ?? 800,
+			scheme: options.scheme ?? "light",
+			reducedMotion: options.reducedMotion === true,
+			...options.waitFor ? { waitFor: options.waitFor } : {}
+		};
+		const name = pathname === "/" ? "home" : pathname.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "");
+		const out = path.resolve(project.root, options.out ?? `visual/.shots/${name}-${String(view.width)}-${view.scheme}.png`);
+		const base = out.replace(/\.png$/, "");
+		const taken = await pictureOf(browser, `${where.origin}${pathname}`, view);
+		if ("problem" in taken) {
+			fail(`${taken.problem} Start the project first: npm start`);
+			return;
+		}
+		await mkdir(path.dirname(out), { recursive: true });
+		await writeFile(out, taken.png);
+		const regions = await taken.page.evaluate(pageRegions, void 0);
+		const report = {
+			path: pathname,
+			width: view.width,
+			scheme: view.scheme,
+			out
+		};
+		if (options.compare) {
+			const other = new URL(options.compare);
+			const target = other.pathname === "/" ? new URL(pathname, other).href : other.href;
+			const theirs = await pictureOf(browser, target, view);
+			if ("problem" in theirs) {
+				fail(theirs.problem);
+				return;
+			}
+			const diff = await comparePictures(taken.page, dataUrl(taken.png), dataUrl(theirs.png), regions);
+			await writeFile(`${base}-compare.png`, fromDataUrl(diff.sideBySide));
+			await writeFile(`${base}-diff.png`, fromDataUrl(diff.diff));
+			report.compare = {
+				url: target,
+				changed: diff.changed,
+				regions: diff.regions,
+				sideBySide: `${base}-compare.png`,
+				diff: `${base}-diff.png`
+			};
+		}
+		const frames = options.frames ?? 0;
+		if (frames > 1) {
+			const every = options.every ?? 500;
+			const pictures = [taken.png];
+			for (let frame = 1; frame < frames; frame += 1) {
+				await taken.page.waitForTimeout(every);
+				pictures.push(await taken.page.screenshot({ fullPage: true }));
+			}
+			const diffs = [];
+			for (let frame = 1; frame < pictures.length; frame += 1) diffs.push(await comparePictures(taken.page, dataUrl(pictures[frame - 1]), dataUrl(pictures[frame]), regions));
+			const moved = framesMoved(diffs);
+			report.frames = {
+				count: frames,
+				every,
+				moving: moved.filter((region) => region.changed > MOVING_PERCENT),
+				still: moved.filter((region) => region.changed <= MOVING_PERCENT).map((region) => region.name)
+			};
+		}
+		if (options.json) {
+			console.log(JSON.stringify(report));
+			return;
+		}
+		console.log(out);
+		if (report.compare) {
+			console.log(`${chalk.bold(`${String(report.compare.changed)}% differs`)} from ${report.compare.url}${report.compare.regions.length > 0 ? ` — ${regionsText(report.compare.regions)}` : ""}`);
+			console.log(chalk.dim(`${report.compare.sideBySide}\n${report.compare.diff}`));
+		}
+		if (report.frames) console.log(report.frames.moving.length > 0 ? `moving over ${String(report.frames.count)} frames: ${regionsText(report.frames.moving)}` : `nothing moved over ${String(report.frames.count)} frames, ${String(report.frames.every)} ms apart`);
+	} finally {
+		await browser.close();
+	}
+};
+//#endregion
+//#region src/commands/skills.ts
+/**
+* `plitzi skills update`: the Plitzi skills in `.claude/skills/` brought up to the packages the project has installed.
+*
+* A skill is copied into a project when `create` writes it and then stays as it was, while `@plitzi/sdk-authoring` moves
+* on — and an agent reading the older one is taught a surface the SDK no longer has, or misses what it gained. Only the
+* `plitzi-*` skills are touched, each replaced whole (a reference it no longer has goes with it); any other skill in the
+* folder is the project's.
+*/
+var readSkill = async (file) => {
+	try {
+		return await fs.readFile(file, "utf-8");
+	} catch {
+		return;
+	}
+};
+var skillsUpdate = async () => {
+	const project = await projectHere("whose skills to update");
+	if (!project) return;
+	const folder = path.join(project.root, ".claude/skills");
+	const present = [];
+	for (const name of SKILL_NAMES) {
+		const skill = await readSkill(path.join(folder, name, "SKILL.md"));
+		if (skill !== void 0) present.push({
+			name,
+			was: skillVersion(skill)
+		});
+	}
+	if (present.length === 0) {
+		fail(`No Plitzi skill in ${path.relative(process.cwd(), folder) || ".claude/skills"}: \`plitzi create\` writes them into a project it makes.`);
+		return;
+	}
+	const files = skillFiles(present.map(({ name }) => name), project.root);
+	for (const { name, was } of present) {
+		const own = Object.fromEntries(Object.entries(files).filter(([file]) => file.startsWith(`.claude/skills/${name}/`)));
+		if (Object.keys(own).length === 0) {
+			console.log(chalk.yellow(`${name}: its package is not installed here, so it was left as it was.`));
+			continue;
+		}
+		await fs.rm(path.join(folder, name), {
+			recursive: true,
+			force: true
+		});
+		await writeFiles(project.root, own);
+		const now = skillVersion(own[`.claude/skills/${name}/SKILL.md`] ?? "");
+		console.log(chalk.green(`${name}: ${was ?? "unversioned"} → ${now ?? "unversioned"}`));
+	}
 };
 //#endregion
 //#region src/commands/uploadPlugin.ts
@@ -5843,6 +7716,29 @@ var uploadPluginCommand = async (zipGiven, options) => {
 	console.log("");
 };
 //#endregion
+//#region src/options.ts
+/**
+* What a flag's value has to be, read once where the command line is declared. A value that is not one is refused
+* there, saying what it takes — never turned into a default the person did not ask for, which is how a typo used to
+* check a page at no width at all and say nothing.
+*/
+var MIN_WIDTH = 320;
+var MAX_WIDTH = 3840;
+/** A viewport width: a whole number of pixels, from a small phone to a 4K screen. */
+var width = (value) => {
+	const parsed = Number(value.trim());
+	if (!Number.isInteger(parsed) || parsed < MIN_WIDTH || parsed > MAX_WIDTH) throw new InvalidArgumentError(`A width is a whole number of pixels from ${String(MIN_WIDTH)} to ${String(MAX_WIDTH)}: 1440 or 390.`);
+	return parsed;
+};
+/** Widths separated by commas, each once, in the order given. */
+var widths = (value) => [...new Set(value.split(",").map(width))];
+/** A whole number from 1: a height in pixels, a count, milliseconds. */
+var positiveInteger = (value) => {
+	const parsed = Number(value.trim());
+	if (!Number.isInteger(parsed) || parsed < 1) throw new InvalidArgumentError("It takes a whole number from 1.");
+	return parsed;
+};
+//#endregion
 //#region src/index.ts
 /**
 * The command line for Plitzi.
@@ -5852,28 +7748,45 @@ var uploadPluginCommand = async (zipGiven, options) => {
 * could tell whether any of it worked. The same holds for an element of one's own, which is the second thing it does.
 */
 program.name("plitzi").description("Plitzi command line");
+/** A flag given more than once, as the list of every value. */
+var collect = (value, previous) => [...previous, value];
 /** The flags that shape a PROJECT: given with `--plugin`, they are a mistake worth saying rather than ignoring. */
 var PROJECT_ONLY = [
 	"mode",
 	"source",
-	"key"
+	"key",
+	"template"
 ];
+/** The widths a page is looked at, as one flag every command that opens a page shares. */
+var widthsOption = (description, fallback) => new Option("--width <px,px>", description).argParser(widths).default(fallback, fallback.join(","));
+var schemeOption = () => new Option("--scheme <scheme>", "The colour scheme").choices(SCHEMES).default("light");
 var API_OPTION = ["--api <url>", "The platform’s API. Defaults to PLITZI_API_URL, else the one signed in to, else https://api.plitzi.com."];
-program.command("create").argument("[directory]", "Where to write it. Defaults to the current directory, or asked for with --plugin.").description("Scaffold a project that renders a Plitzi space, or with --plugin a plugin package").addOption(new Option("-m, --mode <mode>", "server (SSR + RSC on a Node tier) or client (browser only)").choices(["server", "client"])).addOption(new Option("-s, --source <source>", "local (the space travels in the project) or cloud (read it from Plitzi)").choices(["local", "cloud"])).option("-k, --key <key>", "Cloud only: the space key (asked for when omitted)").option("-e, --environment <environment>", "Which version: main (the draft), or a published environment — what --from takes out, and what a cloud project serves", "main").option("--revision <n>", "A published environment’s revision, pinned rather than its latest (with --from or --source cloud)").addOption(new Option("-p, --package-manager <manager>", "The package manager the project is written for. Asked for when left out.").choices([...PACKAGE_MANAGERS])).option("--from <space>", "Make it from a space on Plitzi (its id or permanent URL): its pages, actions, functions, runtime, plugins and files, served by the project alone. Signs in as you; the space must be one you can change.").option(...API_OPTION).option("--plugin", "A plugin package instead: one element any space can load, with a preview and a build").option("--name <name>", "Plugin only: its package name (plitzi-plugin-seat-picker). Asked for when left out.").option("--title <title>", "Plugin only: what the builder calls the element").option("--description <description>", "Plugin only: what the element is for, in a sentence").option("--owner <owner>", "Plugin only: who publishes it").option("--elements <names>", "Plugin only: other elements the package holds, by name, separated by commas").option("--no-install", "Write the files without installing dependencies").option("-f, --force", "Write into a directory that is not empty").option("-y, --yes", "At a terminal: take the defaults for any choice not passed. Without one, every choice must be passed").action((directory, options) => {
+program.command("create").argument("[directory]", "Where to write it. Defaults to the current directory, or asked for with --plugin.").description("Scaffold a project that renders a Plitzi space, or with --plugin a plugin package").addOption(new Option("-m, --mode <mode>", "server (SSR + RSC on a Node tier) or client (browser only)").choices(["server", "client"])).addOption(new Option("-s, --source <source>", "local (the space travels in the project) or cloud (read it from Plitzi)").choices(["local", "cloud"])).option("-k, --key <key>", "Cloud only: the space key (asked for when omitted)").option("-e, --environment <environment>", "Which version: main (the draft), or a published environment — what --from takes out, and what a cloud project serves", "main").option("--revision <n>", "A published environment’s revision, pinned rather than its latest (with --from or --source cloud)").addOption(new Option("-p, --package-manager <manager>", "The package manager the project is written for. Asked for when left out.").choices([...PACKAGE_MANAGERS])).option("--from <space>", "Make it from a space on Plitzi (its id or permanent URL): its pages, actions, functions, runtime, plugins and files, served by the project alone. Signs in as you; the space must be one you can change.").option(...API_OPTION).option("--plugin", "A plugin package instead: one element any space can load, with a preview and a build").option("--name <name>", "Plugin only: its package name (plitzi-plugin-seat-picker). Asked for when left out.").option("--title <title>", "Plugin only: what the builder calls the element").option("--description <description>", "Plugin only: what the element is for, in a sentence").option("--owner <owner>", "Plugin only: who publishes it").option("--elements <names>", "Plugin only: other elements the package holds, by name, separated by commas").addOption(new Option("-t, --template <template>", "What a space written here starts as: welcome (a tour, the default), blank (tokens, a layout, one empty page) or catalog (a shop: layout, card component, data, filtered list, a page per product)").choices([...CREATE_TEMPLATES])).option("--no-install", "Write the files without installing dependencies").option("-f, --force", "Write into a directory that is not empty").option("-y, --yes", "At a terminal: take the defaults for any choice not passed. Without one, every choice must be passed").action((directory, options) => {
 	if (!options.plugin) return create(directory, options);
 	const stray = PROJECT_ONLY.filter((flag) => options[flag] !== void 0);
 	if (stray.length > 0) program.error(`--${stray.join(", --")} shape a project, not a plugin: leave them out with --plugin.`);
 	return createPlugin(directory, options);
 });
 program.command("pull").description("Bring a project made with create --from up to date with its space: what changed there is written, what changed here is kept").option("-f, --force", "Where a file changed both here and on the space, take the space’s copy").option("-e, --environment <environment>", "Follow another version from now on: main (the draft), or a published environment").option("--revision <n>", "Pin a published revision of it, or latest to follow its newest again").option(...API_OPTION).action((options) => pull(options));
-program.command("add").description("Add something to the project you are in").command("plugin").argument("[names...]", "What each element is called: seat-picker. Asked for when left out.").description("Add elements of your own to this project: each one its component, declaration and builder panel").option("-d, --dir <folder>", "The folder that holds the project’s components. Asked for, unless the project says.").option("--title <title>", "One element only: what the builder calls it").option("--description <description>", "One element only: what it is for, in a sentence").option("-f, --force", "Write into a folder that is not empty").action((names, options) => addPlugin(names, options));
+program.command("add").description("Add something to the project you are in").command("plugin").argument("[names...]", "What each element is called: seat-picker. Asked for when left out.").description("Add elements of your own to this project: each one its component, declaration and builder panel").option("-d, --dir <folder>", "The folder that holds the project’s components. Asked for, unless the project says.").option("--title <title>", "One element only: what the builder calls it").option("--description <description>", "One element only: what it is for, in a sentence").option("--prop <name:type=default>", "One element only: an attribute it takes — interval:number=5000, paused:boolean, label:string=Hi. Repeat it", collect, []).option("--trigger <name:fields>", "An event it fires and what a flow reads — onTick:count. Repeat it", collect, []).option("--callback <name>", "An action a flow can call on it — reset. Repeat it", collect, []).option("--headless", "Nothing to see: hidden on a page, a badge in the builder (a clock, a listener)").option("-f, --force", "Write into a folder that is not empty").action((names, options) => addPlugin(names, options));
 var pack = program.command("pack").description("Build something of this project into what the platform takes");
 pack.command("plugin").argument("[folders...]", "Element folders to pack, the main one first. In a plugin package, left out: all of them.").description("Build a plugin: one ES module, its plugin-manifest.json, and the zip the builder takes under Resources").option("-o, --out <folder>", "Where the build goes. Emptied first; it must be inside the project.").option("--no-zip", "Build without the zip").option("--plugin-version <version>", "The version the manifest carries. Defaults to the one in package.json.").option("--source-root <folder>", "The project its source is kept relative to, when the elements are a project of their own inside this one").action((folders, options) => packPluginCommand(folders, options));
 pack.command("source").argument("<entries...>", "The files the build starts from: a runtime module, or each element’s index").description("Write the source snapshot plitzi upload and plitzi runtime push keep beside what they send").addOption(new Option("--kind <kind>", "What it is the source of").choices(["plugin", "runtime"]).makeOptionMandatory()).requiredOption("--name <name>", "The plugin’s type, or runtime").option("--root <folder>", "The project the paths are relative to. Defaults to the nearest package.json’s folder.").requiredOption("-o, --out <file>", "Where the gzipped snapshot goes").action((entries, options) => packSourceCommand(entries, options));
 program.command("login").description("Sign in, in your browser. The session is kept and renewed until plitzi logout").option(...API_OPTION).action((options) => login(options));
 program.command("logout").description("Sign out: the session is revoked on the platform and forgotten here").action(() => logout());
-program.command("whoami").description("Who the CLI is signed in as, and the space it works in").option(...API_OPTION).action((options) => whoami(options));
+program.command("whoami").description("Who the CLI is signed in as, and the space it works in").option("--json", "One object: { api, user, space }, for a tool or an agent").option(...API_OPTION).action((options) => whoami(options));
 program.command("space").description("Choose the space to work in, in your browser. One at a time: it replaces the one chosen before").option(...API_OPTION).action((options) => space(options));
+program.command("check").argument("[path]", "The page: /about. The home page when left out").description("Whether a page of the running project is whole, in text: every element on screen, no broken image, no console error, no failed flow").addOption(widthsOption("The widths to check it at, separated by commas", [1440, 390])).addOption(schemeOption()).option("--state", "Also what the page holds: its state, and every source by name").option("--element <id>", "Also one element: what it reads, its own state, whether it is on screen").option("--json", "One object per width, for a tool or an agent").action((path, options) => check(path, options));
+program.command("fix").description("What authoring would fix in the space, as edits to your source: shown as a diff; with --write written, formatted and checked").option("--write", "Write the edits — kept only when the space authors with each fix gone and no problem added").option("--json", "The plan as one object, for a tool or an agent").action((options) => fix(options));
+program.command("import").argument("<url>", "The page to start from: https://example.com/pricing").description("A page of a site you verified, as a place to start writing from: its tokens, the outline of its blocks per breakpoint, its lists as JSON — never its words").option("-o, --out <dir>", "Where it is written, inside the project", "src/imported").addOption(widthsOption("The widths it is measured at: the widest is desktop, then tablet and mobile", [
+	1440,
+	768,
+	390
+])).option("-f, --force", "Write over what --out already holds").option("--json", "One object, for a tool or an agent").option(...API_OPTION).action((url, options) => importPage(url, options));
+program.command("shot").argument("[path]", "The page: /about. The home page when left out").description("A picture of one page of the running project — and, asked, how it differs from another or what moves").addOption(new Option("--width <px>", "The viewport width").argParser(width).default(1280)).addOption(new Option("--height <px>", "The viewport height (the picture is the whole page)").argParser(positiveInteger).default(800)).addOption(schemeOption()).option("-o, --out <file>", "Where the picture goes. visual/.shots/<page>-<width>-<scheme>.png by default").option("--compare <url>", "Another site: the same page there, side by side, and how much differs by section").addOption(new Option("--frames <n>", "Pictures taken one after another: which sections move (a marquee, an autoplay)").argParser(positiveInteger)).addOption(new Option("--every <ms>", "How far apart --frames are taken").argParser(positiveInteger).default(500)).option("--wait-for <element>", "An element to wait for first: its name (data-plitzi-el) or a CSS selector").option("--reduced-motion", "As a visitor who asked for less motion").option("--json", "One object, for a tool or an agent").action((path, options) => shot(path, options));
+program.command("explain").argument("[name]", "An element, a step, a trigger, a problem’s code or a transformer: container, navigate, class-and-css").description("What a name means when authoring a space — what it takes, fires, reads and how it is written").option("--list <kind>", "Every name of a kind: elements, steps, triggers, codes, transformers").option("--json", "One object, for a tool or an agent").action((name, options) => explainCommand(name, options));
+program.command("skills").description("The Plitzi skills an agent reads in .claude/skills/").command("update").description("Bring them up to the Plitzi packages this project has installed, each replaced whole").action(() => skillsUpdate());
+program.command("data").description("The JSON a project serves (public/data), without reading it whole").command("describe").argument("<file>", "A JSON file: public/data/products.json").description("Its shape — every field, its type, whether every row has it — and one row of its longest list").option("--json", "One object: { shape, example }").action((file, options) => dataDescribe(file, options));
 program.command("upload").description("Put something of this project on the space you work in").command("plugin").argument("[zip]", "The zip plitzi pack plugin built. Left out: the one packed in this project.").description("Upload a packed plugin to a CDN of the space you work in, and install it there").option("--cdn <identifier>", "Which of the space’s CDNs the bucket is in.").option("--bucket <identifier>", "Which public bucket the plugin goes in. Asked for when there are several.").option(...API_OPTION).action((zip, options) => uploadPluginCommand(zip, options));
 var functions = program.command("functions").description("The space’s own server code: functions/ in this project is a working copy of it");
 functions.command("pull").description("Write the space’s functions into functions/ — refused when that would overwrite what is not pushed").option("-f, --force", "Overwrite what is not pushed, or a copy of another space").option(...API_OPTION).action((options) => pullFunctions(options));
@@ -5882,11 +7795,11 @@ functions.command("try").argument("<task>", "The task, <namespace>.<action>").de
 functions.command("dev").argument("<task>", "The task, <namespace>.<action>").description("Run one task from functions/ on this machine, as the platform runs it — nothing reaches the space").option("--params <json>", "Its params, as a JSON object").option("-w, --watch", "Run it again every time a file of functions/ is saved").action((task, options) => devFunction(task, options));
 var runtime = program.command("runtime").description("The space’s runtime: its own server code, run as a process of its own beside the platform");
 runtime.command("push").description("Pack this project’s runtime module and keep it as the space’s draft runtime").option("--entry <path>", "The module whose default export is defineRuntime(…)", "src/runtime.ts").option(...API_OPTION).action((options) => pushRuntime(options));
-runtime.command("status").description("How each environment’s runtime is, and the names of its variables").option(...API_OPTION).action((options) => runtimeStatus(options));
-for (const power of ["start", "stop"]) runtime.command(power).description(power === "start" ? "Start an environment’s runtime again — one stopped for being unused, or by hand" : "Stop an environment’s runtime, and keep it stopped until it is started").option("--environment <name>", "The environment: main (the draft) or a published one", "main").option(...API_OPTION).action((options) => powerRuntime(power, options));
-runtime.command("size").description("Choose the size an environment’s runtime runs at, among those the space’s plan includes").argument("<size>", "small, medium or large — plitzi runtime status says which the plan includes").option("--environment <name>", "The environment: main (the draft) or a published one", "main").option(...API_OPTION).action((size, options) => setRuntimeSize(size, options));
+runtime.command("status").description("How each environment’s runtime is, and the names of its variables").option("--json", "One object: { space, environments, variables, sizes }, for a tool or an agent").option(...API_OPTION).action((options) => runtimeStatus(options));
+for (const power of ["start", "stop"]) runtime.command(power).description(power === "start" ? "Start an environment’s runtime again — one stopped for being unused, or by hand" : "Stop an environment’s runtime, and keep it stopped until it is started").option("-e, --environment <name>", "The environment: main (the draft) or a published one", "main").option(...API_OPTION).action((options) => powerRuntime(power, options));
+runtime.command("size").description("Choose the size an environment’s runtime runs at, among those the space’s plan includes").argument("<size>", "small, medium or large — plitzi runtime status says which the plan includes").option("-e, --environment <name>", "The environment: main (the draft) or a published one", "main").option(...API_OPTION).action((size, options) => setRuntimeSize(size, options));
 var vars = runtime.command("vars").description("What the runtime starts with — written, never read back");
-vars.command("set").argument("<name>", "The variable, in capitals: REDIS_URL").argument("[value]", "Its value — read from standard input when left out, which keeps it out of the shell history").option(...API_OPTION).action((name, value, options) => setRuntimeVariable(name, value, options));
-vars.command("unset").argument("<name>", "The variable").option(...API_OPTION).action((name, options) => unsetRuntimeVariable(name, options));
+vars.command("set").description("Give the runtime a variable, or a new value for one it has").argument("<name>", "The variable, in capitals: REDIS_URL").argument("[value]", "Its value — read from standard input when left out, which keeps it out of the shell history").option(...API_OPTION).action((name, value, options) => setRuntimeVariable(name, value, options));
+vars.command("unset").description("Take a variable away from the runtime").argument("<name>", "The variable").option(...API_OPTION).action((name, options) => unsetRuntimeVariable(name, options));
 program.parse(process.argv);
 //#endregion