@plitzi/cli 0.38.3 → 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
 /**
@@ -1494,7 +1539,7 @@ 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
+		* 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.
@@ -1591,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, 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 \`.plitzi/dev-server.json\` (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.`;
+/**
+* `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
 
@@ -1613,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}
 
@@ -1631,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
@@ -1656,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"}.
@@ -1675,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
@@ -1693,12 +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.
@@ -1765,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.
@@ -1781,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.
@@ -1892,9 +1954,9 @@ 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}/\`);`;
@@ -1912,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';
@@ -1926,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) {
@@ -1936,12 +2003,13 @@ for (const warning of warnings) {
 ${PLUGINS}
 
 /**
- * While developing, the documents are served from the file \`npm run author\` writes, which the server reads again
- * whenever it changes — so a save is re-authored and shown without restarting anything (see \`watchSpace\` below). A
- * deployment keeps them in memory, as authored at boot.
+ * 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, 'space/offline-data.json');
+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\`);
@@ -1961,7 +2029,7 @@ 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,
@@ -2010,7 +2078,7 @@ const watchSpace = (): void => {
     }
 
     authoring = true;
-    const child = spawn(process.execPath, [path.join(PROJECT_ROOT, 'src/author.ts')], {
+    const child = spawn(process.execPath, [path.join(PROJECT_ROOT, 'src/author.ts'), '--out', OFFLINE_DATA], {
       cwd: PROJECT_ROOT,
       stdio: 'inherit'
     });
@@ -2089,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,
@@ -2183,9 +2251,9 @@ 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")]] : [];
 });
 /**
@@ -2199,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;
 };
@@ -2217,22 +2285,25 @@ 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 warnings and suggestions said have one fix \`plitzi fix\` can write in this source — and the line that says so. */
 const fixableHint = (): string | undefined => {
@@ -2282,9 +2353,15 @@ const outdated = (): { skill?: string; files?: string; sdk: string } | undefined
 };
 
 try {
-  const { schema, style, warnings, suggestions } = authorSpace(space, { plugins: declarations });
-  mkdirSync('space', { recursive: true });
-  writeFileSync('space/offline-data.json', \`\${JSON.stringify({ schema, style }, null, 2)}\\n\`);
+  // \`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 behind = outdated();
   if (json) {
@@ -2319,7 +2396,7 @@ try {
     }
 
     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) {
@@ -2418,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 {};
     }
@@ -2442,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.
@@ -2794,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(),
@@ -2933,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",
@@ -3049,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
 		}
@@ -3779,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: {
@@ -3845,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.
@@ -3946,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;
@@ -3977,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;
@@ -3996,7 +4073,7 @@ 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$1 = async (file) => {
 	try {
@@ -4034,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)
 	};
@@ -4048,7 +4125,7 @@ var plitziProject = async (root, packageJson) => {
 	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)
 	};
@@ -4354,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)}` };
 	}
@@ -4372,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 = [];
@@ -4406,12 +4521,20 @@ var checkAt = async (browser, origin, pathname, width, scheme, handles, asked) =
 			hiddenAtWidth: [],
 			consoleErrors,
 			failedRequests,
-			devTools: false
+			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 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}`,
@@ -4429,6 +4552,11 @@ var checkAt = async (browser, origin, pathname, width, scheme, handles, asked) =
 			...issue,
 			width
 		})),
+		...(data?.issues ?? []).map((issue) => ({
+			...issue,
+			width
+		})),
+		...late?.issues ?? [],
 		...failedFlows
 	];
 	return {
@@ -4442,8 +4570,10 @@ var checkAt = async (browser, origin, pathname, width, scheme, handles, asked) =
 		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 }
 	};
 };
@@ -4467,9 +4597,22 @@ var shapeOf = (value) => {
 	const text = value === void 0 ? "undefined" : JSON.stringify(value);
 	return text.length > 60 ? `${text.slice(0, 57)}…` : text;
 };
+/** 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);
+	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`),
@@ -4493,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);
@@ -4505,13 +4648,13 @@ 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));
+		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 {
@@ -4570,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`);
@@ -4622,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({
@@ -4655,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) => {
@@ -4974,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\`,
@@ -4996,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}\`);
@@ -5051,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. */
@@ -5212,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,
@@ -5226,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
@@ -5250,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
 /**
@@ -5264,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) => {
@@ -5335,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
@@ -5902,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"));
@@ -6540,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`
@@ -6576,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;
@@ -6674,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("="));
@@ -6693,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"]
 	};
@@ -6702,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;
@@ -6712,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: _
 	} : {
@@ -7332,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) {
@@ -7381,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]];
@@ -7418,6 +7629,202 @@ var pull = async (options) => {
 	console.log("");
 };
 //#endregion
+//#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)
+		};
+	}
+	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
@@ -7445,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) => {
@@ -7456,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,
@@ -7499,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`);
@@ -7644,55 +8058,840 @@ 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.` };
-	}
-	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();
-	return {
-		page,
-		png: await capture(page, framing(view))
-	};
-};
-var framing = (view) => {
-	if (view.clip) return {
-		kind: "element",
-		selector: selectorOf(view.clip)
+//#region src/commands/uploadPlugin.ts
+/** The zips `plitzi pack plugin` leaves: at a plugin package's root, or under `dist/plugins` of any other project. */
+var packedZips = async (root) => {
+	const inFolder = async (dir) => {
+		try {
+			return (await fs.readdir(dir)).filter((file) => file.endsWith(".zip")).map((file) => path.join(dir, file));
+		} catch {
+			return [];
+		}
 	};
-	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" });
-};
-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
-	}));
+	const zips = [...await inFolder(root), ...await inFolder(path.join(root, "dist/plugins"))];
+	const modified = await Promise.all(zips.map(async (zip) => (await fs.stat(zip)).mtimeMs));
+	return zips.map((zip, index) => ({
+		zip,
+		at: modified[index]
+	})).sort((a, b) => b.at - a.at).map(({ zip }) => zip);
 };
-var shot = async (route, options) => {
-	const project = await projectHere("whose page to picture");
-	if (!project) return;
+/** The zip named, or the one packed here — asked for at a terminal when there are several. */
+var chooseZip = async (given) => {
+	if (given) return path.resolve(given);
+	const project = await findProject(process.cwd());
+	const zips = project ? await packedZips(project.root) : [];
+	if (zips.length === 0) {
+		fail("No packed plugin here. Build one with plitzi pack plugin, or name it: plitzi upload plugin <file.zip>.");
+		return;
+	}
+	if (zips.length === 1) return zips[0];
+	const choices = zips.map((zip) => path.relative(process.cwd(), zip));
+	if (!atTerminal()) {
+		refuseWithoutTerminal("upload", [{
+			flag: "<zip> (the argument)",
+			choices,
+			question: "Which packed plugin is to be uploaded?"
+		}], "plitzi upload plugin stopped before uploading anything: which plugin goes to the space is a choice");
+		return;
+	}
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		return await askPick(rl, "Which packed plugin? The newest is first.", zips.map((zip, index) => ({
+			label: choices[index],
+			value: zip
+		})));
+	} finally {
+		rl.close();
+	}
+};
+/**
+* The manifest a zip carries at its root, read here before anything is sent: a zip that is not a plugin is refused by
+* the platform too, but only after it has travelled.
+*/
+var manifestOf = (zip) => {
+	try {
+		const entry = Object.values(unzipSync(zip, { filter: (file) => file.name === "plugin-manifest.json" })).at(0);
+		const parsed = entry ? JSON.parse(new TextDecoder().decode(entry)) : {};
+		return typeof parsed.root === "string" && parsed.root ? {
+			root: parsed.root,
+			version: typeof parsed.version === "string" ? parsed.version : ""
+		} : void 0;
+	} catch {
+		return;
+	}
+};
+/**
+* The public bucket a plugin goes in — the one `--cdn` and `--bucket` name, the only one there is, or the one picked.
+* A private bucket keeps server code and has no public address, so it is never one.
+*/
+var chooseTarget = async (cdns, { cdn: givenCdn, bucket: givenBucket }, spaceName) => {
+	if (givenCdn && !cdns.some((cdn) => cdn.identifier === givenCdn)) {
+		fail(`${spaceName} has no CDN "${givenCdn}". Its CDNs: ${cdns.map((cdn) => cdn.identifier).join(", ")}.`);
+		return;
+	}
+	const candidates = cdns.filter((cdn) => !givenCdn || cdn.identifier === givenCdn).flatMap((cdn) => cdn.buckets.map((bucket) => ({
+		cdn,
+		bucket
+	})));
+	if (givenBucket) {
+		const named = candidates.find(({ bucket }) => bucket.identifier === givenBucket);
+		if (!named) {
+			fail(`${spaceName} has no bucket "${givenBucket}"${givenCdn ? ` in the CDN "${givenCdn}"` : ""}.`);
+			return;
+		}
+		if (named.bucket.visibility === "private") {
+			fail(`"${givenBucket}" is a private bucket: it has no public address, so no page could load a plugin from it.`);
+			return;
+		}
+		return named;
+	}
+	const targets = candidates.filter(({ bucket }) => bucket.visibility === "public");
+	if (targets.length === 0) {
+		fail(`${spaceName} has no public bucket to put a plugin in. Add one to a CDN in the builder, under Resources.`);
+		return;
+	}
+	if (targets.length === 1) return targets[0];
+	if (!atTerminal()) {
+		refuseWithoutTerminal("upload", [{
+			flag: "--bucket",
+			choices: targets.map(({ bucket }) => bucket.identifier),
+			question: `Which of ${spaceName}'s public buckets does the plugin go in? (narrow with --cdn)`
+		}], "plitzi upload plugin stopped before uploading anything: which bucket serves the plugin is a choice");
+		return;
+	}
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		return await askPick(rl, `Which of ${spaceName}'s public buckets does the plugin go in?`, targets.map((target) => ({
+			label: `${target.cdn.name} — ${target.bucket.name} ${chalk.dim(`${target.bucket.identifier} · ${target.bucket.domain}`)}`,
+			value: target
+		})));
+	} finally {
+		rl.close();
+	}
+};
+/** 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(`${filename} is not a plugin: it has no plugin-manifest.json at its root. Build it with plitzi pack plugin.`);
+		return "failed";
+	}
+	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,
+		bucket: bucket.identifier
+	});
+	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 "failed";
+	}
+	const { status, data } = uploaded.value.reply;
+	if (status === 413) {
+		fail(`${filename} is larger than ${connection.api} accepts.`);
+		return "failed";
+	}
+	if (status !== 201) {
+		fail(data.error ?? `The upload was refused (${status}).`);
+		return "failed";
+	}
+	const installed = data.installed === "updated" ? `now loads ${label}` : `loads ${label} from now on`;
+	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."));
+	if (source) await keepSource(uploaded.value.connection, space.id, source);
+	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);
@@ -7713,49 +8912,42 @@ var shot = async (route, options) => {
 		const view = {
 			width: options.width ?? 1280,
 			height: options.height ?? 800,
-			scheme: options.scheme ?? "light",
+			...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 } : {}
+			...options.viewport ? { viewport: true } : {},
+			still: !options.clip && !options.scrollTo && !options.viewport && (options.frames ?? 0) <= 1
 		};
 		const how = framing(view);
-		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);
+		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: view.scheme,
-			out
+			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 target = other.pathname === "/" ? new URL(pathname, other).href : other.href;
-			const theirs = await pictureOf(browser, target, view);
-			if ("problem" in theirs) {
-				fail(theirs.problem);
+			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;
 			}
-			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`
-			};
+			report.compare = compared;
 		}
 		const frames = options.frames ?? 0;
 		if (frames > 1) {
@@ -7766,7 +8958,7 @@ var shot = async (route, options) => {
 				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));
+			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,
@@ -7784,10 +8976,9 @@ var shot = async (route, options) => {
 			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.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();
@@ -8138,187 +9329,6 @@ var upgrade = async (parts, options) => {
 	}
 };
 //#endregion
-//#region src/commands/uploadPlugin.ts
-/** The zips `plitzi pack plugin` leaves: at a plugin package's root, or under `dist/plugins` of any other project. */
-var packedZips = async (root) => {
-	const inFolder = async (dir) => {
-		try {
-			return (await fs.readdir(dir)).filter((file) => file.endsWith(".zip")).map((file) => path.join(dir, file));
-		} catch {
-			return [];
-		}
-	};
-	const zips = [...await inFolder(root), ...await inFolder(path.join(root, "dist/plugins"))];
-	const modified = await Promise.all(zips.map(async (zip) => (await fs.stat(zip)).mtimeMs));
-	return zips.map((zip, index) => ({
-		zip,
-		at: modified[index]
-	})).sort((a, b) => b.at - a.at).map(({ zip }) => zip);
-};
-/** The zip named, or the one packed here — asked for at a terminal when there are several. */
-var chooseZip = async (given) => {
-	if (given) return path.resolve(given);
-	const project = await findProject(process.cwd());
-	const zips = project ? await packedZips(project.root) : [];
-	if (zips.length === 0) {
-		fail("No packed plugin here. Build one with plitzi pack plugin, or name it: plitzi upload plugin <file.zip>.");
-		return;
-	}
-	if (zips.length === 1) return zips[0];
-	const choices = zips.map((zip) => path.relative(process.cwd(), zip));
-	if (!atTerminal()) {
-		refuseWithoutTerminal("upload", [{
-			flag: "<zip> (the argument)",
-			choices,
-			question: "Which packed plugin is to be uploaded?"
-		}], "plitzi upload plugin stopped before uploading anything: which plugin goes to the space is a choice");
-		return;
-	}
-	const rl = readline.createInterface({
-		input: process.stdin,
-		output: process.stdout
-	});
-	try {
-		return await askPick(rl, "Which packed plugin? The newest is first.", zips.map((zip, index) => ({
-			label: choices[index],
-			value: zip
-		})));
-	} finally {
-		rl.close();
-	}
-};
-/**
-* The manifest a zip carries at its root, read here before anything is sent: a zip that is not a plugin is refused by
-* the platform too, but only after it has travelled.
-*/
-var manifestOf = (zip) => {
-	try {
-		const entry = Object.values(unzipSync(zip, { filter: (file) => file.name === "plugin-manifest.json" })).at(0);
-		const parsed = entry ? JSON.parse(new TextDecoder().decode(entry)) : {};
-		return typeof parsed.root === "string" && parsed.root ? {
-			root: parsed.root,
-			version: typeof parsed.version === "string" ? parsed.version : ""
-		} : void 0;
-	} catch {
-		return;
-	}
-};
-/**
-* The public bucket a plugin goes in — the one `--cdn` and `--bucket` name, the only one there is, or the one picked.
-* A private bucket keeps server code and has no public address, so it is never one.
-*/
-var chooseTarget = async (cdns, { cdn: givenCdn, bucket: givenBucket }, spaceName) => {
-	if (givenCdn && !cdns.some((cdn) => cdn.identifier === givenCdn)) {
-		fail(`${spaceName} has no CDN "${givenCdn}". Its CDNs: ${cdns.map((cdn) => cdn.identifier).join(", ")}.`);
-		return;
-	}
-	const candidates = cdns.filter((cdn) => !givenCdn || cdn.identifier === givenCdn).flatMap((cdn) => cdn.buckets.map((bucket) => ({
-		cdn,
-		bucket
-	})));
-	if (givenBucket) {
-		const named = candidates.find(({ bucket }) => bucket.identifier === givenBucket);
-		if (!named) {
-			fail(`${spaceName} has no bucket "${givenBucket}"${givenCdn ? ` in the CDN "${givenCdn}"` : ""}.`);
-			return;
-		}
-		if (named.bucket.visibility === "private") {
-			fail(`"${givenBucket}" is a private bucket: it has no public address, so no page could load a plugin from it.`);
-			return;
-		}
-		return named;
-	}
-	const targets = candidates.filter(({ bucket }) => bucket.visibility === "public");
-	if (targets.length === 0) {
-		fail(`${spaceName} has no public bucket to put a plugin in. Add one to a CDN in the builder, under Resources.`);
-		return;
-	}
-	if (targets.length === 1) return targets[0];
-	if (!atTerminal()) {
-		refuseWithoutTerminal("upload", [{
-			flag: "--bucket",
-			choices: targets.map(({ bucket }) => bucket.identifier),
-			question: `Which of ${spaceName}'s public buckets does the plugin go in? (narrow with --cdn)`
-		}], "plitzi upload plugin stopped before uploading anything: which bucket serves the plugin is a choice");
-		return;
-	}
-	const rl = readline.createInterface({
-		input: process.stdin,
-		output: process.stdout
-	});
-	try {
-		return await askPick(rl, `Which of ${spaceName}'s public buckets does the plugin go in?`, targets.map((target) => ({
-			label: `${target.cdn.name} — ${target.bucket.name} ${chalk.dim(`${target.bucket.identifier} · ${target.bucket.domain}`)}`,
-			value: target
-		})));
-	} finally {
-		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;
-	}
-	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;
-	}
-	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),
-		bucket: bucket.identifier
-	});
-	const uploaded = await authorizedRequest(listed.value.connection, `/spaces/${space.id}/cdns/${encodeURIComponent(cdn.identifier)}/plugins?${query}`, {
-		method: "POST",
-		headers: { "Content-Type": "application/zip" },
-		body: new Uint8Array(zip)
-	});
-	if (!uploaded.ok) {
-		fail(uploaded.error);
-		return;
-	}
-	const { status, data } = uploaded.value.reply;
-	if (status === 413) {
-		fail(`${path.basename(zipPath)} is larger than ${api} accepts.`);
-		return;
-	}
-	if (status !== 201) {
-		fail(data.error ?? `The upload was refused (${status}).`);
-		return;
-	}
-	const installed = data.installed === "updated" ? `now loads ${label}` : `loads ${label} from now on`;
-	console.log(chalk.green(`\n${space.name} ${installed}.`));
-	if (data.resource?.path) console.log(chalk.dim(`  ${data.resource.path}`));
-	console.log(chalk.dim("  Any builder open on the space loads it now."));
-	const source = await fs.readFile(sourceFileOf(zipPath)).catch(() => void 0);
-	if (source) await keepSource(uploaded.value.connection, space.id, source);
-	console.log("");
-};
-//#endregion
 //#region src/options.ts
 /**
 * What a flag's value has to be, read once where the command line is declared. A value that is not one is refused
@@ -8362,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);
@@ -8371,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));
@@ -8379,15 +9390,15 @@ 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 unless --viewport, --scroll-to or --clip)").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("--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 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("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));