mechanica 2.1.0-beta.5 → 2.1.0-beta.7

package/README.md

@@ -361,7 +361,7 @@ These drive a locally installed Chrome or Edge (or `--browser <path>`) and need
 | `mechanica images` | Generate image dimensions and blur-up previews for `.mech/assets` (needs `sharp`; `--force` redoes all) |
 | `mechanica login` | Sign in to the Mechanica platform and save an access token for this machine (`--host`, `--token`) |
 | `mechanica link <slug>` | Point this repository at a site on the platform (`--create` makes the site); uploads are then kept by the platform, so `.mech/assets/` goes into `.gitignore` |
-| `mechanica push` | Publish the committed project to the platform: pull what was edited online, send the uploads it lacks, `git push`, build and upload the bundle when the code changed, wait for the deploy |
+| `mechanica push` | Publish the committed project to the platform: pull what was edited online, send the uploads it lacks, `git push`, build and upload the bundle when the code changed, wait for the deploy. It pushes the branch that is checked out, under its own name: the first branch a site is pushed is the site itself, any other is deployed to an address of its own (`<slug>--<branch>`) with its own online editor — a branch name is lowercase letters, digits and single hyphens |
 | `mechanica assets pull` | Download the uploads made in the platform's online editor that this project lacks (the dev server fetches them one by one on demand) |
 
 ## Plugin options

package/dist/chunks/{assets-C7yHGJBU.js → assets-nujjbCx8.js}

@@ -1,4 +1,4 @@
-import { W as isAssetName, Y as updateImageManifest, q as readImageManifest } from "./rich-text-codec-BXOKV94u.js";
+import { G as isAssetName, J as readImageManifest, X as updateImageManifest } from "./rich-text-codec-BSD35k2U.js";
 import { join } from "node:path";
 import { chmod, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
 import os from "node:os";

package/dist/chunks/{node-adapter-GZZrfGSz.js → node-adapter-CSkDXYGO.js}

@@ -1,7 +1,7 @@
-import { n as configureSite, r as indexGeneratedPages } from "./site-Co04D3rB.js";
-import { A as pageVersion, C as harvestPageImages, D as movePage, E as listPages, I as setPageDraft, J as storeUpload, K as listUploads, L as translationsOf, M as renamePage, N as savePage, R as contentFilesOf, T as listFolders, U as fsAssetStore, W as isAssetName, _ as deletePage, a as folderOf, b as fillContentDefaults, c as mergeLocaleSiteData, f as readSiteData, g as createTranslation, h as createPage, j as readPage, l as mergeSiteData, m as PageExistsError, o as mergeFolderData, s as mergeLocaleFolderData, u as readFolderData, v as deleteTranslation, w as imageNamesOf, x as fillImageMeta, y as duplicatePage } from "./rich-text-codec-BXOKV94u.js";
+import { n as configureSite, r as indexGeneratedPages } from "./site-DfazSr3_.js";
+import { A as pageVersion, C as harvestPageImages, D as movePage, E as listPages, I as setPageDraft, L as translationsOf, M as renamePage, N as savePage, Q as uploadResponse, R as contentFilesOf, T as listFolders, U as contentTypeOf, W as fsAssetStore, Y as storeUpload, _ as deletePage, a as folderOf, b as fillContentDefaults, c as mergeLocaleSiteData, f as readSiteData, g as createTranslation, h as createPage, j as readPage, l as mergeSiteData, m as PageExistsError, o as mergeFolderData, q as listUploads, s as mergeLocaleFolderData, u as readFolderData, v as deleteTranslation, w as imageNamesOf, x as fillImageMeta, y as duplicatePage } from "./rich-text-codec-BSD35k2U.js";
 import fs, { readFileSync, readdirSync } from "node:fs";
-import { basename, extname, join, resolve, sep } from "node:path";
+import { basename, join, resolve, sep } from "node:path";
 import { EDITOR_DIST_DIR, mergeTranslation, parseLocalePath, passDataToHTML, resolveQueryKey, serializeState } from "mechanica-shared";
 import { parseComposedBlock, serializeComposedBlock } from "mechanica-shared/block-format";
 import { createHash } from "node:crypto";
@@ -362,25 +362,6 @@ var json = (data, status = 200) => new Response(JSON.stringify(data), {
 	status,
 	headers: { "content-type": "application/json" }
 });
-/** Content types of the files a site stores — browsers don't sniff SVG or fonts. */
-var MIME = {
-	".png": "image/png",
-	".jpg": "image/jpeg",
-	".jpeg": "image/jpeg",
-	".gif": "image/gif",
-	".webp": "image/webp",
-	".avif": "image/avif",
-	".svg": "image/svg+xml",
-	".ico": "image/x-icon",
-	".mp4": "video/mp4",
-	".webm": "video/webm",
-	".mp3": "audio/mpeg",
-	".pdf": "application/pdf",
-	".json": "application/json",
-	".txt": "text/plain; charset=utf-8",
-	".woff": "font/woff",
-	".woff2": "font/woff2"
-};
 /**
 * Stream a file from `dir`, containing the resolved path so an encoded `..`
 * (or an absolute path) cannot escape it.
@@ -395,7 +376,7 @@ function serveFile(dir, relative, headers = {}) {
 	const file = resolve(dir, decoded);
 	if (file !== dir && !file.startsWith(dir + sep)) return new Response("Forbidden", { status: 403 });
 	if (!fs.existsSync(file) || !fs.statSync(file).isFile()) return new Response("Not found", { status: 404 });
-	const type = MIME[extname(file).toLowerCase()];
+	const type = contentTypeOf(file);
 	return new Response(Readable.toWeb(fs.createReadStream(file)), { headers: {
 		...type ? { "content-type": type } : {},
 		...headers
@@ -422,19 +403,7 @@ function validateComposed(def) {
 function createEditorService(mech, options = {}) {
 	const mechDir = typeof mech === "string" ? mech : null;
 	const assets = options.assets ?? (mechDir ? fsAssetStore(mechDir) : null);
-	const asset = async (encoded) => {
-		let name;
-		try {
-			name = decodeURIComponent(encoded);
-		} catch {
-			return new Response("Bad request", { status: 400 });
-		}
-		if (!assets || !isAssetName(name)) return null;
-		const body = await assets.open(name);
-		if (!body) return null;
-		const type = MIME[extname(name).toLowerCase()];
-		return new Response(body, { headers: type ? { "content-type": type } : {} });
-	};
+	const asset = (encoded) => uploadResponse(assets, encoded);
 	let configured = null;
 	let generatedIndex = null;
 	const currentSite = async () => {

package/dist/chunks/{rich-text-codec-BXOKV94u.js → rich-text-codec-BSD35k2U.js}

@@ -273,6 +273,74 @@ async function listUploads(assets) {
 		src: assetUrl(name)
 	}));
 }
+/** Content types of the files a site stores — browsers don't sniff SVG or fonts. */
+var MIME = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".avif": "image/avif",
+	".svg": "image/svg+xml",
+	".ico": "image/x-icon",
+	".mp4": "video/mp4",
+	".webm": "video/webm",
+	".mp3": "audio/mpeg",
+	".pdf": "application/pdf",
+	".json": "application/json",
+	".txt": "text/plain; charset=utf-8",
+	".woff": "font/woff",
+	".woff2": "font/woff2"
+};
+/** The content type a stored file is served with, when its extension says. */
+var contentTypeOf = (fileName) => MIME[parse(fileName).ext.toLowerCase()];
+/**
+* The HTTP answer for an upload asked for by its address — the part of
+* `/media/<name>` after the prefix, still percent-encoded. null when it is not
+* an upload of this store, so the caller can fall through; a 400 for a name
+* that is not valid encoding. One function for every host that serves uploads:
+* the dev server, an editing host, a site's live host.
+*/
+async function uploadResponse(assets, encodedName) {
+	let name;
+	try {
+		name = decodeURIComponent(encodedName);
+	} catch {
+		return new Response("Bad request", { status: 400 });
+	}
+	if (!assets || !isAssetName(name)) return null;
+	const body = await assets.open(name);
+	if (!body) return null;
+	const type = contentTypeOf(name);
+	return new Response(body, { headers: type ? { "content-type": type } : {} });
+}
+/**
+* A store for rendering a site whose uploads the host keeps and serves itself.
+* `hosted` is what the host knows about them — a name with its image info. The
+* result knows those names (`list`, `info`) but cannot open them: an export
+* over it fills in their dimensions and previews, copies no bytes, and reports
+* them as the host's to serve (see `ExportResult.uploads`). Whatever the local
+* store has is used as before.
+*/
+function withHostedAssets(local, hosted) {
+	const names = Object.keys(hosted).filter(isAssetName);
+	return {
+		write: (name, data) => local.write(name, data),
+		open: (name) => local.open(name),
+		saveInfo: (entries) => local.saveInfo(entries),
+		async list() {
+			return [.../* @__PURE__ */ new Set([...await local.list(), ...names])];
+		},
+		async info(wanted) {
+			const known = await local.info(wanted);
+			for (const name of wanted) {
+				const entry = hosted[name];
+				if (entry && !known[name]) known[name] = entry;
+			}
+			return known;
+		}
+	};
+}
 var MISS_TTL_MS = 3e4;
 var MEMORY_LIMIT = 67108864;
 /**
@@ -1203,4 +1271,4 @@ function findRichTextProps(props) {
 	return found;
 }
 //#endregion
-export { analyzeImageBuffer as $, pageVersion as A, memoryContentFiles as B, harvestPageImages as C, movePage as D, listPages as E, setPageCodec as F, isDerivedAsset as G, assetFileOf as H, setPageDraft as I, storeUpload as J, listUploads as K, translationsOf as L, renamePage as M, savePage as N, pageOfFile as O, setPageBlocks as P, wasRecentlyMutated as Q, contentFilesOf as R, getPagePath as S, listFolders as T, fsAssetStore as U, UPLOADS_PREFIX$1 as V, isAssetName as W, uploadName as X, updateImageManifest as Y, withRemoteAssets as Z, deletePage as _, folderOf as a, fillContentDefaults as b, mergeLocaleSiteData as c, readFoldersData as d, hasSharp as et, readSiteData as f, createTranslation as g, createPage as h, toBlockMeta as i, readPage as j, pageUrlOf as k, mergeSiteData as l, PageExistsError as m, richTextCodecFromBlocks as n, mergeFolderData as o, readSiteLocaleOverride as p, readImageManifest as q, composedBlockMeta as r, mergeLocaleFolderData as s, buildRichTextCodec as t, isRasterImage as tt, readFolderData as u, deleteTranslation as v, imageNamesOf as w, fillImageMeta as x, duplicatePage as y, fsContentFiles as z };
+export { withHostedAssets as $, pageVersion as A, memoryContentFiles as B, harvestPageImages as C, movePage as D, listPages as E, setPageCodec as F, isAssetName as G, assetFileOf as H, setPageDraft as I, readImageManifest as J, isDerivedAsset as K, translationsOf as L, renamePage as M, savePage as N, pageOfFile as O, setPageBlocks as P, uploadResponse as Q, contentFilesOf as R, getPagePath as S, listFolders as T, contentTypeOf as U, UPLOADS_PREFIX$1 as V, fsAssetStore as W, updateImageManifest as X, storeUpload as Y, uploadName as Z, deletePage as _, folderOf as a, fillContentDefaults as b, mergeLocaleSiteData as c, readFoldersData as d, withRemoteAssets as et, readSiteData as f, createTranslation as g, createPage as h, toBlockMeta as i, isRasterImage as it, readPage as j, pageUrlOf as k, mergeSiteData as l, PageExistsError as m, richTextCodecFromBlocks as n, analyzeImageBuffer as nt, mergeFolderData as o, readSiteLocaleOverride as p, listUploads as q, composedBlockMeta as r, hasSharp as rt, mergeLocaleFolderData as s, buildRichTextCodec as t, wasRecentlyMutated as tt, readFolderData as u, deleteTranslation as v, imageNamesOf as w, fillImageMeta as x, duplicatePage as y, fsContentFiles as z };

package/dist/chunks/{site-Co04D3rB.js → site-DfazSr3_.js}

@@ -1,4 +1,4 @@
-import { F as setPageCodec, P as setPageBlocks, i as toBlockMeta, n as richTextCodecFromBlocks, r as composedBlockMeta } from "./rich-text-codec-BXOKV94u.js";
+import { F as setPageCodec, P as setPageBlocks, i as toBlockMeta, n as richTextCodecFromBlocks, r as composedBlockMeta } from "./rich-text-codec-BSD35k2U.js";
 import fs from "node:fs";
 import { join } from "node:path";
 import { SITE_MANIFEST_FILE, areFieldSchemasRegistered, localePath, registerFieldSchemas } from "mechanica-shared";

package/dist/cli.js

@@ -1,6 +1,6 @@
-import { t as buildSiteManifest } from "./chunks/site-Co04D3rB.js";
-import { $ as analyzeImageBuffer, G as isDerivedAsset, Y as updateImageManifest, et as hasSharp, q as readImageManifest, tt as isRasterImage } from "./chunks/rich-text-codec-BXOKV94u.js";
-import { a as git, c as PlatformError, d as request, f as requireToken, l as REMOTE_NAME, m as saveToken, o as gitAuthEnv, p as hostOrigin, r as runAssetsPull, s as gitOk, t as pushUploads, u as parseRemoteUrl } from "./chunks/assets-C7yHGJBU.js";
+import { t as buildSiteManifest } from "./chunks/site-DfazSr3_.js";
+import { J as readImageManifest, K as isDerivedAsset, W as fsAssetStore, X as updateImageManifest, et as withRemoteAssets, it as isRasterImage, nt as analyzeImageBuffer, rt as hasSharp } from "./chunks/rich-text-codec-BSD35k2U.js";
+import { a as git, c as PlatformError, d as request, f as requireToken, i as uploadsIgnored, l as REMOTE_NAME, m as saveToken, n as remoteAssetsFor, o as gitAuthEnv, p as hostOrigin, r as runAssetsPull, s as gitOk, t as pushUploads, u as parseRemoteUrl } from "./chunks/assets-nujjbCx8.js";
 import { exportBuilt } from "./export.js";
 import fs, { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -128,13 +128,31 @@ async function writeSiteManifest(distDir) {
 //#endregion
 //#region src/cli/run-export.ts
 /**
+* The uploads a local export reads: the project's `.mech/assets`, and — for a
+* project linked to a hosted platform — the uploads kept there, fetched as the
+* pages turn out to need them (and kept in `.mech/assets` when git ignores it).
+* Only local files are *listed*: the uploads the platform holds that no page
+* here refers to are not this export's to warn about.
+*/
+function exportAssets(cwd) {
+	const local = fsAssetStore(join(cwd, ".mech"));
+	return {
+		...withRemoteAssets(local, remoteAssetsFor(cwd), { cache: () => uploadsIgnored(cwd) }),
+		list: () => local.list()
+	};
+}
+/**
 * `mechanica export`: build the project, then statically render every page
 * into `export/`. Kept apart from `export.ts` so that module never imports
 * Vite — `mechanica/export` runs where only a built bundle exists.
 */
 async function runExport(options = {}) {
 	await runBuild();
-	const { pages } = await exportBuilt(process.cwd(), options);
+	const cwd = process.cwd();
+	const { pages } = await exportBuilt(cwd, {
+		assets: exportAssets(cwd),
+		...options
+	});
 	for (const path of pages) console.info("Generated", path);
 	console.info(`Exported ${pages.length} page(s) → ${options.outDir ?? "export"}/`);
 }
@@ -410,7 +428,20 @@ var POLL_MS = 1e3;
 var DEPLOY_TIMEOUT_MS = 3e5;
 var AUTO_DEPLOY_WAIT_MS = 1e4;
 /**
-* `mechanica push`: publish the committed project to the platform.
+* Why a branch cannot be pushed under its name, or null when it can. On the platform a branch
+* is served at an address of its own (`<slug>--<branch>`), so its name must be able to be part
+* of one: lowercase letters, digits and single hyphens. The platform checks the same (and how
+* long the name may be for the site) — this only says it before anything is sent.
+*/
+function branchProblem(name) {
+	if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(name) || name.length > 40 || name.includes("--") || name === "edit") return `The branch "${name}" cannot be pushed under this name: on the platform a branch's name becomes part of its address, so it is up to 40 lowercase letters, digits and single hyphens (and not "edit"). Rename it — \`git branch -m new-name\` — and push again.`;
+	return null;
+}
+/**
+* `mechanica push`: publish the committed project to the platform — the branch that is checked
+* out, under its own name. The first branch a site is pushed becomes the site itself; any
+* other is deployed to an address of its own, with its own online editor, and never touches
+* the site.
 *
 *   1. bring in what was published online since the last pull (`pull --rebase`),
 *   2. send the uploads the platform lacks (they are not in git), then `git push`
@@ -445,18 +476,30 @@ async function runPush() {
 	])).code !== 0) throw new Error("Nothing to push yet — commit your project first");
 	const dirty = await gitOk(cwd, ["status", "--porcelain"]);
 	if (dirty) throw new Error(`Commit or stash your changes first — the working tree is not clean:\n${dirty}`);
+	const current = await git(cwd, [
+		"symbolic-ref",
+		"--quiet",
+		"--short",
+		"HEAD"
+	]);
+	if (current.code !== 0 || !current.stdout) throw new Error("No branch is checked out (a detached HEAD) — switch to the branch you want to push");
+	const branch = current.stdout;
+	const problem = branchProblem(branch);
+	if (problem) throw new Error(problem);
+	const ref = `refs/heads/${branch}`;
+	const query = `?branch=${encodeURIComponent(branch)}`;
 	if (await gitOk(cwd, [
 		"ls-remote",
 		"--heads",
 		"mechanica",
-		"main"
+		ref
 	], auth)) {
 		console.info("Pulling changes from the platform…");
 		const pulled = await git(cwd, [
 			"pull",
 			"--rebase",
 			REMOTE_NAME,
-			"main"
+			branch
 		], auth);
 		if (pulled.code !== 0) throw new Error(`Could not rebase onto the platform's changes:\n${pulled.stderr || pulled.stdout}\nResolve the conflict (\`git rebase --continue\`), then run \`mechanica push\` again.`);
 	}
@@ -466,14 +509,14 @@ async function runPush() {
 		token
 	});
 	const head = await gitOk(cwd, ["rev-parse", "HEAD"]);
-	console.info(`Pushing ${head.slice(0, 8)} to ${link.slug}…`);
+	console.info(`Pushing ${head.slice(0, 8)} to ${link.slug} (${branch})…`);
 	const pushed = await git(cwd, [
 		"push",
 		REMOTE_NAME,
-		"HEAD:refs/heads/main"
+		`HEAD:${ref}`
 	], auth);
 	if (pushed.code !== 0) throw new Error(`git push failed:\n${pushed.stderr || pushed.stdout}`);
-	const statusPath = `/api/sites/${site.uuid}/status`;
+	const statusPath = `/api/sites/${site.uuid}/status${query}`;
 	let status = await request(link.origin, "GET", statusPath, { token });
 	let deployId = null;
 	if (status.needsBundle) {
@@ -483,7 +526,7 @@ async function runPush() {
 			engine: engineVersion()
 		});
 		console.info(`Uploading the bundle (${(body.length / 1024 / 1024).toFixed(1)} MB)…`);
-		const uploaded = await request(link.origin, "POST", `/api/sites/${site.uuid}/bundles`, {
+		const uploaded = await request(link.origin, "POST", `/api/sites/${site.uuid}/bundles${query}`, {
 			token,
 			raw: body
 		});
@@ -513,7 +556,7 @@ async function runPush() {
 		if (deploy.log) console.error(`\n${deploy.log}\n`);
 		throw new Error(`Deploy failed: ${deploy.error ?? "unknown error"}. The previous version stays live.`);
 	}
-	console.info(`\nLive at ${deploy.url ?? status.url} — ${deploy.pages} page(s)`);
+	console.info(`\n${branch} is live at ${deploy.url ?? status.url} — ${deploy.pages} page(s)`);
 }
 //#endregion
 //#region src/cli/headless.ts
@@ -1200,7 +1243,9 @@ Usage:
                             (--create makes the site, --name "Site name")
   mechanica push            Publish the committed project: pull what was edited
                             online, git push, build + upload the bundle when the
-                            code changed, and wait for the deploy
+                            code changed, and wait for the deploy. Pushes the
+                            branch that is checked out: the first one pushed is
+                            the site, any other gets an address of its own
   mechanica shot <blockId>  Screenshot one block via the dev preview route
   mechanica shot </path>    Screenshot a whole page (editor overlay stripped)
                             (--page </path>, --data <json|@file>, --width 1440,768,

package/dist/export.js

@@ -1,4 +1,4 @@
-import { $ as analyzeImageBuffer, E as listPages, F as setPageCodec, G as isDerivedAsset, H as assetFileOf, S as getPagePath, V as UPLOADS_PREFIX$1, Y as updateImageManifest, d as readFoldersData, et as hasSharp, f as readSiteData, i as toBlockMeta, p as readSiteLocaleOverride, q as readImageManifest, r as composedBlockMeta, t as buildRichTextCodec, u as readFolderData } from "./chunks/rich-text-codec-BXOKV94u.js";
+import { $ as withHostedAssets, E as listPages, F as setPageCodec, H as assetFileOf, K as isDerivedAsset, S as getPagePath, V as UPLOADS_PREFIX$1, W as fsAssetStore, d as readFoldersData, f as readSiteData, i as toBlockMeta, nt as analyzeImageBuffer, p as readSiteLocaleOverride, r as composedBlockMeta, rt as hasSharp, t as buildRichTextCodec, u as readFolderData } from "./chunks/rich-text-codec-BSD35k2U.js";
 import { n as blockAssetLinks, t as BLOCKS_MANIFEST_FILE } from "./chunks/page-assets-DsJXmoDs.js";
 import { dirname, join, parse, relative, resolve } from "node:path";
 import { EDITOR_DIST_DIR, SITE_MANIFEST_FILE, applySeoTags, auditPageHtml, buildRobotsTxt, buildSitemap, findUnknownBlocks, generateProject, isPaginatedQuery, localePath, mergeTranslation, migrateContent, paginationVariantPath, registerFieldSchemas, resolveQueryKey, templateBlockIds, validateLinks, walkSchema, walkTree } from "mechanica-shared";
@@ -218,45 +218,52 @@ function fillImageValue(value, entry) {
 	if (entry.width && !value.width) value.width = entry.width;
 	if (entry.height && !value.height) value.height = entry.height;
 }
+/** Everything an upload's bytes come as, in one buffer. */
+var bytesOf = async (body) => body instanceof Uint8Array ? Buffer.from(body) : Buffer.from(await new Response(body).arrayBuffer());
 /**
 * Fill missing image metadata — LQIP `previewSrc` + intrinsic dimensions —
 * into the state being exported (page files are never touched). Sources, in
-* order: the `.mech/images.json` manifest (written by uploads, editor saves
-* and `mechanica images`), then the optional `sharp` dependency for anything
-* still missing — those computed entries are cached back into the manifest.
-* Without sharp, leftover gaps get a one-time hint.
+* order: what the asset store knows (written by uploads, editor saves and
+* `mechanica images`), then the optional `sharp` dependency for anything still
+* missing that the store can open — those computed entries are saved back to
+* it. Without sharp, leftover gaps get a one-time hint.
 */
-async function backfillImageMeta(pages, blocksMap, mechDir, warn) {
-	const manifest = readImageManifest(mechDir);
-	const incomplete = /* @__PURE__ */ new Map();
+async function backfillImageMeta(pages, blocksMap, assets, warn) {
+	const values = /* @__PURE__ */ new Map();
 	for (const page of pages) walkTree(page.content, (block) => {
 		const meta = blocksMap.get(block.blockId);
 		if (!meta) return;
 		walkSchema(block.data, meta.props, (value, schema) => {
 			if (schema.format !== "image") return;
 			const file = assetFileOf(value?.src);
-			if (!file) return;
-			const entry = manifest[file];
-			if (entry) fillImageValue(value, entry);
-			if (!value.previewSrc || value.previewSrc === value.src || !value.width || !value.height) incomplete.set(file, [...incomplete.get(file) ?? [], value]);
+			if (file) values.set(file, [...values.get(file) ?? [], value]);
 		});
 	});
+	if (!values.size) return;
+	const known = await assets.info([...values.keys()]);
+	const incomplete = /* @__PURE__ */ new Map();
+	for (const [file, list] of values) {
+		const entry = known[file];
+		const lacking = list.filter((value) => {
+			if (entry) fillImageValue(value, entry);
+			return !value.previewSrc || value.previewSrc === value.src || !value.width || !value.height;
+		});
+		if (lacking.length) incomplete.set(file, lacking);
+	}
 	if (!incomplete.size) return;
 	if (!await hasSharp()) {
 		warn(`[mechanica] ${incomplete.size} image(s) lack a preview or dimensions — install the optional "sharp" dependency or run \`mechanica images\` to generate them`);
 		return;
 	}
 	const computed = {};
-	for (const [file, values] of incomplete) {
-		const buffer = await readFile(join(mechDir, "assets", file)).catch(() => null);
-		const info = buffer ? await analyzeImageBuffer(buffer) : null;
+	for (const [file, list] of incomplete) {
+		const body = await assets.open(file).catch(() => null);
+		const info = body ? await analyzeImageBuffer(await bytesOf(body)) : null;
 		if (!info) continue;
 		computed[file] = info;
-		for (const value of values) fillImageValue(value, info);
+		for (const value of list) fillImageValue(value, info);
 	}
-	try {
-		updateImageManifest(mechDir, computed);
-	} catch {}
+	await assets.saveInfo(computed).catch(() => {});
 }
 /**
 * Statically render every page of an already-built project into `export/`,
@@ -277,6 +284,7 @@ async function backfillImageMeta(pages, blocksMap, mechDir, warn) {
 */
 async function exportProject(cwd, ssr, options = {}) {
 	const warn = options.onWarn ?? ((message) => console.warn(message));
+	const assets = options.assets ?? fsAssetStore(join(cwd, ".mech"));
 	const index = await readFile(join(cwd, "dist/index.html"), "utf-8");
 	const siteUrl = options.siteUrl ?? ssr.site?.url;
 	const siteName = options.siteName ?? ssr.site?.name;
@@ -374,7 +382,7 @@ async function exportProject(cwd, ssr, options = {}) {
 	}
 	if (!pages.some((page) => page.logicalPath === "/404")) warn("[mechanica] No /404 page — the static host will show its own error page. Create a page at /404 (it exports as 404.html and is noindexed automatically).");
 	for (const issue of validateLinks(pages, blocksMap)) warn(`[mechanica] Broken link on ${issue.page}: ${issue.url} has no matching page`);
-	await backfillImageMeta(pages, blocksMap, join(cwd, ".mech"), warn);
+	await backfillImageMeta(pages, blocksMap, assets, warn);
 	const exportDir = resolve(cwd, options.outDir ?? "export");
 	await mkdir(exportDir, { recursive: true });
 	for (const entry of await readdir(exportDir)) await rm(join(exportDir, entry), {
@@ -435,8 +443,9 @@ async function exportProject(cwd, ssr, options = {}) {
 		onFile,
 		pageLinks
 	};
+	const stored = await assets.list();
 	const unclaimed = /* @__PURE__ */ new Map();
-	for (const name of await readdir(join(cwd, ".mech/assets")).catch(() => [])) {
+	for (const name of stored) {
 		const spellings = [
 			name,
 			encodeURI(name),
@@ -550,26 +559,41 @@ async function exportProject(cwd, ssr, options = {}) {
 		}));
 		recordSitemap(path, source, source.page.pagination.page);
 	}
-	await copyUploads(join(cwd, ".mech/assets"), join(exportDir, MEDIA_DIR), referenced, warn);
+	const uploads = await copyUploads(assets, new Set(stored), join(exportDir, MEDIA_DIR), referenced, warn);
 	if (written.includes("/404")) await copyFile(join(exportDir, "404/index.html"), join(exportDir, "404.html"));
 	if (siteUrl) {
 		await writeFile(join(exportDir, "sitemap.xml"), buildSitemap(siteUrl, sitemapEntries));
 		const robotsPath = join(exportDir, "robots.txt");
 		if (!await access(robotsPath).then(() => true, () => false)) await writeFile(robotsPath, buildRobotsTxt(siteUrl));
 	}
-	return written;
+	return {
+		pages: written,
+		uploads
+	};
 }
-/** Copy referenced uploads into the export; warn about missing + orphaned files. */
-async function copyUploads(assetsDir, outDir, referenced, warn) {
-	for (const relative of referenced) {
-		const target = join(outDir, relative);
-		await mkdir(dirname(target), { recursive: true });
-		await copyFile(join(assetsDir, relative), target).catch(() => {
-			warn(`[mechanica] Missing upload: ${relative} is referenced by a page but not in .mech/assets`);
-		});
+/**
+* Put the referenced uploads into the export: copy the ones the store can open,
+* leave to the host the ones it only knows about, warn about the ones it does
+* not know — and about uploads no page refers to.
+*/
+async function copyUploads(assets, stored, outDir, referenced, warn) {
+	const uploads = {
+		copied: [],
+		hosted: []
+	};
+	for (const name of referenced) {
+		const body = await assets.open(name).catch(() => null);
+		if (body) {
+			const target = join(outDir, name);
+			await mkdir(dirname(target), { recursive: true });
+			await writeFile(target, await bytesOf(body));
+			uploads.copied.push(name);
+		} else if (stored.has(name)) uploads.hosted.push(name);
+		else warn(`[mechanica] Missing upload: ${name} is referenced by a page but is not among the site's uploads`);
 	}
-	const orphans = (await readdir(assetsDir, { recursive: true }).catch(() => [])).map((entry) => entry.replace(/\\/g, "/")).filter((entry) => /\.\w+$/.test(entry) && !referenced.has(entry) && !isDerivedAsset(entry));
-	if (orphans.length) warn(`[mechanica] ${orphans.length} unused upload(s) in .mech/assets (not exported): ${orphans.join(", ")}`);
+	const orphans = [...stored].filter((name) => /\.\w+$/.test(name) && !referenced.has(name) && !isDerivedAsset(name));
+	if (orphans.length) warn(`[mechanica] ${orphans.length} unused upload(s) (not exported): ${orphans.join(", ")}`);
+	return uploads;
 }
 /**
 * Statically render an already-built project: load `<cwd>/dist/ssr.js` and run
@@ -585,13 +609,15 @@ async function exportBuilt(cwd, options = {}) {
 		warnings.push(message);
 		(options.onWarn ?? console.warn)(message);
 	};
+	const { pages, uploads } = await exportProject(cwd, await import(pathToFileURL(join(cwd, "dist/ssr.js")).href), {
+		...options,
+		onWarn
+	});
 	return {
-		pages: await exportProject(cwd, await import(pathToFileURL(join(cwd, "dist/ssr.js")).href), {
-			...options,
-			onWarn
-		}),
-		warnings
+		pages,
+		warnings,
+		uploads
 	};
 }
 //#endregion
-export { exportBuilt, exportProject };
+export { exportBuilt, exportProject, fsAssetStore, withHostedAssets };

package/dist/plugin.js

@@ -1,7 +1,7 @@
-import { a as collectGeneratedPages, n as configureSite, r as indexGeneratedPages, t as buildSiteManifest } from "./chunks/site-Co04D3rB.js";
-import { a as renderEditablePage, c as fillStateImages, d as loadComposedDefinitions, n as toNodeMiddleware, o as buildGeneratedState, r as createEditorService, s as buildPageState, t as toAssetMiddleware, u as collectComposed } from "./chunks/node-adapter-GZZrfGSz.js";
-import { Q as wasRecentlyMutated, U as fsAssetStore, Z as withRemoteAssets, k as pageUrlOf } from "./chunks/rich-text-codec-BXOKV94u.js";
-import { i as uploadsIgnored, n as remoteAssetsFor } from "./chunks/assets-C7yHGJBU.js";
+import { a as collectGeneratedPages, n as configureSite, r as indexGeneratedPages, t as buildSiteManifest } from "./chunks/site-DfazSr3_.js";
+import { a as renderEditablePage, c as fillStateImages, d as loadComposedDefinitions, n as toNodeMiddleware, o as buildGeneratedState, r as createEditorService, s as buildPageState, t as toAssetMiddleware, u as collectComposed } from "./chunks/node-adapter-CSkDXYGO.js";
+import { W as fsAssetStore, et as withRemoteAssets, k as pageUrlOf, tt as wasRecentlyMutated } from "./chunks/rich-text-codec-BSD35k2U.js";
+import { i as uploadsIgnored, n as remoteAssetsFor } from "./chunks/assets-nujjbCx8.js";
 import { t as BLOCKS_MANIFEST_FILE } from "./chunks/page-assets-DsJXmoDs.js";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, relative } from "node:path";

package/dist/server.js

@@ -1,5 +1,5 @@
-import { i as readSiteManifest, n as configureSite, t as buildSiteManifest } from "./chunks/site-Co04D3rB.js";
-import { a as renderEditablePage, i as readEditorTemplate, n as toNodeMiddleware, r as createEditorService, t as toAssetMiddleware } from "./chunks/node-adapter-GZZrfGSz.js";
-import { B as memoryContentFiles, G as isDerivedAsset, O as pageOfFile, U as fsAssetStore, X as uploadName, Z as withRemoteAssets, z as fsContentFiles } from "./chunks/rich-text-codec-BXOKV94u.js";
+import { i as readSiteManifest, n as configureSite, t as buildSiteManifest } from "./chunks/site-DfazSr3_.js";
+import { a as renderEditablePage, i as readEditorTemplate, n as toNodeMiddleware, r as createEditorService, t as toAssetMiddleware } from "./chunks/node-adapter-CSkDXYGO.js";
+import { $ as withHostedAssets, B as memoryContentFiles, G as isAssetName, K as isDerivedAsset, O as pageOfFile, Q as uploadResponse, U as contentTypeOf, W as fsAssetStore, Z as uploadName, et as withRemoteAssets, z as fsContentFiles } from "./chunks/rich-text-codec-BSD35k2U.js";
 import { EDITOR_DIST_DIR, SITE_MANIFEST_FILE, UPLOADS_PREFIX, uploadNameOf } from "mechanica-shared";
-export { EDITOR_DIST_DIR, SITE_MANIFEST_FILE, UPLOADS_PREFIX, buildSiteManifest, configureSite, createEditorService, fsAssetStore, fsContentFiles, isDerivedAsset, memoryContentFiles, pageOfFile, readEditorTemplate, readSiteManifest, renderEditablePage, toAssetMiddleware, toNodeMiddleware, uploadName, uploadNameOf, withRemoteAssets };
+export { EDITOR_DIST_DIR, SITE_MANIFEST_FILE, UPLOADS_PREFIX, buildSiteManifest, configureSite, contentTypeOf, createEditorService, fsAssetStore, fsContentFiles, isAssetName, isDerivedAsset, memoryContentFiles, pageOfFile, readEditorTemplate, readSiteManifest, renderEditablePage, toAssetMiddleware, toNodeMiddleware, uploadName, uploadNameOf, uploadResponse, withHostedAssets, withRemoteAssets };

package/dist/types/cli/export.d.ts

@@ -1,5 +1,6 @@
 import { type ComposedBlockDefinition, type LocalesConfig, type RenderResult, type VirtualPage } from 'mechanica-shared';
 import { type BlockComponent } from '../editor/lib/block-meta';
+import { fsAssetStore, withHostedAssets, type AssetStore, type ImageManifest } from '../server/assets-store';
 /** An already-built SSR bundle (`dist/ssr.js`) exposes these. */
 export interface SsrBundle {
     /**
@@ -69,6 +70,24 @@ export interface ExportOptions {
     fetchJson?: (options: {
         url: string;
     } & Record<string, unknown>) => Promise<unknown>;
+    /**
+     * Where the site's uploads are: their bytes and their image info. Defaults to
+     * the project's `.mech/assets` + `.mech/images.json`. The export reads uploads
+     * only through this — a linked project passes a store that also fetches the
+     * ones kept by its platform, and a hosted render one that knows uploads it
+     * cannot open (`withHostedAssets`): those are not copied, the host serves them.
+     */
+    assets?: AssetStore;
+}
+/** What became of the uploads the pages refer to. */
+export interface ExportedUploads {
+    /** Copied into the export's `media/` directory. */
+    copied: string[];
+    /**
+     * Known to the store but not readable through it — left for the host to
+     * serve at `/media/<name>`. Empty for an export over a plain directory.
+     */
+    hosted: string[];
 }
 /**
  * Statically render every page of an already-built project into `export/`,
@@ -87,13 +106,18 @@ export interface ExportOptions {
  * absolute social-image URLs, pagination prev/next, JSON-LD) and emits
  * `sitemap.xml` + `robots.txt`.
  */
-export declare function exportProject(cwd: string, ssr: SsrBundle, options?: ExportOptions): Promise<string[]>;
+export declare function exportProject(cwd: string, ssr: SsrBundle, options?: ExportOptions): Promise<{
+    pages: string[];
+    uploads: ExportedUploads;
+}>;
 /** What {@link exportBuilt} produced. */
 export interface ExportResult {
     /** The generated page paths, in render order. */
     pages: string[];
     /** Everything the export warned about (broken links, missing uploads, SEO lint). */
     warnings: string[];
+    /** The uploads the pages refer to: which were copied, which the host is to serve. */
+    uploads: ExportedUploads;
 }
 /**
  * Statically render an already-built project: load `<cwd>/dist/ssr.js` and run
@@ -103,3 +127,5 @@ export interface ExportResult {
  * Warnings are collected into the result and still forwarded to `onWarn`.
  */
 export declare function exportBuilt(cwd: string, options?: ExportOptions): Promise<ExportResult>;
+export { fsAssetStore, withHostedAssets };
+export type { AssetStore, ImageManifest };

package/dist/types/cli/platform/push.d.ts

@@ -1,5 +1,15 @@
 /**
- * `mechanica push`: publish the committed project to the platform.
+ * Why a branch cannot be pushed under its name, or null when it can. On the platform a branch
+ * is served at an address of its own (`<slug>--<branch>`), so its name must be able to be part
+ * of one: lowercase letters, digits and single hyphens. The platform checks the same (and how
+ * long the name may be for the site) — this only says it before anything is sent.
+ */
+export declare function branchProblem(name: string): string | null;
+/**
+ * `mechanica push`: publish the committed project to the platform — the branch that is checked
+ * out, under its own name. The first branch a site is pushed becomes the site itself; any
+ * other is deployed to an address of its own, with its own online editor, and never touches
+ * the site.
  *
  *   1. bring in what was published online since the last pull (`pull --rebase`),
  *   2. send the uploads the platform lacks (they are not in git), then `git push`

package/dist/types/cli/run-export.d.ts

@@ -1,4 +1,13 @@
+import { type AssetStore } from '../server/assets-store';
 import { type ExportOptions } from './export';
+/**
+ * The uploads a local export reads: the project's `.mech/assets`, and — for a
+ * project linked to a hosted platform — the uploads kept there, fetched as the
+ * pages turn out to need them (and kept in `.mech/assets` when git ignores it).
+ * Only local files are *listed*: the uploads the platform holds that no page
+ * here refers to are not this export's to warn about.
+ */
+export declare function exportAssets(cwd: string): AssetStore;
 /**
  * `mechanica export`: build the project, then statically render every page
  * into `export/`. Kept apart from `export.ts` so that module never imports

package/dist/types/server/assets-store.d.ts

@@ -84,6 +84,25 @@ export declare function listUploads(assets: AssetStore): Promise<{
     name: string;
     src: string;
 }[]>;
+/** The content type a stored file is served with, when its extension says. */
+export declare const contentTypeOf: (fileName: string) => string | undefined;
+/**
+ * The HTTP answer for an upload asked for by its address — the part of
+ * `/media/<name>` after the prefix, still percent-encoded. null when it is not
+ * an upload of this store, so the caller can fall through; a 400 for a name
+ * that is not valid encoding. One function for every host that serves uploads:
+ * the dev server, an editing host, a site's live host.
+ */
+export declare function uploadResponse(assets: AssetStore | null | undefined, encodedName: string): Promise<Response | null>;
+/**
+ * A store for rendering a site whose uploads the host keeps and serves itself.
+ * `hosted` is what the host knows about them — a name with its image info. The
+ * result knows those names (`list`, `info`) but cannot open them: an export
+ * over it fills in their dimensions and previews, copies no bytes, and reports
+ * them as the host's to serve (see `ExportResult.uploads`). Whatever the local
+ * store has is used as before.
+ */
+export declare function withHostedAssets(local: AssetStore, hosted: ImageManifest): AssetStore;
 /**
  * Where a project's uploads also live — a hosted platform the project is linked
  * to. Uploads made in its online editor are not in the project's directory

package/dist/types/server/index.d.ts

@@ -8,7 +8,7 @@ export { createEditorService, type EditorService, type EditorServiceOptions, typ
 export { toNodeMiddleware, toAssetMiddleware, type NodeMiddleware } from './node-adapter';
 export { fsContentFiles, memoryContentFiles, type ContentFiles, type ContentChanges, type MemoryContentFiles, type Mech, } from './content-files';
 export { pageOfFile } from './pages-store';
-export { fsAssetStore, withRemoteAssets, uploadName, isDerivedAsset, type AssetStore, type RemoteAssets, type RemoteAssetsOptions, type ImageManifest, type ImageManifestEntry, } from './assets-store';
+export { fsAssetStore, withRemoteAssets, withHostedAssets, uploadResponse, contentTypeOf, isAssetName, uploadName, isDerivedAsset, type AssetStore, type RemoteAssets, type RemoteAssetsOptions, type ImageManifest, type ImageManifestEntry, } from './assets-store';
 export { buildSiteManifest, readSiteManifest, configureSite, type SiteManifestInput } from './site';
 export { renderEditablePage, readEditorTemplate, type EditablePageOptions } from './editor-page';
 export { SITE_MANIFEST_FILE, EDITOR_DIST_DIR, UPLOADS_PREFIX, uploadNameOf, type SiteManifest, type EditorHostConfig, } from 'mechanica-shared';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mechanica",
-  "version": "2.1.0-beta.5",
+  "version": "2.1.0-beta.7",
   "description": "Build Vue 3 websites with a visual block editor",
   "license": "MIT",
   "repository": {
@@ -66,7 +66,7 @@
     "prepublishOnly": "bun ../../scripts/ensure-bun-publish.js && bun run build"
   },
   "dependencies": {
-    "mechanica-shared": "2.1.0-beta.5",
+    "mechanica-shared": "2.1.0-beta.7",
     "@vue/compiler-sfc": "^3.5.38",
     "compact-json-schema": "^0.1.5",
     "estree-walker": "^3.0.3",