@plitzi/cli 0.37.2 → 0.37.4

package/dist/index.js

@@ -1,13 +1,648 @@
 #!/usr/bin/env node
 import { Option, program } from "commander";
-import { spawn, spawnSync } from "node:child_process";
+import chalk from "chalk";
 import fs from "node:fs/promises";
+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 chalk from "chalk";
 import { createRequire } from "node:module";
-import { readFileSync, readdirSync } from "node:fs";
-import { blankSpaceSource } from "@plitzi/sdk-authoring";
+import { readFileSync, readdirSync, watch } from "node:fs";
+import { blankSpaceSource, elementTypeNames } from "@plitzi/sdk-authoring";
+import { pathToFileURL } from "node:url";
+import { build } from "esbuild";
+import { unzipSync, zipSync } from "fflate";
+/** `$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");
+	if (process.platform === "win32" && process.env.APPDATA) return path.join(process.env.APPDATA, "plitzi");
+	return path.join(os.homedir(), ".config", "plitzi");
+};
+var connectionFile = () => path.join(configDir(), "connection.json");
+var isConnection = (value) => {
+	const candidate = value;
+	return typeof candidate?.api === "string" && typeof candidate.grant?.clientId === "string" && typeof candidate.grant.accessToken === "string";
+};
+/** The connection, or undefined when there is none — or the file is not one, which is the same as none. */
+var readConnection = async () => {
+	try {
+		const parsed = JSON.parse(await fs.readFile(connectionFile(), "utf-8"));
+		return isConnection(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+};
+var writeConnection = async (connection) => {
+	await fs.mkdir(configDir(), {
+		recursive: true,
+		mode: 448
+	});
+	await fs.writeFile(connectionFile(), `${JSON.stringify(connection, null, 2)}\n`, { mode: 384 });
+	await fs.chmod(connectionFile(), 384);
+};
+var forgetConnection = async () => {
+	await fs.rm(connectionFile(), { force: true });
+};
+/** An API address as it is compared and stored: its origin plus any path, no trailing slash. */
+var normalizeApi = (value) => {
+	const url = new URL(value);
+	return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+};
+/**
+* Which platform a command talks to: `--api`, else `PLITZI_API_URL`, else the one connected to, else Plitzi's own.
+* Undefined when what was given is not an address.
+*/
+var resolveApi = (given, connection) => {
+	const chosen = given ?? process.env.PLITZI_API_URL ?? connection?.api ?? "https://api.plitzi.com";
+	try {
+		return normalizeApi(chosen);
+	} catch {
+		return;
+	}
+};
+//#endregion
+//#region src/account/http.ts
+/**
+* The CLI's requests to the platform, and what it says when one never arrives.
+*
+* Node's `fetch` carries its own bundled certificate authorities and knows nothing about the machine's, so a server
+* whose certificate the machine trusts — a development one issued by a local CA, a company's own — is refused with
+* `UNABLE_TO_VERIFY_LEAF_SIGNATURE` while the browser beside it talks to the same host happily. The desktop app met
+* this first; here the fix is to trust what the system trusts, as the browser the sign-in happens in does.
+*/
+var trusted = false;
+/** The system's certificate authorities, added to Node's own. Once per process; a no-op where Node cannot do it. */
+var trustSystemCertificates = () => {
+	if (trusted) return;
+	trusted = true;
+	try {
+		tls.setDefaultCACertificates([...tls.getCACertificates("default"), ...tls.getCACertificates("system")]);
+	} catch {}
+};
+/**
+* Why a request never reached anyone, in words somebody can act on.
+*
+* `fetch` reports every transport failure as the same "fetch failed"; the useful part is on `cause`. A certificate this
+* machine will not verify and a server that is not running are the two that actually happen.
+*/
+var unreachable = (url, error) => {
+	const cause = error.cause;
+	const detail = cause?.code ?? cause?.message ?? (error instanceof Error ? error.message : String(error));
+	return `Could not reach ${new URL(url).origin} (${detail}).`;
+};
+/** One request, answered as JSON. A gateway's HTML page is said as such rather than read as the server refusing. */
+var requestJson = async (url, init = {}) => {
+	trustSystemCertificates();
+	let response;
+	try {
+		response = await fetch(url, init);
+	} catch (error) {
+		return {
+			ok: false,
+			error: unreachable(url, error)
+		};
+	}
+	const text = await response.text();
+	try {
+		return {
+			ok: true,
+			status: response.status,
+			data: text ? JSON.parse(text) : {}
+		};
+	} catch {
+		return {
+			ok: false,
+			error: `${new URL(url).pathname} answered ${response.status}, and not with JSON.`
+		};
+	}
+};
+var postForm = (url, body) => requestJson(url, {
+	method: "POST",
+	headers: {
+		"Content-Type": "application/x-www-form-urlencoded",
+		Accept: "application/json"
+	},
+	body: new URLSearchParams(body).toString()
+});
+//#endregion
+//#region src/account/oauth.ts
+/**
+* Signing in the way a native application is supposed to: in the person's browser, never at this prompt.
+*
+* The CLI opens the platform's `/authorize`, waits on a loopback address for the answer, and exchanges a one-shot code
+* for the person's session. It never sees a password — so it cannot store one or leak one; MFA and social sign-in work
+* without it knowing they exist; and a session revoked from the account's device list is revoked here.
+*
+* The same flow the desktop app runs (`apps/desktop/electron/signIn.ts`), against the same authorization server: the
+* platform's auth is the one place credentials are granted. Choosing a space is part of it too — asked with the `space`
+* scope, the choice is made on the grant screen and comes back beside the session as the grant's `target`.
+*/
+var base64url = (buffer) => buffer.toString("base64url");
+/**
+* What the account's device list calls this sign-in: the CLI, and the machine it runs on — two laptops signed in are
+* two rows somebody has to tell apart. macOS names a machine `Carlos-MacBook-Pro.local`; the suffix says nothing.
+*/
+var clientName = () => {
+	const host = os.hostname().replace(/\.local$/iu, "");
+	return host ? `Plitzi CLI on ${host}` : "Plitzi CLI";
+};
+/** How long the terminal waits for somebody to finish in the browser before giving the port back. */
+var FLOW_TIMEOUT_MS = 3e5;
+var discover = async (apiUrl) => {
+	const reply = await requestJson(`${apiUrl}/.well-known/oauth-authorization-server`);
+	if (!reply.ok) return reply;
+	const { authorization_endpoint, token_endpoint, registration_endpoint, revocation_endpoint } = reply.data;
+	if (reply.status !== 200 || !authorization_endpoint || !token_endpoint || !registration_endpoint) return {
+		ok: false,
+		error: `${apiUrl} does not offer signing in from the command line.`
+	};
+	return {
+		ok: true,
+		endpoints: {
+			authorization_endpoint,
+			token_endpoint,
+			registration_endpoint,
+			revocation_endpoint
+		}
+	};
+};
+var page = (title, message) => `<!doctype html><meta charset="utf-8"><title>${title}</title>
+<body style="font:15px system-ui;display:grid;place-items:center;height:100vh;margin:0;color-scheme:light dark">
+<p>${message}</p>`;
+var DONE_PAGE = page("Signed in", "Done. You can close this tab and go back to your terminal.");
+var FAILED_PAGE = page("Sign-in failed", "That did not complete. Go back to your terminal and try again.");
+/**
+* A loopback listener that resolves with the code the browser brings back.
+*
+* On 127.0.0.1 explicitly rather than every interface: a server on `0.0.0.0` is reachable from the network, and what
+* it holds is an authorization code. `state` tells this flow's answer from anything else that reaches the port.
+*/
+var awaitCode = (state) => new Promise((resolve) => {
+	let settle = () => void 0;
+	const code = new Promise((done) => {
+		settle = done;
+	});
+	const server = createServer((req, res) => {
+		const url = new URL(req.url ?? "/", "http://127.0.0.1");
+		if (url.pathname !== "/callback") {
+			res.writeHead(404).end();
+			return;
+		}
+		const returned = url.searchParams.get("code") ?? void 0;
+		const ok = returned !== void 0 && url.searchParams.get("state") === state;
+		res.writeHead(ok ? 200 : 400, {
+			"Content-Type": "text/html; charset=utf-8",
+			Connection: "close"
+		});
+		res.end(ok ? DONE_PAGE : FAILED_PAGE);
+		settle(ok ? returned : void 0);
+	});
+	const close = () => new Promise((done) => {
+		server.closeAllConnections();
+		server.close(() => done());
+	});
+	server.listen(0, "127.0.0.1", () => {
+		resolve({
+			close,
+			port: server.address().port,
+			code
+		});
+	});
+});
+/**
+* The person's own browser, at `url`. Printed as well by the caller: over SSH, or with no browser at all, the link is
+* opened by hand — and a failure to start one here is nothing to stop over.
+*/
+var openBrowser = (url) => {
+	const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : ["xdg-open", [url]];
+	try {
+		const child = spawn(command, args, {
+			stdio: "ignore",
+			detached: true
+		});
+		child.on("error", () => void 0);
+		child.unref();
+	} catch {}
+};
+var grantOf = (clientId, token, previousRefresh) => {
+	if (!token.access_token) return {
+		ok: false,
+		reason: "refused",
+		error: token.error_description ?? token.error
+	};
+	return {
+		ok: true,
+		grant: {
+			clientId,
+			accessToken: token.access_token,
+			refreshToken: token.refresh_token ?? previousRefresh,
+			expiresAt: token.expires_in !== void 0 ? Math.floor(Date.now() / 1e3) + token.expires_in : void 0,
+			target: token.target
+		}
+	};
+};
+var signInThroughBrowser = async (apiUrl, { scope, open }) => {
+	const discovered = await discover(apiUrl);
+	if (!discovered.ok) return {
+		ok: false,
+		reason: "unreachable",
+		error: discovered.error
+	};
+	const { endpoints } = discovered;
+	const verifier = base64url(randomBytes(32));
+	const challenge = base64url(createHash("sha256").update(verifier).digest());
+	const state = base64url(randomBytes(16));
+	const { close, port, code } = await awaitCode(state);
+	const redirectUri = `http://127.0.0.1:${port}/callback`;
+	try {
+		const registered = await requestJson(endpoints.registration_endpoint, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json"
+			},
+			body: JSON.stringify({
+				client_name: clientName(),
+				software_id: "plitzi-cli",
+				redirect_uris: [redirectUri]
+			})
+		});
+		if (!registered.ok) return {
+			ok: false,
+			reason: "unreachable",
+			error: registered.error
+		};
+		const clientId = registered.data.client_id;
+		if (!clientId) return {
+			ok: false,
+			reason: "refused",
+			error: registered.data.error_description ?? registered.data.error ?? "The server would not register the CLI."
+		};
+		const authorize = new URL(endpoints.authorization_endpoint);
+		authorize.search = new URLSearchParams({
+			response_type: "code",
+			client_id: clientId,
+			redirect_uri: redirectUri,
+			code_challenge: challenge,
+			code_challenge_method: "S256",
+			state,
+			...scope ? { scope } : {}
+		}).toString();
+		open(authorize.toString());
+		let timer;
+		const timeout = new Promise((done) => {
+			timer = setTimeout(() => done(void 0), FLOW_TIMEOUT_MS);
+		});
+		const returned = await Promise.race([code, timeout]);
+		clearTimeout(timer);
+		if (!returned) return {
+			ok: false,
+			reason: "timeout"
+		};
+		const exchanged = await postForm(endpoints.token_endpoint, {
+			grant_type: "authorization_code",
+			code: returned,
+			redirect_uri: redirectUri,
+			code_verifier: verifier,
+			client_id: clientId
+		});
+		if (!exchanged.ok) return {
+			ok: false,
+			reason: "unreachable",
+			error: exchanged.error
+		};
+		return grantOf(clientId, exchanged.data);
+	} finally {
+		await close();
+	}
+};
+/** A new session for the same grant. The CLI holds a refresh token and never the person's password. */
+var renewGrant = async (apiUrl, grant) => {
+	if (!grant.refreshToken) return {
+		ok: false,
+		reason: "refused",
+		error: "This session cannot be renewed."
+	};
+	const discovered = await discover(apiUrl);
+	if (!discovered.ok) return {
+		ok: false,
+		reason: "unreachable",
+		error: discovered.error
+	};
+	const renewed = await postForm(discovered.endpoints.token_endpoint, {
+		grant_type: "refresh_token",
+		refresh_token: grant.refreshToken,
+		client_id: grant.clientId
+	});
+	if (!renewed.ok) return {
+		ok: false,
+		reason: "unreachable",
+		error: renewed.error
+	};
+	return grantOf(grant.clientId, renewed.data, grant.refreshToken);
+};
+/**
+* Ending the grant, not just forgetting it here: the refresh token could mint another session, so a sign-out that only
+* deleted the file would leave a credential alive that a copy of the file could still use. RFC 7009 answers success
+* either way, so this answers nothing.
+*/
+var revokeGrant = async (apiUrl, grant) => {
+	const discovered = await discover(apiUrl);
+	if (!discovered.ok || !discovered.endpoints.revocation_endpoint || !grant.refreshToken) return;
+	await postForm(discovered.endpoints.revocation_endpoint, {
+		token: grant.refreshToken,
+		token_type_hint: "refresh_token",
+		client_id: grant.clientId
+	});
+};
+//#endregion
+//#region src/account/session.ts
+/** Renewed this long before it expires, so a session is not handed to a request it will not outlive. */
+var RENEW_MARGIN_SECONDS = 60;
+var SPACE_TARGET_PREFIX = "space:";
+var bearer = (grant) => ({
+	Authorization: `Bearer ${grant.accessToken}`,
+	Accept: "application/json"
+});
+/** The space a grant was given for, by the id its target carries, named as the platform names it. */
+var spaceOfGrant = async (api, grant) => {
+	if (!grant.target?.startsWith(SPACE_TARGET_PREFIX)) return {
+		ok: true,
+		value: void 0
+	};
+	const id = grant.target.slice(6);
+	const reply = await requestJson(`${api}/spaces/${encodeURIComponent(id)}?logsLimit=1`, { headers: bearer(grant) });
+	if (!reply.ok) return reply;
+	const space = reply.data.space;
+	if (reply.status !== 200 || typeof space?.id !== "number" || typeof space.permanentUrl !== "string") return {
+		ok: false,
+		error: `The space you chose could not be read (${reply.status}).`
+	};
+	return {
+		ok: true,
+		value: {
+			id: space.id,
+			name: space.name || space.permanentUrl,
+			permanentUrl: space.permanentUrl
+		}
+	};
+};
+/**
+* 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 }) => {
+	const signedIn = await signInThroughBrowser(api, {
+		scope,
+		open
+	});
+	if (!signedIn.ok) return {
+		ok: false,
+		error: signedIn.reason === "timeout" ? "Nothing came back from the browser in five minutes. Run the command again when you are ready." : signedIn.error ?? "The platform refused the sign-in."
+	};
+	const { grant } = signedIn;
+	const space = await spaceOfGrant(api, grant);
+	if (!space.ok) {
+		await revokeGrant(api, grant);
+		return space;
+	}
+	const previous = await readConnection();
+	const connection = {
+		api,
+		grant,
+		...space.value ? { space: space.value } : {}
+	};
+	await writeConnection(connection);
+	if (previous) await revokeGrant(previous.api, previous.grant);
+	return {
+		ok: true,
+		value: connection
+	};
+};
+/** Signing out: the grant revoked at the platform, and the connection forgotten here. */
+var disconnect = async () => {
+	const connection = await readConnection();
+	if (connection) {
+		await revokeGrant(connection.api, connection.grant);
+		await forgetConnection();
+	}
+	return connection;
+};
+/** Why a connection is gone, said with the command that makes it again. */
+var ended = (connection) => connection.space ? `Your connection to ${connection.space.name} has ended — signed out elsewhere, or you no longer have access to that space. Connect again with plitzi space.` : "Your session has ended. Sign in again with plitzi login.";
+/** A fresh session for the connection, kept. A refusal ends the connection; an unreachable server does not. */
+var renew = async (connection) => {
+	const renewed = await renewGrant(connection.api, connection.grant);
+	if (renewed.ok) {
+		const next = {
+			...connection,
+			grant: renewed.grant
+		};
+		await writeConnection(next);
+		return {
+			ok: true,
+			value: next
+		};
+	}
+	if (renewed.reason === "refused") {
+		await forgetConnection();
+		return {
+			ok: false,
+			error: ended(connection)
+		};
+	}
+	return {
+		ok: false,
+		error: renewed.error ?? `Could not reach ${connection.api}.`
+	};
+};
+var nearlyExpired = (grant) => grant.expiresAt !== void 0 && grant.expiresAt - RENEW_MARGIN_SECONDS <= Math.floor(Date.now() / 1e3);
+/**
+* The connection to `api`, renewed if it is about to expire. Undefined when there is none there — including when the
+* CLI is connected, but to another platform: that one is not used for this.
+*/
+var currentConnection = async (api) => {
+	const connection = await readConnection();
+	if (connection?.api !== api) return {
+		ok: true,
+		value: void 0
+	};
+	return nearlyExpired(connection.grant) ? renew(connection) : {
+		ok: true,
+		value: connection
+	};
+};
+/**
+* A request as the connected person. A 401 renews the session and tries once more; a second 401 ends the connection,
+* since the server has now said twice that the credential does not work.
+*/
+var authorizedRequest = async (connection, pathname, init = {}) => {
+	const send = (current) => requestJson(`${current.api}${pathname}`, {
+		...init,
+		headers: {
+			...bearer(current.grant),
+			...init.headers
+		}
+	});
+	const first = await send(connection);
+	if (!first.ok) return first;
+	if (first.status !== 401) return {
+		ok: true,
+		value: {
+			connection,
+			reply: first
+		}
+	};
+	const renewed = await renew(connection);
+	if (!renewed.ok) return renewed;
+	const second = await send(renewed.value);
+	if (!second.ok) return second;
+	if (second.status === 401) {
+		await forgetConnection();
+		return {
+			ok: false,
+			error: ended(connection)
+		};
+	}
+	return {
+		ok: true,
+		value: {
+			connection: renewed.value,
+			reply: second
+		}
+	};
+};
+//#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. */
+var openInBrowser = (url) => {
+	console.log(`\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;
+	}
+	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");
+	if (!answered.ok) return answered;
+	const { reply } = answered.value;
+	if (reply.status !== 200) return {
+		ok: false,
+		error: `${connection.api} would not say who you are (${reply.status}).`
+	};
+	return {
+		ok: true,
+		value: reply.data.details?.email || reply.data.details?.username || "you"
+	};
+};
+var spaceLine = (connection) => connection.space ? `Space: ${chalk.bold(connection.space.name)} ${chalk.dim(`(${connection.space.permanentUrl})`)}` : chalk.dim("No space chosen: choose one with plitzi space.");
+var login = async (options) => {
+	const api = await apiFor(options);
+	if (!api) return;
+	const current = await currentConnection(api);
+	if (current.ok && current.value) {
+		const who = await whoIs(current.value);
+		if (who.ok) {
+			console.log(`\nSigned in to ${api} as ${chalk.bold(who.value)} already.`);
+			console.log(chalk.dim("To sign in as somebody else: plitzi logout, then plitzi login.\n"));
+			return;
+		}
+	}
+	const previous = await readConnection();
+	const connected = await connect$2(api, { open: openInBrowser });
+	if (!connected.ok) {
+		fail(connected.error);
+		return;
+	}
+	const who = await whoIs(connected.value);
+	console.log(chalk.green(`\nSigned in to ${api}${who.ok ? ` as ${who.value}` : ""}.`));
+	if (previous && previous.api !== api) console.log(chalk.dim(`The CLI is connected to one platform at a time: ${previous.api} is signed out.`));
+	console.log(`${spaceLine(connected.value)}\n`);
+};
+var logout = async () => {
+	const connection = await disconnect();
+	console.log(connection ? `\nSigned out of ${connection.api}.\n` : "\nNot signed in.\n");
+};
+var whoami = async (options) => {
+	const api = await apiFor(options);
+	if (!api) return;
+	const current = await currentConnection(api);
+	if (!current.ok) {
+		fail(current.error);
+		return;
+	}
+	if (!current.value) {
+		fail(`Not signed in to ${api}. Sign in with plitzi login.`);
+		return;
+	}
+	const who = await whoIs(current.value);
+	if (!who.ok) {
+		fail(who.error);
+		return;
+	}
+	console.log(`\nSigned in to ${api} as ${chalk.bold(who.value)}.`);
+	console.log(`${spaceLine(current.value)}\n`);
+};
+/**
+* The space to work in, chosen on the platform's grant screen. The connection is REPLACED by the new grant — the CLI
+* 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, {
+		scope: "space",
+		open: openInBrowser
+	});
+	if (connected.ok && !connected.value.space) return {
+		ok: false,
+		error: "No space was chosen."
+	};
+	return connected;
+};
+var space = async (options) => {
+	const api = await apiFor(options);
+	if (!api) return;
+	const connected = await chooseSpace(api);
+	if (!connected.ok) {
+		fail(connected.error);
+		return;
+	}
+	console.log(chalk.green(`\nConnected to ${api}.`));
+	console.log(`${spaceLine(connected.value)}\n`);
+};
+/**
+* The connection to work through: the one there is when it has a space, else one made in the browser now — so the first
+* command that needs a space is one command too. `doing` finishes the prompt: "to upload to", "to pull from".
+*/
+var connectionWithSpace = async (api, doing = "to work in") => {
+	const current = await currentConnection(api);
+	if (!current.ok) {
+		fail(current.error);
+		return;
+	}
+	if (current.value?.space) return current.value;
+	console.log(current.value ? `\nChoose the space ${doing}.` : `\nSign in, and choose the space ${doing}.`);
+	const chosen = await chooseSpace(api);
+	if (!chosen.ok) {
+		fail(chosen.error);
+		return;
+	}
+	return chosen.value;
+};
+//#endregion
 //#region src/scaffold/client.ts
 /**
 * Client mode: the SDK renders in the browser and there is no server at all.
@@ -16,7 +651,7 @@ import { blankSpaceSource } from "@plitzi/sdk-authoring";
 * page without reloading it. Nothing here is a build artefact of Plitzi's: the page is this project's, and the
 * SDK is a dependency it imports.
 */
-var indexHtml = ({ name }) => `<!doctype html>
+var indexHtml$1 = ({ name }) => `<!doctype html>
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
@@ -29,7 +664,7 @@ var indexHtml = ({ name }) => `<!doctype html>
   </body>
 </html>
 `;
-var viteConfig = () => `import { createReadStream } from 'node:fs';
+var viteConfig$1 = () => `import { createReadStream } from 'node:fs';
 import { createRequire } from 'node:module';
 
 import { defineConfig } from 'vite';
@@ -72,7 +707,7 @@ export default defineConfig({
   server: { host: '127.0.0.1', port: 5173 }
 });
 `;
-var preflightCss = () => `/*
+var preflightCss$1 = () => `/*
  * The SDK ships no global CSS on purpose: dropping a space into an existing site must not restyle that site.
  * The browser's own margins therefore survive unless the host page clears them, which is what this does.
  */
@@ -90,25 +725,35 @@ body {
 * Written into both entry points, because how a plugin is registered does not change with where the space lives.
 */
 var PLUGINS$1 = `/**
- * The project's own components, by the \`renderType\` the space names them with.
- *
- * A \`custom\` element naming \`statCard\` renders this component, and the element's attributes arrive as its
- * props — which is what makes a plugin bindable rather than static. There is no server here, so it is part of
- * this project's bundle and Vite hot-replaces it like any other module. Add another by writing it under
- * \`src/plugins\` and adding a line here; see \`src/plugins/README.md\`.
+ * The project's own components: every folder of \`src/plugins\` is one, registered under its name in camelCase —
+ * \`src/plugins/StatCard\` is what a space's \`custom({ renderType: 'statCard' })\` renders, and its attributes arrive
+ * as the component's props. \`plitzi add plugin\` writes a new one there, and Vite picks it up. There is no server
+ * here, so the plugins are part of this project's bundle and hot-replaced like any other module; see
+ * \`src/plugins/README.md\`.
  */
-const plugins = { statCard: { component: StatCard } };`;
+const pluginModules = import.meta.glob<{ default: RenderPlugins[string]['component'] }>('./plugins/*/index.ts', {
+  eager: true
+});
+
+const plugins: RenderPlugins = Object.fromEntries(
+  Object.entries(pluginModules).map(([file, module]) => {
+    const folder = file.split('/')[2];
+
+    return [\`\${folder.charAt(0).toLowerCase()}\${folder.slice(1)}\`, { component: module.default }];
+  })
+);`;
 /** The two ways the space reaches the entry point, written once because both modes phrase them identically. */
 var localMain$1 = () => `import { render } from '@plitzi/plitzi-sdk';
 
 import { authorSpace } from '@plitzi/sdk-authoring';
 
-import StatCard from './plugins/StatCard';
-import { space } from './space';
+import { declarations } from './plugins/declarations.ts';
+import { space } from './space.ts';
 
 import './preflight.css';
 import '@plitzi/plitzi-sdk/plitzi-sdk.css';
 
+import type { RenderPlugins } from '@plitzi/plitzi-sdk';
 import type { SpaceSpec } from '@plitzi/sdk-authoring';
 
 ${PLUGINS$1}
@@ -128,7 +773,7 @@ const mount = (spec: SpaceSpec) =>
        * space, so there is no account, no key and no server in the picture.
        */
       offlineMode: true,
-      offlineData: authorSpace(spec),
+      offlineData: authorSpace(spec, { plugins: declarations }),
       /**
        * Without this the SDK renders inside an IFRAME — its default, because a space dropped into an unknown page
        * is safest isolated from it. This page is yours, so render straight into the DOM: one document, one
@@ -169,11 +814,11 @@ if (import.meta.hot) {
 `;
 var cloudMain$1 = () => `import { render } from '@plitzi/plitzi-sdk';
 
-import StatCard from './plugins/StatCard';
-
 import './preflight.css';
 import '@plitzi/plitzi-sdk/plitzi-sdk.css';
 
+import type { RenderPlugins } from '@plitzi/plitzi-sdk';
+
 ${PLUGINS$1}
 
 /**
@@ -202,9 +847,9 @@ render(
 );
 `;
 var clientFiles = (answers) => ({
-	"index.html": indexHtml(answers),
-	"vite.config.ts": viteConfig(),
-	"src/preflight.css": preflightCss(),
+	"index.html": indexHtml$1(answers),
+	"vite.config.ts": viteConfig$1(),
+	"src/preflight.css": preflightCss$1(),
 	"src/main.ts": answers.source === "cloud" ? cloudMain$1() : localMain$1()
 });
 //#endregion
@@ -223,7 +868,7 @@ var clientFiles = (answers) => ({
 * without a line of plumbing in between. Plitzi's own server-side plugins (the dashboard's world map and its live
 * traffic view) are written to exactly this shape.
 */
-var component = () => `import { useMemo, useState } from 'react';
+var component$1 = () => `import { useMemo, useState } from 'react';
 
 import { RootElement } from '@plitzi/plitzi-sdk';
 
@@ -363,27 +1008,32 @@ export * from './StatCard';
 
 export default StatCard;
 `;
-var readme$1 = ({ mode }) => `# Plugins
+var readme$2 = ({ mode }) => `# Plugins
 
 Components of your own, rendered by the space.
 
-A plugin is a React component and a \`renderType\` it is registered under. The space hosts it with a \`custom\`
-element naming that same \`renderType\` — see \`custom({ renderType: 'statCard', … })\` in \`src/space.ts\` — and the
-element's attributes arrive as the component's props.
+Every folder here is one, registered under its name in camelCase: \`StatCard\` is the \`renderType\` \`statCard\`. The
+space hosts it with a \`custom\` element naming that type — see \`custom({ renderType: 'statCard', … })\` in
+\`src/space.ts\` — and the element's attributes arrive as the component's props.
 
-${mode === "server" ? `\`src/main.ts\` registers this one with \`action: 'compile'\`, which is what makes it **server-rendered**: the
+${mode === "server" ? `\`src/main.ts\` registers each one with \`action: 'compile'\`, which is what makes it **server-rendered**: the
 server builds the entry with esbuild, keeps React external so the plugin runs on the one copy the page already
 has, serves the bundle to the browser AND imports it into the render — so the component's markup is in the HTML
 before any JavaScript arrives. A plugin registered any other way renders only after hydration, which is a hole in
-the document for anyone reading the page before then.` : `\`src/main.ts\` registers this one as the third argument to \`render()\`. There is no server here, so the
-component is part of this project's own bundle and Vite hot-replaces it like any other module.`}
+the document for anyone reading the page before then.` : `\`src/main.ts\` hands them to \`render()\`. There is no server here, so each one is part of this project's own
+bundle and Vite hot-replaces it like any other module.`}
 
 ## Adding another
 
-1. \`src/plugins/YourThing/YourThing.tsx\` — a component whose props are the attributes you want to author.
-2. \`src/plugins/YourThing/index.ts\` — \`export default\`, so the registration has one thing to point at.
-3. Register it in \`src/main.ts\` under a \`renderType\`.
-4. Put a \`custom({ renderType: 'yourThing', … })\` in \`src/space.ts\`.
+\`\`\`bash
+npx @plitzi/cli add plugin seat-picker
+\`\`\`
+
+It asks what to call it and writes \`src/plugins/SeatPicker/\`: the component, the panel the builder edits it with, and
+the \`index.ts\` that hands both over. Then put a \`custom({ renderType: 'seatPicker', … })\` in \`src/space.ts\`.
+
+By hand it is the same three files: \`YourThing/YourThing.tsx\` — a component whose props are the attributes you want
+to author — and \`YourThing/index.ts\` with an \`export default\`.
 
 ## Three things that bite
 
@@ -399,10 +1049,30 @@ break the plugin, it blanks the page. Put live values in an effect.
 **Do not name colours.** The page carries a palette and a light/dark theme; a plugin that hard-codes \`#111\` is
 invisible on one of them. Use \`currentColor\` and the space's own \`var(--…)\` variables.
 `;
+var declarationName = (component) => `${component.charAt(0).toLowerCase()}${component.slice(1)}`;
+/**
+* `src/plugins/declarations.ts`: the declaration of every plugin that has one, which `authorSpace` holds the space to —
+* a flow on an event a plugin never fires, or an attribute it does not read, is refused instead of written. Written
+* from the folders' names alone, so the CLI can tell a list it wrote from one somebody changed, and add to the first.
+*/
+var projectDeclarations = (components) => {
+	const names = components.map(declarationName);
+	const list = `export const declarations: PluginDeclarationData[] = [${names.join(", ")}];`;
+	return `${components.map((component) => `import ${declarationName(component)} from './${component}/declaration.ts';`).join("\n")}${components.length ? "\n\n" : ""}import type { PluginDeclarationData } from '@plitzi/sdk-authoring';
+
+/**
+ * Every plugin's declaration, handed to \`authorSpace\` wherever the space is authored: its flows on a plugin's events,
+ * its steps to a plugin's actions and its attributes are checked like a built-in element's. \`plitzi add plugin\`
+ * writes this list; a plugin written by hand is added with its \`declaration.ts\`.
+ */
+${list.length <= 120 ? list : `export const declarations: PluginDeclarationData[] = [\n${names.map((name) => `  ${name}`).join(",\n")}\n];`}
+`;
+};
 var pluginFiles = (answers) => ({
-	"src/plugins/StatCard/StatCard.tsx": component(),
+	"src/plugins/StatCard/StatCard.tsx": component$1(),
 	"src/plugins/StatCard/index.ts": barrel(),
-	"src/plugins/README.md": readme$1(answers)
+	"src/plugins/README.md": readme$2(answers),
+	...answers.source === "local" ? { "src/plugins/declarations.ts": projectDeclarations([]) } : {}
 });
 //#endregion
 //#region src/scaffold/packageManager.ts
@@ -435,11 +1105,10 @@ var runCommand = (manager, script) => manager === "npm" && script !== "start" ?
 /**
 * Yarn's own file, and the only per-manager file the scaffold writes.
 *
-* Yarn 4 installs Plug'n'Play by default, and a server-mode project cannot start that way: `node --import tsx`
-* dies on its first import with "Some options passed to require() aren't supported by PnP yet (conditions)" —
-* tsx's resolver calls into Node's with conditions PnP does not implement. `node-modules` is the layout npm and
-* pnpm already give it, so pinning it is what makes all three managers produce a project that runs, rather than
-* two that do and one that fails the moment somebody types `yarn start`.
+* Yarn 4 installs Plug'n'Play by default, and this project is run straight from `node_modules`: its server by Node
+* itself, its plugins by the page server's bundler. `node-modules` is the layout npm and pnpm already give it, so
+* pinning it is what makes all three managers produce a project that runs, rather than two that do and one that
+* fails the moment somebody types `yarn start`.
 */
 var YARN_LINKER = "nodeLinker: node-modules\n";
 var YARN_AGE_GATE = `
@@ -503,8 +1172,6 @@ var managerPackageFields = (manager) => manager === "npm" ? { allowScripts: {
 	esbuild: true,
 	fsevents: false
 } } : {};
-//#endregion
-//#region src/scaffold/project.ts
 var SDK_VERSION = `^${createRequire(import.meta.url)("@plitzi/sdk-authoring/package.json").version}`;
 /**
 * What every generated project builds and checks itself with.
@@ -513,6 +1180,9 @@ var SDK_VERSION = `^${createRequire(import.meta.url)("@plitzi/sdk-authoring/pack
 * `.tsx` file wherever it renders. The lint stack is the same one Plitzi's own packages use — type-checked rules,
 * with Prettier owning layout and `eslint-config-prettier` keeping ESLint out of that argument.
 */
+/** The React and the Vite every generated package is written against, project or plugin. */
+var REACT_VERSION = "^19.2.8";
+var VITE_VERSION = "^8.2.1";
 var SHARED_DEV_DEPENDENCIES = {
 	"@eslint/js": "^10.0.1",
 	"@playwright/test": "^1.56.1",
@@ -539,47 +1209,61 @@ var dependencies = ({ mode, source }) => ({
 	"@plitzi/plitzi-sdk": SDK_VERSION,
 	...mode === "server" ? { "@plitzi/sdk-server": SDK_VERSION } : {},
 	...source === "local" ? { "@plitzi/sdk-authoring": SDK_VERSION } : {},
-	react: "^19.2.8",
-	"react-dom": "^19.2.8"
+	react: REACT_VERSION,
+	"react-dom": REACT_VERSION
 });
-var devDependencies = ({ mode }) => mode === "server" ? {
+/** 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,
-	tsx: "^4.23.12"
-} : {
-	...SHARED_DEV_DEPENDENCIES,
-	vite: "^8.2.1"
-};
+	...mode === "server" ? {} : { vite: VITE_VERSION }
+});
+/**
+* Node runs this project's TypeScript itself — the server, `author`, `shot` — by stripping the types, which it does
+* without a flag from 22.18. Nothing transpiles beside the server: `tsx` did, and its loader thread cost a server
+* more memory than the server itself (~270 MB to start where the same server starts in ~90), which is the difference
+* between a small host and one that is killed on boot. The price is the one `tsconfig` enforces: relative imports
+* name their `.ts` file, and only syntax that erases (no `enum`, no parameter properties).
+*/
+var NODE_ENGINES = { node: ">=22.18" };
 /**
 * What `start` means, which is the whole difference between the two modes.
 *
 * `client` runs Vite, so a save is a hot module replacement — the page updates without reloading, and editing the
-* space is a live loop. `server` runs the page server under `tsx watch`: there is no client bundle of this
+* space is a live loop. `server` runs the page server under Node's `--watch`: there is no client bundle of this
 * project's own to hot-replace (the SDK is served by the server from its own copy), so a save restarts the
 * process and the next request renders the change. Both are one command; only one of them is HMR, and calling
 * the other one HMR would be a promise the loop does not keep.
 */
 var scripts = ({ mode, source }) => ({
 	...mode === "server" ? {
-		start: "node --import tsx src/main.ts",
+		start: "node src/main.ts",
 		/**
 		* Watched by PATH, not wholesale.
 		*
 		* The server compiles the project's plugins into `.sdk-plugins/` and then IMPORTS what it built, so a
 		* bare `--watch` sees its own output land, restarts, compiles again, and never stops.
 		*/
-		"start:dev": "node --import tsx --watch-path=./src src/main.ts"
+		"start:dev": "node --watch-path=./src src/main.ts",
+		/**
+		* What production runs: the same entry compiled to JavaScript. Node strips types by loading a TypeScript
+		* transformer into the process — ~10 MB a server keeps for its whole life to read one file — so a deployment
+		* runs what `build` emitted and carries no TypeScript at all.
+		*/
+		build: "tsc -p tsconfig.build.json",
+		"start:prod": "node dist/main.js"
 	} : {
 		start: "vite",
 		build: "vite build",
 		preview: "vite preview"
 	},
-	...source === "local" ? { author: "node --import tsx src/author.ts" } : {},
+	...source === "local" ? { author: "node src/author.ts" } : {},
 	typecheck: "tsc -p tsconfig.json --noEmit",
 	lint: "eslint .",
 	format: "prettier --write .",
-	visual: "playwright test"
+	visual: "playwright test",
+	shot: "node scripts/shot.ts"
 });
-var packageJson = (answers) => `${JSON.stringify({
+var packageJson$1 = (answers) => `${JSON.stringify({
 	name: answers.name,
 	version: "0.0.0",
 	private: true,
@@ -587,9 +1271,25 @@ var packageJson = (answers) => `${JSON.stringify({
 	scripts: scripts(answers),
 	dependencies: dependencies(answers),
 	devDependencies: devDependencies(answers),
+	engines: NODE_ENGINES,
 	...managerPackageFields(answers.packageManager)
 }, null, 2)}\n`;
-var tsconfig = ({ mode }) => `${JSON.stringify({
+/**
+* What `build` compiles: the server's own code, to \`dist/\`, with each \`./space.ts\` import rewritten to the \`.js\` it
+* becomes. The plugins are left out — the page server builds those itself, from their source.
+*/
+var tsconfigBuild = () => `${JSON.stringify({
+	extends: "./tsconfig.json",
+	compilerOptions: {
+		noEmit: false,
+		outDir: "dist",
+		rootDir: "src",
+		rewriteRelativeImportExtensions: true
+	},
+	include: ["src"],
+	exclude: ["src/plugins"]
+}, null, 2)}\n`;
+var tsconfig$1 = ({ mode }) => `${JSON.stringify({
 	compilerOptions: {
 		target: "ES2023",
 		module: "esnext",
@@ -599,6 +1299,9 @@ var tsconfig = ({ mode }) => `${JSON.stringify({
 		esModuleInterop: true,
 		skipLibCheck: true,
 		resolveJsonModule: true,
+		allowImportingTsExtensions: true,
+		verbatimModuleSyntax: true,
+		erasableSyntaxOnly: true,
 		/**
 		* `vite/client` in the browser build, and it is not optional there: it is what declares a side-effect CSS
 		* import and `import.meta.env`, both of which the entry point uses.
@@ -613,6 +1316,7 @@ var tsconfig = ({ mode }) => `${JSON.stringify({
 	},
 	include: [
 		"src",
+		"scripts",
 		"visual",
 		"playwright.config.ts",
 		...mode === "client" ? ["vite.config.ts"] : []
@@ -622,11 +1326,11 @@ var tsconfig = ({ mode }) => `${JSON.stringify({
 * Yarn's four lines are Yarn's own recommendation, and they are not decoration: with the `node-modules` linker it
 * writes `.yarn/install-state.gz` into the project, which is a cache and belongs in no repository.
 */
-var YARN_IGNORES = "\n.yarn/*\n!.yarn/patches\n!.yarn/plugins\n!.yarn/releases\n!.yarn/versions\n";
+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 gitignore = ({ mode, packageManager }) => `node_modules\ndist\n.env\nvisual/.results\nvisual/screenshots\n${mode === "server" ? SERVER_IGNORES : ""}${packageManager === "yarn" ? YARN_IGNORES : ""}`;
-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.` : `\`${runCommand(packageManager, "start")}\` runs Vite on http://127.0.0.1:5173, with hot module replacement.`;
+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 spaceSection = (answers) => {
 	if (answers.source === "cloud") return `## Where the space comes from
 
@@ -649,7 +1353,7 @@ Nothing is fetched and nothing is signed in to: there is no account, no key and
 somewhere else — imported into Plitzi, handed to another server, or checked into a repository with no TypeScript
 in it. Nothing here reads that file; the declaration is the source.`;
 };
-var readme = (answers) => `# ${answers.name}
+var readme$1 = (answers) => `# ${answers.name}
 
 A Plitzi space, rendered ${answers.mode === "server" ? "by a server of your own (SSR + RSC)" : "in the browser, with no server at all"}.
 
@@ -666,7 +1370,8 @@ ${spaceSection(answers)}
 ## The skills
 
 \`.claude/skills/\` carries Plitzi's authoring skill, so an agent working in this repository knows how a space is
-put together before it touches one. Claude Code reads it automatically; \`AGENTS.md\` points any other agent at it.
+put together before it touches one, and the CLI's, so it knows what \`plitzi\` can do for it — plugins, packing,
+uploading. Claude Code reads them automatically; \`AGENTS.md\` points any other agent at them.
 `;
 /**
 * What any agent opening the project reads first, whichever agent it is.
@@ -702,6 +1407,8 @@ ${commands.join("\n")}
 
 Read ${code(".claude/skills/plitzi-authoring/SKILL.md")} — how a space is written, and the references it links to for
 layouts, data, templates and flows. The types of ${code("@plitzi/sdk-authoring")} document every factory and field.
+For a component of your own — a plugin — or anything about packing or uploading one, read
+${code(".claude/skills/plitzi-cli/SKILL.md")} first: ${code("plitzi add plugin")} writes it in the shape everything reads.
 
 ## The rules that go wrong most
 
@@ -740,10 +1447,11 @@ VITE_PLITZI_ENVIRONMENT=${environment}
 `;
 var projectFiles = (answers) => ({
 	...managerFiles(answers.packageManager, answers.managerVersion),
-	"package.json": packageJson(answers),
-	"tsconfig.json": tsconfig(answers),
-	".gitignore": gitignore(answers),
-	"README.md": readme(answers),
+	"package.json": packageJson$1(answers),
+	"tsconfig.json": tsconfig$1(answers),
+	...answers.mode === "server" ? { "tsconfig.build.json": tsconfigBuild() } : {},
+	".gitignore": gitignore$1(answers),
+	"README.md": readme$1(answers),
 	"AGENTS.md": agentsFile(answers),
 	"CLAUDE.md": "@AGENTS.md\n",
 	...answers.source === "cloud" ? { ".env": envFile(answers) } : {}
@@ -771,7 +1479,15 @@ var prettierrc = () => `${JSON.stringify({
 	arrowParens: "avoid",
 	endOfLine: "lf"
 }, null, 2)}\n`;
-var prettierignore = () => "node_modules\ndist\nspace\nvisual/.results\nvisual/screenshots\n";
+/** What a project writes that is nobody's to format or lint: its builds, its authored documents, its test output. */
+var PROJECT_OUTPUTS = [
+	"dist",
+	"space",
+	".sdk-plugins",
+	"visual/.results",
+	"visual/screenshots"
+];
+var prettierignore = (outputs) => `${["node_modules", ...outputs.filter((output) => output !== ".sdk-plugins")].join("\n")}\n`;
 /**
 * Flat config, and only what earns its place.
 *
@@ -780,14 +1496,14 @@ var prettierignore = () => "node_modules\ndist\nspace\nvisual/.results\nvisual/s
 * that no amount of formatting would have shown. `eslintConfigPrettier` goes last, so it can switch off the
 * stylistic rules the earlier entries turned on.
 */
-var eslintConfig = ({ mode }) => `import js from '@eslint/js';
+var eslintConfig = (globals, outputs) => `import js from '@eslint/js';
 import reactHooks from 'eslint-plugin-react-hooks';
 import globals from 'globals';
 import tsEslint from 'typescript-eslint';
 import eslintConfigPrettier from 'eslint-config-prettier';
 
 export default tsEslint.config(
-  { ignores: ['dist', 'space', '.sdk-plugins', 'visual/.results', 'visual/screenshots'] },
+  { ignores: [${outputs.map((output) => `'${output}'`).join(", ")}] },
   js.configs.recommended,
   {
     /**
@@ -800,7 +1516,7 @@ export default tsEslint.config(
     files: ['**/*.{ts,tsx}'],
     extends: [tsEslint.configs.recommendedTypeChecked],
     languageOptions: {
-      globals: { ...globals.${mode === "server" ? "node" : "browser"} },
+      globals: { ...globals.${globals} },
       parserOptions: { projectService: true, tsconfigRootDir: import.meta.dirname }
     }
   },
@@ -819,11 +1535,13 @@ export default tsEslint.config(
   eslintConfigPrettier
 );
 `;
-var qualityFiles = (answers) => ({
+/** The three files for code that runs where `globals` says, with `outputs` left alone. */
+var qualityFilesFor = (globals, outputs) => ({
 	".prettierrc": prettierrc(),
-	".prettierignore": prettierignore(),
-	"eslint.config.mjs": eslintConfig(answers)
+	".prettierignore": prettierignore(outputs),
+	"eslint.config.mjs": eslintConfig(globals, outputs)
 });
+var qualityFiles = ({ mode }) => qualityFilesFor(mode === "server" ? "node" : "browser", PROJECT_OUTPUTS);
 //#endregion
 //#region src/scaffold/server.ts
 /**
@@ -834,20 +1552,27 @@ var qualityFiles = (answers) => ({
 */
 /** Written into both entry points, because how a plugin is registered does not change with where the space lives. */
 var PLUGINS = `/**
- * The project's own components, by the \`renderType\` the space names them with.
+ * The project's own components: every folder of \`src/plugins\` is one, registered under its name in camelCase —
+ * \`src/plugins/StatCard\` is what a space's \`custom({ renderType: 'statCard' })\` renders. \`plitzi add plugin\` writes
+ * a new one there; the next start registers it.
  *
  * \`action: 'compile'\` is what makes them SERVER-rendered. The server builds the entry with esbuild, keeps React
  * external so the plugin runs on the one copy this page already has, serves the bundle to the browser AND imports
- * it into the render — so the component's markup is in the HTML before any JavaScript arrives. Add another by
- * writing it under \`src/plugins\` and adding a line here; see \`src/plugins/README.md\`.
+ * it into the render — so the component's markup is in the HTML before any JavaScript arrives. See
+ * \`src/plugins/README.md\`.
  */
-const plugins = {
-  statCard: {
-    js: path.resolve(import.meta.dirname, 'plugins/StatCard/index.ts'),
-    action: 'compile' as const,
-    version: '1.0.0'
-  }
-};
+// From the project root, so the path holds whether this file runs as \`src/main.ts\` or compiled as \`dist/main.js\`.
+const PROJECT_ROOT = path.resolve(import.meta.dirname, '..');
+const PLUGINS_DIR = path.join(PROJECT_ROOT, 'src/plugins');
+
+const plugins = Object.fromEntries(
+  readdirSync(PLUGINS_DIR, { withFileTypes: true })
+    .filter(entry => entry.isDirectory())
+    .map(entry => [
+      \`\${entry.name.charAt(0).toLowerCase()}\${entry.name.slice(1)}\`,
+      { js: path.join(PLUGINS_DIR, entry.name, 'index.ts'), action: 'compile' as const, version: '1.0.0' }
+    ])
+);
 
 /**
  * Registering a plugin is not the same as turning it on.
@@ -858,15 +1583,19 @@ const plugins = {
  * no error anywhere, which is a long afternoon.
  */
 const pluginNames = Object.keys(plugins);`;
-var localMain = () => `import path from 'node:path';
+var localMain = () => `import { readdirSync } from 'node:fs';
+import path from 'node:path';
 
-import { closeOnSignals, consoleLogger, createJsonAdapters, createServer } from '@plitzi/sdk-server';
+import { closeOnSignals, consoleLogger, createJsonAdapters, createServer, loadFunctions } from '@plitzi/sdk-server';
 
 import { authorSpace } from '@plitzi/sdk-authoring';
 
-import { space } from './space';
+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';
 
 /**
  * The space, held in this project.
@@ -875,7 +1604,8 @@ const PORT = Number(process.env.PORT ?? 8080);
  * boot, so saving that file and letting \`--watch\` restart it is the whole edit loop — and its warnings are printed
  * here for the same reason: this restart is the output somebody editing the space is actually watching.
  */
-const { schema, style, warnings } = authorSpace(space);
+// \`declarations\`: what the project's plugins fire, answer and read, so the space's use of them is checked too.
+const { schema, style, warnings } = authorSpace(space, { plugins: declarations });
 const offlineData = { schema, style };
 
 for (const warning of warnings) {
@@ -884,6 +1614,13 @@ for (const warning of warnings) {
 
 ${PLUGINS}
 
+/**
+ * This project's own server code: \`functions/\` — what \`plitzi functions pull\` writes and \`push\` sends — built
+ * the way Plitzi builds a space's and run here, in this process. Nothing there, no functions; code that does not build
+ * stops the server with the file and line.
+ */
+const functions = await loadFunctions(new URL('../functions/', import.meta.url));
+
 /**
  * Where the server gets a space from, and the only line that knows.
  *
@@ -899,10 +1636,11 @@ const server = createServer({
     deployment: { spaceId: 1, environment: 'main', revision: 0, pluginNames }
   }),
   plugins,
+  functions: { native: functions },
   logger: consoleLogger
 });
 
-server.listen(PORT, '127.0.0.1');
+server.listen(PORT, HOST);
 console.log(\`pages on http://127.0.0.1:\${PORT}/\`);
 
 /**
@@ -912,11 +1650,14 @@ console.log(\`pages on http://127.0.0.1:\${PORT}/\`);
  */
 closeOnSignals(server);
 `;
-var cloudMain = () => `import path from 'node:path';
+var cloudMain = () => `import { readdirSync } from 'node:fs';
+import path from 'node:path';
 
-import { closeOnSignals, consoleLogger, createCloudAdapters, createServer } from '@plitzi/sdk-server';
+import { closeOnSignals, consoleLogger, createCloudAdapters, createServer, 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';
 
 ${PLUGINS}
 
@@ -934,6 +1675,13 @@ if (!HOST_KEY) {
   throw new Error('Set PLITZI_HOST_KEY in .env — Credentials, in the builder.');
 }
 
+/**
+ * This project's own server code: \`functions/\` — what \`plitzi functions pull\` writes and \`push\` sends — built
+ * the way Plitzi builds a space's and run here, in this process. Nothing there, no functions; code that does not build
+ * stops the server with the file and line.
+ */
+const functions = await loadFunctions(new URL('../functions/', import.meta.url));
+
 /**
  * The space stays in Plitzi; the SERVER is this one.
  *
@@ -956,10 +1704,11 @@ const server = createServer({
     deployment: { pluginNames }
   }),
   plugins,
+  functions: { native: functions },
   logger: consoleLogger
 });
 
-server.listen(PORT, '127.0.0.1');
+server.listen(PORT, HOST);
 console.log(\`pages on http://127.0.0.1:\${PORT}/\`);
 
 /**
@@ -980,15 +1729,16 @@ var serverFiles = (answers) => ({ "src/main.ts": answers.source === "cloud" ? cl
 * manager. Read from the installed package rather than embedded here, so the CLI cannot ship a stale copy of
 * somebody else's documentation.
 *
-* Only `plitzi-authoring` travels. `plitzi-render` is the 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.
+* Two travel: `plitzi-authoring` (how a space is written) and `plitzi-cli` (what this command line does — plugins,
+* packing, uploading — so an agent reaches for it instead of hand-writing what it generates). `plitzi-render` is the
+* 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 SKILLS = [{
-	package: "@plitzi/sdk-authoring",
-	name: "plitzi-authoring"
-}];
+var SKILLS = {
+	"plitzi-authoring": "@plitzi/sdk-authoring",
+	"plitzi-cli": "@plitzi/cli"
+};
 /**
 * Where a skill file sits, resolved through the package's own export map rather than guessed from a path.
 *
@@ -1009,11 +1759,12 @@ var filesUnder = (root, folder = root) => readdirSync(folder, { withFileTypes: t
 	if (entry.isDirectory()) return filesUnder(root, path);
 	return entry.isFile() ? [[relative(root, path).split(sep).join("/"), readFileSync(path, "utf-8")]] : [];
 });
-var skillFiles = () => {
+/** 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"]) => {
 	const files = {};
-	for (const skill of SKILLS) try {
-		const root = dirname(skillPath(skill.package, skill.name));
-		for (const [path, content] of filesUnder(root)) files[`.claude/skills/${skill.name}/${path}`] = content;
+	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;
 	}
@@ -1043,9 +1794,10 @@ var authorScript = () => `import { mkdirSync, writeFileSync } from 'node:fs';
 
 import { authorSpace } from '@plitzi/sdk-authoring';
 
-import { space } from './space';
+import { declarations } from './plugins/declarations.ts';
+import { space } from './space.ts';
 
-const { schema, style, warnings } = authorSpace(space);
+const { schema, style, warnings } = authorSpace(space, { plugins: declarations });
 
 mkdirSync('space', { recursive: true });
 writeFileSync('space/offline-data.json', \`\${JSON.stringify({ schema, style }, null, 2)}\\n\`);
@@ -1056,39 +1808,59 @@ for (const warning of warnings) {
 
 console.log('space/offline-data.json');
 `;
+/** The numbers the example shows: in a data file where one is served, on the element where none is. */
+var STATS = {
+	value: 12480,
+	series: [
+		8,
+		12,
+		9,
+		17,
+		14,
+		21,
+		19,
+		26
+	]
+};
 /**
-* The plugin the copy hosts, and the numbers it is authored with.
+* The plugin the copy hosts, and what it is authored with.
 *
 * Asked for here rather than defaulted on in the package: the platform authors a new space from the same
 * declaration and hosts nobody's plugins, so the slot exists only where a project carries the component to fill
-* it. The settings are what the component reads as props — a plain object here, a JSON string on the element,
-* and the same names on both sides.
+* it. Its attributes are the component's props, by name. A client project serves `public/`, so there the numbers
+* come from a data file through a provider — the way a project with no backend shows data it did not invent.
 */
-var PLUGIN_HOST = {
+var pluginHost = ({ mode }) => mode === "client" ? {
 	id: "stat-card",
 	renderType: "statCard",
-	settings: {
+	attributes: {
+		label: "Requests today",
+		unit: "reqs"
+	},
+	data: {
+		id: "stats",
+		query: "/data/stats.json",
+		bind: {
+			value: "stats.data.value",
+			series: "stats.data.series"
+		}
+	}
+} : {
+	id: "stat-card",
+	renderType: "statCard",
+	attributes: {
 		label: "Requests today",
-		value: 12480,
 		unit: "reqs",
-		series: [
-			8,
-			12,
-			9,
-			17,
-			14,
-			21,
-			19,
-			26
-		]
-	}
-};
-var spaceFiles = ({ source, name }) => source === "cloud" ? {} : {
+		...STATS
+	}
+};
+var spaceFiles = (answers) => answers.source === "cloud" ? {} : {
 	"src/space.ts": blankSpaceSource({
-		name,
-		plugin: PLUGIN_HOST
+		name: answers.name,
+		plugin: pluginHost(answers)
 	}),
-	"src/author.ts": authorScript()
+	"src/author.ts": authorScript(),
+	...answers.mode === "client" ? { "public/data/stats.json": `${JSON.stringify(STATS, null, 2)}\n` } : {}
 };
 //#endregion
 //#region src/scaffold/visual.ts
@@ -1099,7 +1871,7 @@ var spaceFiles = ({ source, name }) => 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 = ({ mode, packageManager }) => `import { defineConfig } from '@playwright/test';
+var playwrightConfig$1 = ({ mode, packageManager }) => `import { defineConfig } from '@playwright/test';
 
 const PORT = ${mode === "server" ? "8080" : "5173"};
 
@@ -1119,39 +1891,38 @@ export default defineConfig({
 `;
 var authoredSpec = () => `import { expect, test } from '@playwright/test';
 
-import { authorSpace, locate } from '@plitzi/sdk-authoring';
+import { authorSpace, inspectPage } from '@plitzi/sdk-authoring';
 
-import { space } from '../src/space';
+import { declarations } from '../src/plugins/declarations.ts';
+import { space } from '../src/space.ts';
 
 /**
- * Everything this space NAMES is on screen, on every page it has.
+ * Every page renders whole: everything the space NAMES is on screen, images arrived, nothing scrolls sideways, and no
+ * text is drawn in the colour behind it.
  *
  * The strongest assertion available about a page you did not hand-write, and it costs no upkeep: an id an author
  * bothered to write down is an element somebody meant to point at, and \`authorSpace\` reports which those were.
  * Rename one and this fails at author time with a suggestion, rather than at test time with an empty locator.
  *
  * One test per page, so the second page you add is covered the moment it exists. What a bare visit cannot show is
- * left to tests of its own: a page behind a session or with a route param (\`post/{{slug}}\`), and an element that is
- * on screen only under a condition — a menu that opens on a tap, a confirmation after a submit.
+ * left to tests of its own: a page behind a session or with a route param (\`post/{{slug}}\`). What shows only under a
+ * condition, renders once per list row or has no box of its own, \`inspectPage\` sets aside by itself.
  */
-const { handles } = authorSpace(space);
+const { handles } = authorSpace(space, { plugins: declarations });
 
 const openable = Object.values(handles.pages).filter(
   pageHandle => pageHandle.accessLevel !== 'authenticated' && pageHandle.params.length === 0
 );
 
 for (const pageHandle of openable) {
-  test(\`\${pageHandle.path} renders every element it names\`, async ({ page }) => {
+  test(\`\${pageHandle.path} renders whole\`, async ({ page }) => {
     const errors: string[] = [];
     page.on('pageerror', error => errors.push(error.message));
 
     await page.goto(pageHandle.path, { waitUntil: 'networkidle' });
-    const el = locate(page, handles);
-
-    for (const handle of Object.values(pageHandle.elements).filter(entry => entry.named && !entry.conditional)) {
-      await expect(el(handle.id), \`\${handle.type} "\${handle.id}"\`).toBeVisible();
-    }
 
+    // Every problem at once, each naming the element and why — which ancestor hid it, what overflowed.
+    expect((await inspectPage(page, handles, { page: pageHandle.id })).problems).toEqual([]);
     expect(errors).toEqual([]);
   });
 }
@@ -1178,121 +1949,2578 @@ test('renders the space without errors', async ({ page }) => {
   expect(errors).toEqual([]);
 });
 `;
-var visualFiles = (answers) => ({
-	"playwright.config.ts": playwrightConfig(answers),
+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
-//#region src/scaffold/index.ts
+//#region src/scaffold/pluginPackage/build.ts
 /**
-* Every file of a generated project, assembled from the two decisions that shape it.
+* The preview's Vite config — and only the preview's.
 *
-* Pure, and separate from the command that writes them, so what the scaffold SAYS can be asserted without a
+* Building the plugin is not this package's code: `plitzi pack plugin` does it, the one implementation every plugin is
+* built with, so the platform's contract (React and the SDK kept out, one file, a manifest with each file's hash) moves
+* with the CLI instead of going stale in a copy here.
+*/
+var viteConfig = () => `import { createReadStream } from 'node:fs';
+import { createRequire } from 'node:module';
+
+import { defineConfig } from 'vite';
+
+import type { Plugin } from 'vite';
+
+const require = createRequire(import.meta.url);
+
+/**
+ * Serves the dev tools' stylesheet at the path the SDK asks for.
+ *
+ * They render into a shadow root, which cannot see this page's styles, so they fetch a stylesheet of their own from
+ * \`/plitzi-sdk-devtools.css\` — a path that exists on a server serving the SDK's assets and nowhere else. Development
+ * only, and read from \`node_modules\` on each request, so it cannot go stale against the installed SDK.
+ */
+const devToolsStylesheet = (): Plugin => ({
+  name: 'plitzi-devtools-stylesheet',
+  apply: 'serve',
+  configureServer(server) {
+    server.middlewares.use('/plitzi-sdk-devtools.css', (_request, response) => {
+      response.setHeader('Content-Type', 'text/css');
+      createReadStream(require.resolve('@plitzi/plitzi-sdk/plitzi-sdk-devtools.css')).pipe(response);
+    });
+  }
+});
+
+/**
+ * \`start\` serves the preview: \`index.html\`, every element inside a space. Packing the plugin is the CLI's
+ * (\`plitzi pack plugin\`).
+ *
+ * The host is pinned because Vite binds \`localhost\` — IPv6 on most machines — while what waits for a dev server,
+ * the visual test included, asks for 127.0.0.1.
+ */
+export default defineConfig({
+  plugins: [devToolsStylesheet()],
+  server: { host: '127.0.0.1', port: 5173 }
+});
+`;
+var buildFiles = () => ({ "vite.config.ts": viteConfig() });
+//#endregion
+//#region src/scaffold/pluginPackage/names.ts
+var PREFIX = "plitzi-plugin-";
+/** npm's own rule for a package name, scope included. */
+var PACKAGE_NAME = /^(@[a-z0-9][a-z0-9-._~]*\/)?[a-z0-9][a-z0-9-._~]*$/;
+/** What the name has to leave once the scope and prefix are off: words of letters and digits, starting with a letter. */
+var BASE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+var baseOf = (packageName) => {
+	const unscoped = packageName.replace(/^@[^/]+\//, "");
+	return unscoped.startsWith(PREFIX) ? unscoped.slice(14) : unscoped;
+};
+/** What is wrong with a name as a plugin's, in words that say how to fix it — or `undefined` when nothing is. */
+var pluginNameProblem = (packageName) => {
+	if (!PACKAGE_NAME.test(packageName)) return `"${packageName}" is not a package name npm accepts: lowercase letters, digits and dashes, optionally under a @scope/.`;
+	if (!BASE.test(baseOf(packageName))) return `"${packageName}" has to name the plugin in words — lowercase letters and digits between single dashes, starting with a letter (seat-picker, chart2) — since the component and the type a space uses are made from it.`;
+	const { type } = pluginNames(packageName);
+	if (elementTypeNames.includes(type)) return `"${packageName}" would make the type "${type}", which is a built-in element: a space could not tell the two apart. Name it after what it does (seat-picker, sales-chart).`;
+};
+var words = (base) => base.split("-");
+var capitalised = (word) => `${word.charAt(0).toUpperCase()}${word.slice(1)}`;
+/** The names, for a name `pluginNameProblem` accepted. */
+var pluginNames = (packageName) => {
+	const base = baseOf(packageName);
+	const [first, ...rest] = words(base);
+	return {
+		packageName,
+		base,
+		type: `${first}${rest.map(capitalised).join("")}`,
+		component: words(base).map(capitalised).join(""),
+		title: words(base).map(capitalised).join(" ")
+	};
+};
+//#endregion
+//#region src/scaffold/pluginPackage/docs.ts
+var readme = (elements, { packageName, packageManager }) => {
+	const run = (script) => runCommand(packageManager, script);
+	const { base } = pluginNames(packageName);
+	const [{ type, component }] = elements;
+	const held = elements.map((element) => `\`${element.type}\``).join(", ");
+	return `# ${packageName}
+
+A Plitzi plugin: ${elements.length === 1 ? "an element" : "elements"} of your own that any space can render — ${held}.
+An element of that type renders the component in its folder under \`src/\`, and its attributes arrive as the
+component's props.
+
+\`\`\`bash
+${installCommand(packageManager)}
+${run("start")}    # the plugin inside a space, with hot module replacement
+${run("visual")}   # a browser opens the preview and checks the plugin works
+npx @plitzi/cli pack plugin   # the plugin, built — and zipped the way the builder takes it
+\`\`\`
+
+## What is where
+
+Each element is written the way Plitzi's own elements are (\`@plitzi/sdk-elements\`): one folder, four files.
+
+- \`src/${component}/${component}.tsx\` — the component: what a page renders.
+- \`src/${component}/declaration.ts\` — the element as the platform knows it: its \`type\`, the events it fires and the
+  actions it answers to, its starting attributes, how the catalogue shows it and its default style. Data only; the build
+  writes it into the manifest.
+- \`src/${component}/Settings.tsx\` — its panel in the builder.
+- \`src/${component}/index.ts\` — the three put together: what a space loads.
+- \`src/elements.ts\` and \`src/declarations.ts\` — every element the package holds, the one it is named after first:
+  \`src/index.ts\` publishes the first as the plugin and the rest as its \`plugins\`, and the build writes each
+  declaration into the manifest.
+- \`preview/\` — a space to look at the plugin in, rendered in the browser with no server.
+
+## Publishing
+
+\`npx @plitzi/cli pack plugin\` builds the plugin — the CLI is the one place a plugin is packed, so this package carries
+no build of its own. It writes \`dist/\`: \`${base}.mjs\`, \`plugin-manifest.json\` — which the builder, the page server and
+the MCP server read to know the plugin before they load it — and \`types/\`, the declarations a project installing the
+package reads. Beside it, \`${base}-<version>.zip\`.
+
+- **Through the builder.** Upload the zip under **Resources**, as a plugin: the platform unpacks it at an address of its
+  own and the space can use it.
+- **From your own host.** Serve \`dist/\` at an address that never changes for a given version
+  (\`https://cdn.example.com/${base}/0.1.0\`), with CORS open to plain reads, and list it in the space's plugins:
+  \`{ type: '${type}', resource: '<that address>' }\`.
+- **On npm.** Pack first, then publish: \`exports\` points at \`dist/\`.
+
+## In a project of your own
+
+- **In the browser** — \`render()\`, or \`<PlitziSdk>\` in a React application — install the package and register every
+  element it holds:
+
+  \`\`\`ts
+  import { elements } from '${packageName}';
+
+  render('root', options, Object.fromEntries(elements.map(element => [element.type, { component: element }])));
+  \`\`\`
+
+- **On a page server of your own**, compile each element from its source, which is what renders it on the server:
+  \`plugins: { ${type}: { js: path.resolve('node_modules/${packageName}/src/${component}/index.ts'), action: 'compile' } }\`,
+  one entry per element, each named in the deployment's \`pluginNames\`.
+
+## The contract
+
+- **React and the SDK are the page's.** The build keeps \`react\`, \`react-dom\` and \`@plitzi/plitzi-sdk\` out of the
+  bundle and imports the page's copies — a second React is "Invalid hook call" and a blank element. Anything else you
+  import is bundled.
+- **One file.** A page imports the plugin from a blob URL, where a second chunk has nowhere to be found, so the build
+  never splits it. Import freely; it all ends up in \`${base}.mjs\`.
+- **Render \`RootElement\`, not a \`div\`.** It is what makes the plugin an _element_: the id and classes the space gave
+  it land on what you render, so the CSS authored on it applies, the builder can select it, a test can find it, and
+  its events and actions are its own.
+- **Nothing that differs between a server and the first render in the browser** — a clock, a random number, anything
+  read out of \`window\`. React answers a hydration mismatch by discarding the whole tree: it does not break the plugin,
+  it blanks the page. Put live values in an effect.
+- **Do not name colours.** The page has a palette and a light/dark theme; use \`currentColor\` and the space's own
+  \`var(--…)\` variables.
+
+## Another element
+
+\`\`\`bash
+npx @plitzi/cli add plugin legend
+\`\`\`
+
+Run in this package, it writes \`src/Legend/\` and lists it in \`src/elements.ts\` and \`src/declarations.ts\` — the
+package publishes it from then on, beside \`${type}\`. Put an \`element('legend', { id: 'legend' })\` in
+\`preview/space.ts\` to look at it.
+`;
+};
+var agents = (elements, { packageName, packageManager }) => {
+	const run = (script) => `\`${runCommand(packageManager, script)}\``;
+	return `# ${packageName} — notes for agents
+
+A Plitzi plugin holding ${elements.map((element) => `\`${element.type}\` (\`src/${element.component}\`)`).join(", ")}, each written
+the way \`@plitzi/sdk-elements\` writes its own. An element's \`declaration.ts\` says how the platform knows it.
+
+- ${run("start")} — the preview: the plugin inside a space.
+- ${run("visual")} — a browser checks the preview.
+- ${run("typecheck")} and ${run("lint")} — before calling a change done.
+- \`npx @plitzi/cli pack plugin\` — \`dist/\` (the module, \`plugin-manifest.json\`, the types) and the zip for the builder.
+- \`npx @plitzi/cli add plugin <name>\` — another element, in the same shape; \`upload plugin\` puts the zip on a space.
+  Everything the CLI does, and how it behaves with nobody at the terminal: \`.claude/skills/plitzi-cli/SKILL.md\`.
+
+- The component's props are the element's attributes. A new one goes in three places: the props, the declaration
+  (\`content.attributes\`, and \`bindingsAllowed\` if data may drive it), and \`Settings.tsx\`.
+- A new event or action is declared in \`declaration.ts\` (\`triggers\`, \`callbacks\`) and registered by the component
+  from there — never only in the component.
+- Render through \`RootElement\`; never render anything on the first pass that differs between a server and a browser.
+- Never bundle a second React or SDK: the page provides both — see the README's contract.
+- \`type\` in the declaration is what every space using the plugin names; renaming it orphans those elements.
+`;
+};
+var docsFiles = (elements, answers) => ({
+	"README.md": readme(elements, answers),
+	"AGENTS.md": agents(elements, answers),
+	"CLAUDE.md": "@AGENTS.md\n"
+});
+//#endregion
+//#region src/scaffold/pluginPackage/package.ts
+/**
+* The package itself: what it installs, what it publishes and how it is checked.
+*
+* React and the SDK are PEER dependencies, which is the package-manager spelling of the build's `external`: the page
+* provides them and the plugin uses those, so a project installing the plugin never gets a second copy to fight with.
+* They are dev dependencies too, because the preview renders a page of its own.
+*
+* It builds nothing itself. `plitzi pack plugin` is the one place a plugin is packed — into `dist/`, which `exports`
+* points at, and a zip for the builder — so the package carries no bundler config and no build dependency of its own.
+*/
+var packageJson = ({ packageName, base }, { packageManager, owner }) => `${JSON.stringify({
+	name: packageName,
+	version: "0.1.0",
+	license: "MIT",
+	...owner ? { author: owner } : {},
+	type: "module",
+	files: ["dist", "src"],
+	exports: {
+		".": {
+			types: "./dist/types/index.d.ts",
+			import: `./dist/${base}.mjs`
+		},
+		"./plugin-manifest.json": "./dist/plugin-manifest.json"
+	},
+	scripts: {
+		start: "vite",
+		typecheck: "tsc -p tsconfig.json --noEmit",
+		lint: "eslint .",
+		format: "prettier --write .",
+		visual: "playwright test"
+	},
+	peerDependencies: {
+		"@plitzi/plitzi-sdk": SDK_VERSION,
+		react: REACT_VERSION,
+		"react-dom": REACT_VERSION
+	},
+	devDependencies: {
+		...SHARED_DEV_DEPENDENCIES,
+		"@plitzi/plitzi-sdk": SDK_VERSION,
+		"@plitzi/sdk-authoring": SDK_VERSION,
+		react: REACT_VERSION,
+		"react-dom": REACT_VERSION,
+		vite: VITE_VERSION
+	},
+	engines: { node: ">=22.18" },
+	...managerPackageFields(packageManager)
+}, null, 2)}\n`;
+/**
+* Written out rather than serialised: \`JSON.stringify\` puts every array entry on a line of its own, where the project's
+* own Prettier keeps a short list on one — and a file the formatter rewrites on the first save is noise in the first diff.
+*/
+var tsconfig = () => `{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "erasableSyntaxOnly": true,
+    "types": ["node", "vite/client"],
+    "lib": ["ES2023", "DOM", "DOM.Iterable"],
+    "jsx": "react-jsx"
+  },
+  "include": ["src", "preview", "visual", "vite.config.ts", "playwright.config.ts"]
+}
+`;
+/** Yarn's own recommendation: with the `node-modules` linker it writes a cache into `.yarn/` that no repository wants. */
+var YARN_IGNORES = "\n.yarn/*\n!.yarn/patches\n!.yarn/plugins\n!.yarn/releases\n!.yarn/versions\n";
+var gitignore = ({ packageManager, inProject }) => `node_modules\ndist\n*.zip\nvisual/.results\n${packageManager === "yarn" && !inProject ? YARN_IGNORES : ""}`;
+var packageFiles = (names, answers) => ({
+	"package.json": packageJson(names, answers),
+	"tsconfig.json": tsconfig(),
+	".gitignore": gitignore(answers)
+});
+//#endregion
+//#region src/scaffold/pluginPackage/quote.ts
+/**
+* Free text somebody typed — a title, a description, an owner — written into generated source.
+*
+* Interpolated bare, one apostrophe ("Carlos's picker") ends the string it lands in and the generated project does not
+* parse; these write it the way each kind of file reads it back.
+*/
+/**
+* A TypeScript string literal, quoted the way the generated project's own Prettier would quote it: single quotes,
+* unless the text holds more of them than of double quotes — so the file needs no reformatting on its first save.
+*/
+var tsString = (value) => {
+	const quote = value.split("'").length - 1 > value.split("\"").length - 1 ? "\"" : "'";
+	return `${quote}${value.replace(/\\/g, "\\\\").replaceAll(quote, `\\${quote}`).replace(/\r/g, "\\r").replace(/\n/g, "\\n")}${quote}`;
+};
+/** Text inside an HTML element. */
+var htmlText = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+//#endregion
+//#region src/scaffold/pluginPackage/preview.ts
+/**
+* Where the plugin is looked at while it is written: inside a space, the way a page will show it.
+*
+* Not a gallery of the component on its own. What goes wrong with a plugin goes wrong in a page — the theme it did not
+* expect, the element CSS it did not apply, a flow its event never reached — so the preview is the space a new account
+* starts with, with the plugin in its hero, rendered by the SDK in the browser with no server at all.
+*/
+var indexHtml = ({ title }) => `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${htmlText(title)} — preview</title>
+  </head>
+  <body>
+    <div id="plitzi-root"></div>
+    <script type="module" src="/preview/main.ts"><\/script>
+  </body>
+</html>
+`;
+var preflightCss = () => `/*
+ * The SDK ships no global CSS on purpose: dropping a space into an existing site must not restyle that site.
+ * The browser's own margins therefore survive unless the host page clears them, which is what this does.
+ */
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+}
+`;
+var mainFile = () => `import { render } from '@plitzi/plitzi-sdk';
+
+import { authorSpace } from '@plitzi/sdk-authoring';
+
+import { declarations } from '../src/declarations.ts';
+import { elements } from '../src/elements.ts';
+import { space } from './space.ts';
+
+import './preflight.css';
+import '@plitzi/plitzi-sdk/plitzi-sdk.css';
+
+import type { SpaceSpec } from '@plitzi/sdk-authoring';
+
+/**
+ * Every element of the package, registered from its source under the type a space names it by — so a save is a hot
+ * module replacement. What a published page does instead is load the built file through the manifest;
+ * \`npm run build\` is what makes that file.
+ */
+const plugins = Object.fromEntries(elements.map(element => [element.type, { component: element }]));
+
+/** The types this package's elements are: named, so authoring takes them for plugins and not for typos. */
+const pluginTypes = declarations.map(declaration => declaration.type);
+
+const mount = (spec: SpaceSpec) => {
+  const { schema, style, warnings } = authorSpace(spec, { pluginTypes });
+  for (const warning of warnings) {
+    console.warn(\`[author] \${warning.message}\`);
+  }
+
+  return render(
+    'plitzi-root',
+    {
+      // The SDK renders the documents it is handed: no account, no key and no server in the picture.
+      offlineMode: true,
+      offlineData: { schema, style },
+      // Straight into this page rather than into the SDK's default iframe: one document, one stylesheet.
+      renderMode: 'raw',
+      environment: 'main',
+      // The dev tools — shift+alt+D for the panel: logs, the store, the elements, what a flow did.
+      debugMode: import.meta.env.DEV
+    },
+    plugins
+  );
+};
+
+let mounted = mount(space);
+
+if (import.meta.hot) {
+  import.meta.hot.accept('./space.ts', updated => {
+    // Cast because the dev server cannot know the shape of a module it is swapping; the name is this file's own.
+    const next = (updated as { space?: SpaceSpec } | undefined)?.space;
+    if (!next) {
+      return;
+    }
+
+    mounted?.unmount();
+    mounted = mount(next);
+  });
+}
+`;
+var previewFiles = ([main, ...others]) => ({
+	"index.html": indexHtml(main),
+	"preview/preflight.css": preflightCss(),
+	"preview/main.ts": mainFile(),
+	"preview/space.ts": blankSpaceSource({
+		name: `${main.title} preview`,
+		plugin: [main, ...others].map((names) => ({
+			id: names.base,
+			renderType: names.type,
+			as: "element",
+			attributes: {
+				label: names.title,
+				start: 0,
+				step: 1
+			}
+		}))
+	})
+});
+//#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';
+
+/** 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. The component registers these; the builder offers them as what a flow can start on. */
+  triggers: {
+    // \`preview\` names what a flow started by the event can read — shown in the builder, never sent.
+    onCount: { action: 'onCount', title: 'On Count', type: 'trigger', params: {}, preview: { count: '' } }
+  },
+  /** The actions it answers to, static half: the component adds the function, and a title naming its label. */
+  callbacks: {
+    reset: { action: 'reset', title: 'Reset', type: 'callback', params: {} }
+  },
+  content: {
+    /** The starting attributes — the component's defaults, written where the builder can show them. */
+    attributes: { label: ${tsString(title)}, start: 0, step: 1 },
+    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,
+      canTemplate: 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: [
+          { path: 'label', label: 'Label' },
+          { path: 'start', label: 'Starts at' },
+          { path: 'step', label: 'Step' }
+        ],
+        initialState: []
+      }
+    },
+    settings: {}
+  }
+} satisfies PluginDeclaration<${name}Attributes>;
+
+export default declaration;
+`;
+var component = ({ component: name, title }) => `import { use, useCallback, useMemo, useState } from 'react';
+
+import { RootElement, useElement, usePlitziServiceContext } from '@plitzi/plitzi-sdk';
+
+import declaration from './declaration';
+
+import type { InteractionCallback } from '@plitzi/plitzi-sdk';
+import type { CSSProperties } from 'react';
+
+/**
+ * The props ARE the element's attributes.
+ *
+ * Whatever a space writes on the \`custom\` element that hosts this arrives here by the same name — and so does whatever
+ * a binding writes later, which is what makes a plugin a live component rather than a static one. Everything is
+ * optional and everything has a default: an attribute nobody has authored yet, or a binding whose source has not
+ * answered, is \`undefined\`, and a plugin that renders nothing in that moment is a hole in the page.
+ */
+export interface ${name}Props {
+  label?: string;
+  /** Where the count starts, and where \`reset\` puts it back. */
+  start?: number;
+  /** How much one press adds. */
+  step?: number;
+  /** Supplied by the runtime, not authored: the classes the element's own style rules are written against. */
+  className?: string;
+}
+
+/**
+ * A count somebody raises.
+ *
+ * Deterministic on its first render: it draws the same markup on a server and in the browser, so a server-rendered
+ * page and its hydration agree. React answers a mismatch by throwing away the whole tree it happened in, so a plugin
+ * that renders \`Date.now()\` or reads \`window\` on the first pass does not break itself, it blanks the page. Anything
+ * live belongs in an effect.
+ */
+const ${name} = ({ label = ${tsString(title)}, start = 0, step = 1, className }: ${name}Props) => {
+  const { id } = useElement();
+  const {
+    contexts: { InteractionsContext }
+  } = usePlitziServiceContext();
+  const { interactionsManager } = use(InteractionsContext);
+  const [count, setCount] = useState(start);
+
+  const handleAdd = useCallback(() => {
+    const next = count + step;
+    setCount(next);
+    void interactionsManager.interactionTrigger(id, declaration.triggers.onCount.action, { count: next });
+  }, [count, step, interactionsManager, id]);
+
+  const handleReset = useCallback(() => setCount(start), [start]);
+
+  /** The declared events, titled with this element's label so the builder tells two of them apart. */
+  const interactionTriggers = useMemo<Record<string, InteractionCallback>>(
+    () => ({ onCount: { ...declaration.triggers.onCount, title: \`\${label} counted\` } }),
+    [label]
+  );
+
+  /** The declared actions, with what only a mounted element has: the function that does it. */
+  const interactionCallbacks = useMemo<Record<string, InteractionCallback>>(
+    () => ({ reset: { ...declaration.callbacks.reset, title: \`Reset \${label}\`, callback: handleReset } }),
+    [label, handleReset]
+  );
+
+  /**
+   * \`RootElement\` is the root, and not a \`div\`.
+   *
+   * It is what makes this an ELEMENT rather than a component that happens to be on the page: the element's id and
+   * classes land on it, so the CSS authored on it applies, the builder can select it, a test can find it by name, and
+   * the events and actions above are this element's.
+   */
+  return (
+    <RootElement
+      className={className}
+      style={CARD}
+      interactionTriggers={interactionTriggers}
+      interactionCallbacks={interactionCallbacks}
+    >
+      <span style={LABEL}>{label}</span>
+      {/* A status: announced when it changes, and what a test finds the count by. */}
+      <span style={VALUE} role="status">
+        {count}
+      </span>
+      <button type="button" style={BUTTON} onClick={handleAdd}>
+        +{step}
+      </button>
+    </RootElement>
+  );
+};
+
+/**
+ * Styles inline, and colours borrowed rather than chosen.
+ *
+ * A plugin is dropped into a page whose palette it does not know, so naming a colour here is how a component ends up
+ * black on black the first time somebody switches the theme. \`currentColor\` and the space's own variables follow
+ * whatever the page decided. The element's own look belongs in \`defaultStyle\` in the declaration, where the space can
+ * restyle it; these are only what makes it usable before anybody does.
+ */
+const CARD: CSSProperties = {
+  display: 'inline-flex',
+  alignItems: 'center',
+  gap: '12px',
+  padding: '12px 16px',
+  borderRadius: '12px',
+  border: '1px solid color-mix(in srgb, currentColor 15%, transparent)',
+  background: 'color-mix(in srgb, currentColor 6%, transparent)'
+};
+
+const LABEL: CSSProperties = { fontSize: '12px', letterSpacing: '0.08em', textTransform: 'uppercase', opacity: 0.65 };
+
+const VALUE: CSSProperties = { fontSize: '24px', fontWeight: 600, fontVariantNumeric: 'tabular-nums' };
+
+const BUTTON: CSSProperties = {
+  font: 'inherit',
+  color: 'inherit',
+  padding: '4px 12px',
+  borderRadius: '8px',
+  border: '1px solid color-mix(in srgb, currentColor 25%, transparent)',
+  background: 'transparent',
+  cursor: 'pointer'
+};
+
+export default ${name};
+`;
+var settings = ({ component: name }) => `import { useCallback } from 'react';
+
+import type { ${name}Attributes } from './declaration';
+import type { ChangeEvent, CSSProperties } from 'react';
+
+/**
+ * The builder's panel for the element.
+ *
+ * The builder hands it the element's attributes as props and gives it \`onUpdate\` to write one back — the same
+ * attributes the component reads, so what is edited here is what renders. Only the builder loads it: a published page
+ * never draws a panel.
+ */
+export type SettingsProps = ${name}Attributes & {
+  onUpdate?: (attribute: string, value: string | number) => void;
+};
+
+const Settings = ({ label = '', start = 0, step = 1, onUpdate }: SettingsProps) => {
+  const handleLabel = useCallback(
+    (event: ChangeEvent<HTMLInputElement>) => onUpdate?.('label', event.target.value),
+    [onUpdate]
+  );
+  const handleStart = useCallback(
+    (event: ChangeEvent<HTMLInputElement>) => onUpdate?.('start', Number(event.target.value)),
+    [onUpdate]
+  );
+  const handleStep = useCallback(
+    (event: ChangeEvent<HTMLInputElement>) => onUpdate?.('step', Number(event.target.value)),
+    [onUpdate]
+  );
+
+  return (
+    <div style={PANEL}>
+      <label style={FIELD}>
+        Label
+        <input style={INPUT} value={label} onChange={handleLabel} />
+      </label>
+      <label style={FIELD}>
+        Starts at
+        <input style={INPUT} type="number" value={start} onChange={handleStart} />
+      </label>
+      <label style={FIELD}>
+        Step
+        <input style={INPUT} type="number" min={1} value={step} onChange={handleStep} />
+      </label>
+    </div>
+  );
+};
+
+/** The builder's own theme is light or dark, so the panel borrows its colours the way the component does. */
+const PANEL: CSSProperties = { display: 'flex', flexDirection: 'column', gap: '12px', padding: '8px 0' };
+
+const FIELD: CSSProperties = { display: 'flex', flexDirection: 'column', gap: '4px', fontSize: '12px' };
+
+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;
+`;
+var elementIndex = ({ component: name }) => `import Base${name} from './${name}';
+import declaration from './declaration';
+import Settings from './Settings';
+
+/**
+ * The element, as whatever registers it reads it: the component, everything its declaration says — its \`type\` first
+ * — and the panel the builder edits it with. The same three things Plitzi's own elements are made of.
+ */
+const ${name} = Object.assign(Base${name}, declaration, { pluginSettings: Settings });
+
+export * from './${name}';
+
+export type { ${name}Attributes } from './declaration';
+
+export default ${name};
+`;
+/** A type's spelling as a variable: `seatPicker` for `SeatPicker`. */
+var typeOf = (component) => `${component.charAt(0).toLowerCase()}${component.slice(1)}`;
+/**
+* `export const <name> = [...]`, laid out the way Prettier lays it out — on one line while it fits in 120 columns,
+* one entry per line past that — so a list the CLI rewrote is a list the project's formatter leaves alone.
+*/
+var listSource = (name, entries) => {
+	const inline = `export const ${name} = [${entries.join(", ")}];`;
+	return inline.length <= 120 ? inline : `export const ${name} = [\n${entries.map((entry) => `  ${entry}`).join(",\n")}\n];`;
+};
+/**
+* `src/elements.ts`: every element the package holds, the one it is named after first. Written from the folders'
+* names alone, so the CLI can tell a list it wrote from one somebody changed — and add to the first safely.
+*/
+var elementsRegistry = (components) => `${components.map((component) => `import ${component} from './${component}';`).join("\n")}
+
+/**
+ * Every element this package holds, the one it is named after first. \`plitzi add plugin\` writes this list — add an
+ * element with it, or by hand: its folder, and a line here and in \`declarations.ts\`.
+ */
+${listSource("elements", components)}
+`;
+/** `src/declarations.ts`: the same elements' declarations, which the build reads without loading any React. */
+var declarationsRegistry = (components) => `${components.map((component) => `import ${typeOf(component)} from './${component}/declaration';`).join("\n")}
+
+/**
+ * Every element's declaration, in the order of \`elements.ts\`: the build writes each into \`plugin-manifest.json\`, and
+ * the first is the one a space's \`plugins\` entry loads the package by. \`plitzi add plugin\` writes this list.
+ */
+${listSource("declarations", components.map(typeOf))}
+`;
+var entry = () => `import { elements } from './elements';
+
+/**
+ * What a space loads: the element the package is named after, and every other element it holds as \`plugins\`, by
+ * type. Nothing here changes when one is added — \`plitzi add plugin\` writes its folder and lists it in \`elements.ts\`.
+ */
+const [main, ...others] = elements;
+
+export const plugins = Object.fromEntries(others.map(element => [element.type, element]));
+
+/** Every element, for a project that installs the package and registers them itself. */
+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),
+	"index.ts": elementIndex(names)
+});
+/** Every element of a plugin package in its own folder, the two lists that gather them, and the entry. */
+var packageSourceFiles = (elements) => {
+	const components = elements.map(({ names }) => names.component);
+	return {
+		...Object.fromEntries(elements.flatMap(({ names, text }) => Object.entries(elementFiles(names, text)).map(([file, contents]) => [`src/${names.component}/${file}`, contents]))),
+		"src/elements.ts": elementsRegistry(components),
+		"src/declarations.ts": declarationsRegistry(components),
+		"src/index.ts": entry()
+	};
+};
+//#endregion
+//#region src/scaffold/pluginPackage/visual.ts
+/**
+* A browser opens the preview and checks the plugin works in a space: that it is there, and that it does what it says.
+*
+* What goes wrong with a plugin rarely throws. The element renders "Custom Component … Not Found", or renders and
+* cannot be clicked, or hydrates blank — and the preview looks fine to somebody who did not scroll to it.
+*/
+var playwrightConfig = ({ packageManager }) => `import { defineConfig } from '@playwright/test';
+
+const PORT = 5173;
+
+export default defineConfig({
+  testDir: './visual',
+  outputDir: './visual/.results',
+  use: { baseURL: \`http://127.0.0.1:\${PORT}\` },
+  // Playwright starts the preview itself, so \`${runCommand(packageManager, "visual")}\` is one command from a cold checkout.
+  webServer: {
+    command: '${runCommand(packageManager, "start")}',
+    url: \`http://127.0.0.1:\${PORT}\`,
+    reuseExistingServer: true,
+    timeout: 120_000
+  }
+});
+`;
+var spec = (elements) => `import { expect, test } from '@playwright/test';
+
+import { authorSpace, inspectPage } from '@plitzi/sdk-authoring';
+
+import { space } from '../preview/space.ts';
+import { declarations } from '../src/declarations.ts';
+
+/** The preview's elements, by the id the preview space gives each and the label it shows. */
+const ELEMENTS = [
+${elements.map(({ base, title }) => `  { id: '${base}', label: ${tsString(title)} }`).join(",\n")}
+];
+
+/**
+ * Each element, in the preview's space: on screen and answering a click.
+ *
+ * Found by its element id, which is what \`RootElement\` writes on it — so this also fails if a component stops
+ * rendering its root through \`RootElement\`, the mistake that leaves a plugin looking right and being unreachable.
+ */
+for (const { id, label } of ELEMENTS) {
+  test(\`\${id} renders in a space, and counts\`, async ({ page }) => {
+    await page.goto('/', { waitUntil: 'networkidle' });
+
+    const element = page.locator(\`[data-plitzi-el="\${id}"]\`);
+    await expect(element).toBeVisible();
+    await expect(element).toContainText(label);
+
+    await expect(element.getByRole('status')).toHaveText('0');
+    await element.getByRole('button').click();
+    await expect(element.getByRole('status')).toHaveText('1');
+  });
+}
+
+/**
+ * The rest of the page too: an element that overflows or hides its neighbours is a page problem. And the space says
+ * nothing it would have to be told twice — authoring knows the package's types for plugins, not typos.
+ */
+test('leaves the page whole', async ({ page }) => {
+  const errors: string[] = [];
+  page.on('pageerror', error => errors.push(error.message));
+
+  await page.goto('/', { waitUntil: 'networkidle' });
+
+  const { handles, warnings } = authorSpace(space, { pluginTypes: declarations.map(declaration => declaration.type) });
+  expect(warnings).toEqual([]);
+  expect((await inspectPage(page, handles)).problems).toEqual([]);
+  expect(errors).toEqual([]);
+});
+`;
+var visualFiles = (elements, answers) => ({
+	"playwright.config.ts": playwrightConfig(answers),
+	"visual/plugin.spec.ts": spec(elements)
+});
+//#endregion
+//#region src/scaffold/pluginPackage/index.ts
+/** What the build writes, and what is nobody's to format or lint. */
+var OUTPUTS = ["dist", "visual/.results"];
+/**
+* Every file of a plugin package: the element, the build that publishes it, a space to preview it in, and what checks
+* it — a project of its own, with nothing about it shared with whatever repository it sits in except the folder.
+*/
+var scaffoldPlugin = (answers) => {
+	const names = pluginNames(answers.packageName);
+	const elements = answers.elements.map((element) => ({
+		names: {
+			...pluginNames(element.name),
+			title: element.title
+		},
+		text: {
+			title: element.title,
+			description: element.description,
+			owner: answers.owner
+		}
+	}));
+	const elementNames = elements.map((element) => element.names);
+	return {
+		...answers.inProject ? {} : managerFiles(answers.packageManager, answers.managerVersion),
+		...packageFiles(names, answers),
+		...qualityFilesFor("browser", OUTPUTS),
+		...packageSourceFiles(elements),
+		...buildFiles(),
+		...previewFiles(elementNames),
+		...visualFiles(elementNames, answers),
+		...docsFiles(elementNames, answers),
+		...skillFiles(["plitzi-cli"])
+	};
+};
+/**
+* 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({
+	...pluginNames(name),
+	title: text.title
+}, text);
+//#endregion
+//#region src/scaffold/index.ts
+/**
+* Every file of a generated project, assembled from the two decisions that shape it.
+*
+* Pure, and separate from the command that writes them, so what the scaffold SAYS can be asserted without a
 * filesystem — and because the interesting part of this feature is the contents. A scaffold that produces a
 * project nobody can read is one its owner replaces rather than learns from, so each file carries the reasoning
 * that would otherwise live in documentation they have not opened.
 */
-var scaffold = (answers) => ({
-	...projectFiles(answers),
-	...qualityFiles(answers),
-	...spaceFiles(answers),
-	...pluginFiles(answers),
-	...answers.mode === "server" ? serverFiles(answers) : clientFiles(answers),
-	...visualFiles(answers),
-	...skillFiles()
+var scaffold = (answers) => ({
+	...projectFiles(answers),
+	...qualityFiles(answers),
+	...spaceFiles(answers),
+	...pluginFiles(answers),
+	...answers.mode === "server" ? serverFiles(answers) : clientFiles(answers),
+	...visualFiles$1(answers),
+	...skillFiles()
+});
+//#endregion
+//#region src/commands/existingProject.ts
+var LOCKFILES = [
+	["yarn.lock", "yarn"],
+	["pnpm-lock.yaml", "pnpm"],
+	["package-lock.json", "npm"]
+];
+var exists = async (file) => {
+	try {
+		await fs.access(file);
+		return true;
+	} catch {
+		return false;
+	}
+};
+var readPackageJson = async (dir) => {
+	try {
+		return JSON.parse(await fs.readFile(path.join(dir, "package.json"), "utf-8"));
+	} catch {
+		return;
+	}
+};
+/** The workspace globs a root declares — npm's and Yarn's `workspaces`, or pnpm's own file. */
+var workspaceGlobs = async (dir, packageJson) => {
+	const { workspaces } = packageJson;
+	if (Array.isArray(workspaces)) return workspaces;
+	if (workspaces?.packages) return workspaces.packages;
+	try {
+		const pnpm = await fs.readFile(path.join(dir, "pnpm-workspace.yaml"), "utf-8");
+		return [...(/^packages:\s*\n((?:\s+-\s*.+\n?)+)/m.exec(pnpm)?.[1] ?? "").matchAll(/-\s*['"]?([^'"\n]+)['"]?/g)].map((match) => match[1].trim());
+	} catch {
+		return [];
+	}
+};
+/** From every directory upward, the first that holds a `package.json`. */
+var nearestPackage = async (from) => {
+	let dir = from;
+	for (;;) {
+		if (await exists(path.join(dir, "package.json"))) return dir;
+		const parent = path.dirname(dir);
+		if (parent === dir) return;
+		dir = parent;
+	}
+};
+/** The first directory at or above `from` that declares workspaces, with what it declares. */
+var nearestWorkspace = async (from) => {
+	for (let dir = await nearestPackage(from); dir; dir = await nearestPackage(path.dirname(dir))) {
+		const packageJson = await readPackageJson(dir);
+		const globs = packageJson ? await workspaceGlobs(dir, packageJson) : [];
+		if (globs.length > 0) return {
+			root: dir,
+			globs
+		};
+		if (path.dirname(dir) === dir) return;
+	}
+};
+var lockfileManager = async (dirs) => {
+	for (const dir of dirs) for (const [file, manager] of LOCKFILES) if (await exists(path.join(dir, file))) return manager;
+};
+var readText = async (file) => {
+	try {
+		return await fs.readFile(file, "utf-8");
+	} catch {
+		return;
+	}
+};
+/**
+* A plugin package's elements, read off its `src/elements.ts` — and trusted only when writing them back out gives both
+* of its lists byte for byte, which is what says nobody has changed them since the CLI did.
+*/
+var packageComponents = async (root) => {
+	const [elements, declarations] = await Promise.all([readText(path.join(root, "src/elements.ts")), readText(path.join(root, "src/declarations.ts"))]);
+	if (elements === void 0 || declarations === void 0) return;
+	const components = [...elements.matchAll(/^import (\w+) from '\.\/(\w+)';$/gm)].filter(([, name, folder]) => name === folder).map(([, name]) => name);
+	return components.length > 0 && elementsRegistry(components) === elements && declarationsRegistry(components) === declarations ? components : void 0;
+};
+/**
+* A project's declared plugins, read off `src/plugins/declarations.ts` — and trusted only when writing them back out
+* gives the file byte for byte, as with a plugin package's lists.
+*/
+var projectDeclared = async (root) => {
+	const listed = await readText(path.join(root, "src/plugins/declarations.ts"));
+	if (listed === void 0) return;
+	const components = [...listed.matchAll(/^import \w+ from '\.\/(\w+)\/declaration\.ts';$/gm)].map(([, folder]) => folder);
+	return projectDeclarations(components) === listed ? components : void 0;
+};
+/**
+* What `plitzi create` wrote, if it did — told by what the project depends on and the files it keeps, never by its
+* name.
+*
+* - A plugin package publishes the SDK as a peer and keeps its elements' lists in `src/`.
+* - A project renders a space: the SDK is a dependency and `src/main.ts` registers the project's plugins — by folder
+*   in a project written since that was how, by a list written in the file before then.
+*/
+var plitziProject = async (root, packageJson) => {
+	if (packageJson.peerDependencies?.["@plitzi/plitzi-sdk"] && await exists(path.join(root, "src/elements.ts"))) return {
+		kind: "plugin",
+		components: await packageComponents(root)
+	};
+	const dependencies = {
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	};
+	const main = await readText(path.join(root, "src/main.ts"));
+	if (!("@plitzi/plitzi-sdk" in dependencies) || main === void 0 || !/src\/plugins|\.\/plugins\//.test(main)) return;
+	const server = "@plitzi/sdk-server" in dependencies;
+	return {
+		kind: "project",
+		mode: server ? "server" : "client",
+		source: await exists(path.join(root, "src/space.ts")) ? "local" : "cloud",
+		discovers: server ? main.includes("readdirSync(PLUGINS_DIR") : main.includes("import.meta.glob<{ default: RenderPlugins[string]"),
+		declared: await projectDeclared(root)
+	};
+};
+/** The project `from` is inside, or `undefined` when no directory above it has a `package.json`. */
+var findProject = async (from) => {
+	const root = await nearestPackage(from);
+	if (!root) return;
+	const packageJson = await readPackageJson(root) ?? {};
+	const workspace = await nearestWorkspace(root);
+	const workspaceFolders = (workspace?.globs ?? []).filter((glob) => glob.endsWith("/*") && !glob.startsWith("!")).map((glob) => glob.slice(0, -2));
+	return {
+		root,
+		packageManager: await lockfileManager(workspace ? [root, workspace.root] : [root]),
+		workspaceRoot: workspace?.root,
+		workspaceFolders,
+		plitzi: await plitziProject(root, packageJson)
+	};
+};
+/** 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.
+*/
+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} && `;
+};
+//#endregion
+//#region src/commands/addPlugin.ts
+var DEFAULT_NAME$1 = "my-element";
+/** Where a project keeps its components, most likely first: offered as where the element goes. */
+var COMPONENT_FOLDERS = [
+	"src/plugins",
+	"src/components",
+	"src/elements"
+];
+var splitNames$1 = (list) => list.split(",").map((name) => name.trim()).filter(Boolean);
+/** What is wrong with the names asked for, if anything: one that makes no element, or two that make the same one. */
+var namesProblem = (names) => {
+	if (names.length === 0) return "Name at least one element.";
+	for (const name of names) {
+		const problem = pluginNameProblem(name);
+		if (problem) return problem;
+	}
+	const types = names.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;
+};
+var isDirectory = async (dir) => {
+	try {
+		return (await fs.stat(dir)).isDirectory();
+	} catch {
+		return false;
+	}
+};
+/** The folders offered: the ones the project already has, and `src/plugins` whatever it has. */
+var folderOptions$1 = async (project) => {
+	const present = [];
+	for (const folder of COMPONENT_FOLDERS) if (folder === "src/plugins" || await isDirectory(path.join(project.root, folder))) present.push(folder);
+	return present.map((folder) => ({
+		label: folder,
+		value: path.join(project.root, folder)
+	}));
+};
+/**
+* The folder that HOLDS the elements, each of which gets a folder of its own inside it: `--dir` when it was given,
+* `src/` in a plugin package, `src/plugins` in a project `plitzi create` wrote, and otherwise the one the person picks.
+*/
+var holderFolder = async (rl, project, options) => {
+	if (options.dir) return path.resolve(options.dir);
+	if (project.plitzi?.kind === "plugin") return path.join(project.root, "src");
+	if (project.plitzi?.kind === "project") return path.join(project.root, "src/plugins");
+	if (!rl) return;
+	return path.resolve(await askChoice(rl, "Where should it go? (each element gets a folder of its own inside)", await folderOptions$1(project), {
+		label: "Somewhere else",
+		question: "Which folder holds the project’s components? (relative to here)",
+		fallback: "src/plugins"
+	}));
+};
+var importPath = (from, target) => `./${path.relative(from, target).split(path.sep).join("/")}`;
+/** What a project that does not find its plugins by folder has to write, for each way it may render a space. */
+var registration = (added) => {
+	const entries = (shape) => added.map(({ names, target }) => shape(names, importPath(process.cwd(), target))).join(", ");
+	return [
+		...added.map(({ names, target }) => `import ${names.component} from '${importPath(process.cwd(), target)}';`),
+		"",
+		"// render(), in the browser:",
+		`render('root', options, { ${entries((names) => `${names.type}: { component: ${names.component} }`)} });`,
+		"",
+		"// <PlitziSdk>, in a React application — inside <PlitziSdk>:",
+		...added.map(({ names }) => `<PlitziSdk.Plugin renderType="${names.type}" component={${names.component}} />`),
+		"",
+		"// createServer(), on a page server of your own — and each name in the deployment’s pluginNames:",
+		`plugins: { ${entries((names, from) => `${names.type}: { js: path.resolve('${from}/index.ts'), action: 'compile' }`)} }`
+	].join("\n");
+};
+/** The lines a project from before plugins were found by folder adds to the list in its `src/main.ts`. */
+var mainEntries = (project, added) => project.mode === "server" ? added.map((names) => `  ${names.type}: { js: path.resolve(PROJECT_ROOT, 'src/plugins/${names.component}/index.ts'), action: 'compile' as const, version: '1.0.0' },`).join("\n") : [
+	...added.map((names) => `import ${names.component} from './plugins/${names.component}';`),
+	"",
+	...added.map((names) => `  ${names.type}: { component: ${names.component} },`)
+].join("\n");
+/** How to put the elements on a page, in the project they were added to. */
+var placement = (project, added) => {
+	if (project.source === "cloud") return `In the builder, add a Custom element with the render type ${added.map((names) => `"${names.type}"`).join(", ")}. The builder does not load this project’s components, so it shows “Not Found” there; the pages this project serves render them.`;
+	return `Put them on a page in src/space.ts: ${added.map((names) => `custom({ id: '${names.base}', renderType: '${names.type}' })`).join(", ")}.`;
+};
+/** A plugin package's two lists, extended with what was added — or said to be the author's when they were changed. */
+var listInPackage = async (root, components, added) => {
+	const several = added.length > 1;
+	if (!components) {
+		console.log(chalk.yellow(`
+src/elements.ts and src/declarations.ts are not the lists the CLI wrote, so they are yours to change: add ${added.map((names) => `${names.component} (and its declaration)`).join(", ")} to both.`));
+		return;
+	}
+	const listed = [...components, ...added.map((names) => names.component)];
+	await writeFiles(root, {
+		"src/elements.ts": elementsRegistry(listed),
+		"src/declarations.ts": declarationsRegistry(listed)
+	});
+	console.log(`\nListed in src/elements.ts and src/declarations.ts: the package publishes ${several ? "them" : "it"} from now on. Look at ${several ? "them" : "it"} in the preview with ${added.map((names) => `element('${names.type}', { id: '${names.base}' })`).join(", ")} in preview/space.ts.`);
+};
+/**
+* A project's `src/plugins/declarations.ts`, extended with what was added — so the space is checked against the new
+* plugins' events, actions and attributes from its next authoring on. A list somebody changed is theirs to extend.
+*/
+var declareInProject = async (project, root, added) => {
+	if (project.source !== "local") return;
+	const { declared } = project;
+	if (!declared) {
+		console.log(chalk.yellow(`
+src/plugins/declarations.ts is missing or not the list the CLI wrote, so it is yours to change: import ${added.map((names) => `${names.component}/declaration.ts`).join(", ")} there and add ${added.length > 1 ? "them" : "it"} to \`declarations\` — what \`authorSpace(space, { plugins: declarations })\` checks the space against.`));
+		return;
+	}
+	await writeFiles(root, { "src/plugins/declarations.ts": projectDeclarations([...declared, ...added.map((names) => names.component)]) });
+	console.log(`\nDeclared in src/plugins/declarations.ts: flows on ${added.length > 1 ? "their" : "its"} events and the attributes written on ${added.length > 1 ? "them" : "it"} are checked when the space is authored.`);
+};
+/** 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"));
+	if (!("@plitzi/plitzi-sdk" in {
+		...dependencies,
+		...devDependencies
+	})) console.log(chalk.yellow("\nThe elements import @plitzi/plitzi-sdk, which this project does not depend on yet."));
+};
+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;
+		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;
+		return;
+	}
+	const givenProblem = namesGiven.length > 0 ? namesProblem(namesGiven) : void 0;
+	if (givenProblem) {
+		console.error(chalk.red(givenProblem));
+		process.exitCode = 1;
+		return;
+	}
+	const folderKnown = options.dir !== void 0 || project.plitzi !== void 0;
+	const terminal = atTerminal();
+	if (!terminal && (namesGiven.length === 0 || !folderKnown)) {
+		refuseWithoutTerminal("element", [...namesGiven.length === 0 ? [{
+			flag: "<names> (the arguments)",
+			choices: ["<name> …"],
+			question: "What is each element called? e.g. seat-picker."
+		}] : [], ...folderKnown ? [] : [{
+			flag: "--dir",
+			choices: ["<folder>"],
+			question: "Which folder holds the project’s components?"
+		}]]);
+		return;
+	}
+	const rl = terminal ? readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	}) : void 0;
+	try {
+		const askedNames = async () => rl ? splitNames$1(await askText(rl, "What is the element called? Several: separate them with commas.", DEFAULT_NAME$1, (reply) => namesProblem(splitNames$1(reply)))) : [DEFAULT_NAME$1];
+		const names = namesGiven.length > 0 ? namesGiven : await askedNames();
+		const holder = await holderFolder(rl, project, options);
+		if (!holder) return;
+		const planned = names.map((name) => {
+			const elementNames = pluginNames(name);
+			return {
+				name,
+				names: elementNames,
+				target: path.join(holder, elementNames.component)
+			};
+		});
+		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;
+			return;
+		}
+		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, {
+				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: ""
+			}));
+			added.push({
+				names: {
+					...elementNames,
+					title
+				},
+				target
+			});
+		}
+		const addedNames = added.map(({ names: elementNames }) => elementNames);
+		const written = added.map(({ names: elementNames, target }) => {
+			return `${path.relative(process.cwd(), target)} — the ${elementNames.type} element`;
+		});
+		console.log(chalk.green(`\n${written.join("\n")}`));
+		const { plitzi } = project;
+		if (plitzi?.kind === "plugin") await listInPackage(project.root, plitzi.components, addedNames);
+		else if (plitzi?.kind === "project" && plitzi.discovers) {
+			console.log(`\nRegistered: src/main.ts finds every folder of src/plugins. ${placement(plitzi, addedNames)}`);
+			await declareInProject(plitzi, project.root, addedNames);
+		} else if (plitzi?.kind === "project") console.log(`
+This project lists its plugins in src/main.ts (projects created since find them by folder). Add to its \`plugins\`:\n\n${chalk.dim(mainEntries(plitzi, addedNames))}\n\n${placement(plitzi, addedNames)}`);
+		else await registerElsewhere(project.root, added);
+		console.log("");
+	} finally {
+		rl?.close();
+	}
+};
+//#endregion
+//#region src/commands/create.ts
+var MODES = ["server", "client"];
+var SOURCES = ["local", "cloud"];
+/**
+* The choices a project is BUILT around, which belong to whoever it is for — never to a default nobody chose.
+*
+* Each one is written into the project: the package manager into every command its README, lockfile, Playwright config
+* and install use; the mode into whether there is a Node tier at all; the source into whether the space is in the repo.
+* Assumed, they are the wrong project for somebody, and an agent running this was the one assuming. So what was not
+* passed is asked for when a person is at the terminal, and refused when nobody is — with the exact questions to put
+* to the person.
+*/
+var resolveDecisions = async (options) => {
+	const detected = detectPackageManager();
+	const packageManager = {
+		flag: "--package-manager",
+		choices: PACKAGE_MANAGERS,
+		question: `Which package manager will you work in? (this was run through ${detected})`,
+		given: PACKAGE_MANAGERS.find((manager) => manager === options.packageManager),
+		fallback: detected
+	};
+	const mode = {
+		flag: "--mode",
+		choices: MODES,
+		question: "Should pages render on a Node server of your own (server: SSR + RSC), or only in the browser (client)?",
+		given: MODES.find((candidate) => candidate === options.mode),
+		fallback: "server"
+	};
+	const source = {
+		flag: "--source",
+		choices: SOURCES,
+		question: "Should the space live in the project as code you edit (local), or be read live from your Plitzi account (cloud, which needs a key from Credentials in the builder)?",
+		given: SOURCES.find((candidate) => candidate === options.source),
+		fallback: "local"
+	};
+	const missing = [
+		packageManager,
+		mode,
+		source
+	].filter((question) => question.given === void 0);
+	if (missing.length === 0 || options.yes && atTerminal()) return {
+		packageManager: packageManager.given ?? packageManager.fallback,
+		mode: mode.given ?? mode.fallback,
+		source: source.given ?? source.fallback
+	};
+	if (!atTerminal()) {
+		refuseWithoutTerminal("project", missing);
+		return;
+	}
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		const manager = packageManager.given ?? await ask(rl, packageManager);
+		const tier = manager && (mode.given ?? await ask(rl, mode));
+		const origin = tier && (source.given ?? await ask(rl, source));
+		if (!manager || !tier || !origin) {
+			process.exitCode = 1;
+			return;
+		}
+		return {
+			packageManager: manager,
+			mode: tier,
+			source: origin
+		};
+	} finally {
+		rl.close();
+	}
+};
+var keyQuestion = (mode) => `The ${mode === "server" ? "self-hosting" : "public render"} key the project reads the space with (Credentials, in the builder).`;
+var askForKey = async (mode) => {
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		return (await rl.question(`\n${keyQuestion(mode)}\n> `)).trim();
+	} finally {
+		rl.close();
+	}
+};
+var create = async (directory, options) => {
+	const target = path.resolve(directory ?? ".");
+	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;
+		return;
+	}
+	const decisions = await resolveDecisions(options);
+	if (!decisions) return;
+	const { packageManager, mode, source } = decisions;
+	if (source === "cloud" && !options.key && !atTerminal()) {
+		refuseWithoutTerminal("project", [{
+			flag: "--key",
+			choices: ["<key>"],
+			question: keyQuestion(mode)
+		}]);
+		return;
+	}
+	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;
+		return;
+	}
+	await writeFiles(target, scaffold({
+		name,
+		mode,
+		source,
+		key,
+		environment: options.environment ?? "main",
+		packageManager,
+		managerVersion: detectManagerVersion(packageManager, await nearestExisting(target))
+	}));
+	const wantsInstall = options.install !== false;
+	const installed = wantsInstall && await install(packageManager, target);
+	/**
+	* A failed install is a failed command, not a next step.
+	*
+	* The files are already written, so the summary below still prints — but printed on its own after a screen of
+	* resolver errors it reads as success, and a script that ran `create` carries on into a project with no
+	* `node_modules`.
+	*/
+	if (wantsInstall && !installed) {
+		console.error(chalk.red(`\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
+	* tables and lists whose layout depends on what they hold. Only into a folder that was empty: `--force` into one
+	* with work in it must never reformat that work.
+	*/
+	if (installed && wasEmpty) await runScript(packageManager, "format", target);
+	const where = cdPrefix(target);
+	console.log(chalk.green(`\n${name} — ${mode === "server" ? "server-rendered" : "browser-rendered"}, space ${source === "cloud" ? "from Plitzi" : "in the project"}.`));
+	console.log("");
+	if (!installed) console.log(`  ${where}${installCommand(packageManager)}`);
+	console.log(`  ${where}${runCommand(packageManager, "start")}`);
+	console.log("");
+	console.log(chalk.dim(`.claude/skills carries Plitzi's authoring skill; \`${runCommand(packageManager, "visual")}\` opens the page and checks it.`));
+	if (source === "cloud") console.log(chalk.dim(".env holds the key and is already git-ignored."));
+	console.log("");
+};
+//#endregion
+//#region src/commands/createPlugin.ts
+var DEFAULT_NAME = "plitzi-plugin-my-element";
+/** What an agent is told to ask for, and the flags that carry the answers. */
+var QUESTIONS = {
+	name: {
+		flag: "--name",
+		choices: ["<package name>"],
+		question: "What is the plugin called? Its package name, e.g. plitzi-plugin-seat-picker."
+	},
+	directory: {
+		flag: "<directory> (the first argument)",
+		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;
+	}
+	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) {
+		console.error(chalk.red(nameProblem));
+		process.exitCode = 1;
+		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) {
+			console.error(chalk.red(`${target} is not empty. Pass --force to write into it anyway.`));
+			process.exitCode = 1;
+			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) {
+			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("");
+	} finally {
+		rl?.close();
+	}
+};
+//#endregion
+//#region ../../packages/sdk-shared/dist/actions/functions.mjs
+var n = (e) => /^[A-Za-z0-9_][A-Za-z0-9_./-]*\.(ts|js|mjs|json)$/.test(e) && !e.split("/").some((e) => e === ".." || e === "." || e === "");
+var r = async (e, t) => {
+	let r = {}, i = async (a) => {
+		let o;
+		try {
+			o = await t.list(a ? `${e}/${a}` : e);
+		} catch {
+			return;
+		}
+		for (let s of o) {
+			let o = a ? `${a}/${s.name}` : s.name;
+			s.directory ? s.name !== "node_modules" && !s.name.startsWith(".") && await i(o) : n(o) && (r[o] = await t.read(`${e}/${o}`));
+		}
+	};
+	return await i(""), r;
+};
+//#endregion
+//#region src/commands/functions.ts
+var FUNCTIONS_DIR = "functions";
+var STATE_FILE = path.join(".plitzi", "functions.json");
+var isRecord$2 = (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();
+/** Every source file under `functions/`, by its path there — read by the one rule of what a source is. */
+var readLocal = (root) => r(path.join(root, FUNCTIONS_DIR), {
+	list: async (dir) => (await fs.readdir(dir, { withFileTypes: true })).map((entry) => ({
+		name: entry.name,
+		directory: entry.isDirectory()
+	})),
+	read: (file) => fs.readFile(file, "utf8")
+});
+var readState = async (root) => {
+	try {
+		const value = JSON.parse(await fs.readFile(path.join(root, STATE_FILE), "utf8"));
+		if (!isRecord$2(value) || typeof value.space !== "number" || typeof value.version !== "string" || !isRecord$2(value.files)) return;
+		const files = Object.fromEntries(Object.entries(value.files).flatMap(([name, text]) => typeof text === "string" ? [[name, text]] : []));
+		return {
+			space: value.space,
+			version: value.version,
+			files
+		};
+	} catch {
+		return;
+	}
+};
+var writeState = async (root, state) => {
+	await fs.mkdir(path.join(root, ".plitzi"), { recursive: true });
+	await fs.writeFile(path.join(root, STATE_FILE), `${JSON.stringify(state, null, 2)}\n`);
+};
+/** 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) {
+		fail(answered.error);
+		return;
+	}
+	const { reply } = answered.value;
+	if (reply.status !== 200) {
+		fail(reply.data.error ?? `Could not read the space’s functions (${reply.status}).`);
+		return;
+	}
+	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 [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) {
+		fail("functions/ is a copy of another space’s. Pull into another project, or pass --force to replace it.");
+		return;
+	}
+	if (!options.force && unpushed.length) {
+		fail(`Pulling would overwrite what is not pushed yet: ${unpushed.join(", ")}.\nPush it first, or pass --force to throw it away.`);
+		return;
+	}
+	const draft = await readDraft(connection, connection.space.id);
+	if (!draft) return;
+	const base = path.join(root, FUNCTIONS_DIR);
+	await Promise.all(Object.keys(local).filter((file) => !Object.hasOwn(draft.files, file)).map((file) => fs.rm(path.join(base, file))));
+	for (const [file, text] of Object.entries(draft.files)) {
+		await fs.mkdir(path.dirname(path.join(base, file)), { recursive: true });
+		await fs.writeFile(path.join(base, file), text);
+	}
+	await writeState(root, {
+		space: connection.space.id,
+		version: draft.version,
+		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.`);
+};
+var printProblems = (problems) => {
+	console.error(chalk.red("The functions were not saved:"));
+	problems.forEach(({ file, line, column, message }) => {
+		const where = file ? `functions/${file}${line ? `:${String(line)}${column ? `:${String(column)}` : ""}` : ""}` : "functions";
+		console.error(`  ${chalk.bold(where)} ${message}`);
+	});
+	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 [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.");
+		return;
+	}
+	let base = state?.space === connection.space.id ? state.version : void 0;
+	if (base === void 0) {
+		const draft = await readDraft(connection, connection.space.id);
+		if (!draft) return;
+		if (Object.keys(draft.files).length) {
+			fail(`${connection.space.name} already has functions. Pull them first: plitzi functions pull.`);
+			return;
+		}
+		base = draft.version;
+	}
+	if (state?.space === connection.space.id && !changedFiles(local, state.files).length) {
+		console.log("Nothing to push: functions/ is what was pulled.");
+		return;
+	}
+	const answered = await authorizedRequest(connection, `/spaces/${connection.space.id}/functions`, {
+		method: "PUT",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			files: local,
+			base
+		})
+	});
+	if (!answered.ok) {
+		fail(answered.error);
+		return;
+	}
+	const { reply } = answered.value;
+	if (reply.status === 422 && reply.data.problems) {
+		printProblems(reply.data.problems);
+		return;
+	}
+	if (reply.status === 409) {
+		fail(`${connection.space.name}’s functions changed since your pull — in the builder, or from another copy. Keep your changes aside, pull, and apply them again.`);
+		return;
+	}
+	if (reply.status !== 200 || !reply.data.version) {
+		fail(reply.data.refusal?.error ?? reply.data.error ?? `The functions were not saved (${reply.status}).`);
+		return;
+	}
+	await writeState(root, {
+		space: connection.space.id,
+		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."));
+};
+/** 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) => {
+	const step = report.steps?.find((entry) => entry.action === task);
+	const took = step ? `${String(step.endTime - step.startTime)} ms` : "";
+	step?.logs?.forEach((line) => console.log(chalk.dim(`log  ${line}`)));
+	if (step?.error) {
+		fail(`${task} failed after ${took}: ${step.error}`);
+		return;
+	}
+	console.log(`${chalk.green(report.status ?? "completed")} ${chalk.dim(took ? `in ${took}` : "")}`);
+	console.log(JSON.stringify(report.output?.value ?? null, null, 2));
+};
+/** `--params`, read: an object of the task's params by name, or nothing when it is not one. */
+var paramsOf = (given) => {
+	try {
+		const params = given ? JSON.parse(given) : {};
+		if (isRecord$2(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");
+	if (!connection?.space) return;
+	const answered = await authorizedRequest(connection, `/spaces/${connection.space.id}/functions/try`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			task,
+			params
+		})
+	});
+	if (!answered.ok) {
+		fail(answered.error);
+		return;
+	}
+	const { reply } = answered.value;
+	if (reply.status !== 200) {
+		fail(reply.data.error ?? `The task could not be tried (${reply.status}).`);
+		return;
+	}
+	printRun(task, reply.data);
+};
+var isLocalRunner = (value) => isRecord$2(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.
+*/
+var projectRunner = async (root) => {
+	try {
+		const entry = createRequire(path.join(root, "package.json")).resolve("@plitzi/sdk-server/functions-runner");
+		const loaded = await import(pathToFileURL(entry).href);
+		if (isLocalRunner(loaded)) return loaded;
+	} catch {}
+	fail("plitzi functions dev runs them with this project’s own @plitzi/sdk-server, and the isolates it needs:\n  npm install --save-dev @plitzi/sdk-server isolated-vm core-js");
+};
+/** `PLITZI_FUNCTIONS_CREDENTIALS`, a JSON object of credential id → its keys: what `ctx.fetch` may name locally. */
+var localCredentials = () => {
+	const raw = process.env.PLITZI_FUNCTIONS_CREDENTIALS;
+	try {
+		const value = raw ? JSON.parse(raw) : {};
+		return isRecord$2(value) ? Object.fromEntries(Object.entries(value).flatMap(([id, keys]) => isRecord$2(keys) ? [[id, Object.fromEntries(Object.entries(keys).filter((pair) => typeof pair[1] === "string"))]] : [])) : {};
+	} catch {
+		return {};
+	}
+};
+var NO_NODE_SNAPSHOT = "--no-node-snapshot";
+/**
+* The isolates `dev` runs need Node's startup snapshot off, and a process cannot turn it off once started: `dev` runs
+* itself again with it, and answers with that run's exit code.
+*/
+var rerunWithoutNodeSnapshot = () => new Promise((resolve, reject) => {
+	const child = spawn(process.execPath, [
+		...process.execArgv,
+		NO_NODE_SNAPSHOT,
+		...process.argv.slice(1)
+	], { stdio: "inherit" });
+	child.once("error", reject);
+	child.once("exit", (code) => {
+		resolve(code ?? 1);
+	});
 });
+/**
+* `plitzi functions dev <task>`: the task run from `functions/` on this machine, as the platform would run it — and,
+* with `--watch`, again every time a file is saved. Nothing reaches the space: its draft is what `push` sends.
+*/
+var devFunction = async (task, options) => {
+	if (!process.execArgv.includes(NO_NODE_SNAPSHOT)) {
+		process.exitCode = await rerunWithoutNodeSnapshot();
+		return;
+	}
+	const params = paramsOf(options.params);
+	const root = await rootOf();
+	const runner = params ? await projectRunner(root) : void 0;
+	if (!params || !runner) return;
+	const local = runner.createLocalFunctions({ credentials: localCredentials() });
+	const run = async () => {
+		const loaded = await local.load(await readLocal(root));
+		if (!loaded.ok) {
+			printProblems(loaded.problems);
+			return;
+		}
+		if (!loaded.tasks.includes(task)) {
+			fail(`functions/ declares no task ${task}. It declares: ${loaded.tasks.join(", ") || "none"}.`);
+			return;
+		}
+		printRun(task, await local.tryTask(task, params));
+	};
+	await run();
+	if (!options.watch) return;
+	console.log(chalk.dim("\nWatching functions/ — every save runs it again. ^C to stop."));
+	let pending;
+	watch(path.join(root, FUNCTIONS_DIR), { recursive: true }, () => {
+		clearTimeout(pending);
+		pending = setTimeout(() => {
+			process.exitCode = void 0;
+			console.log(chalk.dim(`\n— ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`));
+			run();
+		}, 150);
+	});
+};
 //#endregion
-//#region src/commands/create.ts
-var MODES = ["server", "client"];
-var SOURCES = ["local", "cloud"];
-/** 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) => {
+//#region src/pack/typeDeclarations.ts
+var loadTypeScript = (root) => {
 	try {
-		return (await fs.readdir(target)).length === 0;
+		return createRequire(path.join(root, "package.json"))("typescript");
 	} catch {
-		return true;
+		return;
 	}
 };
-var isDirectory = async (candidate) => {
+var emitTypeDeclarations = (root, outDir) => {
+	const ts = loadTypeScript(root);
+	if (!ts) return "no-typescript";
+	const configFile = ts.findConfigFile(root, (file) => ts.sys.fileExists(file));
+	const config = configFile ? ts.readConfigFile(configFile, (file) => ts.sys.readFile(file)).config : {};
+	const parsed = ts.parseJsonConfigFileContent(config, ts.sys, root);
+	const source = path.join(root, "src");
+	const files = parsed.fileNames.filter((file) => file.startsWith(`${source}${path.sep}`));
+	const { diagnostics } = ts.createProgram(files, {
+		...parsed.options,
+		noEmit: false,
+		declaration: true,
+		emitDeclarationOnly: true,
+		outDir: path.join(outDir, "types"),
+		rootDir: source
+	}).emit();
+	if (diagnostics.length > 0) {
+		const messages = diagnostics.map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+		throw new Error(messages.join("\n"));
+	}
+	return "written";
+};
+//#endregion
+//#region src/pack/pack.ts
+/**
+* A plugin built into what a space loads: one ES module, the `plugin-manifest.json` that describes it, and the zip the
+* builder takes under Resources — from the elements of a plugin package, or from element folders of any project.
+*
+* One implementation, here, rather than a build copied into every package: a copy is what went stale in the template
+* this replaced, and the contract it has to keep is the platform's, which moves with the CLI's releases.
+*
+* The contract, enforced rather than described:
+* - React and the SDK are the page's. They stay out of the bundle and are imported from the page — a second React is
+*   "Invalid hook call" and a blank element; a second SDK is an element that cannot see the space it is in.
+* - One file. A page imports the plugin from a blob URL, where a second chunk has nowhere to be found; images and fonts
+*   travel inside it for the same reason.
+* - The manifest describes what was built: each element's declaration, and each file with the hash it has.
+*/
+/** What the page provides, and the plugin imports rather than carries. */
+var EXTERNAL = [
+	"react",
+	"react-dom",
+	"react/*",
+	"react-dom/*",
+	"@plitzi/plitzi-sdk",
+	"@plitzi/plitzi-sdk/*"
+];
+/** Kept inside the one file: a path relative to a blob URL points nowhere. */
+var INLINED = [
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".svg",
+	".webp",
+	".avif",
+	".woff",
+	".woff2",
+	".ttf",
+	".otf"
+];
+/** A plugin that cannot be packed, with what to change — never a stack trace out of esbuild. */
+var PackError = class extends Error {};
+var isRecord$1 = (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$1(value) || typeof value.type !== "string" || !value.type) throw missing("`type`");
+	const { content } = value;
+	if (!isRecord$1(content)) throw missing("`content`");
+	for (const field of [
+		"attributes",
+		"definition",
+		"builder",
+		"market",
+		"defaultStyle"
+	]) if (!isRecord$1(content[field])) throw missing(`\`content.${field}\``);
+	if (!isRecord$1(content.definition) || typeof content.definition.label !== "string") throw missing("`content.definition.label`");
+	return value;
+};
+var toImportPath = (file) => file.split(path.sep).join("/");
+/** Runs a module esbuild produced, in this process: bundled, it imports nothing it would have to resolve. */
+var evaluate = async (code) => await import(`data:text/javascript;base64,${Buffer.from(code).toString("base64")}`);
+/**
+* The declarations, read the way the build reads the rest: bundled by esbuild, then run. A declaration is data — it
+* imports types at most — so running it loads no React and touches no DOM.
+*/
+var readDeclarations = async (root, source) => {
+	const contents = source.kind === "package" ? `export { declarations } from '${toImportPath(source.declarations)}';` : [...source.folders.map((folder, index) => `import d${index} from '${toImportPath(path.join(folder, "declaration.ts"))}';`), `export const declarations = [${source.folders.map((_folder, index) => `d${index}`).join(", ")}];`].join("\n");
+	const { declarations } = await evaluate((await build({
+		stdin: {
+			contents,
+			resolveDir: root,
+			sourcefile: "plitzi-declarations.ts",
+			loader: "ts"
+		},
+		bundle: true,
+		write: false,
+		format: "esm",
+		platform: "neutral",
+		external: EXTERNAL,
+		logLevel: "silent"
+	}).catch((error) => {
+		throw new PackError(`The declarations could not be read: ${error instanceof Error ? error.message : String(error)}`);
+	})).outputFiles[0].text);
+	if (!Array.isArray(declarations) || declarations.length === 0) throw new PackError("No element to pack: the list of declarations is empty.");
+	const where = (index) => source.kind === "package" ? `${path.relative(root, source.declarations)}[${index}]` : path.relative(root, source.folders[index]);
+	const checked = declarations.map((declaration, index) => checkDeclaration(declaration, where(index)));
+	const types = checked.map((declaration) => declaration.type);
+	const repeated = types.find((type, index) => types.indexOf(type) !== index);
+	if (repeated) throw new PackError(`Two elements are both "${repeated}": a space could not tell them apart.`);
+	return checked;
+};
+/** The entry a space loads: the package's own, or one written for the folders — the first the plugin, the rest its `plugins`. */
+var entryOf = (source, root) => source.kind === "package" ? { entryPoints: [source.entry] } : { stdin: {
+	resolveDir: root,
+	contents: [
+		...source.folders.map((folder, index) => `import e${index} from '${toImportPath(path.join(folder, "index.ts"))}';`),
+		"export default e0;",
+		`export const plugins = { ${source.folders.slice(1).map((_folder, index) => `[e${index + 1}.type]: e${index + 1}`).join(", ")} };`,
+		`export const elements = [${source.folders.map((_folder, index) => `e${index}`).join(", ")}];`
+	].join("\n"),
+	sourcefile: "plitzi-plugin.ts",
+	loader: "ts"
+} };
+var writeTypes = (root, outDir) => {
 	try {
-		return (await fs.stat(candidate)).isDirectory();
+		return emitTypeDeclarations(root, outDir);
+	} catch (error) {
+		throw new PackError(`The type declarations could not be written: ${error instanceof Error ? error.message : String(error)}`);
+	}
+};
+var integrityOf = async (file) => {
+	const content = await fs.readFile(file);
+	return `sha384-${createHash("sha384").update(content).digest("base64")}`;
+};
+var packPlugin = async ({ root, source, base, version, outDir, zip, types = false }) => {
+	const relative = path.relative(root, outDir);
+	if (relative.startsWith("..") || path.isAbsolute(relative) || relative === "") throw new PackError(`${outDir} is not a folder inside ${root}: the build empties it first, so it has to be.`);
+	if (source.kind === "elements") for (const folder of source.folders) for (const file of ["index.ts", "declaration.ts"]) try {
+		await fs.access(path.join(folder, file));
+	} catch {
+		throw new PackError(`${path.relative(root, folder) || folder} has no ${file}: an element is a folder holding its component, declaration and index. \`plitzi add plugin\` writes one.`);
+	}
+	const declarations = await readDeclarations(root, source);
+	await fs.rm(outDir, {
+		recursive: true,
+		force: true
+	});
+	await fs.mkdir(outDir, { recursive: true });
+	await build({
+		...entryOf(source, root),
+		bundle: true,
+		format: "esm",
+		platform: "browser",
+		target: "es2022",
+		jsx: "automatic",
+		minify: true,
+		legalComments: "none",
+		define: { "process.env.NODE_ENV": JSON.stringify("production") },
+		external: EXTERNAL,
+		loader: Object.fromEntries(INLINED.map((extension) => [extension, "dataurl"])),
+		outfile: path.join(outDir, `${base}.mjs`),
+		logLevel: "silent"
+	}).catch((error) => {
+		throw new PackError(`The plugin could not be built: ${error instanceof Error ? error.message : String(error)}`);
+	});
+	const built = (await fs.readdir(outDir)).filter((file) => file.endsWith(".mjs") || file.endsWith(".css")).sort();
+	const assets = Object.fromEntries(await Promise.all(built.map(async (file) => [file, {
+		src: file,
+		type: file.endsWith(".css") ? "style" : "script",
+		integrity: await integrityOf(path.join(outDir, file)),
+		isMain: true
+	}])));
+	const [main] = declarations;
+	const { definition, market } = main.content;
+	const manifest = {
+		root: main.type,
+		version,
+		author: typeof market.owner === "string" ? market.owner : "",
+		definition: {
+			name: definition.label,
+			description: definition.description ?? "",
+			...market,
+			verified: false
+		},
+		pluginSchema: Object.fromEntries(declarations.map(({ type, content: { attributes, definition: elementDefinition, builder, defaultStyle } }) => [type, {
+			attributes,
+			definition: elementDefinition,
+			builder,
+			defaultStyle
+		}])),
+		assets,
+		assetsSettings: {}
+	};
+	await fs.writeFile(path.join(outDir, "plugin-manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+	const files = [...built, "plugin-manifest.json"];
+	if (zip) {
+		const entries = await Promise.all(files.map(async (file) => [file, await fs.readFile(path.join(outDir, file))]));
+		await fs.mkdir(path.dirname(zip), { recursive: true });
+		await fs.writeFile(zip, zipSync(Object.fromEntries(entries)));
+	}
+	const typesOutcome = types ? writeTypes(root, outDir) : void 0;
+	return {
+		root: main.type,
+		types: declarations.map((declaration) => declaration.type),
+		files,
+		zip,
+		typesOutcome
+	};
+};
+//#endregion
+//#region src/commands/packPlugin.ts
+var hasElement = async (folder) => {
+	try {
+		await Promise.all(["index.ts", "declaration.ts"].map((file) => fs.access(path.join(folder, file))));
+		return true;
 	} 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(dir) && path.dirname(dir) !== dir) dir = path.dirname(dir);
-	return dir;
+/** The element folders a project keeps in `src/plugins` — the ones with a declaration, which is what packs. */
+var elementFolders = async (project) => {
+	const dir = path.join(project.root, "src/plugins");
+	let entries = [];
+	try {
+		entries = (await fs.readdir(dir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	} catch {
+		return [];
+	}
+	const folders = entries.map((name) => path.join(dir, name));
+	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. */
+var askFolders = async (candidates, root) => {
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		return (await askText(rl, `Which elements go in the plugin? The first is the one it is named after.\n${candidates.map((folder, index) => `  ${index + 1}. ${path.relative(root, folder)}`).join("\n")}\nTheir numbers, separated by commas:`, "1", (answer) => answer.split(",").every((part) => {
+			const index = Number(part.trim()) - 1;
+			return Number.isInteger(index) && index >= 0 && index < candidates.length;
+		}) ? void 0 : `Numbers from 1 to ${candidates.length}, separated by commas.`)).split(",").map((part) => candidates[Number(part.trim()) - 1]);
+	} finally {
+		rl.close();
+	}
 };
 /**
-* 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.
+* The element folders to pack, when this is not a plugin package packing itself: those named, or else the ones the
+* project keeps in `src/plugins`, asked for at a terminal. `undefined` when there is nothing to pack or nobody to ask.
 */
-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 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;
+		return;
+	}
+	if (!atTerminal()) {
+		refuseWithoutTerminal("plugin", [{
+			flag: "<folders> (the arguments)",
+			choices: candidates.map((folder) => path.relative(process.cwd(), folder)),
+			question: "Which elements go in the plugin? The first is the one it is named after."
+		}], "plitzi pack plugin stopped before building anything: which elements go in it shape the whole plugin");
+		return;
+	}
+	return askFolders(candidates, project.root);
 };
-var install = (manager, cwd) => new Promise((resolve) => {
-	const child = spawn(manager, ["install"], {
-		cwd,
-		stdio: "inherit",
-		shell: process.platform === "win32"
+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;
+		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 source = inPackage ? {
+		kind: "package",
+		entry: path.join(project.root, "src/index.ts"),
+		declarations: path.join(project.root, "src/declarations.ts")
+	} : {
+		kind: "elements",
+		folders
+	};
+	const outDir = options.out ? path.resolve(options.out) : path.join(project.root, inPackage ? "dist" : `dist/plugins/${base}`);
+	const zip = options.zip === false ? void 0 : path.join(inPackage ? project.root : path.dirname(outDir), `${base}-${version}.zip`);
+	try {
+		const result = await packPlugin({
+			root: project.root,
+			source,
+			base,
+			version,
+			outDir,
+			zip,
+			types: inPackage
+		});
+		console.log(chalk.green(`\n${result.types.join(", ")} — packed at ${path.relative(process.cwd(), outDir) || "."}`));
+		for (const file of result.files) console.log(chalk.dim(`  ${file}`));
+		if (result.typesOutcome === "written") console.log(chalk.dim("  types/"));
+		else if (result.typesOutcome === "no-typescript") console.log(chalk.yellow("  No type declarations: the package has no TypeScript installed to write them with."));
+		if (result.zip) {
+			console.log(`\n  ${path.relative(process.cwd(), result.zip)}`);
+			console.log(chalk.dim("  Upload it in the builder under Resources, as a plugin."));
+		}
+		console.log("");
+	} catch (error) {
+		if (!(error instanceof PackError)) throw error;
+		console.error(chalk.red(error.message));
+		process.exitCode = 1;
+	}
+};
+//#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";
+/** This project's own packer — read, since it is the project's. */
+var projectPacker = async (root) => {
+	try {
+		const entry = createRequire(path.join(root, "package.json")).resolve("@plitzi/sdk-server/runtime");
+		const loaded = await import(pathToFileURL(entry).href);
+		if (isPacker(loaded)) return loaded;
+	} 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 entry = path.resolve(root, options.entry ?? DEFAULT_ENTRY);
+	try {
+		await fs.access(entry);
+	} catch {
+		fail(`There is no ${path.relative(root, entry)}: the module whose default export is defineRuntime({ start }).`);
+		return;
+	}
+	const packer = await projectPacker(root);
+	if (!packer) return;
+	let bytes;
+	try {
+		bytes = await packer.packRuntime(entry);
+	} catch (error) {
+		fail(`It does not pack: ${error instanceof Error ? error.message : String(error)}`);
+		return;
+	}
+	const answered = await authorizedRequest(connection, `/spaces/${String(connection.space.id)}/runtime`, {
+		method: "PUT",
+		headers: { "content-type": "application/octet-stream" },
+		body: new Uint8Array(bytes)
 	});
-	child.on("error", () => resolve(false));
-	child.on("close", (code) => resolve(code === 0));
-});
-/** 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.help}\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;
+	if (!answered.ok) {
+		fail(answered.error);
+		return;
+	}
+	const { reply } = answered.value;
+	if (reply.status !== 200 || !reply.data.digest) {
+		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.`);
 };
-var resolveDecisions = async (options) => {
-	const detected = detectPackageManager();
-	const packageManager = {
-		flag: "--package-manager",
-		choices: PACKAGE_MANAGERS,
-		help: `The package manager the project will be worked in (this was run through ${detected}).`,
-		given: PACKAGE_MANAGERS.find((manager) => manager === options.packageManager),
-		fallback: detected
-	};
-	const mode = {
-		flag: "--mode",
-		choices: MODES,
-		help: "server: SSR + RSC on a Node tier. client: browser only.",
-		given: MODES.find((candidate) => candidate === options.mode),
-		fallback: "server"
+var readRuntime = async (connection, spaceId) => {
+	const answered = await authorizedRequest(connection, `/spaces/${String(spaceId)}/runtime`);
+	if (!answered.ok) {
+		fail(answered.error);
+		return;
+	}
+	const { reply } = answered.value;
+	if (reply.status !== 200) {
+		fail(reply.data.error ?? `Could not read the runtime (${String(reply.status)}).`);
+		return;
+	}
+	return {
+		environments: reply.data.environments ?? [],
+		variables: reply.data.variables ?? [],
+		sizes: reply.data.sizes ?? []
 	};
-	const source = {
-		flag: "--source",
-		choices: SOURCES,
-		help: "local: the space travels in the project. cloud: read it from Plitzi.",
-		given: SOURCES.find((candidate) => candidate === options.source),
-		fallback: "local"
+};
+/** How each environment's runtime is, and the names of its variables. */
+var runtimeStatus = async (options) => {
+	const connection = await connect(options, "to read");
+	if (!connection?.space) return;
+	const runtime = await readRuntime(connection, connection.space.id);
+	if (!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);
+		return size ? `${size.label}, ${size.cpu} CPU / ${size.memory}` : name;
 	};
-	const missing = [
-		packageManager,
-		mode,
-		source
-	].filter((question) => question.given === void 0);
-	if (missing.length === 0 || options.yes) return {
-		packageManager: packageManager.given ?? packageManager.fallback,
-		mode: mode.given ?? mode.fallback,
-		source: source.given ?? source.fallback
+	runtime.environments.forEach(({ environment, revision, digest, status, error, endpoints, tasks, size, ...rest }) => {
+		const version = revision === 0 ? "draft" : `revision ${String(revision)}`;
+		console.log(`${chalk.bold(environment)} (${version}, ${digest.slice(0, 12)}): ${status} — ${spendOf(size)}`);
+		if (status === "stopped") {
+			const why = rest.stoppedReason === "idle" ? "unused for too long" : "stopped by hand";
+			console.log(`  ${chalk.yellow(`Stopped (${why}): plitzi runtime start${environment === "main" ? "" : ` --environment ${environment}`}`)}`);
+		}
+		if (rest.idleStopsAt) console.log(`  Stops by itself on ${(/* @__PURE__ */ new Date(rest.idleStopsAt * 1e3)).toLocaleString()} if nothing uses it`);
+		if (error) console.log(`  ${chalk.red(error)}`);
+		if (status === "ready") console.log(`  ${String(tasks.length)} tasks${endpoints.length ? `, answers ${endpoints.join(", ")}` : ""}`);
+	});
+	console.log(`Variables: ${runtime.variables.length ? runtime.variables.join(", ") : "none"}`);
+	const included = runtime.sizes.filter((option) => option.included).map((option) => option.name);
+	console.log(`Sizes in this plan: ${included.length ? included.join(", ") : "none"}`);
+};
+/** 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");
+	if (!connection?.space) return;
+	const environment = options.environment ?? "main";
+	const answered = await authorizedRequest(connection, `/spaces/${String(connection.space.id)}/runtime/${power}`, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({ environment })
+	});
+	if (!answered.ok) {
+		fail(answered.error);
+		return;
+	}
+	const { reply } = answered.value;
+	if (reply.status !== 204) {
+		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"}.`);
+};
+/** 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");
+	if (!connection?.space) return;
+	const environment = options.environment ?? "main";
+	const answered = await authorizedRequest(connection, `/spaces/${String(connection.space.id)}/runtime/size`, {
+		method: "PUT",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({
+			size,
+			environment
+		})
+	});
+	if (!answered.ok) {
+		fail(answered.error);
+		return;
+	}
+	const { reply } = answered.value;
+	if (reply.status !== 204) {
+		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.`);
+};
+/** Everything sent on standard input: a value piped in rather than typed where the shell history keeps it. */
+var readStdin = async () => {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+	return Buffer.concat(chunks).toString("utf8").replace(/\r?\n$/, "");
+};
+/**
+* Sets one of the runtime's variables — the runtime starts again with it. Without a value it is read from standard
+* 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");
+	if (!connection?.space) return;
+	const given = value ?? await readStdin();
+	const answered = await authorizedRequest(connection, `/spaces/${String(connection.space.id)}/runtime/variables/${encodeURIComponent(name)}`, {
+		method: "PUT",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({ value: given })
+	});
+	if (!answered.ok) {
+		fail(answered.error);
+		return;
+	}
+	const { reply } = answered.value;
+	if (reply.status !== 204) {
+		fail(reply.data.error ?? `${name} was not set (${String(reply.status)}).`);
+		return;
+	}
+	console.log(`${chalk.green("✓")} ${name} set — the runtime starts again with it.`);
+};
+var unsetRuntimeVariable = async (name, options) => {
+	const connection = await connect(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.`);
+};
+//#endregion
+//#region src/commands/uploadPlugin.ts
+/** The zips `plitzi pack plugin` leaves: at a plugin package's root, or under `dist/plugins` of any other project. */
+var packedZips = async (root) => {
+	const inFolder = async (dir) => {
+		try {
+			return (await fs.readdir(dir)).filter((file) => file.endsWith(".zip")).map((file) => path.join(dir, file));
+		} catch {
+			return [];
+		}
 	};
-	if (!process.stdin.isTTY || !process.stdout.isTTY) {
-		console.error(chalk.red("\nplitzi create needs these decided by whoever the project is for. Ask them; do not assume:"));
-		for (const question of missing) console.error(`  ${`${question.flag} ${question.choices.join("|")}`.padEnd(36)} ${chalk.dim(question.help)}`);
-		const defaults = missing.map((question) => `${question.flag} ${question.fallback}`).join(" ");
-		console.error(chalk.dim(`\nThen run it again with those flags — or with --yes to take ${defaults}.`));
-		process.exitCode = 1;
+	const zips = [...await inFolder(root), ...await inFolder(path.join(root, "dist/plugins"))];
+	const modified = await Promise.all(zips.map(async (zip) => (await fs.stat(zip)).mtimeMs));
+	return zips.map((zip, index) => ({
+		zip,
+		at: modified[index]
+	})).sort((a, b) => b.at - a.at).map(({ zip }) => zip);
+};
+/** The zip named, or the one packed here — asked for at a terminal when there are several. */
+var chooseZip = async (given) => {
+	if (given) return path.resolve(given);
+	const project = await findProject(process.cwd());
+	const zips = project ? await packedZips(project.root) : [];
+	if (zips.length === 0) {
+		fail("No packed plugin here. Build one with plitzi pack plugin, or name it: plitzi upload plugin <file.zip>.");
+		return;
+	}
+	if (zips.length === 1) return zips[0];
+	const choices = zips.map((zip) => path.relative(process.cwd(), zip));
+	if (!atTerminal()) {
+		refuseWithoutTerminal("upload", [{
+			flag: "<zip> (the argument)",
+			choices,
+			question: "Which packed plugin is to be uploaded?"
+		}], "plitzi upload plugin stopped before uploading anything: which plugin goes to the space is a choice");
 		return;
 	}
 	const rl = readline.createInterface({
@@ -1300,106 +4528,160 @@ var resolveDecisions = async (options) => {
 		output: process.stdout
 	});
 	try {
-		const manager = packageManager.given ?? await ask(rl, packageManager);
-		const tier = manager && (mode.given ?? await ask(rl, mode));
-		const origin = tier && (source.given ?? await ask(rl, source));
-		if (!manager || !tier || !origin) {
-			process.exitCode = 1;
-			return;
-		}
-		return {
-			packageManager: manager,
-			mode: tier,
-			source: origin
-		};
+		return await askPick(rl, "Which packed plugin? The newest is first.", zips.map((zip, index) => ({
+			label: choices[index],
+			value: zip
+		})));
 	} finally {
 		rl.close();
 	}
 };
-var askForKey = async (mode) => {
+/**
+* The manifest a zip carries at its root, read here before anything is sent: a zip that is not a plugin is refused by
+* the platform too, but only after it has travelled.
+*/
+var manifestOf = (zip) => {
+	try {
+		const entry = Object.values(unzipSync(zip, { filter: (file) => file.name === "plugin-manifest.json" })).at(0);
+		const parsed = entry ? JSON.parse(new TextDecoder().decode(entry)) : {};
+		return typeof parsed.root === "string" && parsed.root ? {
+			root: parsed.root,
+			version: typeof parsed.version === "string" ? parsed.version : ""
+		} : void 0;
+	} catch {
+		return;
+	}
+};
+var chooseCdn = async (cdns, given, spaceName) => {
+	if (cdns.length === 0) {
+		fail(`${spaceName} has no CDN to put a plugin on. Add one in the builder, under the space's settings.`);
+		return;
+	}
+	if (given) {
+		const named = cdns.find((cdn) => cdn.identifier === given);
+		if (!named) fail(`${spaceName} has no CDN "${given}". Its CDNs: ${cdns.map((cdn) => cdn.identifier).join(", ")}.`);
+		return named;
+	}
+	if (cdns.length === 1) return cdns[0];
+	if (!atTerminal()) {
+		refuseWithoutTerminal("upload", [{
+			flag: "--cdn",
+			choices: cdns.map((cdn) => cdn.identifier),
+			question: `Which of ${spaceName}'s CDNs does the plugin go on?`
+		}], "plitzi upload plugin stopped before uploading anything: which CDN serves the plugin is a choice");
+		return;
+	}
 	const rl = readline.createInterface({
 		input: process.stdin,
 		output: process.stdout
 	});
 	try {
-		const which = mode === "server" ? "self-hosting" : "public render";
-		return (await rl.question(`\n${which} key (Credentials, in the builder)\n> `)).trim();
+		return await askPick(rl, `Which of ${spaceName}'s CDNs does the plugin go on?`, cdns.map((cdn) => ({
+			label: `${cdn.name} ${chalk.dim(`${cdn.identifier} · ${cdn.domain}`)}`,
+			value: cdn
+		})));
 	} finally {
 		rl.close();
 	}
 };
-var create = async (directory, options) => {
-	const target = path.resolve(directory ?? ".");
-	const name = path.basename(target);
-	if (!options.force && !await isEmpty(target)) {
-		console.error(chalk.red(`${target} is not empty. Pass --force to write into it anyway.`));
-		process.exitCode = 1;
+var uploadPluginCommand = async (zipGiven, options) => {
+	const api = await apiFor(options);
+	const zipPath = api ? await chooseZip(zipGiven) : void 0;
+	if (!api || !zipPath) return;
+	let zip;
+	try {
+		zip = await fs.readFile(zipPath);
+	} catch {
+		fail(`Could not read ${zipPath}.`);
 		return;
 	}
-	const decisions = await resolveDecisions(options);
-	if (!decisions) return;
-	const { packageManager, mode, source } = decisions;
-	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;
+	const manifest = manifestOf(zip);
+	if (!manifest) {
+		fail(`${path.basename(zipPath)} is not a plugin: it has no plugin-manifest.json at its root. Build it with plitzi pack plugin.`);
 		return;
 	}
-	const files = scaffold({
-		name,
-		mode,
-		source,
-		key,
-		environment: options.environment ?? "main",
-		packageManager,
-		managerVersion: detectManagerVersion(packageManager, await nearestExisting(target))
+	const connection = await connectionWithSpace(api, "to upload to");
+	if (!connection?.space) return;
+	const { space } = connection;
+	const listed = await authorizedRequest(connection, `/spaces/${space.id}/cdns`);
+	if (!listed.ok) {
+		fail(listed.error);
+		return;
+	}
+	if (listed.value.reply.status !== 200) {
+		fail(listed.value.reply.data.error ?? `Could not list ${space.name}'s CDNs (${listed.value.reply.status}).`);
+		return;
+	}
+	const cdn = await chooseCdn(listed.value.reply.data.cdns ?? [], options.cdn, space.name);
+	if (!cdn) return;
+	const label = `${manifest.root}${manifest.version ? ` ${manifest.version}` : ""}`;
+	console.log(`\nUploading ${chalk.bold(label)} to ${chalk.bold(space.name)}, on ${cdn.name}…`);
+	const query = new URLSearchParams({ filename: path.basename(zipPath) });
+	const uploaded = await authorizedRequest(listed.value.connection, `/spaces/${space.id}/cdns/${encodeURIComponent(cdn.identifier)}/plugins?${query}`, {
+		method: "POST",
+		headers: { "Content-Type": "application/zip" },
+		body: new Uint8Array(zip)
 	});
-	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);
-	}));
-	const wantsInstall = options.install !== false;
-	const installed = wantsInstall && await install(packageManager, target);
-	/**
-	* A failed install is a failed command, not a next step.
-	*
-	* The files are already written, so the summary below still prints — but printed on its own after a screen of
-	* resolver errors it reads as success, and a script that ran `create` carries on into a project with no
-	* `node_modules`.
-	*/
-	if (wantsInstall && !installed) {
-		console.error(chalk.red(`\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;
+	if (!uploaded.ok) {
+		fail(uploaded.error);
+		return;
 	}
-	/**
-	* How to get there, 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.
-	*/
-	const relative = path.relative(process.cwd(), target);
-	const where = target === process.cwd() ? "" : `cd ${relative.length < target.length ? relative : target} && `;
-	console.log(chalk.green(`\n${name} — ${mode === "server" ? "server-rendered" : "browser-rendered"}, space ${source === "cloud" ? "from Plitzi" : "in the project"}.`));
-	console.log("");
-	if (!installed) console.log(`  ${where}${installCommand(packageManager)}`);
-	console.log(`  ${where}${runCommand(packageManager, "start")}`);
-	console.log("");
-	console.log(chalk.dim(`.claude/skills carries Plitzi's authoring skill; \`${runCommand(packageManager, "visual")}\` opens the page and checks it.`));
-	if (source === "cloud") console.log(chalk.dim(".env holds the key and is already git-ignored."));
-	console.log("");
+	const { status, data } = uploaded.value.reply;
+	if (status === 413) {
+		fail(`${path.basename(zipPath)} is larger than ${api} accepts.`);
+		return;
+	}
+	if (status !== 201) {
+		fail(data.error ?? `The upload was refused (${status}).`);
+		return;
+	}
+	const installed = data.installed === "updated" ? `now loads ${label}` : `loads ${label} from now on`;
+	console.log(chalk.green(`\n${space.name} ${installed}.`));
+	if (data.resource?.path) console.log(chalk.dim(`  ${data.resource.path}`));
+	console.log(chalk.dim("  Any builder open on the space loads it now.\n"));
 };
 //#endregion
 //#region src/index.ts
 /**
 * The command line for Plitzi.
 *
-* One command, and deliberately: the gap worth closing first is between installing the SDK and having a page on
-* screen. Everything needed for that was documented, which was the problem — a person had to read four things and
-* write three files correctly before they could tell whether any of it worked.
+* The gap it closes first is between installing the SDK and having a page on screen. Everything needed for that was
+* documented, which was the problem — a person had to read four things and write three files correctly before they
+* 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");
-program.command("create").argument("[directory]", "Where to write the project. Defaults to the current directory.").description("Scaffold a project that renders a Plitzi space").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 to serve: main, or a published environment", "main").addOption(new Option("-p, --package-manager <manager>", "The package manager the project is written for. Asked for when left out.").choices([...PACKAGE_MANAGERS])).option("--no-install", "Write the files without installing dependencies").option("-f, --force", "Write into a directory that is not empty").option("-y, --yes", "Take the defaults for any choice not passed (server, local, the invoking package manager)").action(create);
+/** The flags that shape a PROJECT: given with `--plugin`, they are a mistake worth saying rather than ignoring. */
+var PROJECT_ONLY = [
+	"mode",
+	"source",
+	"key"
+];
+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 to serve: main, or a published environment", "main").addOption(new Option("-p, --package-manager <manager>", "The package manager the project is written for. Asked for when left out.").choices([...PACKAGE_MANAGERS])).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) => {
+	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("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("pack").description("Build something of this project into what the platform takes").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.").action((folders, options) => packPluginCommand(folders, options));
+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("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("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("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. Asked for when it has 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));
+functions.command("push").description("Save functions/ as the space’s draft: built and checked on the platform, refused if it moved on since").option(...API_OPTION).action((options) => pushFunctions(options));
+functions.command("try").argument("<task>", "The task, <namespace>.<action>").description("Run one task of the draft in the sandbox: its value, what it logged, and why it failed").option("--params <json>", "Its params, as a JSON object").option(...API_OPTION).action((task, options) => tryFunction(task, options));
+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));
+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));
 program.parse(process.argv);
 //#endregion