@plitzi/cli 0.38.2 → 0.38.4

package/dist/index.js

@@ -12,15 +12,27 @@ import { createServer } from "node:http";
 import tls from "node:tls";
 import readline from "node:readline/promises";
 import { readFileSync, readdirSync, watch } from "node:fs";
-import { EXPLAIN_KINDS, actionSpecFromEntry, actionToSource, authorSpace, blankSpaceSource, catalogTemplateFiles, comparePictures, darkScheme, elementTriggers, elementTypeNames, emptySpaceSource, explain, explainKindOf, explainList, explanationText, failedFlowText, importProbe, importedFiles, inspectDocument, inspectPage, pageRegions, planFixes, readDevTools, refusalOf } from "@plitzi/sdk-authoring";
+import { EXPLAIN_KINDS, PAGE_TEXT_LIMIT, actionSpecFromEntry, actionToSource, authorSpace, blankSpaceSource, catalogTemplateFiles, comparePictures, compareTexts, darkScheme, dataIssues, elementTriggers, elementTypeNames, emptySpaceSource, explain, explainKindOf, explainList, explanationText, failedFlowText, importProbe, importedFiles, inspectDocument, inspectPage, loadImages, pageRegions, pageTexts, planFixes, readDevTools, refusalOf, unrollPage } from "@plitzi/sdk-authoring";
 import { promisify } from "node:util";
 import { lookup } from "node:dns/promises";
 import { build } from "esbuild";
 import { unzipSync, zipSync } from "fflate";
 import { gzipSync } from "node:zlib";
+import { emitKeypressEvents } from "node:readline";
+var t$3 = `[data-plitzi-devtools] { display: none !important; }`;
+//#endregion
 //#region ../../packages/sdk-shared/dist/helpers/isRecord.mjs
 var e$1 = (e) => typeof e == "object" && !!e && !Array.isArray(e);
 //#endregion
+//#region ../../packages/sdk-shared/dist/theme/themeCookie.mjs
+var t$2 = "theme";
+/** The port `npm start` took and the name its `/health` answers with: what `check`, `shot` and `visual` find it by. */
+var DEV_SERVER_FILE = `tmp/dev-server.json`;
+/** The space as last authored while developing, re-read by the server on every change: never the source of it. */
+var DEV_SPACE_FILE = `tmp/space.json`;
+/** What Playwright leaves of a run: traces, failures' pictures. */
+var VISUAL_OUTPUT = `tmp/visual`;
+//#endregion
 //#region src/browser/index.ts
 /**
 * A browser on the project's own Playwright, and the project's own server to point it at — what `plitzi check`,
@@ -54,7 +66,7 @@ var launchBrowser = async (root) => {
 /** What `npm start` wrote down when it took a port: the port, and the name its `/health` answers with. */
 var recorded = async (root) => {
 	try {
-		const value = JSON.parse(await readFile(path.join(root, ".plitzi/dev-server.json"), "utf8"));
+		const value = JSON.parse(await readFile(path.join(root, DEV_SERVER_FILE), "utf8"));
 		if (!e$1(value)) return {};
 		return {
 			...typeof value.port === "number" ? { port: value.port } : {},
@@ -83,6 +95,39 @@ var projectOrigin = async (root, project) => {
 var dataUrl = (png) => `data:image/png;base64,${Buffer.from(png).toString("base64")}`;
 /** A data URL's picture back as bytes, to write to a file. */
 var fromDataUrl = (url) => Buffer.from(url.slice(url.indexOf(",") + 1), "base64");
+/**
+* A page for the project's own server, in the theme asked for. The machine's preference alone is not enough: a space
+* whose default is dark paints dark whatever the machine prefers, as it would for any visitor. So a scheme asked for
+* is also the space's own choice — the `theme` cookie a visitor's `themeToggle` writes and the server paints `<html>`
+* by — set before the page is asked for, so the first paint is already in it.
+*/
+var openProjectPage = async (browser, origin, view) => {
+	const page = await browser.newPage({
+		viewport: {
+			width: view.width,
+			height: view.height
+		},
+		colorScheme: view.scheme ?? "light",
+		reducedMotion: view.reducedMotion ? "reduce" : "no-preference"
+	});
+	if (view.scheme) await page.context().addCookies([{
+		name: t$2,
+		value: view.scheme,
+		url: origin
+	}]);
+	return page;
+};
+/**
+* The theme a page was painted in: the class on `<html>` (a space's own choice, or its default), else the one the
+* machine prefers — which is what a page with neither follows.
+*/
+var paintedScheme = (page, machine) => page.evaluate((prefers) => {
+	const { classList } = document.documentElement;
+	if (classList.contains("dark")) return "dark";
+	return classList.contains("light") ? "light" : prefers;
+}, machine);
+/** The page as a visitor sees it: the dev tools' own chrome — the badge, the panel — left out of whatever is looked at. */
+var withoutDevTools = (page) => page.addStyleTag({ content: t$3 });
 //#endregion
 //#region src/commands/terminal.ts
 /**
@@ -1186,6 +1231,10 @@ const StatCard = ({ label = 'Metric', value = 0, unit = '', series, className }:
    * 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 in \`src/space.ts\` applies, the builder can select it, a test
    * can find it by name, and interactions fire on it. A plain tag renders the same pixels and none of that.
+   *
+   * Its \`style\` is inline, and inline outranks every class: what \`CARD\` sets — its display, its padding — the CSS
+   * authored on the element can never change. Keep it to what the element cannot render without, and leave layout and
+   * position (\`position\`, \`width\`, \`margin\`) to the space's classes.
    */
   return (
     <RootElement className={className} style={CARD}>
@@ -1420,6 +1469,8 @@ var managerPackageFields = (manager) => manager === "npm" ? { allowScripts: {
 	fsevents: false
 } } : {};
 var SDK_VERSION = `^${createRequire(import.meta.url)("@plitzi/sdk-authoring/package.json").version}`;
+/** The same version, bare: this CLI's own — what `--version` prints and what wrote a project's machinery. */
+var CLI_VERSION = SDK_VERSION.slice(1);
 /**
 * What every generated project builds and checks itself with.
 *
@@ -1478,8 +1529,8 @@ var NODE_ENGINES = { node: ">=22.18" };
 *
 * `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 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
+* project's own to hot-replace (the SDK is served by the server from its own copy), so a save to the server's code
+* restarts the process — and a save to a local space is re-authored in place and the open page reloads. 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 }) => ({
@@ -1488,10 +1539,12 @@ var scripts = ({ mode, source }) => ({
 		/**
 		* 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.
+		* The server compiles the project's plugins into `tmp/.sdk-plugins/` and then IMPORTS what it built, so a
+		* bare `--watch` sees its own output land, restarts, compiles again, and never stops. A local space is not
+		* among them: `main.ts` re-authors it on save in a process of its own and the open pages load again
+		* (`reloadPages`), so only the server's own code and the plugins restart it.
 		*/
-		"start:dev": "node --watch-path=./src src/main.ts",
+		"start:dev": source === "local" ? "node --watch-path=./src/main.ts --watch-path=./src/plugins src/main.ts" : "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
@@ -1583,10 +1636,12 @@ var tsconfig$1 = ({ mode }) => `${JSON.stringify({
 * writes `.yarn/install-state.gz` into the project, which is a cache and belongs in no repository.
 */
 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.plitzi\n";
-var gitignore$1 = ({ mode, packageManager }) => `node_modules\ndist\n.env\nvisual/.results\nvisual/screenshots\n${mode === "server" ? SERVER_IGNORES : ""}${packageManager === "yarn" ? YARN_IGNORES$1 : ""}`;
-var startLine = ({ mode, packageManager }) => mode === "server" ? `\`${runCommand(packageManager, "start")}\` serves pages on http://127.0.0.1:8080 — or, when something else holds 8080, the next free port, which it prints and writes to \`.plitzi/dev-server.json\` (set \`PORT\` to choose one). \`${runCommand(packageManager, "start:dev")}\` restarts on save. In production, \`${runCommand(packageManager, "build")}\` once and run \`${runCommand(packageManager, "start:prod")}\` with \`NODE_ENV=production\`: the compiled server, with no TypeScript in the process.` : `\`${runCommand(packageManager, "start")}\` runs Vite on http://127.0.0.1:5173, with hot module replacement.`;
+/**
+* `tmp/` is everything the project writes for itself (`./paths`); `.plitzi/` is what the CLI records about it, and is
+* committed — a clone without it could not pull, push or upgrade.
+*/
+var gitignore$1 = ({ packageManager }) => `node_modules\ndist\n.env\ntmp\n${packageManager === "yarn" ? YARN_IGNORES$1 : ""}`;
+var startLine = ({ mode, packageManager, source }) => mode === "server" ? `\`${runCommand(packageManager, "start")}\` serves pages on http://127.0.0.1:8080 — or, when something else holds 8080, the next free port, which it prints and writes to \`${DEV_SERVER_FILE}\` (set \`PORT\` to choose one). \`${runCommand(packageManager, "start:dev")}\` restarts on a save to the server's code${source === "local" ? "; a save to the space reloads the open page" : ""}. 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
 
@@ -1605,9 +1660,9 @@ from what is written there, so authoring it twice writes byte-identical document
 
 Nothing is fetched and nothing is signed in to: there is no account, no key and no network in the picture.
 
-\`${runCommand(answers.packageManager, "author")}\` writes the documents out as \`space/offline-data.json\`, for the moment you want the space
-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.`;
+\`${runCommand(answers.packageManager, "author")}\` authors it and says what it found — warnings, suggestions, what a newer SDK changed. It
+writes nothing: the declaration is the source, and \`npx plitzi push\` puts it on a space in Plitzi when you want it
+there.`;
 };
 var readme$1 = (answers) => `# ${answers.name}
 
@@ -1623,6 +1678,16 @@ ${startLine(answers)}
 
 ${spaceSection(answers)}
 
+## Folders that are not the source
+
+- \`public/\` is served to anyone who asks, as it is: every file in it is on the internet once the project is deployed.
+  Data and pictures for every visitor go there — never a secret, a key, a private document or what only some visitors
+  may read.
+- \`tmp/\` is what the project writes for itself while it runs — the plugins it builds, the port it took, test
+  output. Ignored by git, and rebuilt whenever it is missing.
+- \`.plitzi/\` is what the CLI records about the project — the space it came from, its functions' working copy, the
+  files \`create\` wrote — so \`plitzi pull\`, \`push\` and \`upgrade\` know where they stand. Commit it.
+
 ## The skills
 
 \`.claude/skills/\` carries Plitzi's authoring skill, so an agent working in this repository knows how a space is
@@ -1648,10 +1713,10 @@ var agentsFile = (answers) => {
 		`| ${run("visual")} | open the page in a browser and check it rendered |`
 	];
 	const zeroWarnings = local ? `Zero warnings from ${run("author")}.` : "Zero warnings from authoring.";
-	const port = answers.mode === "server" ? `${run("start")} serves on 8080, or on the next free port when something else holds it — printed, and written to ${code(".plitzi/dev-server.json")}, where ${code("check")}, ${code("shot")} and ${code("visual")} read it. ${code("PORT")} chooses one.` : `${run("start")} runs Vite on 5173.`;
+	const port = answers.mode === "server" ? `${run("start")} serves on 8080, or on the next free port when something else holds it — printed, and written to ${code(DEV_SERVER_FILE)}, where ${code("check")}, ${code("shot")} and ${code("visual")} read it. ${code("PORT")} chooses one.` : `${run("start")} runs Vite on 5173.`;
 	const pictures = answers.mode === "server" ? `- **Pictures from other sites** are resized by this server once ${code("src/main.ts")} names their hosts — ${code("images: { domains }")} in ${code("createServer")}, a list of hosts like ${code("images.example.com")} — and ${code("sharp")} is installed: an ${code("image")} then offers a ${code("srcset")} (give it ${code("sizes")}, and ${code("width")}/${code("height")} so nothing jumps).\n` : "";
-	const serverData = answers.mode === "server" ? `; one whose ${code("runtime")} is ${code("server")} is read by the server, and the page arrives with it` : "";
-	const generated = [...local ? [`- ${code("space/offline-data.json")} — what ${run("author")} writes out; the space is ${code("src/space.ts")}.`] : [], ...answers.mode === "server" ? [`- ${code(".sdk-plugins/")} and ${code(".plitzi/")} — built and written by the server.`] : []];
+	const serverData = answers.mode === "server" ? `; one whose ${code("runtime")} is ${code("server")} is read by the server, and the page arrives with it — bound the same way (${code("products.data.items")}), on a page or a layout, never inside a component` : "";
+	const generated = [`- ${code(`tmp/`)} — what the project writes for itself while it runs: the plugins it built, the port it took${local ? ", the space as last authored" : ""}, test output. Never committed, rebuilt when missing.`, `- ${code(".plitzi/")} — what the CLI records about the project: where it came from, what it wrote. Committed; the CLI's to change.`];
 	return `# ${answers.name} — notes for agents
 
 A Plitzi space, rendered ${answers.mode === "server" ? "by the server in this project (SSR + RSC)" : "in the browser by a Vite app"}.
@@ -1667,7 +1732,8 @@ ${commands.join("\n")}
 
 - **Port.** ${port}
 - **Data with no backend** goes in ${code("public/data/*.json")}, served as it is and read by an ${code("apiContainer")} whose ${code("query")} is ${code("/data/products.json")}${serverData}.
-${pictures}- **Check a page in text first:** ${code(`${runCommand(answers.packageManager, "check")} -- / --width 1440,390`)} says whether every element is on screen, nothing overflows and the console is clean — a picture only when it says something is wrong: ${code(`${runCommand(answers.packageManager, "shot")} -- / --width 390`)} (add ${code("--scheme dark")}; ${code("--frames 4")} to see what moves; ${code("--compare <url>")} against another site, by section). ${run("visual")} runs the checks as tests.
+- **${code("public/")} is on the internet.** Every file in it is served to anyone who asks for it, as it is, the moment the project is deployed — no sign-in, no check. Never put in it a secret, a key, a ${code(".env")}, a private document, a database dump, or data only some visitors may read: that goes through a server action or a provider that checks who is asking.
+${pictures}- **Check a page in text first:** ${code(`${runCommand(answers.packageManager, "check")} -- / --width 1440,390`)} says whether every element is on screen, nothing overflows and the console is clean — a picture only when it says something is wrong: ${code(`${runCommand(answers.packageManager, "shot")} -- / --width 390`)} (add ${code("--scheme dark")}; ${code("--frames 4")} to see what moves; ${code("--compare <url>")} against another site: by section, and each text measured). ${run("visual")} runs the checks as tests.
 - **What the page holds, in text:** ${code(`${runCommand(answers.packageManager, "check")} -- /products --state --element <id>`)} adds its state, every source by name and one element (what it reads, its own state, whether it is on screen); every check already lists the flows that failed. Read it instead of guessing from classes in the DOM.
 
 ## Do not read
@@ -1685,11 +1751,22 @@ layouts, data, templates and flows. The types of ${code("@plitzi/sdk-authoring")
 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.
 
+## Keep the project clean
+
+What you leave behind is the next reader's problem — the user's, or the next agent's. Before calling a change done:
+
+- **Nothing unused.** Delete what you made and no longer use — a file, a page, a component, a class, a token, a data file, an import, a plugin folder. No commented-out code, no ${code("console.log")} left from debugging, no copy of a file kept "just in case": git keeps the history.
+- **Scratch goes in ${code(`tmp/`)}, or nowhere.** A one-off script, a dump, a picture to look at — never at the root or beside the source, where it reads as part of the project.
+- **One of everything.** A look used twice is a class; a value used twice is a token; a block used twice is a component, and rows of data are one list. Change it where it is defined, and rename everywhere when you rename.
+- **Files a reader can find.** One part per file, named after what it is, in the folder of its kind — the shape ${code("src/space.ts")} already has. Do not start a parallel layout of your own.
+- **Leave it passing.** ${local ? `${run("author")} with zero warnings, ` : ""}${run("typecheck")}, ${run("lint")} and ${run("format")} clean, and the page checked (${run("check")}).
+
 ## The rules that go wrong most
 
 - Never write schema/style JSON by hand; author it. A refusal names the fix — fix the declaration; ${code("npx plitzi fix --write")} writes the ones with a single reading.
+- After the ${code("@plitzi/*")} packages move, ${code("npx plitzi upgrade")}: what this project's CLI files, scripts, skills and renamed names should now be — ${code("--write")} makes it, a file you changed comes as a diff.
 - ${zeroWarnings}
-- Chrome shared by pages is a layout; a look used twice is a class; a repeated block is a function or a ${code("map")}.
+- Chrome shared by pages is a layout; a look used twice is a class; a block placed again with other content is a component, and rows of data are one ${code("list")} (a short menu may be a ${code("map")} in code).
 - Ids are one namespace for the whole space: name what is referred to; a helper that runs more than once builds inside ${code("scope()")}.
 - A file per part — the tokens, the layout, each component, each page — short enough to read whole; ${code("src/space.ts")} assembles them. ${code("npx plitzi create <dir> --template catalog")} is a complete example of the shape.
 - Rebuilding a page the user owns: ${code("npx plitzi import <url>")} writes its tokens, outline and lists as a start — then split it into parts and write the content. It reads only a site whose domain the user verified on one of their spaces.
@@ -1756,14 +1833,8 @@ var prettierrc = () => `${JSON.stringify({
 	arrowParens: "avoid",
 	endOfLine: "lf"
 }, null, 2)}\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"
-];
+/** What a project writes that is nobody's to format or lint: its builds, and everything it writes for itself. */
+var PROJECT_OUTPUTS = ["dist", "tmp"];
 /**
 * What is the agents' and not the project's: the skills copied in, whose recipes are TypeScript no program of the
 * project includes — linted with types, they would stop the lint before its first file.
@@ -1772,7 +1843,7 @@ var AGENT_FILES = ".claude";
 var prettierignore = (outputs) => `${[
 	"node_modules",
 	AGENT_FILES,
-	...outputs.filter((output) => output !== ".sdk-plugins")
+	...outputs
 ].join("\n")}\n`;
 /**
 * Flat config, and only what earns its place.
@@ -1883,13 +1954,14 @@ const PORT = process.env.PORT
     : await freePort(8080, HOST);`;
 /** Where the server says it is: the port it took, for `npm run shot` and the visual tests to find. */
 var LISTEN_SNIPPET = `server.listen(PORT, HOST);
-mkdirSync(path.join(PROJECT_ROOT, '.plitzi'), { recursive: true });
+mkdirSync(path.join(PROJECT_ROOT, 'tmp'), { recursive: true });
 writeFileSync(
-  path.join(PROJECT_ROOT, '.plitzi/dev-server.json'),
+  path.join(PROJECT_ROOT, '${DEV_SERVER_FILE}'),
   \`\${JSON.stringify({ name: SERVER_NAME, port: PORT, url: \`http://127.0.0.1:\${PORT}\` }, null, 2)}\\n\`
 );
 console.log(\`pages on http://127.0.0.1:\${PORT}/\`);`;
-var localMain = () => `import { mkdirSync, readdirSync, writeFileSync } from 'node:fs';
+var localMain = () => `import { spawn } from 'node:child_process';
+import { mkdirSync, readdirSync, watch, writeFileSync } from 'node:fs';
 import path from 'node:path';
 
 import {
@@ -1902,6 +1974,7 @@ import {
 } from '@plitzi/sdk-server';
 
 import { authorSpace } from '@plitzi/sdk-authoring';
+import { publicData } from '@plitzi/sdk-authoring/node';
 
 import { declarations } from './plugins/declarations.ts';
 import { space } from './space.ts';
@@ -1916,7 +1989,11 @@ ${PORT_SNIPPET}
  * here for the same reason: this restart is the output somebody editing the space is actually watching.
  */
 // \`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 });
+// \`data\`: the files of \`public/\` a provider reads, so a binding onto a path one of them does not have is warned.
+const { schema, style, warnings } = authorSpace(space, {
+  plugins: declarations,
+  data: publicData(new URL('../public/', import.meta.url))
+});
 const offlineData = { schema, style };
 
 for (const warning of warnings) {
@@ -1925,6 +2002,19 @@ for (const warning of warnings) {
 
 ${PLUGINS}
 
+/**
+ * While developing, the documents are served from \`${DEV_SPACE_FILE}\`, which the server reads again whenever it changes —
+ * so a save is re-authored into it and shown without restarting anything (see \`watchSpace\` below). A by-product, in
+ * \`tmp/\` with everything else the project writes for itself: the space is \`src/space.ts\`. A deployment keeps the
+ * documents in memory, as authored at boot.
+ */
+const DEVELOPING = process.env.NODE_ENV !== 'production';
+const OFFLINE_DATA = path.join(PROJECT_ROOT, '${DEV_SPACE_FILE}');
+if (DEVELOPING) {
+  mkdirSync(path.dirname(OFFLINE_DATA), { recursive: true });
+  writeFileSync(OFFLINE_DATA, \`\${JSON.stringify(offlineData, null, 2)}\\n\`);
+}
+
 /**
  * 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
@@ -1939,14 +2029,16 @@ const functions = await loadFunctions(new URL('../functions/', import.meta.url))
  * page server makes. A real deployment swaps this for adapters onto its own database, or for
  * \`createCloudAdapters\` to read the live space out of Plitzi — the server never learns the difference.
  */
-// What \`/health\` answers with, and \`.plitzi/dev-server.json\` records: how a tool knows it reached THIS project.
+// What \`/health\` answers with, and \`${DEV_SERVER_FILE}\` records: how a tool knows it reached THIS project.
 const SERVER_NAME = schema.definition.permanentUrl;
 const server = createServer({
   port: PORT,
   devMode: process.env.NODE_ENV !== 'production',
+  // A save to the space re-authors it and the open pages load again (\`watchSpace\` below).
+  devReload: DEVELOPING,
   health: { name: SERVER_NAME },
   adapters: createJsonAdapters({
-    offlineData,
+    offlineData: DEVELOPING ? OFFLINE_DATA : offlineData,
     deployment: { spaceId: 1, environment: 'main', revision: 0, pluginNames }
   }),
   plugins,
@@ -1966,6 +2058,56 @@ ${LISTEN_SNIPPET}
  * queue for whichever server runs next. A second ^C exits at once.
  */
 closeOnSignals(server);
+
+/**
+ * A save to the space, while developing: re-authored by \`src/author.ts\` in a process of its own — the only way to
+ * read every file of it again, which an import never does twice — and every open page loads again once it wrote the
+ * new documents. What it refuses is printed and the page keeps the last space that authored. A change to this file or
+ * to a plugin restarts the server instead (\`start:dev\` watches those).
+ */
+const RESTARTS = ['main.ts', 'plugins'];
+const watchSpace = (): void => {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let authoring = false;
+  let again = false;
+  const author = (): void => {
+    if (authoring) {
+      again = true;
+
+      return;
+    }
+
+    authoring = true;
+    const child = spawn(process.execPath, [path.join(PROJECT_ROOT, 'src/author.ts'), '--out', OFFLINE_DATA], {
+      cwd: PROJECT_ROOT,
+      stdio: 'inherit'
+    });
+    child.on('close', code => {
+      authoring = false;
+      if (code === 0) {
+        server.reloadPages();
+      }
+
+      if (again) {
+        again = false;
+        author();
+      }
+    });
+  };
+
+  watch(path.join(PROJECT_ROOT, 'src'), { recursive: true }, (_event, file) => {
+    if (!file || RESTARTS.some(name => file === name || file.startsWith(\`\${name}\${path.sep}\`))) {
+      return;
+    }
+
+    clearTimeout(timer);
+    timer = setTimeout(author, 100);
+  });
+};
+
+if (DEVELOPING) {
+  watchSpace();
+}
 `;
 var cloudMain = (name) => `import { mkdirSync, readdirSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
@@ -2015,7 +2157,7 @@ const functions = await loadFunctions(new URL('../functions/', import.meta.url))
  * on every request; a published environment with no \`revision\` serves the latest and releases itself; with a
  * \`revision\` it serves exactly that version, for a deployment that rolls forward on its own schedule.
  */
-// What \`/health\` answers with, and \`.plitzi/dev-server.json\` records: how a tool knows it reached THIS project.
+// What \`/health\` answers with, and \`${DEV_SERVER_FILE}\` records: how a tool knows it reached THIS project.
 const SERVER_NAME = ${JSON.stringify(name)};
 const server = createServer({
   port: PORT,
@@ -2109,14 +2251,14 @@ var skillVersion = (skill) => /^version: (.+)$/m.exec(skill)?.[1]?.trim();
 * sit beside it and are opened when the task needs them. Copying \`SKILL.md\` alone left every one of those links
 * pointing at nothing.
 */
-var filesUnder$1 = (root, folder = root) => readdirSync(folder, { withFileTypes: true }).flatMap((entry) => {
+var filesUnder$2 = (root, folder = root) => readdirSync(folder, { withFileTypes: true }).flatMap((entry) => {
 	const path = join(folder, entry.name);
-	if (entry.isDirectory()) return filesUnder$1(root, path);
+	if (entry.isDirectory()) return filesUnder$2(root, path);
 	return entry.isFile() ? [[relative(root, path).split(sep).join("/"), readFileSync(path, "utf-8")]] : [];
 });
 /**
 * The skills a project carries: both for a project that renders a space, the CLI's alone for a plugin package. With
-* `root`, from the packages that project installed — what `plitzi skills update` brings it up to.
+* `root`, from the packages that project installed — what `plitzi upgrade skills` brings it up to.
 */
 var skillFiles = (names = SKILL_NAMES, root) => {
 	const resolvers = resolversFor(root);
@@ -2125,7 +2267,7 @@ var skillFiles = (names = SKILL_NAMES, root) => {
 		const entry = resolveFrom(resolvers, `${SKILLS[name]}/skills/${name}/SKILL.md`);
 		if (!entry) continue;
 		const version = versionOf(resolvers, SKILLS[name]);
-		for (const [path, content] of filesUnder$1(dirname(entry))) files[`.claude/skills/${name}/${path}`] = path === "SKILL.md" && version ? stampVersion(content, version) : content;
+		for (const [path, content] of filesUnder$2(dirname(entry))) files[`.claude/skills/${name}/${path}`] = path === "SKILL.md" && version ? stampVersion(content, version) : content;
 	}
 	return files;
 };
@@ -2143,24 +2285,27 @@ var skillFiles = (names = SKILL_NAMES, root) => {
 * signing up gives you cannot come apart.
 */
 /**
-* Writes the declaration out as documents.
+* Authors the declaration and says what it found: the check an agent and a person run after every change.
 *
-* Nothing in the project reads it — the server and the browser both author at boot — so it exists for the moment
-* the space has to go somewhere else: imported into Plitzi, handed to another server, or checked into a
-* repository with no TypeScript in it.
+* It writes nothing — the space is \`src/space.ts\`, and the server and the browser both author it at boot. Only the
+* server asks for the documents, while developing: \`--out <file>\` writes them where it re-reads them on a save.
 */
 var authorScript = () => `import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
+import path from 'node:path';
 
 import { authorSpace, planFixes, refusalOf, SpaceRefusedError } from '@plitzi/sdk-authoring';
+import { publicData } from '@plitzi/sdk-authoring/node';
 
 import { declarations } from './plugins/declarations.ts';
 import { space } from './space.ts';
 
 // \`--json\` answers in one object, for a tool or an agent; otherwise one line on success, the problems on failure.
 const json = process.argv.includes('--json');
+// \`--out <file>\`: where to write the documents — the server's, while developing. Left out, nothing is written.
+const out = process.argv.includes('--out') ? process.argv[process.argv.indexOf('--out') + 1] : undefined;
 
-/** How many of the problems said have one fix \`plitzi fix\` can write in this source — and the line that says so. */
+/** How many of the warnings and suggestions said have one fix \`plitzi fix\` can write in this source — and the line that says so. */
 const fixableHint = (): string | undefined => {
   let count: number;
   try {
@@ -2172,18 +2317,21 @@ const fixableHint = (): string | undefined => {
   return count === 0 ? undefined : \`[fix] \${count} of these have one fix: npx plitzi fix shows it in your source, --write writes it\`;
 };
 
-/**
- * The skill an agent reads was copied from the SDK at one version: a newer SDK has what the older skill never taught.
- * Both versions, when they differ — \`npx @plitzi/cli skills update\` brings the skill up to the SDK.
- */
-const outdatedSkill = (): { skill: string; sdk: string } | undefined => {
-  let skill: string | undefined;
+/** A file's text, or undefined when there is none to read. */
+const readOptional = (file: string): string | undefined => {
   try {
-    skill = /^version: (.+)$/m.exec(readFileSync('.claude/skills/plitzi-authoring/SKILL.md', 'utf-8'))?.[1]?.trim();
+    return readFileSync(file, 'utf-8');
   } catch {
     return undefined;
   }
+};
 
+/**
+ * What of the project is older than the SDK installed: the skill an agent reads, copied from the SDK at one version,
+ * and the files the CLI wrote (\`.plitzi/scaffold.json\`) — a newer SDK has what neither taught nor wired. Each version
+ * that differs — \`npx plitzi upgrade\` brings both up.
+ */
+const outdated = (): { skill?: string; files?: string; sdk: string } | undefined => {
   const manifest: unknown = JSON.parse(
     readFileSync(createRequire(import.meta.url).resolve('@plitzi/sdk-authoring/package.json'), 'utf-8')
   );
@@ -2191,44 +2339,64 @@ const outdatedSkill = (): { skill: string; sdk: string } | undefined => {
     typeof manifest === 'object' && manifest !== null && 'version' in manifest && typeof manifest.version === 'string'
       ? manifest.version
       : undefined;
+  const skill = /^version: (.+)$/m.exec(readOptional('.claude/skills/plitzi-authoring/SKILL.md') ?? '')?.[1]?.trim();
+  const record: unknown = JSON.parse(readOptional('.plitzi/scaffold.json') ?? 'null');
+  const files =
+    typeof record === 'object' && record !== null && 'cli' in record && typeof record.cli === 'string'
+      ? record.cli
+      : undefined;
+  if (!sdk || ((!skill || skill === sdk) && (!files || files === sdk))) {
+    return undefined;
+  }
 
-  return skill && sdk && skill !== sdk ? { skill, sdk } : undefined;
+  return { ...(skill && skill !== sdk ? { skill } : {}), ...(files && files !== sdk ? { files } : {}), sdk };
 };
 
 try {
-  const { schema, style, warnings, suggestions } = authorSpace(space, { plugins: declarations });
-  mkdirSync('space', { recursive: true });
-  writeFileSync('space/offline-data.json', \`\${JSON.stringify({ schema, style }, null, 2)}\\n\`);
+  // \`data\`: the files of \`public/\` a provider reads, so a binding onto a path one of them does not have is said here.
+  const { schema, style, warnings, suggestions } = authorSpace(space, {
+    plugins: declarations,
+    data: publicData(new URL('../public/', import.meta.url))
+  });
+  if (out) {
+    mkdirSync(path.dirname(out), { recursive: true });
+    writeFileSync(out, \`\${JSON.stringify({ schema, style }, null, 2)}\\n\`);
+  }
 
-  const outdated = outdatedSkill();
+  const behind = outdated();
   if (json) {
     console.log(
-      JSON.stringify({ ok: true, pages: schema.pages.length, warnings, suggestions, ...(outdated ? { outdated } : {}) })
+      JSON.stringify({ ok: true, pages: schema.pages.length, warnings, suggestions, ...(behind ? { outdated: behind } : {}) })
     );
   } else {
     for (const warning of warnings) {
       console.warn(\`[author] \${warning.code} · \${warning.message}\`);
     }
 
-    const hint = warnings.length > 0 ? fixableHint() : undefined;
-    if (hint) {
-      console.warn(hint);
-    }
-
     // Not problems: a shorter way to the same page, the one that saves the most elements first.
     for (const suggestion of suggestions) {
       const at = suggestion.at ? \` · \${suggestion.at}\` : '';
       console.warn(\`[suggest] \${suggestion.code} · \${suggestion.message} (saves \${suggestion.saves})\${at}\`);
     }
 
-    if (outdated) {
+    // After both: \`plitzi fix\` writes a warning's fix and a suggestion's alike, where it has one reading.
+    const hint = warnings.length + suggestions.length > 0 ? fixableHint() : undefined;
+    if (hint) {
+      console.warn(hint);
+    }
+
+    if (behind) {
+      const older = [
+        behind.skill ? \`the authoring skill is \${behind.skill}\` : '',
+        behind.files ? \`its files are from \${behind.files}\` : ''
+      ].filter(Boolean);
       console.warn(
-        \`[skills] the authoring skill is \${outdated.skill} and @plitzi/sdk-authoring is \${outdated.sdk}: npx @plitzi/cli skills update\`
+        \`[upgrade] \${older.join(' and ')}, and @plitzi/sdk-authoring is \${behind.sdk}: npx plitzi upgrade shows what changes, --write makes it\`
       );
     }
 
     console.log(
-      \`ok · \${schema.pages.length} pages · \${warnings.length} warnings · \${suggestions.length} suggestions · space/offline-data.json\`
+      \`ok · \${schema.pages.length} pages · \${warnings.length} warnings · \${suggestions.length} suggestions\`
     );
   }
 } catch (error) {
@@ -2327,7 +2495,7 @@ var spaceFiles = (answers) => {
 var RECORDED = `/** What \`npm start\` wrote down when it took a port: the port, and the name its \`/health\` answers with. */
 const recorded = (): { port?: number; name?: string } => {
   try {
-    const value: unknown = JSON.parse(readFileSync('.plitzi/dev-server.json', 'utf8'));
+    const value: unknown = JSON.parse(readFileSync('${DEV_SERVER_FILE}', 'utf8'));
     if (typeof value !== 'object' || value === null) {
       return {};
     }
@@ -2351,7 +2519,7 @@ const PORT = Number(process.env.PORT ?? recorded().port ?? ${mode === "server" ?
 
 export default defineConfig({
   testDir: './visual',
-  outputDir: './visual/.results',
+  outputDir: './${VISUAL_OUTPUT}',
   use: { baseURL: \`http://127.0.0.1:\${PORT}\` },
   // Playwright starts the project itself, so \`${runCommand(packageManager, "visual")}\` is one command from a
   // cold checkout.
@@ -2703,7 +2871,7 @@ var tsconfig = () => `{
 `;
 /** 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 gitignore = ({ packageManager, inProject }) => `node_modules\ndist\n*.zip\ntmp\n${packageManager === "yarn" && !inProject ? YARN_IGNORES : ""}`;
 var packageFiles = (names, answers) => ({
 	"package.json": packageJson(names, answers),
 	"tsconfig.json": tsconfig(),
@@ -2842,7 +3010,7 @@ var previewFiles = ([main, ...others]) => ({
 //#endregion
 //#region ../../packages/sdk-shared/dist/helpers/scroll.mjs
 var e = ["smooth", "auto"];
-var t = [
+var t$1 = [
 	"start",
 	"center",
 	"end",
@@ -2958,13 +3126,13 @@ var a$1 = {
 				type: "select",
 				description: "Where the element lands, top to bottom.",
 				default: "start",
-				options: [...t]
+				options: [...t$1]
 			},
 			inline: {
 				type: "select",
 				description: "Where it lands, side to side.",
 				default: "nearest",
-				options: [...t]
+				options: [...t$1]
 			},
 			behavior: r$2
 		}
@@ -3473,6 +3641,10 @@ const ${name} = ({ label = ${tsString(title)}, start = 0, step = 1, className }:
    * 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.
+   *
+   * Its \`style\` is inline, and inline outranks every class: what \`CARD\` sets — its display, its padding — the CSS
+   * authored on the element can never change. Keep it to what the element cannot render without, and leave layout and
+   * position (\`position\`, \`width\`, \`margin\`) to the space's classes.
    */
   return (
     <RootElement
@@ -3684,7 +3856,7 @@ const PORT = 5173;
 
 export default defineConfig({
   testDir: './visual',
-  outputDir: './visual/.results',
+  outputDir: './${VISUAL_OUTPUT}',
   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: {
@@ -3750,7 +3922,7 @@ var visualFiles = (elements, answers) => ({
 //#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"];
+var OUTPUTS = ["dist", "tmp"];
 /**
 * 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.
@@ -3815,6 +3987,35 @@ var scaffold = (answers) => ({
 	...visualFiles$1(answers),
 	...skillFiles()
 });
+/**
+* The files of a project that are this CLI's machinery rather than the project's own: what `plitzi upgrade` keeps up
+* with the CLI. Named, not inferred, so a file the scaffold starts a project with — its space, pages, plugins, data,
+* README, `.env` — can never be taken for one: those are the project's from the moment they are written.
+*
+* `package.json` is not among them: it is merged, never replaced (`upgrade packages`). Nor are the skills, which come
+* from the packages installed (`upgrade skills`).
+*/
+var MACHINERY = /* @__PURE__ */ new Set([
+	"src/author.ts",
+	"src/main.ts",
+	"src/preflight.css",
+	"index.html",
+	"vite.config.ts",
+	"tsconfig.json",
+	"tsconfig.build.json",
+	".gitignore",
+	"AGENTS.md",
+	"CLAUDE.md",
+	".prettierrc",
+	".prettierignore",
+	"eslint.config.mjs",
+	"playwright.config.ts",
+	"visual/home.spec.ts",
+	"src/plugins/README.md",
+	".yarnrc.yml",
+	"pnpm-workspace.yaml"
+]);
+var machineryFiles = (answers) => Object.fromEntries(Object.entries(scaffold(answers)).filter(([file]) => MACHINERY.has(file)));
 //#endregion
 //#region src/commands/existingProject.ts
 var LOCKFILES = [
@@ -3822,7 +4023,7 @@ var LOCKFILES = [
 	["pnpm-lock.yaml", "pnpm"],
 	["package-lock.json", "npm"]
 ];
-var exists = async (file) => {
+var exists$1 = async (file) => {
 	try {
 		await fs.access(file);
 		return true;
@@ -3853,7 +4054,7 @@ var workspaceGlobs = async (dir, packageJson) => {
 var nearestPackage = async (from) => {
 	let dir = from;
 	for (;;) {
-		if (await exists(path.join(dir, "package.json"))) return dir;
+		if (await exists$1(path.join(dir, "package.json"))) return dir;
 		const parent = path.dirname(dir);
 		if (parent === dir) return;
 		dir = parent;
@@ -3872,9 +4073,9 @@ var nearestWorkspace = async (from) => {
 	}
 };
 var lockfileManager = async (dirs) => {
-	for (const dir of dirs) for (const [file, manager] of LOCKFILES) if (await exists(path.join(dir, file))) return manager;
+	for (const dir of dirs) for (const [file, manager] of LOCKFILES) if (await exists$1(path.join(dir, file))) return manager;
 };
-var readText = async (file) => {
+var readText$1 = async (file) => {
 	try {
 		return await fs.readFile(file, "utf-8");
 	} catch {
@@ -3886,7 +4087,7 @@ var readText = async (file) => {
 * 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"))]);
+	const [elements, declarations] = await Promise.all([readText$1(path.join(root, "src/elements.ts")), readText$1(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;
@@ -3896,7 +4097,7 @@ var packageComponents = async (root) => {
 * 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"));
+	const listed = await readText$1(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;
@@ -3910,7 +4111,7 @@ var projectDeclared = async (root) => {
 *   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 {
+	if (packageJson.peerDependencies?.["@plitzi/plitzi-sdk"] && await exists$1(path.join(root, "src/elements.ts"))) return {
 		kind: "plugin",
 		components: await packageComponents(root)
 	};
@@ -3918,13 +4119,13 @@ var plitziProject = async (root, packageJson) => {
 		...packageJson.dependencies,
 		...packageJson.devDependencies
 	};
-	const main = await readText(path.join(root, "src/main.ts"));
+	const main = await readText$1(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",
+		source: await exists$1(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)
 	};
@@ -4230,12 +4431,16 @@ var loadProjectSpace = async (root) => {
 };
 //#endregion
 //#region src/commands/check.ts
-/** The space the project declares, authored — the handles say what each page owes. Only for one written here. */
-var projectHandles = async (root) => {
+/** The space the project declares, authored. Only for one written here. */
+var projectSpace = async (root) => {
 	const project = await loadProjectSpace(root);
 	if ("problem" in project) return { problem: `${project.problem} There is nothing to check the page against.` };
 	try {
-		return authorSpace(project.space, { plugins: project.plugins }).handles;
+		const { handles, schema } = authorSpace(project.space, { plugins: project.plugins });
+		return {
+			handles,
+			schema
+		};
 	} catch (error) {
 		return { problem: `The space does not author — npm run author says why: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}` };
 	}
@@ -4248,14 +4453,48 @@ var pageFor = (handles, pathname) => {
 		return segments.length === wanted.length && segments.every((segment, index) => segment.startsWith(":") || /^\{\{.*\}\}$/.test(segment) || segment === wanted[index]);
 	})?.id;
 };
-var checkAt = async (browser, origin, pathname, width, scheme, handles, asked) => {
-	const page = await browser.newPage({
-		viewport: {
-			width,
-			height: 900
-		},
-		colorScheme: scheme,
-		reducedMotion: "no-preference"
+/** The elements a piece of HTML carries, by the id each is marked with. */
+var markedIn = (html) => new Set([...html.matchAll(/data-plitzi-el="([^"]+)"/g)].map(([, id]) => id));
+/** The `runtime: 'server'` provider an element is inside — or is — if any: what the server's HTML owes. */
+var serverProviderOf = (schema, id) => {
+	const seen = /* @__PURE__ */ new Set();
+	let current = schema.flat[id];
+	while (current && !seen.has(current.id)) {
+		seen.add(current.id);
+		if (current.definition.type === "apiContainer" && current.definition.runtime === "server") return current.id;
+		const parent = current.definition.parentId;
+		current = parent ? schema.flat[parent] : void 0;
+	}
+};
+/**
+* What the page has once hydrated and the server's HTML did not: inside a server provider, an issue per provider — its
+* answer was meant to be in the page as it arrived; anywhere else, what the browser renders on its own, said apart.
+*/
+var lateElements = (schema, served, hydrated, width) => {
+	const late = [...new Set(hydrated)].filter((id) => !served.has(id));
+	const byProvider = /* @__PURE__ */ new Map();
+	const browserOnly = [];
+	for (const id of late) {
+		const provider = schema ? serverProviderOf(schema, id) : void 0;
+		if (provider) byProvider.set(provider, [...byProvider.get(provider) ?? [], id]);
+		else browserOnly.push(id);
+	}
+	return {
+		issues: [...byProvider].map(([provider, ids]) => ({
+			code: "not-server-rendered",
+			message: `apiContainer "${provider}" is resolved on the server, and ${String(ids.length)} of what it holds was not in the HTML the server sent (${ids.slice(0, 6).join(", ")}${ids.length > 6 ? ", …" : ""}) — it arrived after the page, so the first paint and a crawler miss it`,
+			elementId: provider,
+			width
+		})),
+		browserOnly
+	};
+};
+var checkAt = async (browser, origin, pathname, width, scheme, authored, asked, ssr) => {
+	const handles = authored?.handles;
+	const page = await openProjectPage(browser, origin, {
+		width,
+		height: 900,
+		...scheme ? { scheme } : {}
 	});
 	const consoleErrors = [];
 	const failedRequests = [];
@@ -4266,35 +4505,75 @@ var checkAt = async (browser, origin, pathname, width, scheme, handles, asked) =
 	page.on("response", (response) => {
 		if (response.status() >= 400 && response.url().startsWith(origin)) failedRequests.push(`${String(response.status())} ${response.url().slice(origin.length)}`);
 	});
-	if (!await page.goto(`${origin}${pathname}`, { waitUntil: "networkidle" }).catch(() => null)) return {
-		path: pathname,
-		width,
-		ok: false,
-		checked: 0,
-		problems: [`nothing answers at ${origin}${pathname}`],
-		consoleErrors,
-		failedRequests,
-		devTools: false
-	};
+	if (!await page.goto(`${origin}${pathname}`, { waitUntil: "networkidle" }).catch(() => null)) {
+		const issue = {
+			code: "no-answer",
+			message: `nothing answers at ${origin}${pathname}`,
+			width
+		};
+		return {
+			path: pathname,
+			width,
+			ok: false,
+			checked: 0,
+			problems: [issue.message],
+			issues: [issue],
+			hiddenAtWidth: [],
+			consoleErrors,
+			failedRequests,
+			devTools: false,
+			lists: {}
+		};
+	}
+	await withoutDevTools(page);
 	const pageId = handles ? pageFor(handles, pathname) : void 0;
 	const report = handles && pageId ? await inspectPage(page, handles, { page: pageId }) : await inspectDocument(page);
-	const devTools = await readDevTools(page, asked);
-	const problems = [
-		...handles && !pageId ? [`no page of the space answers at ${pathname}`] : [],
-		...report.problems,
-		...devTools.flows.filter((flow) => flow.status === "failed").map(failedFlowText)
+	const devTools = await readDevTools(page, {
+		...asked,
+		state: true
+	});
+	const data = authored && pageId && devTools.sources ? dataIssues(authored.schema, pageId, devTools.sources) : void 0;
+	const served = ssr ? markedIn(await (await fetch(`${origin}${pathname}`)).text()) : void 0;
+	const late = served ? lateElements(authored?.schema, served, await page.evaluate((selector) => Array.from(document.querySelectorAll(selector), (element) => element.getAttribute("data-plitzi-el") ?? ""), "[data-plitzi-el]"), width) : void 0;
+	const noPage = handles && !pageId ? [{
+		code: "no-page",
+		message: `no page of the space answers at ${pathname}`,
+		width
+	}] : [];
+	const failedFlows = devTools.flows.filter((flow) => flow.status === "failed").map((flow) => ({
+		code: "flow-failed",
+		message: failedFlowText(flow),
+		...flow.on === void 0 ? {} : { elementId: flow.on },
+		width
+	}));
+	const issues = [
+		...noPage,
+		...report.issues.map((issue) => ({
+			...issue,
+			width
+		})),
+		...(data?.issues ?? []).map((issue) => ({
+			...issue,
+			width
+		})),
+		...late?.issues ?? [],
+		...failedFlows
 	];
 	return {
 		path: pathname,
 		width,
-		ok: problems.length === 0 && consoleErrors.length === 0 && failedRequests.length === 0,
+		ok: issues.length === 0 && consoleErrors.length === 0 && failedRequests.length === 0,
 		checked: report.checked,
-		problems,
+		problems: issues.map((issue) => issue.message),
+		issues,
+		hiddenAtWidth: report.hiddenAtWidth,
 		consoleErrors,
 		failedRequests,
 		devTools: devTools.available,
-		...devTools.state === void 0 ? {} : { state: devTools.state },
-		...devTools.sources === void 0 ? {} : { sources: devTools.sources },
+		lists: data?.lists ?? {},
+		...late ? { browserOnly: late.browserOnly } : {},
+		...!asked.state || devTools.state === void 0 ? {} : { state: devTools.state },
+		...!asked.state || devTools.sources === void 0 ? {} : { sources: devTools.sources },
 		...devTools.element === void 0 ? {} : { element: devTools.element }
 	};
 };
@@ -4318,10 +4597,28 @@ var shapeOf = (value) => {
 	const text = value === void 0 ? "undefined" : JSON.stringify(value);
 	return text.length > 60 ? `${text.slice(0, 57)}…` : text;
 };
-var reportText = (report, asked) => {
+/** Each list's rows in a few words — `plan-list 3 rows` — so an empty one is seen, not inferred from a box. */
+var listsText = (lists) => {
+	const entries = Object.entries(lists);
+	if (entries.length === 0) return [];
+	const rows = entries.map(([id, count]) => `${id} ${count === null ? "reads nothing" : `${String(count)} row${count === 1 ? "" : "s"}`}`);
+	return [chalk.dim(`  · lists: ${rows.join(", ")}`)];
+};
+/** With `--ssr`, what only the browser renders — not a problem outside a server provider, and said so it is seen. */
+var browserOnlyText = (report) => report.browserOnly && report.browserOnly.length > 0 ? [chalk.dim(`  · rendered only in the browser, outside any server provider: ${report.browserOnly.slice(0, 10).join(", ")}${report.browserOnly.length > 10 ? `, … (${String(report.browserOnly.length)})` : ""}`)] : [];
+var reportText$1 = (report, asked) => {
 	const head = `${report.path} at ${String(report.width)} px`;
-	const held = heldText(report, asked);
-	if (report.ok) return [chalk.green(`✓ ${head} — ${report.checked > 0 ? `${String(report.checked)} elements on screen, ` : ""}nothing wrong`), ...held].join("\n");
+	const held = [
+		...listsText(report.lists),
+		...browserOnlyText(report),
+		...heldText(report, asked)
+	];
+	const atWidth = report.hiddenAtWidth.length > 0 ? chalk.dim(`  · hidden at this width by a breakpoint, on purpose: ${report.hiddenAtWidth.join(", ")}`) : void 0;
+	if (report.ok) return [
+		chalk.green(`✓ ${head} — ${report.checked > 0 ? `${String(report.checked)} elements on screen, ` : ""}nothing wrong`),
+		...atWidth ? [atWidth] : [],
+		...held
+	].join("\n");
 	return [
 		chalk.red(`✗ ${head}`),
 		...report.problems.map((problem) => `  - ${problem}`),
@@ -4339,9 +4636,9 @@ var check = async (route, options) => {
 		fail(where.problem);
 		return;
 	}
-	const handles = plitzi?.source === "local" ? await projectHandles(project.root) : void 0;
-	if (handles && "problem" in handles) {
-		fail(handles.problem);
+	const authored = plitzi?.source === "local" ? await projectSpace(project.root) : void 0;
+	if (authored && "problem" in authored) {
+		fail(authored.problem);
 		return;
 	}
 	const browser = await launchBrowser(project.root);
@@ -4351,14 +4648,14 @@ var check = async (route, options) => {
 	}
 	try {
 		const widths = options.width ?? [1440, 390];
-		const scheme = options.scheme ?? "light";
+		const { scheme } = options;
 		const asked = {
 			state: Boolean(options.state),
 			...options.element ? { element: options.element } : {}
 		};
 		const reports = [];
-		for (const width of widths) reports.push(await checkAt(browser, where.origin, route ?? "/", width, scheme, handles, asked));
-		console.log(options.json ? JSON.stringify(reports) : reports.map((report) => reportText(report, asked)).join("\n"));
+		for (const width of widths) reports.push(await checkAt(browser, where.origin, route ?? "/", width, scheme, authored, asked, Boolean(options.ssr)));
+		console.log(options.json ? JSON.stringify(reports) : reports.map((report) => reportText$1(report, asked)).join("\n"));
 		if (reports.some((report) => !report.ok)) process.exitCode = 1;
 	} finally {
 		await browser.close();
@@ -4416,6 +4713,15 @@ var writeFunctionsState = async (root, state) => {
 };
 /** The files that differ between two copies — added, removed or changed — sorted. */
 var changedFiles = (a, b) => [.../* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])].filter((file) => a[file] !== b[file]).sort();
+/**
+* What `functions/` holds that the space does not: nothing at all (`none`, no `functions/index.ts`), something changed
+* since it was pulled from this space or never pulled (`changed`), or exactly what was pulled (`unchanged`).
+*/
+var functionsChange = async (root, spaceId) => {
+	const [local, state] = await Promise.all([readLocal(root), readState(root)]);
+	if (!Object.hasOwn(local, "index.ts")) return "none";
+	return state?.space === spaceId && !changedFiles(local, state.files).length ? "unchanged" : "changed";
+};
 var taskList = (draft) => draft.manifest?.tasks.length ? draft.manifest.tasks.map((task) => `${task.namespace}.${task.action}`).join(", ") : "no tasks";
 var readDraft = async (connection, spaceId) => {
 	const answered = await authorizedRequest(connection, `/spaces/${spaceId}/functions`);
@@ -4468,30 +4774,29 @@ var printProblems = (problems) => {
 	});
 	process.exitCode = 1;
 };
-var pushFunctions = async (options) => {
-	const root = await rootOf();
-	const connection = root && await connectToSpace(options, "to push to");
-	if (!root || !connection || !connection.space) return;
+/**
+* `functions/` saved as the draft of the space the connection works in: refused when the space's copy moved on since the
+* pull, and — for a project that never pulled them — when the space already has functions of its own. `force` replaces
+* whatever the space holds now, which is what `plitzi push --force` asks of every part.
+*/
+var pushFunctionsOf = async (root, connection, space, { force = false } = {}) => {
 	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;
+		return "failed";
 	}
-	let base = state?.space === connection.space.id ? state.version : void 0;
+	if (state?.space === space.id && !changedFiles(local, state.files).length) return "unchanged";
+	let base = state?.space === space.id && !force ? 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;
+		const draft = await readDraft(connection, space.id);
+		if (!draft) return "failed";
+		if (Object.keys(draft.files).length && !force) {
+			fail(`${space.name} already has functions. Pull them first: plitzi functions pull.`);
+			return "failed";
 		}
 		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`, {
+	const answered = await authorizedRequest(connection, `/spaces/${space.id}/functions`, {
 		method: "PUT",
 		headers: { "Content-Type": "application/json" },
 		body: JSON.stringify({
@@ -4501,27 +4806,36 @@ var pushFunctions = async (options) => {
 	});
 	if (!answered.ok) {
 		fail(answered.error);
-		return;
+		return "failed";
 	}
 	const { reply } = answered.value;
 	if (reply.status === 422 && reply.data.problems) {
 		printProblems(reply.data.problems);
-		return;
+		return "failed";
 	}
 	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;
+		fail(`${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 "failed";
 	}
 	if (reply.status !== 200 || !reply.data.version) {
 		fail(reply.data.refusal?.error ?? reply.data.error ?? `The functions were not saved (${reply.status}).`);
-		return;
+		return "failed";
 	}
 	await writeFunctionsState(root, {
-		space: connection.space.id,
+		space: space.id,
 		version: reply.data.version,
 		files: local
 	});
-	console.log(chalk.green(`Pushed to ${connection.space.name}’s draft — ${taskList({ manifest: reply.data.manifest ?? null })}.`) + chalk.dim(" The live site runs them once the space is published."));
+	console.log(chalk.green(`Functions pushed to ${space.name}’s draft — ${taskList({ manifest: reply.data.manifest ?? null })}.`));
+	return "pushed";
+};
+var pushFunctions = async (options) => {
+	const root = await rootOf();
+	const connection = root && await connectToSpace(options, "to push to");
+	if (!root || !connection || !connection.space) return;
+	const outcome = await pushFunctionsOf(root, connection, connection.space);
+	if (outcome === "unchanged") console.log("Nothing to push: functions/ is what was pulled.");
+	else if (outcome === "pushed") console.log(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) => {
@@ -4820,7 +5134,7 @@ var fromSpaceMain = (options) => {
 import path from 'node:path';
 
 import { closeOnSignals, consoleLogger, ${local ? "createJsonAdapters" : "createCloudAdapters"}, createServer, loadFunctions } from '@plitzi/sdk-server';
-${hasRuntime ? importLine(`{ ${runtimeImports} }`, "@plitzi/sdk-server/runtime") : ""}${local ? `\n${importLine("{ authorSpace }", "@plitzi/sdk-authoring")}` : ""}
+${hasRuntime ? importLine(`{ ${runtimeImports} }`, "@plitzi/sdk-server/runtime") : ""}${local ? `\n${importLine("{ authorSpace }", "@plitzi/sdk-authoring")}${importLine("{ publicData }", "@plitzi/sdk-authoring/node")}` : ""}
 ${importLine("{ lookups }", "./actions.ts")}${local ? importLine("{ declarations }", "./plugins/declarations.ts") : ""}${runtimeEntry ? importLine("spaceRuntime", runtimeEntry) : ""}${local ? importLine("{ space }", "./space.ts") : ""}
 /**
  * The project's settings — the key its actions sign with, the variables the space was given on Plitzi — kept in \`.env\`,
@@ -4842,7 +5156,10 @@ ${builtPlugins ? BUILT_PLUGINS : ""}${local ? `
  * The space, held in this project: \`src/space/\`, authored at boot — saving a page and letting \`--watch\` restart is
  * the whole edit loop, and the warnings are printed where somebody editing it is watching.
  */
-const { schema, style, warnings } = authorSpace(space, { plugins: declarations${builtPlugins ? ", pluginTypes: builtTypes" : ""} });
+const { schema, style, warnings } = authorSpace(space, {
+  plugins: declarations,${builtPlugins ? "\n  pluginTypes: builtTypes," : ""}
+  data: publicData(new URL('../public/', import.meta.url))
+});
 
 for (const warning of warnings) {
   console.warn(\`[author] \${warning.message}\`);
@@ -4897,6 +5214,22 @@ var placeOf = (paths) => {
 	const prefix = paths.length > 0 && paths.every((path) => path.startsWith("src/")) ? "" : "src/";
 	return (path) => `${prefix}${path}`;
 };
+/**
+* Where the project keeps what the space's runtime and plugins are built from: the module the runtime starts at, and the
+* files each plugin's elements start at — the paths `create --from` writes them at, which `plitzi push` packs again.
+*/
+var projectEntries = ({ source }) => {
+	const place = placeOf(Object.keys(source.files));
+	const runtime = source.runtime?.entries[0];
+	return {
+		runtime: runtime ? place(runtime) : null,
+		plugins: source.plugins.map(({ type, entries }) => ({
+			type,
+			entries: entries.map(place)
+		})),
+		files: Object.keys(source.files).map(place)
+	};
+};
 /** The import `src/main.ts` names the runtime's module by. */
 var fromMain = (path) => `./${path.replace(/^src\//, "")}`;
 /** What the space was given on Plitzi, by name, as `.env.example` lists it — and `.env`, with values where they are known. */
@@ -5058,7 +5391,7 @@ var digestsOf = async (root, file, format) => {
 var readOrigin = async (root) => {
 	try {
 		const value = JSON.parse(await fs.readFile(path.join(root, ORIGIN_FILE), "utf-8"));
-		if (!e$1(value) || value.format !== 1 || typeof value.api !== "string" || !e$1(value.space) || typeof value.space.id !== "number" || typeof value.space.name !== "string" || typeof value.space.permanentUrl !== "string" || value.source !== "local" && value.source !== "cloud" || !e$1(value.version) || typeof value.version.environment !== "string" || value.version.revision !== void 0 && typeof value.version.revision !== "number" || !isStrings(value.files) || !isStrings(value.downloads) || !isStrings(value.dependencies)) return;
+		if (!e$1(value) || value.format !== 1 || typeof value.api !== "string" || !e$1(value.space) || typeof value.space.id !== "number" || typeof value.space.name !== "string" || typeof value.space.permanentUrl !== "string" || value.source !== "local" && value.source !== "cloud" || !e$1(value.version) || typeof value.version.environment !== "string" || value.version.revision !== void 0 && typeof value.version.revision !== "number" || value.draft !== void 0 && typeof value.draft !== "string" || !isStrings(value.files) || !isStrings(value.downloads) || !isStrings(value.dependencies)) return;
 		return {
 			format: 1,
 			api: value.api,
@@ -5072,6 +5405,7 @@ var readOrigin = async (root) => {
 				environment: value.version.environment,
 				...typeof value.version.revision === "number" ? { revision: value.version.revision } : {}
 			},
+			...typeof value.draft === "string" ? { draft: value.draft } : {},
 			files: value.files,
 			downloads: value.downloads,
 			dependencies: value.dependencies
@@ -5096,6 +5430,17 @@ var digestsOnDisk = async (root, files, format) => {
 	const digests = await Promise.all(files.map(async (file) => [file, (await digestsOf(root, file, format))?.formatted]));
 	return Object.fromEntries(digests.filter((entry) => entry[1] !== void 0));
 };
+/**
+* The files a space gives a project — its text as the project's formatter writes it, its binaries as they are — by
+* path: what a pull compares with what is on disk, and what a push records as given once the space holds the project.
+* The files of its CDN are not among them: they are fetched, and only when the space names another address for one.
+*/
+var givenFiles = async (project, format) => {
+	const given = /* @__PURE__ */ new Map();
+	for (const [file, text] of Object.entries(project.files)) given.set(file, Buffer.from(await format(file, text)));
+	Object.entries(project.binaries).forEach(([file, base64]) => given.set(file, Buffer.from(base64, "base64")));
+	return given;
+};
 //#endregion
 //#region src/commands/createFrom.ts
 /**
@@ -5110,30 +5455,49 @@ var versionLabel = ({ environment, revision }) => {
 	return revision ? `${environment} r${String(revision)}` : `${environment} (latest)`;
 };
 /**
-* A version of the space named — its id or its permanent URL — put together as a project, or why not, said and
-* `undefined`. `name` is what it is called in what is printed: `from`, unless a pull names it by its id.
+* A version of the space named — its id or its permanent URL — put together as a project, asked for on a connection that
+* is signed in: the export, or why not in words. `name` is what the space is called in them.
 */
-var fetchExport = async (api, from, { source, version, name = from }) => {
-	const connection = await signedIn(api, `to take ${from} out of Plitzi`);
-	if (!connection) return;
-	console.log(`\nTaking ${chalk.bold(name)} (${versionLabel(version)}) out of ${api}…`);
+var requestExport = async (connection, from, { source, version, name = from }) => {
 	const query = new URLSearchParams({
 		source,
 		environment: version.environment,
 		...version.revision ? { revision: String(version.revision) } : {}
 	});
 	const answered = await authorizedRequest(connection, `/spaces/${encodeURIComponent(from)}/export?${query.toString()}`);
-	if (!answered.ok) {
-		fail(answered.error);
-		return;
-	}
+	if (!answered.ok) return answered;
 	const { status, data } = answered.value.reply;
-	if (status === 200 && isExport(data)) return data;
+	if (status === 200 && isExport(data)) return {
+		ok: true,
+		value: data
+	};
 	const said = e$1(data) && typeof data.error === "string" ? data.error : void 0;
-	fail({
-		403: `You may not take ${from} out: it takes being able to change it — its owner, an administrator or a writer.`,
-		404: said ?? `There is no space ${from} you can reach.`
-	}[status] ?? said ?? `The platform would not hand ${from} over (${String(status)}).`);
+	return {
+		ok: false,
+		error: {
+			403: `You may not take ${name} out: it takes being able to change it — its owner, an administrator or a writer.`,
+			404: said ?? `There is no space ${name} you can reach.`
+		}[status] ?? said ?? `The platform would not hand ${name} over (${String(status)}).`
+	};
+};
+/**
+* A version of the space named put together as a project — signing in first when there is no session — or why not,
+* said and `undefined`. `name` is what it is called in what is printed: `from`, unless a pull names it by its id.
+*/
+var fetchExport = async (api, from, { source, version, name = from }) => {
+	const connection = await signedIn(api, `to take ${from} out of Plitzi`);
+	if (!connection) return;
+	console.log(`\nTaking ${chalk.bold(name)} (${versionLabel(version)}) out of ${api}…`);
+	const exported = await requestExport(connection, from, {
+		source,
+		version,
+		name
+	});
+	if (!exported.ok) {
+		fail(exported.error);
+		return;
+	}
+	return exported.value;
 };
 /** A file of the space's CDN, fetched. */
 var download = async (url) => {
@@ -5181,6 +5545,7 @@ var recordOrigin = async (root, { api, exported, source, pinned, project }) => {
 			environment: exported.version.environment,
 			...pinned ? { revision: exported.version.revision } : {}
 		},
+		...exported.draft ? { draft: exported.draft } : {},
 		files,
 		downloads: Object.fromEntries(project.downloads.filter(({ to }) => Object.hasOwn(files, to)).map(({ url, to }) => [to, url])),
 		dependencies: project.dependencies
@@ -5192,6 +5557,43 @@ var recordOrigin = async (root, { api, exported, source, pinned, project }) => {
 	});
 };
 //#endregion
+//#region src/commands/scaffoldRecord.ts
+/**
+* What the CLI last wrote of a project's machinery (`machineryFiles`): a digest of each file as it was written, never
+* the file — as `.plitzi/space.json` keeps of what a pull wrote. Enough for `plitzi upgrade` to tell a file nobody
+* touched since, which it may replace, from one somebody made their own, which it only shows.
+*
+* Kept where the CLI keeps its other state. A project without one — made before it existed, or a clone that did not
+* carry it — is not refused anything: every file that differs is then shown as the project's, for its author to take.
+*/
+var SCAFFOLD_RECORD_FILE = path.join(".plitzi", "scaffold.json");
+var digestOf = (contents) => createHash("sha256").update(contents).digest("hex");
+var readScaffoldRecord = async (root) => {
+	let parsed;
+	try {
+		parsed = JSON.parse(await fs.readFile(path.join(root, SCAFFOLD_RECORD_FILE), "utf-8"));
+	} catch {
+		return;
+	}
+	if (!e$1(parsed) || parsed.format !== 1 || typeof parsed.cli !== "string" || !e$1(parsed.files)) return;
+	const files = Object.fromEntries(Object.entries(parsed.files).filter((entry) => typeof entry[1] === "string"));
+	return {
+		format: 1,
+		cli: parsed.cli,
+		files
+	};
+};
+/** What the CLI wrote, file → its digest (`digestOf`), as `cli` wrote it. */
+var writeScaffoldRecord = async (root, cli, digests) => {
+	const record = {
+		format: 1,
+		cli,
+		files: Object.fromEntries(Object.entries(digests).sort(([a], [b]) => a.localeCompare(b)))
+	};
+	await fs.mkdir(path.join(root, ".plitzi"), { recursive: true });
+	await fs.writeFile(path.join(root, SCAFFOLD_RECORD_FILE), `${JSON.stringify(record, null, 2)}\n`);
+};
+//#endregion
 //#region src/commands/create.ts
 var MODES = ["server", "client"];
 var SOURCES = ["local", "cloud"];
@@ -5349,6 +5751,7 @@ var create = async (directory, options) => {
 		".env": envFromSpace(exported, answers, randomBytes(32).toString("hex"))
 	} : files);
 	const missing = fromSpace ? await writeFromSpace(target, fromSpace) : [];
+	await writeScaffoldRecord(target, CLI_VERSION, Object.fromEntries(Object.keys(machineryFiles(answers)).filter((file) => file in files).map((file) => [file, digestOf(files[file])])));
 	const wantsInstall = options.install !== false;
 	const installed = wantsInstall && await install(packageManager, target);
 	/**
@@ -5710,7 +6113,7 @@ var explainCommand = (name, options) => {
 	}
 	const explanations = explain(name);
 	if (explanations.length === 0) {
-		fail(`"${name}" is no element, step, trigger, code or transformer. See what there is: --list ${kinds}.`);
+		fail(`"${name}" is no element, step, trigger, code, transformer or helper. See what there is: --list ${kinds}.`);
 		return;
 	}
 	console.log(options.json ? JSON.stringify(explanations) : explanations.map(explanationText).join("\n\n"));
@@ -5815,6 +6218,7 @@ var verdict = (before, written, after) => {
 };
 //#endregion
 //#region src/fix/sourceEdits.ts
+var one = (change) => ({ changes: [change] });
 var SINGLE = "'";
 var quoted = (text) => `${SINGLE}${text.replace(/\\/g, "\\\\").replaceAll(SINGLE, `\\${SINGLE}`)}${SINGLE}`;
 var literalText = (value) => typeof value === "string" ? quoted(value) : String(value);
@@ -5910,27 +6314,27 @@ var editKey = (ts, sourceFile, object, nested, edit) => {
 	const property = holder ? findProperty(ts, holder, edit.key) : void 0;
 	if (edit.op === "set") {
 		if (edit.value === void 0) return { unplaced: "there is no value to write" };
-		if (!holder || !property) return { change: insertInto(sourceFile, inner ?? object, edit.key, literalText(edit.value)) };
+		if (!holder || !property) return one(insertInto(sourceFile, inner ?? object, edit.key, literalText(edit.value)));
 		if (!ts.isPropertyAssignment(property) || !isLiteral(ts, property.initializer)) return { unplaced: `\`${edit.key}\` is not written as a value there` };
-		return { change: {
+		return one({
 			start: property.initializer.getStart(sourceFile),
 			end: property.initializer.getEnd(),
 			text: literalText(edit.value)
-		} };
+		});
 	}
 	if (!holder || !property) return { unplaced: `\`${edit.key}\` is not written in that call` };
-	if (edit.op === "remove") return { change: removeFromList(sourceFile, holder.properties, holder.properties.indexOf(property)) };
+	if (edit.op === "remove") return one(removeFromList(sourceFile, holder.properties, holder.properties.indexOf(property)));
 	if (edit.op === "rename" && edit.to !== void 0) {
-		if (ts.isShorthandPropertyAssignment(property)) return { change: {
+		if (ts.isShorthandPropertyAssignment(property)) return one({
 			start: property.getStart(sourceFile),
 			end: property.getEnd(),
 			text: `${keyText(edit.to)}: ${property.name.text}`
-		} };
-		if (ts.isPropertyAssignment(property)) return { change: {
+		});
+		if (ts.isPropertyAssignment(property)) return one({
 			start: property.name.getStart(sourceFile),
 			end: property.name.getEnd(),
 			text: keyText(edit.to)
-		} };
+		});
 	}
 	return { unplaced: `\`${edit.key}\` is not a property that edit applies to` };
 };
@@ -5946,18 +6350,18 @@ var editBinding = (ts, sourceFile, props, edit) => {
 			ts.forEachChild(node, visit);
 		};
 		visit(list);
-		return found ? { change: {
+		return found ? one({
 			start: found.getStart(sourceFile),
 			end: found.getEnd(),
 			text: quoted(edit.to)
-		} } : { unplaced: `"${edit.key}" is not written as a transformer there` };
+		}) : { unplaced: `"${edit.key}" is not written as a transformer there` };
 	}
 	if (edit.op !== "remove") return { unplaced: "that change to a binding has no one way to be written" };
-	const dropBind = () => ({ change: removeFromList(sourceFile, props.properties, props.properties.indexOf(bind)) });
+	const dropBind = () => one(removeFromList(sourceFile, props.properties, props.properties.indexOf(bind)));
 	if (ts.isObjectLiteralExpression(list)) {
 		const property = findProperty(ts, list, edit.key);
 		if (!property) return { unplaced: `the binding onto "${edit.key}" is not written there` };
-		return list.properties.length === 1 ? dropBind() : { change: removeFromList(sourceFile, list.properties, list.properties.indexOf(property)) };
+		return list.properties.length === 1 ? dropBind() : one(removeFromList(sourceFile, list.properties, list.properties.indexOf(property)));
 	}
 	if (ts.isArrayLiteralExpression(list)) {
 		const index = list.elements.findIndex((entry) => {
@@ -5966,10 +6370,95 @@ var editBinding = (ts, sourceFile, props, edit) => {
 			return to !== void 0 && ts.isPropertyAssignment(to) && ts.isStringLiteral(to.initializer) && to.initializer.text === edit.key;
 		});
 		if (index === -1) return { unplaced: `the binding onto "${edit.key}" is not written there` };
-		return list.elements.length === 1 ? dropBind() : { change: removeFromList(sourceFile, list.elements, index) };
+		return list.elements.length === 1 ? dropBind() : one(removeFromList(sourceFile, list.elements, index));
 	}
 	return { unplaced: "`bind` is not written as a literal there" };
 };
+/** The factories a child of the moved kind is written with: what a move may leave imported and unused. */
+var WORD_FACTORIES = ["text", "fontAwesome"];
+/**
+* `children: [text(words), fontAwesome({ icon })]` written as the element's own `content: words, icon` — the words
+* kept as written, a literal or an expression (`entry.label`). Only children written exactly so are moved: a `text`
+* handed options (a class, an id) or an icon with more than its class is something the element's own attributes would
+* not say, and is left for the author.
+*/
+var moveChildrenToContent = (ts, sourceFile, props, edit) => {
+	const children = findProperty(ts, props, "children");
+	if (!children || !ts.isPropertyAssignment(children) || !ts.isArrayLiteralExpression(children.initializer)) return { unplaced: "`children` is not written as a list there" };
+	let words;
+	let icon;
+	for (const child of children.initializer.elements) {
+		const call = ts.isCallExpression(child) && ts.isIdentifier(child.expression) && child.arguments.length === 1 ? {
+			factory: child.expression.text,
+			argument: child.arguments[0]
+		} : void 0;
+		if (call?.factory === "text" && !words) {
+			words = call.argument;
+			continue;
+		}
+		const iconProperty = call?.factory === "fontAwesome" && ts.isObjectLiteralExpression(call.argument) && call.argument.properties.length === 1 ? findProperty(ts, call.argument, "icon") : void 0;
+		if (iconProperty && ts.isPropertyAssignment(iconProperty) && !icon) {
+			icon = iconProperty.initializer;
+			continue;
+		}
+		return { unplaced: "a child carries more than its words or its icon there" };
+	}
+	if (Boolean(icon) !== (edit.icon !== void 0) || words === void 0 && edit.value !== "") return { unplaced: "the children written there are not the ones it holds" };
+	if (words && ts.isStringLiteral(words) && words.text !== edit.value) return { unplaced: "the words written there are not the ones it shows" };
+	if (icon && findProperty(ts, props, "icon")) return { unplaced: "it is written with an `icon` of its own already" };
+	const content = findProperty(ts, props, "content");
+	if (content && words && !(ts.isPropertyAssignment(content) && ts.isStringLiteral(content.initializer) && content.initializer.text === "")) return { unplaced: "it is written with words of its own beside its children" };
+	const written = [
+		words && `content: ${words.getText(sourceFile)}`,
+		icon && `icon: ${icon.getText(sourceFile)}`,
+		edit.iconPlacement && `iconPlacement: ${quoted(edit.iconPlacement)}`
+	].filter((part) => Boolean(part));
+	return {
+		changes: [...content && words ? [removeFromList(sourceFile, props.properties, props.properties.indexOf(content))] : [], {
+			start: children.getStart(sourceFile),
+			end: children.getEnd(),
+			text: written.join(", ")
+		}],
+		orphans: WORD_FACTORIES
+	};
+};
+/**
+* The named imports among `names` that nothing in the file uses any longer — what a move left behind, taken out with
+* the import that held only them.
+*/
+var pruneImports = (ts, fileName, text, names) => {
+	const sourceFile = ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const used = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (ts.isIdentifier(node) && !ts.isImportSpecifier(node.parent)) used.add(node.text);
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	const changes = [];
+	for (const statement of sourceFile.statements) {
+		const clause = ts.isImportDeclaration(statement) ? statement.importClause : void 0;
+		const bindings = clause?.namedBindings;
+		if (!clause || !bindings || !ts.isNamedImports(bindings)) continue;
+		const elements = bindings.elements;
+		const unused = elements.filter((element) => names.includes(element.name.text) && !used.has(element.name.text));
+		if (unused.length === 0) continue;
+		if (unused.length === elements.length && !clause.name) {
+			changes.push({
+				start: statement.getFullStart(),
+				end: statement.getEnd(),
+				text: ""
+			});
+			continue;
+		}
+		const kept = elements.filter((element) => !unused.includes(element));
+		changes.push({
+			start: bindings.getStart(sourceFile),
+			end: bindings.getEnd(),
+			text: `{ ${kept.map((element) => element.getText(sourceFile)).join(", ")} }`
+		});
+	}
+	return applyChanges(text, changes) ?? text;
+};
 /**
 * What an edit planned on a spec changes in the source that wrote it: the call at its position, the props it was
 * handed, and in them only what is written as a literal. Anything else — a value computed, props spread from a
@@ -5981,6 +6470,7 @@ var sourceEdit = (ts, sourceFile, position, edit) => {
 	const props = propsOf(ts, call);
 	if (!props) return { unplaced: "the call that wrote it was handed no props to edit" };
 	if (edit.on === "binding") return editBinding(ts, sourceFile, props, edit);
+	if (edit.on === "children") return moveChildrenToContent(ts, sourceFile, props, edit);
 	if (edit.on === "step") {
 		const step = edit.step ? stepIn(ts, props, edit.step.flow, edit.step.index) : void 0;
 		return step ? editKey(ts, sourceFile, step, "params", edit) : { unplaced: "the step is not written in that call" };
@@ -6047,7 +6537,8 @@ var editSources = async (root, fixes) => {
 		else placed.push({
 			fix,
 			file,
-			change: outcome.change
+			changes: outcome.changes,
+			orphans: outcome.orphans ?? []
 		});
 	}
 	const format = await projectFormatter(root);
@@ -6055,7 +6546,7 @@ var editSources = async (root, fixes) => {
 	const written = [];
 	for (const [file, { text }] of sources) {
 		const mine = placed.filter((entry) => entry.file === file);
-		const changed = applyChanges(text, mine.map((entry) => entry.change));
+		const changed = applyChanges(text, mine.flatMap((entry) => entry.changes));
 		if (changed === void 0) {
 			left.push(...mine.map((entry) => ({
 				fix: entry.fix,
@@ -6064,10 +6555,12 @@ var editSources = async (root, fixes) => {
 			continue;
 		}
 		if (mine.length > 0) {
+			const orphans = [...new Set(mine.flatMap((entry) => entry.orphans))];
+			const pruned = ts && orphans.length > 0 ? pruneImports(ts, file, changed, orphans) : changed;
 			files.push({
 				file,
 				before: text,
-				after: await formatLikeBefore(format, path.relative(root, file), text, changed)
+				after: await formatLikeBefore(format, path.relative(root, file), text, pruned)
 			});
 			written.push(...mine.map((entry) => entry.fix));
 		}
@@ -6258,18 +6751,18 @@ var measure = async (browser, url, width, scheme, read = []) => {
 	};
 };
 /** Every file under a folder, by its path inside it — none when there is no such folder. */
-var filesUnder = async (folder) => {
+var filesUnder$1 = async (folder) => {
 	return (await readdir(folder, {
 		recursive: true,
 		withFileTypes: true
 	}).catch(() => [])).filter((entry) => entry.isFile()).map((entry) => path.relative(folder, path.join(entry.parentPath, entry.name)));
 };
-var count = (amount, one, many = `${one}s`) => `${String(amount)} ${amount === 1 ? one : many}`;
+var count$1 = (amount, one, many = `${one}s`) => `${String(amount)} ${amount === 1 ? one : many}`;
 var summaryText = (summary, out, stale) => [
 	chalk.green(`Imported ${summary.url} into ${out}`),
-	`  tokens   ${count(summary.colours, "colour")} (${summary.dark ? "light and dark" : "no dark scheme: dark repeats light"}), ${count(summary.shadows, "shadow")}, ${count(summary.radii, "radius", "radii")}${summary.fonts.length > 0 ? `, fonts ${summary.fonts.join(", ")}` : ""}`,
-	`  outline  ${count(summary.blocks, "block")} at ${summary.widths.join(", ")} px`,
-	...summary.lists.length > 0 ? [`  lists    ${summary.lists.map((list) => `${list.file} (${count(list.rows, "row")})`).join(", ")}`] : [],
+	`  tokens   ${count$1(summary.colours, "colour")} (${summary.dark ? "light and dark" : "no dark scheme: dark repeats light"}), ${count$1(summary.shadows, "shadow")}, ${count$1(summary.radii, "radius", "radii")}${summary.fonts.length > 0 ? `, fonts ${summary.fonts.join(", ")}` : ""}`,
+	`  outline  ${count$1(summary.blocks, "block")} at ${summary.widths.join(", ")} px`,
+	...summary.lists.length > 0 ? [`  lists    ${summary.lists.map((list) => `${list.file} (${count$1(list.rows, "row")})`).join(", ")}`] : [],
 	`  pictures ${String(summary.pictures)} in assets.json`,
 	...stale.length > 0 ? [chalk.yellow(`  earlier  ${stale.join(", ")} ${stale.length === 1 ? "was" : "were"} there before and not written this time: delete what is stale`)] : [],
 	`  next     ${path.join(out, "IMPORT.md")} says what was not carried over`
@@ -6294,7 +6787,7 @@ var importPage = async (address, options) => {
 		fail(`${out} is outside the project: the import is written inside it.`);
 		return;
 	}
-	const existing = await filesUnder(target);
+	const existing = await filesUnder$1(target);
 	if (existing.length > 0 && !options.force) {
 		fail(`${out} already has files: choose another --out, or --force to write over them.`);
 		return;
@@ -6392,16 +6885,16 @@ var a = [
 		pattern: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/
 	}
 ];
-var o = (e) => {
+var o$1 = (e) => {
 	let t = e.split("/");
 	if (!e || e.startsWith("/") || /^[a-zA-Z]:/.test(e) || e.includes("\\")) return `"${e}" is not a path relative to the project, with forward slashes`;
 	if (t.some((e) => e === "" || e === "." || e === "..")) return `"${e}" climbs out of the project, or has an empty part`;
 	if (t.some((e) => e === "node_modules" || e === ".git")) return `"${e}" is in node_modules or .git: a package is a dependency, not a file of the project`;
 	if (i.some((t) => t.test(e))) return `"${e}" is a file of credentials: they stay where the project runs, never in what Plitzi keeps`;
 };
-var s = (e) => a.find(({ pattern: t }) => t.test(e))?.what;
-var c = (e) => typeof e == "string" && r.some((t) => t === e);
-var l = (e) => typeof e == "string" && /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(e);
+var s$1 = (e) => a.find(({ pattern: t }) => t.test(e))?.what;
+var c$1 = (e) => typeof e == "string" && r.some((t) => t === e);
+var l$1 = (e) => typeof e == "string" && /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(e);
 var u = (e) => Array.isArray(e) && e.length > 0 && e.every((e) => typeof e == "string");
 var d = (t) => e$1(t) && Object.values(t).every((e) => typeof e == "string");
 var f = (e) => Math.floor(e.length * 3 / 4) - (e.endsWith("==") ? 2 : +!!e.endsWith("="));
@@ -6411,7 +6904,7 @@ var p = (t, i) => {
 		problems: ["Not a source snapshot of format 1"]
 	};
 	let { kind: a, name: p, entries: m, files: h, dependencies: g } = t, _ = [];
-	if (c(a) || _.push(`Its kind is one of ${r.join(", ")}`), l(p) || _.push("Its name is a plugin type or \"runtime\": letters, digits, dashes and underscores"), !d(h) || !d(g)) return {
+	if (c$1(a) || _.push(`Its kind is one of ${r.join(", ")}`), l$1(p) || _.push("Its name is a plugin type or \"runtime\": letters, digits, dashes and underscores"), !d(h) || !d(g)) return {
 		ok: !1,
 		problems: [..._, "Its files and dependencies are maps of text"]
 	};
@@ -6420,7 +6913,7 @@ var p = (t, i) => {
 	v.length > n.files && _.push(`It holds ${String(v.length)} files; a snapshot holds at most ${String(n.files)}`);
 	let y = 0;
 	return v.forEach((e) => {
-		let t = o(e);
+		let t = o$1(e);
 		if (t) {
 			_.push(t);
 			return;
@@ -6430,9 +6923,9 @@ var p = (t, i) => {
 			_.push(`"${e}" is ${(r / 1024 / 1024).toFixed(1)} MB; a file of source is at most 4 MB`);
 			return;
 		}
-		let a = s(i(h[e]));
+		let a = s$1(i(h[e]));
 		a && _.push(`"${e}" holds ${a}: take it out of the code and give it to the project as a variable`);
-	}), y > n.totalBytes && _.push(`It holds ${(y / 1024 / 1024).toFixed(1)} MB of files; a snapshot holds at most 24 MB`), _.length > 0 || !c(a) || !l(p) || !u(m) ? {
+	}), y > n.totalBytes && _.push(`It holds ${(y / 1024 / 1024).toFixed(1)} MB of files; a snapshot holds at most 24 MB`), _.length > 0 || !c$1(a) || !l$1(p) || !u(m) ? {
 		ok: !1,
 		problems: _
 	} : {
@@ -7050,9 +7543,7 @@ var pull = async (options) => {
 	if (!exported) return;
 	const next = projectFromSpace(exported, origin.source);
 	const format = await projectFormatter(root);
-	const given = /* @__PURE__ */ new Map();
-	for (const [file, text] of Object.entries(next.files)) given.set(file, Buffer.from(await format(file, text)));
-	Object.entries(next.binaries).forEach(([file, base64]) => given.set(file, Buffer.from(base64, "base64")));
+	const given = await givenFiles(next, format);
 	const missing = [];
 	const untouched = /* @__PURE__ */ new Set();
 	for (const { url, to } of next.downloads) {
@@ -7099,10 +7590,12 @@ var pull = async (options) => {
 	if (dependencies.changed.length > 0) await fs.writeFile(packageFile, `${JSON.stringify(dependencies.manifest, null, 2)}\n`);
 	const files = Object.fromEntries([...[...given].map(([file, bytes]) => [file, digest(bytes)]), ...[...untouched].flatMap((file) => origin.files[file] ? [[file, origin.files[file]]] : [])]);
 	await writeOrigin(root, {
-		...origin,
+		format: origin.format,
 		api,
+		source: origin.source,
 		space: exported.space,
 		version: asked.version,
+		...exported.draft ? { draft: exported.draft } : {},
 		files,
 		downloads: Object.fromEntries(next.downloads.flatMap(({ url, to }) => {
 			if (given.has(to)) return [[to, url]];
@@ -7136,25 +7629,221 @@ var pull = async (options) => {
 	console.log("");
 };
 //#endregion
-//#region src/commands/keepSource.ts
-/**
-* A packed source snapshot sent beside what was just uploaded or pushed, and kept on the space (docs/en/projects-from-spaces.md): what lets
-* `plitzi create --from` take the space back out as a project. Never undoes what went up before it — the plugin or the
-* runtime runs either way — so a refusal is said, with why, and the command still succeeds.
-*/
-var keepSource = async (connection, spaceId, bytes) => {
-	const sent = await authorizedRequest(connection, `/spaces/${String(spaceId)}/sources`, {
-		method: "PUT",
-		headers: { "Content-Type": "application/octet-stream" },
-		body: new Uint8Array(bytes)
-	});
-	if (!sent.ok) {
-		console.log(chalk.yellow(`  Its source is not kept: ${sent.error}`));
-		return;
+//#region src/commands/askChecks.ts
+/** What a key does to the list: a new state, or the end of the question — taken or given up. */
+var checksAfter = (state, key) => {
+	const count = state.checked.length;
+	if (key.name === "escape" || key.ctrl && key.name === "c") return "cancel";
+	if (key.name === "return" || key.name === "enter") return "done";
+	if (key.name === "up" || key.name === "k") return {
+		...state,
+		cursor: (state.cursor - 1 + count) % count
+	};
+	if (key.name === "down" || key.name === "j") return {
+		...state,
+		cursor: (state.cursor + 1) % count
+	};
+	if (key.name === "space") return {
+		...state,
+		checked: state.checked.map((on, index) => index === state.cursor ? !on : on)
+	};
+	if (key.name === "a") {
+		const all = state.checked.every(Boolean);
+		return {
+			...state,
+			checked: state.checked.map(() => !all)
+		};
 	}
-	const { status, data } = sent.value.reply;
-	if (status === 200 && data.ok) {
-		console.log(chalk.dim(`  Its source too (${String(data.files ?? 0)} files): plitzi create --from can take it back out.`));
+	return state;
+};
+/** The list as it is drawn: the question, a line per option, and the keys. */
+var renderChecks = (question, options, state) => [
+	chalk.bold(question),
+	...options.map(({ label, hint }, index) => {
+		return `${index === state.cursor ? chalk.cyan("›") : " "} ${state.checked[index] ? chalk.green("[x]") : "[ ]"} ${label}${hint ? chalk.dim(`  ${hint}`) : ""}`;
+	}),
+	chalk.dim("  ↑/↓ move · space ticks · a all · enter takes · esc cancels")
+];
+/** What is ticked once the person takes the list — `undefined` when they give it up. */
+var askChecks = async (question, options) => {
+	const { stdin, stdout } = process;
+	let state = {
+		cursor: 0,
+		checked: options.map(({ checked }) => checked)
+	};
+	let drawn = 0;
+	const draw = () => {
+		const lines = renderChecks(question, options, state);
+		stdout.write(`${drawn ? `\x1b[${String(drawn)}A\x1b[0J` : ""}${lines.join("\n")}\n`);
+		drawn = lines.length;
+	};
+	emitKeypressEvents(stdin);
+	const wasRaw = stdin.isRaw;
+	stdin.setRawMode(true);
+	stdin.resume();
+	stdout.write("\x1B[?25l");
+	draw();
+	return new Promise((resolve) => {
+		const onKey = (_text, key) => {
+			const next = checksAfter(state, key ?? {});
+			if (next !== "done" && next !== "cancel") {
+				state = next;
+				draw();
+				return;
+			}
+			stdin.off("keypress", onKey);
+			stdin.setRawMode(wasRaw);
+			stdin.pause();
+			stdout.write("\x1B[?25h");
+			resolve(next === "done" ? options.filter((_option, index) => state.checked[index]).map(({ value }) => value) : void 0);
+		};
+		stdin.on("keypress", onKey);
+	});
+};
+//#endregion
+//#region src/commands/pushSpace.ts
+/** The JSON documents of a folder, by file: none when there is no such folder. */
+var readJsonFolder = async (dir) => {
+	let files;
+	try {
+		files = (await fs.readdir(dir)).filter((file) => file.endsWith(".json")).sort();
+	} catch {
+		return;
+	}
+	return Promise.all(files.map(async (file) => ({
+		file,
+		value: JSON.parse(await fs.readFile(path.join(dir, file), "utf-8"))
+	})));
+};
+/** The project's server actions, as its `src/actions.ts` serves them — `undefined` when it has no such module. */
+var projectActions = async (root) => {
+	const file = path.join(root, "src/actions.ts");
+	try {
+		await fs.access(file);
+	} catch {
+		return;
+	}
+	const loaded = await import(pathToFileURL(file).href);
+	const lookups = e$1(loaded) && e$1(loaded.lookups) ? loaded.lookups : void 0;
+	if (!lookups || typeof lookups.listActions !== "function") return { problem: "src/actions.ts exports no `lookups` with a listActions: it is where the project’s actions are." };
+	const listed = await lookups.listActions();
+	if (!Array.isArray(listed)) return { problem: "src/actions.ts: lookups.listActions() answers no list." };
+	return listed.flatMap((entry) => e$1(entry) && typeof entry.id === "string" && e$1(entry.document) ? [{
+		identifier: entry.id,
+		name: typeof entry.document.name === "string" ? entry.document.name : entry.id,
+		document: entry.document
+	}] : []);
+};
+/** The connectors in `src/connectors/`, one manifest a file — `undefined` when there is no such folder. */
+var projectConnectors = async (root) => {
+	const read = await readJsonFolder(path.join(root, "src/connectors"));
+	if (!read) return;
+	const broken = read.find(({ value }) => !e$1(value) || typeof value.id !== "string" || !e$1(value.manifest));
+	return broken ? { problem: `src/connectors/${broken.file} is not a connector: { "id", "name", "manifest" }.` } : read.flatMap(({ value }) => e$1(value) && typeof value.id === "string" && e$1(value.manifest) ? [{
+		identifier: value.id,
+		name: typeof value.name === "string" ? value.name : value.id,
+		manifest: value.manifest
+	}] : []);
+};
+/** The element types of plugins the project runs as they were built (`vendor/plugins/<type>/`): authored as known. */
+var builtPluginTypes = async (root) => {
+	try {
+		return (await fs.readdir(path.join(root, "vendor/plugins"), { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	} catch {
+		return [];
+	}
+};
+var count = (entries, noun) => entries ? `${String(entries.length)} ${noun}${entries.length === 1 ? "" : "s"}` : `the space’s ${noun}s as they are`;
+/**
+* The project's space sent as the draft of the space the connection works in: refused when the draft moved on since
+* `base` (the draft the project last had), or — with no base — when the space holds work of its own; `force` takes it
+* anyway.
+*/
+var pushSpaceOf = async (root, connection, space, { base, force }) => {
+	const project = await loadProjectSpace(root);
+	if ("problem" in project) {
+		fail(project.problem);
+		return { outcome: "failed" };
+	}
+	let documents;
+	try {
+		const { schema, style } = authorSpace(project.space, {
+			plugins: project.plugins,
+			pluginTypes: await builtPluginTypes(root)
+		});
+		documents = {
+			schema,
+			style
+		};
+	} catch (error) {
+		fail(`The space does not author, so nothing was pushed — npm run author says why:\n${String(error instanceof Error ? error.message : error)}`);
+		return { outcome: "failed" };
+	}
+	const [actions, connectors] = await Promise.all([projectActions(root), projectConnectors(root)]);
+	for (const read of [actions, connectors]) if (read && "problem" in read) {
+		fail(read.problem);
+		return { outcome: "failed" };
+	}
+	const sent = {
+		format: 1,
+		documents,
+		...Array.isArray(actions) ? { actions } : {},
+		...Array.isArray(connectors) ? { connectors } : {},
+		base,
+		force
+	};
+	const answered = await authorizedRequest(connection, `/spaces/${String(space.id)}/import`, {
+		method: "PUT",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(sent)
+	});
+	if (!answered.ok) {
+		fail(answered.error);
+		return { outcome: "failed" };
+	}
+	const { status, data } = answered.value.reply;
+	if (status === 409) {
+		fail(data.refusal?.code === "DRAFT_NOT_EMPTY" ? `${space.name} already holds work of its own, and this project never had it: pushing would replace it.\nTake it out first (plitzi create --from ${space.permanentUrl}), or pass --force to replace it with this project.` : `${space.name}’s draft changed since this project last had it — in the builder, or from another copy.\nPull first (plitzi pull) and push again, or pass --force to replace it with this project.`);
+		return { outcome: "failed" };
+	}
+	if (status === 422 && data.problems) {
+		fail(`${space.name} would not take the space as it is:${data.problems.map((problem) => `\n  ${problem}`).join("")}`);
+		return { outcome: "failed" };
+	}
+	if (status !== 200 || !data.draft) {
+		fail(data.error ?? `The space was not pushed (${String(status)}).`);
+		return { outcome: "failed" };
+	}
+	if (!data.changed) return {
+		outcome: "unchanged",
+		draft: data.draft
+	};
+	console.log(chalk.green(`The space is ${space.name}’s draft now — its pages and styles, ${count(sent.actions, "action")}, ${count(sent.connectors, "connector")}.`) + chalk.dim(" Any builder open on it shows it now."));
+	return {
+		outcome: "pushed",
+		draft: data.draft
+	};
+};
+//#endregion
+//#region src/commands/keepSource.ts
+/**
+* A packed source snapshot sent beside what was just uploaded or pushed, and kept on the space (docs/en/projects-from-spaces.md): what lets
+* `plitzi create --from` take the space back out as a project. Never undoes what went up before it — the plugin or the
+* runtime runs either way — so a refusal is said, with why, and the command still succeeds.
+*/
+var keepSource = async (connection, spaceId, bytes) => {
+	const sent = await authorizedRequest(connection, `/spaces/${String(spaceId)}/sources`, {
+		method: "PUT",
+		headers: { "Content-Type": "application/octet-stream" },
+		body: new Uint8Array(bytes)
+	});
+	if (!sent.ok) {
+		console.log(chalk.yellow(`  Its source is not kept: ${sent.error}`));
+		return;
+	}
+	const { status, data } = sent.value.reply;
+	if (status === 200 && data.ok) {
+		console.log(chalk.dim(`  Its source too (${String(data.files ?? 0)} files): plitzi create --from can take it back out.`));
 		return;
 	}
 	const problems = data.problems ?? [`The platform answered ${String(status)}`];
@@ -7163,7 +7852,6 @@ var keepSource = async (connection, spaceId, bytes) => {
 };
 //#endregion
 //#region src/commands/runtime.ts
-var DEFAULT_ENTRY = path.join("src", "runtime.ts");
 var isPacker = (value) => e$1(value) && typeof value.packRuntime === "function";
 /** This project's own packer — read, since it is the project's. */
 var projectPacker = async (root) => {
@@ -7174,42 +7862,42 @@ var projectPacker = async (root) => {
 	} catch {}
 	fail("plitzi runtime packs it with this project’s own @plitzi/sdk-server:\n  npm install @plitzi/sdk-server");
 };
-/** 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 root = (await projectHere("whose runtime to push"))?.root;
-	const connection = root && await connectToSpace(options, "to push to");
-	if (!root || !connection || !connection.space) return;
-	const entry = path.resolve(root, options.entry ?? DEFAULT_ENTRY);
+var DEFAULT_RUNTIME_ENTRY = path.join("src", "runtime.ts");
+/**
+* The project's runtime module packed and kept as the draft runtime of the space the connection works in — which a
+* publish takes live — with the source it was packed from beside it.
+*/
+var pushRuntimeOf = async (root, connection, space, entry) => {
 	try {
 		await fs.access(entry);
 	} catch {
 		fail(`There is no ${path.relative(root, entry)}: the module whose default export is defineRuntime({ start }).`);
-		return;
+		return "failed";
 	}
 	const packer = await projectPacker(root);
-	if (!packer) return;
+	if (!packer) return "failed";
 	let bytes;
 	try {
 		bytes = await packer.packRuntime(entry);
 	} catch (error) {
 		fail(`It does not pack: ${error instanceof Error ? error.message : String(error)}`);
-		return;
+		return "failed";
 	}
-	const answered = await authorizedRequest(connection, `/spaces/${String(connection.space.id)}/runtime`, {
+	const answered = await authorizedRequest(connection, `/spaces/${String(space.id)}/runtime`, {
 		method: "PUT",
 		headers: { "content-type": "application/octet-stream" },
 		body: new Uint8Array(bytes)
 	});
 	if (!answered.ok) {
 		fail(answered.error);
-		return;
+		return "failed";
 	}
 	const { reply } = answered.value;
 	if (reply.status !== 200 || !reply.data.digest) {
 		fail(reply.data.error ?? `The runtime was not kept (${String(reply.status)}).`);
-		return;
+		return "failed";
 	}
-	console.log(chalk.green(`${connection.space.name}’s draft runtime is ${reply.data.digest.slice(0, 12)} (${(bytes.byteLength / 1024).toFixed(0)} KB).`) + chalk.dim(" It starts in a moment; publish the space to take it live."));
+	console.log(chalk.green(`${space.name}’s draft runtime is ${reply.data.digest.slice(0, 12)} (${(bytes.byteLength / 1024).toFixed(0)} KB).`) + chalk.dim(" It starts in a moment; publish the space to take it live."));
 	try {
 		const source = await packSource({
 			root,
@@ -7217,11 +7905,19 @@ var pushRuntime = async (options) => {
 			name: "runtime",
 			entries: [entry]
 		});
-		await keepSource(answered.value.connection, connection.space.id, source.bytes);
+		await keepSource(answered.value.connection, space.id, source.bytes);
 	} catch (error) {
 		console.log(chalk.yellow("  Its source is not kept, so a project taken from the space gets it built only:"));
 		console.log(chalk.yellow(`  ${error instanceof Error ? error.message : String(error)}`));
 	}
+	return "pushed";
+};
+/** 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 root = (await projectHere("whose runtime to push"))?.root;
+	const connection = root && await connectToSpace(options, "to push to");
+	if (!root || !connection || !connection.space) return;
+	await pushRuntimeOf(root, connection, connection.space, path.resolve(root, options.entry ?? DEFAULT_RUNTIME_ENTRY));
 };
 var readRuntime = async (connection, spaceId) => {
 	const answered = await authorizedRequest(connection, `/spaces/${String(spaceId)}/runtime`);
@@ -7362,179 +8058,6 @@ var unsetRuntimeVariable = async (name, options) => {
 	console.log(chalk.green(`${name} removed — the runtime starts again without it.`));
 };
 //#endregion
-//#region src/commands/shot.ts
-/** A region moves when more than this share of it changed between two frames: below is anti-aliasing and carets. */
-var MOVING_PERCENT = .5;
-/** A selector, or an element's name — what `data-plitzi-el` carries. */
-var selectorOf = (target) => /^[#.[]/.test(target) ? target : `[data-plitzi-el="${target}"]`;
-var pictureOf = async (browser, url, view) => {
-	const page = await browser.newPage({
-		viewport: {
-			width: view.width,
-			height: view.height
-		},
-		colorScheme: view.scheme,
-		reducedMotion: view.reducedMotion ? "reduce" : "no-preference"
-	});
-	if (!await page.goto(url, { waitUntil: "networkidle" }).catch(() => null)) return { problem: `Nothing answers at ${url}.` };
-	if (view.waitFor) {
-		if (!await page.waitForSelector(selectorOf(view.waitFor), { timeout: 1e4 }).catch(() => null)) return { problem: `${view.waitFor} did not appear on ${url} within 10 s.` };
-	}
-	return {
-		page,
-		png: await page.screenshot({ fullPage: true })
-	};
-};
-var regionsText = (regions) => regions.map((region) => `${region.name} ${String(region.changed)}%`).join(", ");
-/** Compared frame to frame: the most each region changed between two that follow each other. */
-var framesMoved = (diffs) => {
-	const most = /* @__PURE__ */ new Map();
-	for (const diff of diffs) for (const region of diff.regions) most.set(region.name, Math.max(most.get(region.name) ?? 0, region.changed));
-	return [...most].map(([name, changed]) => ({
-		name,
-		changed
-	}));
-};
-var shot = async (route, options) => {
-	const project = await projectHere("whose page to picture");
-	if (!project) return;
-	const where = await projectOrigin(project.root, project.plitzi?.kind === "project" ? project.plitzi : void 0);
-	if ("problem" in where) {
-		fail(where.problem);
-		return;
-	}
-	const browser = await launchBrowser(project.root);
-	if ("problem" in browser) {
-		fail(browser.problem);
-		return;
-	}
-	try {
-		const pathname = route ?? "/";
-		const view = {
-			width: options.width ?? 1280,
-			height: options.height ?? 800,
-			scheme: options.scheme ?? "light",
-			reducedMotion: options.reducedMotion === true,
-			...options.waitFor ? { waitFor: options.waitFor } : {}
-		};
-		const name = pathname === "/" ? "home" : pathname.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "");
-		const out = path.resolve(project.root, options.out ?? `visual/.shots/${name}-${String(view.width)}-${view.scheme}.png`);
-		const base = out.replace(/\.png$/, "");
-		const taken = await pictureOf(browser, `${where.origin}${pathname}`, view);
-		if ("problem" in taken) {
-			fail(`${taken.problem} Start the project first: npm start`);
-			return;
-		}
-		await mkdir(path.dirname(out), { recursive: true });
-		await writeFile(out, taken.png);
-		const regions = await taken.page.evaluate(pageRegions, void 0);
-		const report = {
-			path: pathname,
-			width: view.width,
-			scheme: view.scheme,
-			out
-		};
-		if (options.compare) {
-			const other = new URL(options.compare);
-			const target = other.pathname === "/" ? new URL(pathname, other).href : other.href;
-			const theirs = await pictureOf(browser, target, view);
-			if ("problem" in theirs) {
-				fail(theirs.problem);
-				return;
-			}
-			const diff = await comparePictures(taken.page, dataUrl(taken.png), dataUrl(theirs.png), regions);
-			await writeFile(`${base}-compare.png`, fromDataUrl(diff.sideBySide));
-			await writeFile(`${base}-diff.png`, fromDataUrl(diff.diff));
-			report.compare = {
-				url: target,
-				changed: diff.changed,
-				regions: diff.regions,
-				sideBySide: `${base}-compare.png`,
-				diff: `${base}-diff.png`
-			};
-		}
-		const frames = options.frames ?? 0;
-		if (frames > 1) {
-			const every = options.every ?? 500;
-			const pictures = [taken.png];
-			for (let frame = 1; frame < frames; frame += 1) {
-				await taken.page.waitForTimeout(every);
-				pictures.push(await taken.page.screenshot({ fullPage: true }));
-			}
-			const diffs = [];
-			for (let frame = 1; frame < pictures.length; frame += 1) diffs.push(await comparePictures(taken.page, dataUrl(pictures[frame - 1]), dataUrl(pictures[frame]), regions));
-			const moved = framesMoved(diffs);
-			report.frames = {
-				count: frames,
-				every,
-				moving: moved.filter((region) => region.changed > MOVING_PERCENT),
-				still: moved.filter((region) => region.changed <= MOVING_PERCENT).map((region) => region.name)
-			};
-		}
-		if (options.json) {
-			console.log(JSON.stringify(report));
-			return;
-		}
-		console.log(out);
-		if (report.compare) {
-			console.log(`${chalk.bold(`${String(report.compare.changed)}% differs`)} from ${report.compare.url}${report.compare.regions.length > 0 ? ` — ${regionsText(report.compare.regions)}` : ""}`);
-			console.log(chalk.dim(`${report.compare.sideBySide}\n${report.compare.diff}`));
-		}
-		if (report.frames) console.log(report.frames.moving.length > 0 ? `moving over ${String(report.frames.count)} frames: ${regionsText(report.frames.moving)}` : `nothing moved over ${String(report.frames.count)} frames, ${String(report.frames.every)} ms apart`);
-	} finally {
-		await browser.close();
-	}
-};
-//#endregion
-//#region src/commands/skills.ts
-/**
-* `plitzi skills update`: the Plitzi skills in `.claude/skills/` brought up to the packages the project has installed.
-*
-* A skill is copied into a project when `create` writes it and then stays as it was, while `@plitzi/sdk-authoring` moves
-* on — and an agent reading the older one is taught a surface the SDK no longer has, or misses what it gained. Only the
-* `plitzi-*` skills are touched, each replaced whole (a reference it no longer has goes with it); any other skill in the
-* folder is the project's.
-*/
-var readSkill = async (file) => {
-	try {
-		return await fs.readFile(file, "utf-8");
-	} catch {
-		return;
-	}
-};
-var skillsUpdate = async () => {
-	const project = await projectHere("whose skills to update");
-	if (!project) return;
-	const folder = path.join(project.root, ".claude/skills");
-	const present = [];
-	for (const name of SKILL_NAMES) {
-		const skill = await readSkill(path.join(folder, name, "SKILL.md"));
-		if (skill !== void 0) present.push({
-			name,
-			was: skillVersion(skill)
-		});
-	}
-	if (present.length === 0) {
-		fail(`No Plitzi skill in ${path.relative(process.cwd(), folder) || ".claude/skills"}: \`plitzi create\` writes them into a project it makes.`);
-		return;
-	}
-	const files = skillFiles(present.map(({ name }) => name), project.root);
-	for (const { name, was } of present) {
-		const own = Object.fromEntries(Object.entries(files).filter(([file]) => file.startsWith(`.claude/skills/${name}/`)));
-		if (Object.keys(own).length === 0) {
-			console.log(chalk.yellow(`${name}: its package is not installed here, so it was left as it was.`));
-			continue;
-		}
-		await fs.rm(path.join(folder, name), {
-			recursive: true,
-			force: true
-		});
-		await writeFiles(project.root, own);
-		const now = skillVersion(own[`.claude/skills/${name}/SKILL.md`] ?? "");
-		console.log(chalk.green(`${name}: ${was ?? "unversioned"} → ${now ?? "unversioned"}`));
-	}
-};
-//#endregion
 //#region src/commands/uploadPlugin.ts
 /** The zips `plitzi pack plugin` leaves: at a plugin package's root, or under `dist/plugins` of any other project. */
 var packedZips = async (root) => {
@@ -7652,68 +8175,1158 @@ var chooseTarget = async (cdns, { cdn: givenCdn, bucket: givenBucket }, spaceNam
 		rl.close();
 	}
 };
-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;
-	}
+/** The space's CDNs and their buckets, asked for — or why not, in words. */
+var listCdns = async (connection, space) => {
+	const listed = await authorizedRequest(connection, `/spaces/${space.id}/cdns`);
+	if (!listed.ok) return listed;
+	const { reply } = listed.value;
+	if (reply.status !== 200) return {
+		ok: false,
+		error: reply.data.error ?? `Could not list ${space.name}'s CDNs (${reply.status}).`
+	};
+	return {
+		ok: true,
+		value: {
+			connection: listed.value.connection,
+			cdns: reply.data.cdns ?? []
+		}
+	};
+};
+/**
+* A packed plugin uploaded to a bucket of the space and installed there — and its source kept beside it, when it was
+* packed with one.
+*/
+var uploadZip = async (connection, space, { zip, filename, target, source }) => {
 	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 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;
+		fail(`${filename} is not a plugin: it has no plugin-manifest.json at its root. Build it with plitzi pack plugin.`);
+		return "failed";
 	}
-	const target = await chooseTarget(listed.value.reply.data.cdns ?? [], options, space.name);
-	if (!target) return;
 	const { cdn, bucket } = target;
 	const label = `${manifest.root}${manifest.version ? ` ${manifest.version}` : ""}`;
 	console.log(`\nUploading ${chalk.bold(label)} to ${chalk.bold(space.name)}, in ${cdn.name} — ${bucket.name}…`);
 	const query = new URLSearchParams({
-		filename: path.basename(zipPath),
+		filename,
 		bucket: bucket.identifier
 	});
-	const uploaded = await authorizedRequest(listed.value.connection, `/spaces/${space.id}/cdns/${encodeURIComponent(cdn.identifier)}/plugins?${query}`, {
+	const uploaded = await authorizedRequest(connection, `/spaces/${space.id}/cdns/${encodeURIComponent(cdn.identifier)}/plugins?${query}`, {
 		method: "POST",
 		headers: { "Content-Type": "application/zip" },
 		body: new Uint8Array(zip)
 	});
 	if (!uploaded.ok) {
 		fail(uploaded.error);
-		return;
+		return "failed";
 	}
 	const { status, data } = uploaded.value.reply;
 	if (status === 413) {
-		fail(`${path.basename(zipPath)} is larger than ${api} accepts.`);
-		return;
+		fail(`${filename} is larger than ${connection.api} accepts.`);
+		return "failed";
 	}
 	if (status !== 201) {
 		fail(data.error ?? `The upload was refused (${status}).`);
-		return;
+		return "failed";
 	}
 	const installed = data.installed === "updated" ? `now loads ${label}` : `loads ${label} from now on`;
-	console.log(chalk.green(`\n${space.name} ${installed}.`));
+	console.log(chalk.green(`${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."));
-	const source = await fs.readFile(sourceFileOf(zipPath)).catch(() => void 0);
 	if (source) await keepSource(uploaded.value.connection, space.id, source);
-	console.log("");
+	return "pushed";
+};
+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;
+	}
+	if (!manifestOf(zip)) {
+		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 connection = await connectionWithSpace(api, "to upload to");
+	if (!connection?.space) return;
+	const { space } = connection;
+	const listed = await listCdns(connection, space);
+	if (!listed.ok) {
+		fail(listed.error);
+		return;
+	}
+	const target = await chooseTarget(listed.value.cdns, options, space.name);
+	if (!target) return;
+	const source = await fs.readFile(sourceFileOf(zipPath)).catch(() => void 0);
+	await uploadZip(listed.value.connection, space, {
+		zip,
+		filename: path.basename(zipPath),
+		target,
+		...source ? { source } : {}
+	});
+	console.log("");
+};
+//#endregion
+//#region src/commands/push.ts
+/**
+* `plitzi push`: the project put back on the space it works with — the way back of `plitzi pull`
+* (docs/en/projects-from-spaces.md). Whatever changed since the project last had the space, or the parts named:
+*
+* - `plugins` — each plugin whose source changed, packed and uploaded to the space's CDN, as `plitzi upload plugin`;
+* - `functions` — `functions/`, as `plitzi functions push`;
+* - `runtime` — the runtime module, packed, as `plitzi runtime push`;
+* - `space` — the pages, styles, actions and connectors, as the space's draft.
+*
+* In that order: the pages name the plugins' elements and the actions name the functions' tasks, so what is named goes
+* up before what names it. A part that fails stops the push there.
+*
+* Always to the space the CLI is connected to, which must be the one the project came from; always the draft, never a
+* published environment. A draft edited in the builder since the project last had it is never replaced unseen: the push
+* is refused, and `--force` replaces it.
+*/
+var PUSH_PARTS = [
+	"space",
+	"functions",
+	"runtime",
+	"plugins"
+];
+/** What goes up first: what the rest names. */
+var ORDER = [
+	"plugins",
+	"functions",
+	"runtime",
+	"space"
+];
+var isPart = (value) => PUSH_PARTS.some((part) => part === value);
+var exists = async (file) => {
+	try {
+		await fs.access(file);
+		return true;
+	} catch {
+		return false;
+	}
+};
+/** Every file under a folder of the project, by its path in the project: none when there is no such folder. */
+var filesUnder = async (root, folder) => {
+	try {
+		return (await fs.readdir(path.join(root, folder), {
+			recursive: true,
+			withFileTypes: true
+		})).filter((entry) => entry.isFile()).map((entry) => path.relative(root, path.join(entry.parentPath, entry.name)));
+	} catch {
+		return [];
+	}
+};
+/**
+* Whether any of the files changed since the project last had the space: one not recorded, or not as it was recorded —
+* formatting aside. Everything has, for a project that never had it.
+*/
+var changedSince = async (root, origin, files, format) => {
+	if (!origin) return true;
+	for (const file of files) {
+		const was = origin.files[file];
+		const here = await digestsOf(root, file, format);
+		if (!was || !here || here.raw !== was && here.formatted !== was) return true;
+	}
+	return false;
+};
+/** The project's files a build of the runtime or of a plugin is made of — none when that cannot be told. */
+var closureOf = async (root, kind, name, entries) => {
+	try {
+		return Object.keys((await packSource({
+			root,
+			kind,
+			name,
+			entries
+		})).snapshot.files);
+	} catch {
+		return;
+	}
+};
+/** The files the space part is made of, as `create --from` lays them out: the pages, the actions, the connectors. */
+var SPACE_FILES = ["src/space.ts", "src/actions.ts"];
+var SPACE_FOLDERS = [
+	"src/space/",
+	"src/actions/",
+	"src/connectors/"
+];
+var isSpaceFile = (file) => SPACE_FILES.includes(file) || SPACE_FOLDERS.some((folder) => file.startsWith(folder));
+/** A plugin's type as the project's folder spells it: `src/plugins/SeatPicker` is `seatPicker`. */
+var typeOfFolder = (folder) => {
+	const name = path.basename(folder);
+	return `${name.charAt(0).toLowerCase()}${name.slice(1)}`;
+};
+/**
+* What the project can send, and whether each changed since the project last had the space. The plugins are grouped as
+* the space keeps them — a plugin can be several elements — and an element folder the space has no plugin of is a
+* plugin of its own.
+*/
+var survey = async (root, { origin, source, before, spaceId, format }) => {
+	const found = [];
+	if (source === "local" && await exists(path.join(root, "src/space.ts"))) {
+		const files = [...await Promise.all(SPACE_FILES.map(async (file) => await exists(path.join(root, file)) ? [file] : [])), ...await Promise.all(SPACE_FOLDERS.map((folder) => filesUnder(root, folder)))].flat();
+		const gone = Object.keys(origin?.files ?? {}).some((file) => isSpaceFile(file) && !files.includes(file));
+		found.push({
+			part: "space",
+			label: "space — its pages, styles, actions and connectors",
+			changed: gone || await changedSince(root, origin, files.filter((file) => isSpaceFile(file)), format)
+		});
+	}
+	const functions = await functionsChange(root, spaceId);
+	if (functions !== "none") found.push({
+		part: "functions",
+		label: "functions — functions/",
+		changed: functions === "changed"
+	});
+	const entries = before && projectEntries(before);
+	const candidates = [...entries?.runtime ? [entries.runtime] : [], DEFAULT_RUNTIME_ENTRY];
+	const present = await Promise.all(candidates.map((entry) => exists(path.join(root, entry))));
+	const runtimeEntry = candidates.find((_entry, index) => present[index]);
+	if (runtimeEntry) {
+		const entry = path.join(root, runtimeEntry);
+		const files = await closureOf(root, "runtime", "runtime", [entry]);
+		found.push({
+			part: "runtime",
+			label: `runtime — ${runtimeEntry}`,
+			changed: !files || await changedSince(root, origin, files, format),
+			entry,
+			files: files ?? []
+		});
+	}
+	const folders = await elementFolders({ root });
+	const grouped = (entries?.plugins ?? []).map(({ type, entries: starts }) => ({
+		type,
+		folders: starts.map((start) => path.join(root, path.dirname(start)))
+	})).filter((group) => group.folders.every((folder) => folders.includes(folder)));
+	const alone = folders.filter((folder) => !grouped.some((group) => group.folders.includes(folder))).map((folder) => ({
+		type: typeOfFolder(folder),
+		folders: [folder]
+	}));
+	for (const { type, folders: group } of [...grouped, ...alone]) {
+		const files = await closureOf(root, "plugin", type, group.map((folder) => path.join(folder, "index.ts")));
+		found.push({
+			part: "plugins",
+			label: `plugin ${type} — ${group.map((folder) => path.relative(root, folder)).join(", ")}`,
+			changed: !files || await changedSince(root, origin, files, format),
+			folders: group,
+			files: files ?? []
+		});
+	}
+	return found;
+};
+/**
+* What to send: the parts named; at a terminal, what the person ticks — what changed, ticked to begin with; with nobody
+* there, what changed. `undefined` when there is nothing to send, said why.
+*/
+var choose = async (found, asked, spaceName) => {
+	if (asked.length > 0) {
+		const unknown = asked.filter((part) => !isPart(part));
+		if (unknown.length > 0) {
+			fail(`plitzi push sends ${PUSH_PARTS.join(", ")} — not ${unknown.join(", ")}.`);
+			return;
+		}
+		const missing = asked.filter((part) => !found.some((item) => item.part === part));
+		if (missing.length > 0) {
+			fail(`This project has no ${missing.join(", ")} to push.`);
+			return;
+		}
+		return found.filter((item) => asked.includes(item.part));
+	}
+	if (found.length === 0) {
+		fail("This project has nothing to push: no src/space.ts, functions/, runtime or plugin.");
+		return;
+	}
+	if (!atTerminal()) return found.filter((item) => item.changed);
+	const chosen = await askChecks(`What goes to ${spaceName}? Ticked: what changed since the project last had it.`, found.map((item) => ({
+		label: item.label,
+		value: item,
+		checked: item.changed,
+		hint: item.changed ? "changed" : "unchanged"
+	})));
+	if (!chosen) console.log("Nothing was pushed.");
+	return chosen;
+};
+/** A plugin packed as `plitzi pack plugin` packs it, and uploaded and installed as `plitzi upload plugin` does. */
+var pushPlugin = async (root, connection, space, { folders, target, version }) => {
+	const base = fileNameOf(folders[0]);
+	const zip = path.join(root, "dist/plugins", `${base}-${version}.zip`);
+	let packed;
+	try {
+		packed = await packPlugin({
+			root,
+			source: {
+				kind: "elements",
+				folders
+			},
+			base,
+			version,
+			outDir: path.join(root, "dist/plugins", base),
+			zip
+		});
+	} catch (error) {
+		if (!(error instanceof PackError)) throw error;
+		fail(error.message);
+		return "failed";
+	}
+	if ("problem" in packed.source) {
+		console.log(chalk.yellow(`  Its source is not kept, so the space can be taken out with ${base} built only:`));
+		console.log(chalk.yellow(`  ${packed.source.problem}`));
+	}
+	return uploadZip(connection, space, {
+		zip: await fs.readFile(zip),
+		filename: path.basename(zip),
+		target,
+		..."file" in packed.source ? { source: await fs.readFile(packed.source.file) } : {}
+	});
+};
+/**
+* `.plitzi/space.json` as the space now holds the project, so `plitzi pull` compares with it from here on: the files of
+* the parts sent recorded as the space gives them back, the rest as they were — a page changed in the builder and not
+* pushed over is still the builder's change to the next pull. A project that never had the space records it whole.
+*/
+var recordPush = async (root, connection, space, { origin, source, found, sent, draft }) => {
+	const exported = await requestExport(connection, String(space.id), {
+		source,
+		version: { environment: "main" },
+		name: space.name
+	});
+	if (!exported.ok) {
+		console.log(chalk.yellow(`Pushed, but .plitzi/space.json is not brought up to date — ${exported.error}\nThe next plitzi pull compares with what it recorded before.`));
+		return;
+	}
+	const format = await projectFormatter(root);
+	const next = projectFromSpace(exported.value, source);
+	const given = await givenFiles(next, format);
+	const parts = new Set(sent.map((item) => item.part));
+	const codeOf = (items) => items.flatMap((item) => item.part === "runtime" || item.part === "plugins" ? item.files : []);
+	const built = new Set(codeOf(sent));
+	const code = /* @__PURE__ */ new Set([...codeOf(found), ...projectEntries(exported.value).files]);
+	const downloads = new Set(Object.keys(origin?.downloads ?? {}));
+	const isSent = (file) => {
+		if (!origin || built.has(file)) return true;
+		if (file.startsWith("functions/")) return parts.has("functions");
+		return !code.has(file) && !file.startsWith("vendor/") && parts.has("space");
+	};
+	const files = Object.fromEntries(Object.entries(origin?.files ?? {}).filter(([file]) => downloads.has(file) || !isSent(file) || given.has(file)));
+	given.forEach((bytes, file) => {
+		if (isSent(file)) files[file] = digest(bytes);
+	});
+	const recorded = draft ?? origin?.draft;
+	await writeOrigin(root, {
+		format: 1,
+		api: connection.api,
+		space: exported.value.space,
+		source,
+		version: { environment: "main" },
+		...recorded ? { draft: recorded } : {},
+		files,
+		downloads: origin?.downloads ?? {},
+		dependencies: !origin || parts.has("runtime") || parts.has("plugins") ? next.dependencies : origin.dependencies
+	});
+};
+var push = async (asked, options) => {
+	const project = await findProject(process.cwd());
+	if (!project) {
+		fail("There is no package.json here or above: run plitzi push in the project to send.");
+		return;
+	}
+	if (project.plitzi?.kind === "plugin") {
+		fail("This is a plugin package: plitzi pack plugin and plitzi upload plugin put it on a space.");
+		return;
+	}
+	const { root } = project;
+	const origin = await readOrigin(root);
+	if (origin && origin.version.environment !== "main") {
+		fail(`This project follows ${versionLabel(origin.version)} of ${origin.space.name}, and a push writes the draft.\nFollow the draft first: plitzi pull --environment main.`);
+		return;
+	}
+	const connection = await connectToSpace({
+		...options,
+		api: options.api ?? origin?.api
+	}, "to push to");
+	const space = connection?.space;
+	if (!connection || !space) return;
+	if (origin && origin.space.id !== space.id) {
+		fail(`This project is ${origin.space.name}’s, and the CLI works in ${space.name}. Switch to it with plitzi space, and push again.`);
+		return;
+	}
+	const source = origin?.source ?? (project.plitzi?.kind === "project" ? project.plitzi.source : "local");
+	let before;
+	if (origin) {
+		const exported = await requestExport(connection, String(space.id), {
+			source: "cloud",
+			version: { environment: "main" },
+			name: space.name
+		});
+		if (!exported.ok) {
+			fail(exported.error);
+			return;
+		}
+		before = exported.value;
+	}
+	const format = await projectFormatter(root);
+	const found = await survey(root, {
+		origin,
+		source,
+		before,
+		spaceId: space.id,
+		format
+	});
+	const chosen = await choose(found, asked, space.name);
+	if (!chosen) return;
+	if (chosen.length === 0) {
+		console.log(`Nothing to push: the project is what ${space.name} last gave it.`);
+		return;
+	}
+	const force = options.force ?? false;
+	const sent = [];
+	const settled = [];
+	const unchanged = [];
+	let draft;
+	let target;
+	const version = (await readPackageJson(root))?.version ?? "0.0.0";
+	for (const item of [...chosen].sort((a, b) => ORDER.indexOf(a.part) - ORDER.indexOf(b.part))) {
+		let outcome;
+		if (item.part === "plugins") {
+			if (!target) {
+				const listed = await listCdns(connection, space);
+				if (!listed.ok) {
+					fail(listed.error);
+					return;
+				}
+				target = await chooseTarget(listed.value.cdns, options, space.name);
+				if (!target) return;
+			}
+			outcome = await pushPlugin(root, connection, space, {
+				folders: item.folders,
+				target,
+				version
+			});
+		} else if (item.part === "functions") outcome = await pushFunctionsOf(root, connection, space, { force });
+		else if (item.part === "runtime") outcome = await pushRuntimeOf(root, connection, space, item.entry);
+		else {
+			const pushed = await pushSpaceOf(root, connection, space, {
+				base: origin?.draft ?? null,
+				force
+			});
+			outcome = pushed.outcome;
+			draft = pushed.draft;
+		}
+		if (outcome === "failed") {
+			if (sent.length > 0) {
+				console.log(chalk.yellow(`\nPushed before it stopped: ${sent.map((done) => done.label).join("; ")}.`));
+				await recordPush(root, connection, space, {
+					origin,
+					source,
+					found,
+					sent: settled,
+					draft
+				});
+			}
+			return;
+		}
+		if (outcome === "pushed") sent.push(item);
+		else unchanged.push(item.label);
+		if (outcome === "pushed" || item.part === "space") settled.push(item);
+	}
+	if (settled.length > 0) await recordPush(root, connection, space, {
+		origin,
+		source,
+		found,
+		sent: settled,
+		draft
+	});
+	if (unchanged.length > 0) console.log(chalk.dim(`Already ${space.name}’s: ${unchanged.join("; ")}.`));
+	if (sent.length > 0) console.log(chalk.green(`\nPushed to ${space.name}’s draft.`) + chalk.dim(" Publish it in the builder to take it live."));
+};
+//#endregion
+//#region ../../packages/sdk-shared/dist/schema/motion.mjs
+var t = [
+	"fade",
+	"fade-up",
+	"fade-down",
+	"slide-left",
+	"slide-right",
+	"slide-up",
+	"scale",
+	"zoom-in",
+	"zoom-out",
+	"pop",
+	"bounce-in",
+	"tilt",
+	"spin-in"
+];
+var o = {
+	fade: [{
+		at: 0,
+		opacity: 0
+	}],
+	"fade-up": [{
+		at: 0,
+		opacity: 0,
+		translate: "0 24px"
+	}],
+	"fade-down": [{
+		at: 0,
+		opacity: 0,
+		translate: "0 -24px"
+	}],
+	"slide-left": [{
+		at: 0,
+		opacity: 0,
+		translate: "32px 0"
+	}],
+	"slide-right": [{
+		at: 0,
+		opacity: 0,
+		translate: "-32px 0"
+	}],
+	"slide-up": [{
+		at: 0,
+		opacity: 0,
+		translate: "0 72px"
+	}],
+	scale: [{
+		at: 0,
+		opacity: 0,
+		scale: "0.94"
+	}],
+	"zoom-in": [{
+		at: 0,
+		opacity: 0,
+		scale: "0.6"
+	}],
+	"zoom-out": [{
+		at: 0,
+		opacity: 0,
+		scale: "1.25"
+	}],
+	pop: [
+		{
+			at: 0,
+			opacity: 0,
+			scale: "0.5"
+		},
+		{
+			at: 55,
+			opacity: 1,
+			scale: "1.08"
+		},
+		{
+			at: 78,
+			scale: "0.97"
+		}
+	],
+	"bounce-in": [
+		{
+			at: 0,
+			opacity: 0,
+			translate: "0 -64px"
+		},
+		{
+			at: 55,
+			opacity: 1,
+			translate: "0 10px"
+		},
+		{
+			at: 75,
+			translate: "0 -5px"
+		},
+		{
+			at: 90,
+			translate: "0 2px"
+		}
+	],
+	tilt: [{
+		at: 0,
+		opacity: 0,
+		translate: "0 32px",
+		rotate: "-6deg"
+	}],
+	"spin-in": [{
+		at: 0,
+		opacity: 0,
+		scale: "0.4",
+		rotate: "-180deg"
+	}]
+};
+Object.fromEntries(t.map((e) => {
+	let [{ at: t, ...n }] = o[e];
+	return [e, n];
+}));
+var c = (e, t) => {
+	let n = t * 2 * Math.PI, r = Math.round(Math.sin(n) * e * 10) / 10, i = Math.round(-Math.cos(n) * e * 10) / 10;
+	return `translate(${String(r)}px, ${String(i)}px)`;
+};
+Array.from({ length: 9 }, (e, t) => ({
+	at: t * 100 / 8,
+	transform: c(6, t / 8)
+}));
+var _ = `[data-motion-enter], [data-motion-stagger] > *, [data-motion-loop] { animation: none !important; }`;
+[
+	"[data-motion-loop] { animation-play-state: running, running !important; }",
+	"[data-motion-on=\"view\"][data-motion-enter], [data-motion-on=\"view\"][data-motion-stagger] > * { animation-play-state: running, running !important; }",
+	"[data-motion-on=\"scroll\"][data-motion-enter], [data-motion-on=\"scroll\"][data-motion-stagger] > * { animation-timeline: auto, auto !important; }"
+].join("\n");
+//#endregion
+//#region src/commands/shot.ts
+/** A region moves when more than this share of it changed between two frames: below is anti-aliasing and carets. */
+var MOVING_PERCENT = .5;
+/** How long a whole page waits for its pictures before it is taken anyway. */
+var IMAGES_BUDGET_MS = 8e3;
+/** How many texts that differ are written out; `--json` has every one. */
+var TEXTS_SHOWN = 12;
+/** A shift within this is where it was: a pixel or two is rounding. */
+var DRIFT_PX = 2;
+/** An arrival that waits for the scroll and has not had it: one waiting to be seen, or one tied to the scroll. */
+var WAITING_FOR_SCROLL = "[data-motion-on=\"view\"]:not([data-motion-seen]), [data-motion-on=\"scroll\"]";
+/** A selector, or an element's name — what `data-plitzi-el` carries. */
+var selectorOf = (target) => /^[#.[]/.test(target) ? target : `[data-plitzi-el="${target}"]`;
+var framing = (view) => {
+	if (view.clip) return {
+		kind: "element",
+		selector: selectorOf(view.clip)
+	};
+	return view.viewport || view.scrollTo ? { kind: "viewport" } : { kind: "page" };
+};
+var capture = (page, how) => {
+	if (how.kind === "element") return page.locator(how.selector).first().screenshot();
+	return page.screenshot({ fullPage: how.kind === "page" });
+};
+/**
+* One page, pictured: the project's own (`origin` given — in the space's theme when one is asked for) or another site,
+* in the scheme it is told.
+*/
+var pictureOf = async (browser, url, view, origin) => {
+	const page = origin ? await openProjectPage(browser, origin, view) : await browser.newPage({
+		viewport: {
+			width: view.width,
+			height: view.height
+		},
+		colorScheme: view.scheme ?? "light",
+		reducedMotion: view.reducedMotion ? "reduce" : "no-preference"
+	});
+	if (!await page.goto(url, { waitUntil: "networkidle" }).catch(() => null)) return { problem: `Nothing answers at ${url}.` };
+	if (view.waitFor) {
+		if (!await page.waitForSelector(selectorOf(view.waitFor), { timeout: 1e4 }).catch(() => null)) return { problem: `${view.waitFor} did not appear on ${url} within 10 s.` };
+	}
+	for (const target of [view.scrollTo, view.clip]) if (target && !await page.waitForSelector(selectorOf(target), { timeout: 1e4 }).catch(() => null)) return { problem: `${target} is not on ${url}.` };
+	if (view.scrollTo) await page.locator(selectorOf(view.scrollTo)).first().scrollIntoViewIfNeeded();
+	await withoutDevTools(page);
+	const settled = view.still ? await page.evaluate((selector) => document.querySelectorAll(selector).length, WAITING_FOR_SCROLL) : 0;
+	const whole = framing(view).kind === "page";
+	const pictures = whole ? await page.evaluate(loadImages, IMAGES_BUDGET_MS) : void 0;
+	if (whole) await page.evaluate(unrollPage, void 0);
+	if (view.still) await page.addStyleTag({ content: _ });
+	return {
+		page,
+		png: await capture(page, framing(view)),
+		scheme: await paintedScheme(page, view.scheme ?? "light"),
+		settled,
+		unloaded: pictures?.missing ?? 0
+	};
+};
+var shiftText = (shift) => shift !== void 0 && Math.abs(shift) > DRIFT_PX ? ` (${shift > 0 ? "+" : ""}${String(shift)}px there)` : "";
+var regionsText = (regions) => regions.map((region) => `${region.name} ${String(region.changed)}%${shiftText(region.shift)}`).join(", ");
+/** Compared frame to frame: the most each region changed between two that follow each other. */
+var framesMoved = (diffs) => {
+	const most = /* @__PURE__ */ new Map();
+	for (const diff of diffs) for (const region of diff.regions) most.set(region.name, Math.max(most.get(region.name) ?? 0, region.changed));
+	return [...most].map(([name, changed]) => ({
+		name,
+		changed
+	}));
+};
+var differenceText = (entry) => `  ${entry.tag} ${JSON.stringify(entry.text.length > 48 ? `${entry.text.slice(0, 47)}…` : entry.text)} — ${entry.differences.join(" · ")}`;
+var someOf = (texts) => {
+	return `${texts.slice(0, 3).map((text) => JSON.stringify(text.length > 32 ? `${text.slice(0, 31)}…` : text)).join(", ")}${texts.length > 3 ? ` (+${String(texts.length - 3)})` : ""}`;
+};
+/** What a comparison found, in the lines an agent reads before it opens a picture. */
+var compareText = (compare) => {
+	const lines = [`${chalk.bold(`${String(compare.changed)}% differs`)} from ${compare.url}${compare.regions.length > 0 ? ` — ${regionsText(compare.regions)}` : ""}`];
+	const longer = compare.heights.there - compare.heights.here;
+	const drift = compare.driftFrom;
+	const placed = [Math.abs(longer) > DRIFT_PX ? `the page there is ${String(Math.abs(longer))}px ${longer > 0 ? "longer" : "shorter"} (${String(compare.heights.here)} → ${String(compare.heights.there)})` : "", drift ? `from ${drift.name} on, it sits ${String(Math.abs(drift.shift))}px ${drift.shift > 0 ? "lower" : "higher"} there — each section is compared where it is` : ""].filter(Boolean);
+	if (placed.length > 0) lines.push(placed.join("; "));
+	const { texts } = compare;
+	if (texts.differ.length > 0) lines.push(`texts: ${String(texts.same)} the same, ${String(texts.differ.length)} differ (here → there):`, ...texts.differ.slice(0, TEXTS_SHOWN).map(differenceText), ...texts.differ.length > TEXTS_SHOWN ? [chalk.dim(`  …and ${String(texts.differ.length - TEXTS_SHOWN)} more: --json lists them`)] : []);
+	else if (texts.same > 0) lines.push(`texts: the ${String(texts.same)} both pages have look the same`);
+	if (texts.onlyHere.length > 0 || texts.onlyThere.length > 0) lines.push(chalk.dim([texts.onlyHere.length > 0 ? `only here: ${someOf(texts.onlyHere)}` : "", texts.onlyThere.length > 0 ? `only there: ${someOf(texts.onlyThere)}` : ""].filter(Boolean).join(" · ")));
+	if (compare.unloaded > 0) lines.push(chalk.yellow(`${String(compare.unloaded)} picture(s) there had not loaded when it was taken: those parts compare against a hole`));
+	lines.push(chalk.dim(`${compare.sideBySide}\n${compare.diff}`));
+	return lines;
+};
+/** The other site beside this page: section by section where each one is, and the words both have, measured. */
+var compareWith = async (browser, taken, target, view, regions, base) => {
+	const theirs = await pictureOf(browser, target, {
+		...view,
+		scheme: taken.scheme
+	});
+	if ("problem" in theirs) return theirs;
+	const diff = await comparePictures(taken.page, dataUrl(taken.png), dataUrl(theirs.png), {
+		regions,
+		align: true
+	});
+	await writeFile(`${base}-compare.png`, fromDataUrl(diff.sideBySide));
+	await writeFile(`${base}-diff.png`, fromDataUrl(diff.diff));
+	const rowShift = diff.rowShift ?? [];
+	const shiftAt = (y) => rowShift[Math.min(Math.max(0, Math.round(y)), rowShift.length - 1)] ?? 0;
+	const texts = compareTexts(await taken.page.evaluate(pageTexts, PAGE_TEXT_LIMIT), await theirs.page.evaluate(pageTexts, PAGE_TEXT_LIMIT), shiftAt);
+	return {
+		url: target,
+		changed: diff.changed,
+		heights: {
+			here: diff.heights.a,
+			there: diff.heights.b
+		},
+		...diff.driftFrom ? { driftFrom: diff.driftFrom } : {},
+		regions: diff.regions,
+		texts,
+		unloaded: theirs.unloaded,
+		sideBySide: `${base}-compare.png`,
+		diff: `${base}-diff.png`
+	};
+};
+var shot = async (route, options) => {
+	const project = await projectHere("whose page to picture");
+	if (!project) return;
+	const where = await projectOrigin(project.root, project.plitzi?.kind === "project" ? project.plitzi : void 0);
+	if ("problem" in where) {
+		fail(where.problem);
+		return;
+	}
+	const browser = await launchBrowser(project.root);
+	if ("problem" in browser) {
+		fail(browser.problem);
+		return;
+	}
+	if (options.compare && (options.clip || options.scrollTo || options.viewport)) {
+		await browser.close();
+		fail("`--compare` sets the whole page beside the other site, section by section: leave out --clip, --scroll-to and --viewport.");
+		return;
+	}
+	try {
+		const pathname = route ?? "/";
+		const view = {
+			width: options.width ?? 1280,
+			height: options.height ?? 800,
+			...options.scheme ? { scheme: options.scheme } : {},
+			reducedMotion: options.reducedMotion === true,
+			...options.waitFor ? { waitFor: options.waitFor } : {},
+			...options.clip ? { clip: options.clip } : {},
+			...options.scrollTo ? { scrollTo: options.scrollTo } : {},
+			...options.viewport ? { viewport: true } : {},
+			still: !options.clip && !options.scrollTo && !options.viewport && (options.frames ?? 0) <= 1
+		};
+		const how = framing(view);
+		const taken = await pictureOf(browser, `${where.origin}${pathname}`, view, where.origin);
+		if ("problem" in taken) {
+			fail(`${taken.problem} Start the project first: npm start`);
+			return;
+		}
+		const name = pathname === "/" ? "home" : pathname.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "");
+		const out = path.resolve(project.root, options.out ?? `tmp/shots/${name}-${String(view.width)}-${taken.scheme}.png`);
+		const base = out.replace(/\.png$/, "");
+		await mkdir(path.dirname(out), { recursive: true });
+		await writeFile(out, taken.png);
+		const regions = how.kind === "page" ? await taken.page.evaluate(pageRegions, void 0) : [];
+		const report = {
+			path: pathname,
+			width: view.width,
+			scheme: taken.scheme,
+			out,
+			...taken.settled > 0 ? { settled: taken.settled } : {},
+			...taken.unloaded > 0 ? { unloaded: taken.unloaded } : {}
+		};
+		if (options.compare) {
+			const other = new URL(options.compare);
+			const compared = await compareWith(browser, taken, other.pathname === "/" ? new URL(pathname, other).href : other.href, view, regions, base);
+			if ("problem" in compared) {
+				fail(compared.problem);
+				return;
+			}
+			report.compare = compared;
+		}
+		const frames = options.frames ?? 0;
+		if (frames > 1) {
+			const every = options.every ?? 500;
+			const pictures = [taken.png];
+			for (let frame = 1; frame < frames; frame += 1) {
+				await taken.page.waitForTimeout(every);
+				pictures.push(await capture(taken.page, how));
+			}
+			const diffs = [];
+			for (let frame = 1; frame < pictures.length; frame += 1) diffs.push(await comparePictures(taken.page, dataUrl(pictures[frame - 1]), dataUrl(pictures[frame]), { regions }));
+			const whole = how.kind === "element" ? options.clip ?? "element" : "viewport";
+			const moved = how.kind === "page" ? framesMoved(diffs) : [{
+				name: whole,
+				changed: Math.max(0, ...diffs.map((diff) => diff.changed))
+			}];
+			report.frames = {
+				count: frames,
+				every,
+				moving: moved.filter((region) => region.changed > MOVING_PERCENT),
+				still: moved.filter((region) => region.changed <= MOVING_PERCENT).map((region) => region.name)
+			};
+		}
+		if (options.json) {
+			console.log(JSON.stringify(report));
+			return;
+		}
+		console.log(out);
+		if (report.settled) console.log(chalk.dim(`${String(report.settled)} arrival${report.settled === 1 ? "" : "s"} waiting for the scroll shown as they end — --scroll-to <id> --viewport --frames 4 shows one arriving`));
+		if (report.unloaded) console.log(chalk.yellow(`${String(report.unloaded)} picture(s) had not loaded when the page was taken`));
+		if (report.compare) console.log(compareText(report.compare).join("\n"));
+		if (report.frames) console.log(report.frames.moving.length > 0 ? `moving over ${String(report.frames.count)} frames: ${regionsText(report.frames.moving)}` : `nothing moved over ${String(report.frames.count)} frames, ${String(report.frames.every)} ms apart`);
+	} finally {
+		await browser.close();
+	}
+};
+//#endregion
+//#region src/commands/upgrade.ts
+/**
+* `plitzi upgrade`: a project brought up to the CLI it now has — what `create` would write today, for what is the
+* CLI's to write. Every part on its own, or all of them:
+*
+* - `files`: the machinery (`machineryFiles`) — `author.ts`, `main.ts`, the Playwright and lint configs, AGENTS.md. One
+*   nobody changed since the CLI wrote it is replaced; one the project made its own is shown as a diff and left, unless
+*   `--take` names it.
+* - `packages`: `package.json` merged — the scripts and dependencies it lacks added, `@plitzi/*` raised to this
+*   version. A script or a dependency the project has is never changed; then the install.
+* - `skills`: `.claude/skills/plitzi-*` from the packages installed, each replaced whole.
+* - `renames`: a name a version renamed, still written in the source (`canTemplate`), at its file and line — and with
+*   `--write`, renamed.
+*
+* Shown by default; `--write` makes it. What the space is — its pages, plugins, data — is the project's, never named.
+*
+*   plitzi upgrade                    # everything, as it would be
+*   plitzi upgrade skills --write     # only the skills
+*   plitzi upgrade --write --take src/author.ts
+*/
+var UPGRADE_PARTS = [
+	"files",
+	"packages",
+	"skills",
+	"renames"
+];
+var RENAMES = [{
+	name: "canTemplate",
+	to: "canSnippet",
+	since: "0.38.0",
+	what: "a plugin’s builder config key"
+}, ...[
+	"authorTemplate",
+	"validateTemplate",
+	"TemplateSpec",
+	"AuthoredTemplate"
+].map((name) => ({
+	name,
+	to: name.replace("Template", "Snippet"),
+	since: "0.38.0",
+	what: "what the builder saves from a subtree is a snippet",
+	from: "@plitzi/sdk-authoring"
+}))];
+/** The project's own source: TypeScript and JavaScript under `src/` and `visual/`, never what was installed or built. */
+var sourceFiles = async (root) => {
+	const found = [];
+	const walk = async (dir) => {
+		let entries;
+		try {
+			entries = await fs.readdir(path.join(root, dir), { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const relative = path.join(dir, entry.name);
+			if (entry.isDirectory()) await walk(relative);
+			else if (/\.(ts|tsx|mts|js|jsx|mjs)$/.test(entry.name)) found.push(relative);
+		}
+	};
+	await walk("src");
+	await walk("visual");
+	return found;
+};
+var wordOf = (name) => new RegExp(`\\b${name}\\b`, "g");
+var importsFrom = (text, name, from) => new RegExp(`import\\s+(type\\s+)?\\{[^}]*\\b${name}\\b[^}]*\\}\\s*from\\s*['"]${from}['"]`).test(text);
+var renamesIn = (file, text) => RENAMES.filter((rename) => !rename.from || importsFrom(text, rename.name, rename.from)).flatMap((rename) => text.split("\n").flatMap((line, index) => wordOf(rename.name).test(line) ? [{
+	file,
+	line: index + 1,
+	name: rename.name,
+	to: rename.to,
+	since: rename.since,
+	what: rename.what
+}] : []));
+/** The lowest version a range allows, as numbers: `^0.38.2` → [0, 38, 2]. */
+var floorOf = (range) => {
+	const match = /(\d+)\.(\d+)\.(\d+)/.exec(range);
+	return match ? match.slice(1).map(Number) : void 0;
+};
+var isBelow = (range, than) => {
+	const [a, b] = [floorOf(range), floorOf(than)];
+	if (!a || !b) return false;
+	const at = a.findIndex((part, index) => part !== b[index]);
+	return at !== -1 && a[at] < b[at];
+};
+var stringsOf = (value) => e$1(value) ? Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string")) : {};
+var planPackages = (text, answers) => {
+	const parsed = JSON.parse(text);
+	const ours = JSON.parse(packageJson$1(answers));
+	const project = e$1(parsed) ? { ...parsed } : {};
+	const scaffold = e$1(ours) ? ours : {};
+	const plan = {
+		added: [],
+		raised: [],
+		scripts: [],
+		ownScripts: []
+	};
+	const scripts = stringsOf(project.scripts);
+	for (const [name, command] of Object.entries(stringsOf(scaffold.scripts))) if (!(name in scripts)) {
+		plan.scripts.push({
+			name,
+			command
+		});
+		scripts[name] = command;
+	} else if (scripts[name] !== command) plan.ownScripts.push({
+		name,
+		yours: scripts[name],
+		ours: command
+	});
+	const sections = {
+		dependencies: stringsOf(project.dependencies),
+		devDependencies: stringsOf(project.devDependencies)
+	};
+	for (const section of ["dependencies", "devDependencies"]) for (const [name, range] of Object.entries(stringsOf(scaffold[section]))) {
+		const where = name in sections.dependencies ? "dependencies" : name in sections.devDependencies ? "devDependencies" : void 0;
+		if (!where) {
+			plan.added.push({
+				section,
+				name,
+				range
+			});
+			sections[section][name] = range;
+		} else if (name.startsWith("@plitzi/") && isBelow(sections[where][name], range)) {
+			plan.raised.push({
+				section: where,
+				name,
+				from: sections[where][name],
+				to: range
+			});
+			sections[where][name] = range;
+		}
+	}
+	if (plan.added.length + plan.raised.length + plan.scripts.length === 0) return plan;
+	const sorted = (entries) => Object.fromEntries(Object.entries(entries).sort(([a], [b]) => a.localeCompare(b)));
+	const indent = /^\{\n([ \t]+)"/.exec(text)?.[1] ?? "  ";
+	const merged = {
+		...project,
+		scripts,
+		dependencies: sorted(sections.dependencies),
+		devDependencies: sorted(sections.devDependencies)
+	};
+	return {
+		...plan,
+		after: `${JSON.stringify(merged, null, indent)}\n`
+	};
+};
+var readText = async (file) => {
+	try {
+		return await fs.readFile(file, "utf-8");
+	} catch {
+		return;
+	}
+};
+var planFiles = async (root, files, recorded, take) => Promise.all(Object.entries(files).map(async ([file, ours]) => {
+	const yours = await readText(path.join(root, file));
+	if (yours === void 0) return {
+		file,
+		status: "added",
+		ours
+	};
+	if (yours === ours) return {
+		file,
+		status: "current",
+		ours,
+		yours
+	};
+	if (recorded[file] === digestOf(yours)) return {
+		file,
+		status: "updated",
+		ours,
+		yours
+	};
+	return {
+		file,
+		status: take.includes("all") || take.includes(file) ? "taken" : "yours",
+		ours,
+		yours
+	};
+}));
+var WRITES = /* @__PURE__ */ new Set([
+	"added",
+	"updated",
+	"taken"
+]);
+var planSkills = async (root) => {
+	const files = skillFiles(SKILL_NAMES, root);
+	const plans = [];
+	for (const name of SKILL_NAMES) {
+		const skill = `.claude/skills/${name}/SKILL.md`;
+		if (!(skill in files)) continue;
+		const now = files[skill];
+		const was = await readText(path.join(root, skill));
+		if (was !== now) plans.push({
+			name,
+			...was === void 0 ? {} : { was: skillVersion(was) ?? "unversioned" },
+			now: skillVersion(now) ?? "unversioned"
+		});
+	}
+	return {
+		plans,
+		files
+	};
+};
+var writeSkills = async (root, plans, files) => {
+	for (const { name } of plans) {
+		await fs.rm(path.join(root, ".claude/skills", name), {
+			recursive: true,
+			force: true
+		});
+		await writeFiles(root, Object.fromEntries(Object.entries(files).filter(([file]) => file.startsWith(`.claude/skills/${name}/`))));
+	}
+};
+/** What a project was made with, as far as its machinery cares: none of it reads the key or the environment. */
+var answersFor = async (root, plitzi, manager) => {
+	const name = (await readPackageJson(root))?.name ?? path.basename(root);
+	const managerVersion = detectManagerVersion(manager, root);
+	return {
+		name,
+		mode: plitzi.mode,
+		source: plitzi.source,
+		key: "",
+		environment: "main",
+		packageManager: manager,
+		...managerVersion === void 0 ? {} : { managerVersion }
+	};
+};
+var statusLine = {
+	current: (file) => chalk.dim(`  = ${file}`),
+	added: (file) => chalk.green(`  + ${file}`),
+	updated: (file) => chalk.green(`  ~ ${file}`),
+	taken: (file) => chalk.yellow(`  ~ ${file} (yours, taken)`),
+	yours: (file) => chalk.yellow(`  ! ${file} — yours: the CLI's version below; --take ${file} to replace it`)
+};
+var reportText = (report) => {
+	const lines = [chalk.bold(`plitzi upgrade → ${report.version}${report.write ? "" : " (shown; --write makes it)"}`)];
+	if (report.files) {
+		const changed = report.files.filter((file) => file.status !== "current");
+		lines.push(changed.length === 0 ? chalk.green("files: up to date") : "files:");
+		for (const file of changed) {
+			lines.push(statusLine[file.status](file.file));
+			if (file.diff) lines.push(chalk.dim(file.diff));
+		}
+	}
+	if (report.packages) {
+		const { added, raised, scripts, ownScripts, install: installed } = report.packages;
+		const none = added.length + raised.length + scripts.length === 0;
+		lines.push(none ? chalk.green("packages: up to date") : "packages:");
+		lines.push(...raised.map((entry) => chalk.green(`  ~ ${entry.name} ${entry.from} → ${entry.to}`)), ...added.map((entry) => chalk.green(`  + ${entry.name} ${entry.range} (${entry.section})`)), ...scripts.map((entry) => chalk.green(`  + script ${entry.name}: ${entry.command}`)), ...ownScripts.map((entry) => chalk.dim(`  = script ${entry.name} is yours ("${entry.yours}"; the CLI writes "${entry.ours}")`)));
+		if (installed === "needed") lines.push(chalk.yellow("  then install, for the new versions to be the ones that run"));
+		else if (installed === "failed") lines.push(chalk.red("  the install failed: the reason is in the output above"));
+	}
+	if (report.skills) {
+		lines.push(report.skills.length === 0 ? chalk.green("skills: up to date") : "skills:");
+		lines.push(...report.skills.map((skill) => chalk.green(`  ~ ${skill.name}: ${skill.was ?? "none"} → ${skill.now ?? "?"}`)));
+	}
+	if (report.renames) {
+		lines.push(report.renames.length === 0 ? chalk.green("renames: none written") : "renames:");
+		lines.push(...report.renames.map((found) => chalk.yellow(`  ${report.write ? "~" : "!"} ${found.file}:${String(found.line)} ${found.name} → ${found.to} (${found.since}: ${found.what})`)));
+	}
+	return lines.join("\n");
+};
+var upgrade = async (parts, options) => {
+	const unknown = parts.filter((part) => !UPGRADE_PARTS.includes(part));
+	if (unknown.length > 0) {
+		fail(`Not a part of a project to upgrade: ${unknown.join(", ")}. The parts are ${UPGRADE_PARTS.join(", ")}.`);
+		return;
+	}
+	const project = await projectHere("to upgrade");
+	if (!project) return;
+	const wanted = new Set(parts.length === 0 ? UPGRADE_PARTS : parts);
+	const { root } = project;
+	const manager = project.packageManager ?? "npm";
+	const write = Boolean(options.write);
+	const report = {
+		version: CLI_VERSION,
+		write
+	};
+	const plitzi = project.plitzi?.kind === "project" ? project.plitzi : void 0;
+	if (!plitzi && (wanted.has("files") || wanted.has("packages"))) {
+		fail("Its files and package.json are those of a project `plitzi create` wrote, and this is not one: `plitzi upgrade skills renames` brings up the rest.");
+		return;
+	}
+	const answers = plitzi ? await answersFor(root, plitzi, manager) : void 0;
+	if (answers && wanted.has("files")) {
+		const ours = machineryFiles(answers);
+		const recorded = (await readScaffoldRecord(root))?.files ?? {};
+		const plans = await planFiles(root, ours, recorded, options.take ?? []);
+		if (write) {
+			const written = plans.filter((plan) => WRITES.has(plan.status));
+			await writeFiles(root, Object.fromEntries(written.map((plan) => [plan.file, plan.ours])));
+			await writeScaffoldRecord(root, CLI_VERSION, Object.fromEntries(plans.flatMap((plan) => {
+				if (WRITES.has(plan.status) || plan.status === "current") return [[plan.file, digestOf(plan.ours)]];
+				return plan.file in recorded ? [[plan.file, recorded[plan.file]]] : [];
+			})));
+		}
+		report.files = plans.map((plan) => ({
+			file: plan.file,
+			status: plan.status,
+			...plan.status === "yours" && plan.yours !== void 0 ? { diff: unifiedDiff(plan.file, plan.yours, plan.ours) } : {}
+		}));
+	}
+	if (answers && wanted.has("packages")) {
+		const text = await readText(path.join(root, "package.json"));
+		const plan = text === void 0 ? void 0 : planPackages(text, answers);
+		if (plan) {
+			const { after, ...rest } = plan;
+			let installed;
+			if (after !== void 0) {
+				installed = "needed";
+				if (write) {
+					await fs.writeFile(path.join(root, "package.json"), after);
+					if (options.install !== false && !options.json) installed = await install(manager, root) ? "done" : "failed";
+				}
+			}
+			report.packages = {
+				...rest,
+				...installed === void 0 ? {} : { install: installed }
+			};
+		}
+	}
+	if (wanted.has("skills")) {
+		const { plans, files } = await planSkills(root);
+		if (write) await writeSkills(root, plans, files);
+		report.skills = plans;
+	}
+	if (wanted.has("renames")) {
+		const found = [];
+		for (const file of await sourceFiles(root)) {
+			const text = await readText(path.join(root, file));
+			const inFile = text === void 0 ? [] : renamesIn(file, text);
+			if (write && text !== void 0 && inFile.length > 0) {
+				const renamed = [...new Set(inFile.map((entry) => entry.name))].reduce((result, name) => result.replace(wordOf(name), RENAMES.find((rename) => rename.name === name)?.to ?? name), text);
+				await fs.writeFile(path.join(root, file), renamed);
+			}
+			found.push(...inFile);
+		}
+		report.renames = found;
+	}
+	console.log(options.json ? JSON.stringify(report) : reportText(report));
+	if (report.packages?.install === "failed") {
+		process.exitCode = 1;
+		console.error(chalk.dim(`\`${installCommand(manager)}\` failed.`));
+	}
 };
 //#endregion
 //#region src/options.ts
@@ -7747,7 +9360,7 @@ var positiveInteger = (value) => {
 * 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.name("plitzi").description("Plitzi command line").version(CLI_VERSION);
 /** A flag given more than once, as the list of every value. */
 var collect = (value, previous) => [...previous, value];
 /** The flags that shape a PROJECT: given with `--plugin`, they are a mistake worth saying rather than ignoring. */
@@ -7759,7 +9372,7 @@ var PROJECT_ONLY = [
 ];
 /** The widths a page is looked at, as one flag every command that opens a page shares. */
 var widthsOption = (description, fallback) => new Option("--width <px,px>", description).argParser(widths).default(fallback, fallback.join(","));
-var schemeOption = () => new Option("--scheme <scheme>", "The colour scheme").choices(SCHEMES).default("light");
+var schemeOption = () => new Option("--scheme <scheme>", "The space’s theme, as a visitor’s toggle sets it. The space’s own default when left out").choices(SCHEMES);
 var API_OPTION = ["--api <url>", "The platform’s API. Defaults to PLITZI_API_URL, else the one signed in to, else https://api.plitzi.com."];
 program.command("create").argument("[directory]", "Where to write it. Defaults to the current directory, or asked for with --plugin.").description("Scaffold a project that renders a Plitzi space, or with --plugin a plugin package").addOption(new Option("-m, --mode <mode>", "server (SSR + RSC on a Node tier) or client (browser only)").choices(["server", "client"])).addOption(new Option("-s, --source <source>", "local (the space travels in the project) or cloud (read it from Plitzi)").choices(["local", "cloud"])).option("-k, --key <key>", "Cloud only: the space key (asked for when omitted)").option("-e, --environment <environment>", "Which version: main (the draft), or a published environment — what --from takes out, and what a cloud project serves", "main").option("--revision <n>", "A published environment’s revision, pinned rather than its latest (with --from or --source cloud)").addOption(new Option("-p, --package-manager <manager>", "The package manager the project is written for. Asked for when left out.").choices([...PACKAGE_MANAGERS])).option("--from <space>", "Make it from a space on Plitzi (its id or permanent URL): its pages, actions, functions, runtime, plugins and files, served by the project alone. Signs in as you; the space must be one you can change.").option(...API_OPTION).option("--plugin", "A plugin package instead: one element any space can load, with a preview and a build").option("--name <name>", "Plugin only: its package name (plitzi-plugin-seat-picker). Asked for when left out.").option("--title <title>", "Plugin only: what the builder calls the element").option("--description <description>", "Plugin only: what the element is for, in a sentence").option("--owner <owner>", "Plugin only: who publishes it").option("--elements <names>", "Plugin only: other elements the package holds, by name, separated by commas").addOption(new Option("-t, --template <template>", "What a space written here starts as: welcome (a tour, the default), blank (tokens, a layout, one empty page) or catalog (a shop: layout, card component, data, filtered list, a page per product)").choices([...CREATE_TEMPLATES])).option("--no-install", "Write the files without installing dependencies").option("-f, --force", "Write into a directory that is not empty").option("-y, --yes", "At a terminal: take the defaults for any choice not passed. Without one, every choice must be passed").action((directory, options) => {
 	if (!options.plugin) return create(directory, options);
@@ -7768,6 +9381,7 @@ program.command("create").argument("[directory]", "Where to write it. Defaults t
 	return createPlugin(directory, options);
 });
 program.command("pull").description("Bring a project made with create --from up to date with its space: what changed there is written, what changed here is kept").option("-f, --force", "Where a file changed both here and on the space, take the space’s copy").option("-e, --environment <environment>", "Follow another version from now on: main (the draft), or a published environment").option("--revision <n>", "Pin a published revision of it, or latest to follow its newest again").option(...API_OPTION).action((options) => pull(options));
+program.command("push").argument("[parts...]", `Only these: ${PUSH_PARTS.join(", ")}. None named: what changed — ticked at a terminal, to choose from`).description("Put the project back on the space it works with, as its draft: the way back of pull. Refused when the draft changed since").option("-f, --force", "Replace the space’s draft even when it changed since, or holds work this project never had").option("--cdn <identifier>", "Which of the space’s CDNs a plugin goes to, when it has several").option("--bucket <identifier>", "Which public bucket a plugin goes in, when there are several").option(...API_OPTION).action((parts, options) => push(parts, options));
 program.command("add").description("Add something to the project you are in").command("plugin").argument("[names...]", "What each element is called: seat-picker. Asked for when left out.").description("Add elements of your own to this project: each one its component, declaration and builder panel").option("-d, --dir <folder>", "The folder that holds the project’s components. Asked for, unless the project says.").option("--title <title>", "One element only: what the builder calls it").option("--description <description>", "One element only: what it is for, in a sentence").option("--prop <name:type=default>", "One element only: an attribute it takes — interval:number=5000, paused:boolean, label:string=Hi. Repeat it", collect, []).option("--trigger <name:fields>", "An event it fires and what a flow reads — onTick:count. Repeat it", collect, []).option("--callback <name>", "An action a flow can call on it — reset. Repeat it", collect, []).option("--headless", "Nothing to see: hidden on a page, a badge in the builder (a clock, a listener)").option("-f, --force", "Write into a folder that is not empty").action((names, options) => addPlugin(names, options));
 var pack = program.command("pack").description("Build something of this project into what the platform takes");
 pack.command("plugin").argument("[folders...]", "Element folders to pack, the main one first. In a plugin package, left out: all of them.").description("Build a plugin: one ES module, its plugin-manifest.json, and the zip the builder takes under Resources").option("-o, --out <folder>", "Where the build goes. Emptied first; it must be inside the project.").option("--no-zip", "Build without the zip").option("--plugin-version <version>", "The version the manifest carries. Defaults to the one in package.json.").option("--source-root <folder>", "The project its source is kept relative to, when the elements are a project of their own inside this one").action((folders, options) => packPluginCommand(folders, options));
@@ -7776,16 +9390,17 @@ program.command("login").description("Sign in, in your browser. The session is k
 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("--json", "One object: { api, user, space }, for a tool or an agent").option(...API_OPTION).action((options) => whoami(options));
 program.command("space").description("Choose the space to work in, in your browser. One at a time: it replaces the one chosen before").option(...API_OPTION).action((options) => space(options));
-program.command("check").argument("[path]", "The page: /about. The home page when left out").description("Whether a page of the running project is whole, in text: every element on screen, no broken image, no console error, no failed flow").addOption(widthsOption("The widths to check it at, separated by commas", [1440, 390])).addOption(schemeOption()).option("--state", "Also what the page holds: its state, and every source by name").option("--element <id>", "Also one element: what it reads, its own state, whether it is on screen").option("--json", "One object per width, for a tool or an agent").action((path, options) => check(path, options));
+program.command("check").argument("[path]", "The page: /about. The home page when left out").description("Whether a page of the running project is whole, in text: every element on screen, no broken image, no console error, no failed flow").addOption(widthsOption("The widths to check it at, separated by commas", [1440, 390])).addOption(schemeOption()).option("--state", "Also what the page holds: its state, and every source by name").option("--element <id>", "Also one element: what it reads, its own state, whether it is on screen").option("--ssr", "Also the HTML the server sent against the hydrated page: what a server provider sent late").option("--json", "One object per width, for a tool or an agent").action((path, options) => check(path, options));
 program.command("fix").description("What authoring would fix in the space, as edits to your source: shown as a diff; with --write written, formatted and checked").option("--write", "Write the edits — kept only when the space authors with each fix gone and no problem added").option("--json", "The plan as one object, for a tool or an agent").action((options) => fix(options));
 program.command("import").argument("<url>", "The page to start from: https://example.com/pricing").description("A page of a site you verified, as a place to start writing from: its tokens, the outline of its blocks per breakpoint, its lists as JSON — never its words").option("-o, --out <dir>", "Where it is written, inside the project", "src/imported").addOption(widthsOption("The widths it is measured at: the widest is desktop, then tablet and mobile", [
 	1440,
 	768,
 	390
 ])).option("-f, --force", "Write over what --out already holds").option("--json", "One object, for a tool or an agent").option(...API_OPTION).action((url, options) => importPage(url, options));
-program.command("shot").argument("[path]", "The page: /about. The home page when left out").description("A picture of one page of the running project — and, asked, how it differs from another or what moves").addOption(new Option("--width <px>", "The viewport width").argParser(width).default(1280)).addOption(new Option("--height <px>", "The viewport height (the picture is the whole page)").argParser(positiveInteger).default(800)).addOption(schemeOption()).option("-o, --out <file>", "Where the picture goes. visual/.shots/<page>-<width>-<scheme>.png by default").option("--compare <url>", "Another site: the same page there, side by side, and how much differs by section").addOption(new Option("--frames <n>", "Pictures taken one after another: which sections move (a marquee, an autoplay)").argParser(positiveInteger)).addOption(new Option("--every <ms>", "How far apart --frames are taken").argParser(positiveInteger).default(500)).option("--wait-for <element>", "An element to wait for first: its name (data-plitzi-el) or a CSS selector").option("--reduced-motion", "As a visitor who asked for less motion").option("--json", "One object, for a tool or an agent").action((path, options) => shot(path, options));
-program.command("explain").argument("[name]", "An element, a step, a trigger, a problem’s code or a transformer: container, navigate, class-and-css").description("What a name means when authoring a space — what it takes, fires, reads and how it is written").option("--list <kind>", "Every name of a kind: elements, steps, triggers, codes, transformers").option("--json", "One object, for a tool or an agent").action((name, options) => explainCommand(name, options));
-program.command("skills").description("The Plitzi skills an agent reads in .claude/skills/").command("update").description("Bring them up to the Plitzi packages this project has installed, each replaced whole").action(() => skillsUpdate());
+program.command("shot").argument("[path]", "The page: /about. The home page when left out").description("A picture of one page of the running project — and, asked, how it differs from another or what moves").addOption(new Option("--width <px>", "The viewport width").argParser(width).default(1280)).addOption(new Option("--height <px>", "The viewport height (the picture is the whole page unless --viewport, --scroll-to or --clip)").argParser(positiveInteger).default(800)).addOption(schemeOption()).option("-o, --out <file>", "Where the picture goes. tmp/shots/<page>-<width>-<scheme>.png by default").option("--compare <url>", "Another site: the same page there, side by side, and how much differs by section").addOption(new Option("--frames <n>", "Pictures taken one after another: which sections move (a marquee, an autoplay)").argParser(positiveInteger)).addOption(new Option("--every <ms>", "How far apart --frames are taken").argParser(positiveInteger).default(500)).option("--wait-for <element>", "An element to wait for first: its name (data-plitzi-el) or a CSS selector").option("--clip <element>", "Only this element — its name or a CSS selector — scrolled to wherever it is").option("--scroll-to <element>", "The page scrolled until this element is in view; the picture is the screen there").option("--viewport", "Only what fits the viewport, not the whole page").option("--reduced-motion", "As a visitor who asked for less motion").option("--json", "One object, for a tool or an agent").action((path, options) => shot(path, options));
+program.command("explain").argument("[name]", "An element, a step, a trigger, a problem’s code, a transformer or a helper: container, navigate, class-and-css, bindTemplate, motion").description("What a name means when authoring a space — what it takes, fires, reads and how it is written").option("--list <kind>", "Every name of a kind: elements, steps, triggers, codes, transformers, helpers").option("--json", "One object, for a tool or an agent").action((name, options) => explainCommand(name, options));
+program.command("upgrade").alias("update").argument("[parts...]", `Only these: ${UPGRADE_PARTS.join(", ")} — every one when none is named`).description("Bring the project up to this CLI: its machinery files, package.json, the skills and renamed names — shown; with --write made").option("--write", "Make the changes: files nobody changed replaced, package.json merged and installed, names renamed").option("--take <files...>", "Replace these files of your own too (`all` for every one), after reading their diff").option("--no-install", "Write package.json and leave the install to you").option("--json", "One object, for a tool or an agent").action((parts, options) => upgrade(parts, options));
+program.command("skills").description("The Plitzi skills an agent reads in .claude/skills/").command("update").description("Bring them up to the Plitzi packages this project has installed, each replaced whole (`upgrade skills --write`)").action(() => upgrade(["skills"], { write: true }));
 program.command("data").description("The JSON a project serves (public/data), without reading it whole").command("describe").argument("<file>", "A JSON file: public/data/products.json").description("Its shape — every field, its type, whether every row has it — and one row of its longest list").option("--json", "One object: { shape, example }").action((file, options) => dataDescribe(file, options));
 program.command("upload").description("Put something of this project on the space you work in").command("plugin").argument("[zip]", "The zip plitzi pack plugin built. Left out: the one packed in this project.").description("Upload a packed plugin to a CDN of the space you work in, and install it there").option("--cdn <identifier>", "Which of the space’s CDNs the bucket is in.").option("--bucket <identifier>", "Which public bucket the plugin goes in. Asked for when there are several.").option(...API_OPTION).action((zip, options) => uploadPluginCommand(zip, options));
 var functions = program.command("functions").description("The space’s own server code: functions/ in this project is a working copy of it");