mechanica 2.1.0-beta.3 → 2.1.0-beta.5

package/README.md

@@ -360,8 +360,9 @@ These drive a locally installed Chrome or Edge (or `--browser <path>`) and need
 | `mechanica thumbs [--blocks]` | Regenerate page or block thumbnails for the editor |
 | `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) |
-| `mechanica push` | Publish the committed project to the platform: pull what was edited online, `git push`, build and upload the bundle when the code changed, wait for the deploy |
+| `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 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

@@ -0,0 +1,322 @@
+import { W as isAssetName, Y as updateImageManifest, q as readImageManifest } from "./rich-text-codec-BXOKV94u.js";
+import { join } from "node:path";
+import { chmod, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import { spawn } from "node:child_process";
+/** Normalize a host argument to an origin (`https://example.com`, no trailing slash or path). */
+function hostOrigin(host) {
+	const value = host ?? process.env.MECHANICA_HOST ?? "https://mechanica.jt3.ru";
+	return new URL(/^https?:\/\//.test(value) ? value : `https://${value}`).origin;
+}
+/** Where access tokens are kept: one file per user, outside any project. */
+function credentialsFile() {
+	return join(process.env.MECHANICA_CONFIG_DIR ?? join(os.homedir(), ".mechanica"), "credentials.json");
+}
+async function readAll() {
+	try {
+		const parsed = JSON.parse(await readFile(credentialsFile(), "utf-8"));
+		return parsed && typeof parsed === "object" ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+/**
+* The access token for a platform origin: `MECHANICA_TOKEN` (CI) wins over the
+* one `mechanica login` saved.
+*/
+async function getToken(origin) {
+	if (process.env.MECHANICA_TOKEN) return process.env.MECHANICA_TOKEN;
+	return (await readAll())[origin] ?? null;
+}
+/** Remember the token for an origin, in a file only the user can read. */
+async function saveToken(origin, token) {
+	const file = credentialsFile();
+	const all = await readAll();
+	all[origin] = token;
+	await mkdir(join(file, ".."), { recursive: true });
+	await writeFile(file, JSON.stringify(all, null, 2) + "\n", { mode: 384 });
+	await chmod(file, 384).catch(() => {});
+	return file;
+}
+//#endregion
+//#region src/cli/platform/api.ts
+/** A failed platform request: the HTTP status plus the message the platform gave. */
+var PlatformError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+	}
+};
+/** The platform answers errors as plain text or as `{ error: { field: { message } } }`. */
+function errorMessage(status, text) {
+	try {
+		const error = JSON.parse(text)?.error;
+		if (typeof error === "string") return error;
+		if (error && typeof error === "object") {
+			const messages = Object.values(error).map((item) => item?.message).filter((message) => typeof message === "string");
+			if (messages.length) return messages.join("; ");
+		}
+	} catch {}
+	return text.trim() || `Request failed (${status})`;
+}
+/** One request to the platform API; resolves with the parsed JSON body (or null). */
+async function request(origin, method, path, options = {}) {
+	const headers = {};
+	if (options.token) headers.authorization = `Bearer ${options.token}`;
+	if (options.raw) headers["content-type"] = "application/octet-stream";
+	else if (options.body !== void 0) headers["content-type"] = "application/json";
+	let response;
+	try {
+		response = await fetch(origin + path, {
+			method,
+			headers,
+			body: options.raw ?? (options.body !== void 0 ? JSON.stringify(options.body) : void 0)
+		});
+	} catch (error) {
+		throw new PlatformError(0, `Could not reach ${origin} (${error.message})`);
+	}
+	const text = await response.text();
+	if (!response.ok) throw new PlatformError(response.status, errorMessage(response.status, text));
+	return text ? JSON.parse(text) : null;
+}
+/** The saved token for `origin`, or an error telling the user to log in. */
+async function requireToken(origin) {
+	const token = await getToken(origin);
+	if (!token) throw new Error(`Not logged in to ${origin} — run \`mechanica login\` first`);
+	return token;
+}
+/** The name of the git remote `mechanica link` manages. */
+var REMOTE_NAME = "mechanica";
+/**
+* Split a site's git remote URL (`https://host/git/<slug>.git`) into the
+* platform origin and the slug; null for a URL that is not one of ours.
+*/
+function parseRemoteUrl(url) {
+	try {
+		const parsed = new URL(url);
+		const match = /^\/git\/([a-z0-9][a-z0-9-]*[a-z0-9])\.git\/?$/.exec(parsed.pathname);
+		if (!match || !/^https?:$/.test(parsed.protocol)) return null;
+		return {
+			origin: parsed.origin,
+			slug: match[1]
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/cli/platform/git.ts
+/**
+* Environment that makes git send the access token to one origin only, as HTTP
+* Basic credentials. Passed through `GIT_CONFIG_*` variables so the token never
+* appears on a command line (visible to other processes) or in the repo config.
+*/
+function gitAuthEnv(origin, token) {
+	const basic = Buffer.from(`mechanica:${token}`).toString("base64");
+	return {
+		GIT_CONFIG_COUNT: "1",
+		GIT_CONFIG_KEY_0: `http.${origin}/.extraHeader`,
+		GIT_CONFIG_VALUE_0: `Authorization: Basic ${basic}`,
+		GIT_TERMINAL_PROMPT: "0"
+	};
+}
+/** Run git in `cwd` and collect its output; never throws on a non-zero exit. */
+function git(cwd, args, env = {}) {
+	return new Promise((resolve, reject) => {
+		const child = spawn("git", args, {
+			cwd,
+			env: {
+				...process.env,
+				...env
+			},
+			windowsHide: true
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout.on("data", (chunk) => stdout += chunk);
+		child.stderr.on("data", (chunk) => stderr += chunk);
+		child.on("error", (error) => reject(error.code === "ENOENT" ? /* @__PURE__ */ new Error("git is not installed (or not on PATH)") : error));
+		child.on("close", (code) => resolve({
+			code: code ?? 1,
+			stdout: stdout.trim(),
+			stderr: stderr.trim()
+		}));
+	});
+}
+/** Like {@link git}, but a non-zero exit throws with git's own message. */
+async function gitOk(cwd, args, env = {}) {
+	const result = await git(cwd, args, env);
+	if (result.code !== 0) throw new Error(result.stderr || result.stdout || `git ${args[0]} failed`);
+	return result.stdout;
+}
+//#endregion
+//#region src/cli/platform/assets.ts
+var ASSETS_DIR = ".mech/assets";
+/**
+* The site this project is linked to (the `mechanica` git remote) with the
+* saved token for it — or null when it is not linked, not logged in, or the
+* account has no access to the site. Never throws: an unlinked project is the
+* normal case for the dev server.
+*/
+async function resolveLink(cwd) {
+	try {
+		const remote = await git(cwd, [
+			"remote",
+			"get-url",
+			REMOTE_NAME
+		]);
+		const link = remote.code === 0 ? parseRemoteUrl(remote.stdout) : null;
+		if (!link) return null;
+		const token = await getToken(link.origin);
+		if (!token) return null;
+		const site = (await request(link.origin, "GET", "/api/sites", { token })).find((item) => item.slug === link.slug);
+		return site ? {
+			...link,
+			uuid: site.uuid,
+			token
+		} : null;
+	} catch {
+		return null;
+	}
+}
+/** The uploads the platform's store holds for the site. */
+var listRemoteAssets = (link) => request(link.origin, "GET", `/api/sites/${link.uuid}/assets`, { token: link.token });
+var fileUrl = (link, name) => `${link.origin}/api/sites/${link.uuid}/assets/file?name=${encodeURIComponent(name)}`;
+/** One upload's bytes from the platform, or null when it has none of that name. */
+async function downloadRemoteAsset(link, name) {
+	const response = await fetch(fileUrl(link, name), { headers: { authorization: `Bearer ${link.token}` } });
+	if (response.status === 404) return null;
+	if (!response.ok) throw new Error(`Could not download ${name} (${response.status})`);
+	return new Uint8Array(await response.arrayBuffer());
+}
+var imageInfoOf = ({ width, height, previewSrc }) => ({
+	...width ? { width } : {},
+	...height ? { height } : {},
+	...previewSrc ? { previewSrc } : {}
+});
+/** The files in the project's uploads directory (flat: an upload is one file name). */
+async function localAssets(cwd) {
+	const dir = join(cwd, ASSETS_DIR);
+	return (await readdir(dir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isFile() && isAssetName(entry.name)).map((entry) => entry.name);
+}
+/** The uploads git already carries: those reach the platform with the push itself. */
+async function trackedAssets(cwd) {
+	const listed = await git(cwd, [
+		"ls-files",
+		"-z",
+		"--",
+		ASSETS_DIR
+	]);
+	if (listed.code !== 0) return /* @__PURE__ */ new Set();
+	return new Set(listed.stdout.split("\0").filter(Boolean).map((path) => path.slice(13)));
+}
+/**
+* Send the platform the uploads this project has and it lacks — the files in
+* `.mech/assets` that are not committed (committed ones travel with git) — with
+* what `.mech/images.json` knows about them. Returns the names sent.
+*/
+async function pushUploads(cwd, link, log = console.info) {
+	const tracked = await trackedAssets(cwd);
+	const candidates = (await localAssets(cwd)).filter((name) => !tracked.has(name));
+	if (!candidates.length) return [];
+	const remote = new Set((await listRemoteAssets(link)).map((asset) => asset.name));
+	const missing = candidates.filter((name) => !remote.has(name));
+	if (!missing.length) return [];
+	log(`Uploading ${missing.length} file(s)…`);
+	for (const name of missing) {
+		const data = await readFile(join(cwd, ASSETS_DIR, name));
+		await request(link.origin, "POST", `/api/sites/${link.uuid}/assets/file?name=${encodeURIComponent(name)}`, {
+			token: link.token,
+			raw: new Uint8Array(data)
+		});
+	}
+	const manifest = readImageManifest(join(cwd, ".mech"));
+	const info = {};
+	for (const name of missing) if (manifest[name]) info[name] = manifest[name];
+	if (Object.keys(info).length) await request(link.origin, "POST", `/api/sites/${link.uuid}/assets/info`, {
+		token: link.token,
+		body: info
+	});
+	return missing;
+}
+/**
+* Whether git ignores the project's uploads directory — i.e. whether a file
+* fetched into it stays out of `git status`. Decides if the dev server may
+* keep what it fetches (see `withRemoteAssets`).
+*/
+async function uploadsIgnored(cwd) {
+	return (await git(cwd, [
+		"check-ignore",
+		"-q",
+		`${ASSETS_DIR}/probe.bin`
+	]).catch(() => ({ code: 1 }))).code === 0;
+}
+/**
+* The platform's uploads as the dev server sees them: resolved lazily, once —
+* a project that is not linked (or is offline) simply has none.
+*/
+function remoteAssetsFor(cwd) {
+	let link = null;
+	const linked = () => link ??= resolveLink(cwd);
+	let listing = null;
+	const assets = async () => {
+		const site = await linked();
+		if (!site) return [];
+		if (!listing || Date.now() - listing.at > 3e4) listing = {
+			at: Date.now(),
+			assets: listRemoteAssets(site).catch(() => [])
+		};
+		return listing.assets;
+	};
+	return {
+		async fetch(name) {
+			const site = await linked();
+			if (!site) return null;
+			const data = await downloadRemoteAsset(site, name);
+			if (!data) return null;
+			const entry = (await assets()).find((asset) => asset.name === name);
+			return {
+				data,
+				...entry ? { info: imageInfoOf(entry) } : {}
+			};
+		},
+		list: async () => (await assets()).map((asset) => asset.name)
+	};
+}
+/**
+* `mechanica assets pull` — download every upload the platform has and this
+* project lacks into `.mech/assets`, with its image info. What the dev server
+* does one file at a time, for all of them: before an offline session, a local
+* `mechanica export`, or leaving the platform. Returns the names downloaded.
+*/
+async function runAssetsPull(options = {}) {
+	const cwd = options.cwd ?? process.cwd();
+	const link = await resolveLink(cwd);
+	if (!link) throw new Error("This project is not linked to a site you can reach — run `mechanica login` and `mechanica link <slug>`");
+	const dir = join(cwd, ASSETS_DIR);
+	const have = new Set(await localAssets(cwd));
+	const missing = (await listRemoteAssets(link)).filter((asset) => isAssetName(asset.name) && !have.has(asset.name));
+	if (!missing.length) {
+		console.info("Nothing to download — every upload of the site is already here");
+		return [];
+	}
+	await mkdir(dir, { recursive: true });
+	const info = {};
+	const done = [];
+	for (const asset of missing) {
+		const data = await downloadRemoteAsset(link, asset.name);
+		if (!data) continue;
+		await writeFile(join(dir, asset.name), data);
+		const entry = imageInfoOf(asset);
+		if (Object.keys(entry).length) info[asset.name] = entry;
+		done.push(asset.name);
+		console.info(`✓ ${asset.name}`);
+	}
+	updateImageManifest(join(cwd, ".mech"), info);
+	console.info(`Downloaded ${done.length} file(s) into ${ASSETS_DIR}`);
+	if (!await uploadsIgnored(cwd) && await stat(join(cwd, ".git")).catch(() => null)) console.info(`Note: ${ASSETS_DIR} is not ignored by git, so these files show as changes. Uploads live on the platform — add \`.mech/assets/\` and \`.mech/images.json\` to .gitignore.`);
+	return done;
+}
+//#endregion
+export { git as a, PlatformError as c, request as d, requireToken as f, uploadsIgnored as i, REMOTE_NAME as l, saveToken as m, remoteAssetsFor as n, gitAuthEnv as o, hostOrigin as p, runAssetsPull as r, gitOk as s, pushUploads as t, parseRemoteUrl as u };

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

@@ -1,5 +1,5 @@
-import { n as configureSite, r as indexGeneratedPages } from "./site-ONN3eU9_.js";
-import { A as pageVersion, C as harvestPageImages, D as movePage, E as listPages, G as listUploads, H as fsAssetStore, I as setPageDraft, L as translationsOf, M as renamePage, N as savePage, R as contentFilesOf, T as listFolders, U 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, q as storeUpload, s as mergeLocaleFolderData, u as readFolderData, v as deleteTranslation, w as imageNamesOf, x as fillImageMeta, y as duplicatePage } from "./rich-text-codec-D8JAuJIS.js";
+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 fs, { readFileSync, readdirSync } from "node:fs";
 import { basename, extname, join, resolve, sep } from "node:path";
 import { EDITOR_DIST_DIR, mergeTranslation, parseLocalePath, passDataToHTML, resolveQueryKey, serializeState } from "mechanica-shared";

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

@@ -273,6 +273,75 @@ async function listUploads(assets) {
 		src: assetUrl(name)
 	}));
 }
+var MISS_TTL_MS = 3e4;
+var MEMORY_LIMIT = 67108864;
+/**
+* A store that falls back to {@link RemoteAssets} for what the local one lacks:
+* an upload made in a hosted editor shows up in the dev server the first time a
+* page asks for it, and (when `cache` allows) stays in the project's directory.
+* Everything written goes to the local store; a remote failure is a miss, never
+* an error — the dev server works offline with what it has.
+*/
+function withRemoteAssets(local, remote, options = {}) {
+	const fetched = /* @__PURE__ */ new Map();
+	let memory = 0;
+	const caching = async () => typeof options.cache === "function" ? await options.cache() : options.cache !== false;
+	const pull = (name) => {
+		let pending = fetched.get(name);
+		if (!pending) {
+			pending = (async () => {
+				const result = await remote.fetch(name).catch(() => null);
+				if (!result) {
+					setTimeout(() => fetched.delete(name), MISS_TTL_MS).unref?.();
+					return null;
+				}
+				if (await caching()) {
+					await local.write(name, result.data);
+					if (result.info && Object.keys(result.info).length) await local.saveInfo({ [name]: result.info });
+					fetched.delete(name);
+					return result;
+				}
+				memory += result.data.byteLength;
+				if (memory > MEMORY_LIMIT) {
+					memory -= result.data.byteLength;
+					fetched.delete(name);
+				}
+				return result;
+			})();
+			fetched.set(name, pending);
+		}
+		return pending;
+	};
+	let remoteNames = null;
+	const listRemote = () => {
+		if (!remoteNames || Date.now() - remoteNames.at > 3e4) remoteNames = {
+			at: Date.now(),
+			names: remote.list().catch(() => [])
+		};
+		return remoteNames.names;
+	};
+	return {
+		write: (name, data) => local.write(name, data),
+		saveInfo: (entries) => local.saveInfo(entries),
+		async open(name) {
+			return await local.open(name) ?? (await pull(name))?.data ?? null;
+		},
+		async list() {
+			return [.../* @__PURE__ */ new Set([...await local.list(), ...await listRemote()])];
+		},
+		async info(names) {
+			const known = await local.info(names);
+			const unknown = names.filter((name) => !known[name]);
+			if (!unknown.length) return known;
+			const here = new Set(await local.list());
+			await Promise.all(unknown.filter((name) => !here.has(name)).map(async (name) => {
+				const info = (await pull(name))?.info;
+				if (info && Object.keys(info).length) known[name] = info;
+			}));
+			return known;
+		}
+	};
+}
 //#endregion
 //#region src/server/content-files.ts
 var slash = (path) => path.replace(/\\/g, "/");
@@ -1134,4 +1203,4 @@ function findRichTextProps(props) {
 	return found;
 }
 //#endregion
-export { isRasterImage as $, pageVersion as A, memoryContentFiles as B, harvestPageImages as C, movePage as D, listPages as E, setPageCodec as F, listUploads as G, fsAssetStore as H, setPageDraft as I, updateImageManifest as J, readImageManifest as K, translationsOf as L, renamePage as M, savePage as N, pageOfFile as O, setPageBlocks as P, hasSharp as Q, contentFilesOf as R, getPagePath as S, listFolders as T, isAssetName as U, assetFileOf as V, isDerivedAsset as W, wasRecentlyMutated as X, uploadName as Y, analyzeImageBuffer as Z, deletePage as _, folderOf as a, fillContentDefaults as b, mergeLocaleSiteData as c, readFoldersData as d, 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, storeUpload as q, composedBlockMeta as r, mergeLocaleFolderData as s, buildRichTextCodec as t, readFolderData as u, deleteTranslation as v, imageNamesOf as w, fillImageMeta as x, duplicatePage as y, fsContentFiles as z };
+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 };

package/dist/chunks/{site-ONN3eU9_.js → site-Co04D3rB.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-D8JAuJIS.js";
+import { F as setPageCodec, P as setPageBlocks, i as toBlockMeta, n as richTextCodecFromBlocks, r as composedBlockMeta } from "./rich-text-codec-BXOKV94u.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,14 +1,15 @@
-import { t as buildSiteManifest } from "./chunks/site-ONN3eU9_.js";
-import { $ as isRasterImage, J as updateImageManifest, K as readImageManifest, Q as hasSharp, W as isDerivedAsset, Z as analyzeImageBuffer } from "./chunks/rich-text-codec-D8JAuJIS.js";
+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 { exportBuilt } from "./export.js";
 import fs, { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { EDITOR_DIST_DIR, LEGACY_UPLOADS_PREFIX, SITE_MANIFEST_FILE, UPLOADS_PREFIX } from "mechanica-shared";
-import { chmod, mkdir, readFile, readdir, realpath, rm, writeFile } from "node:fs/promises";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { build } from "vite";
+import { appendFile, mkdir, readFile, readdir, realpath, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import { spawn } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { build } from "vite";
 import readline from "node:readline";
 //#region src/cli/args.ts
 /** Parse `argv` (without node/script) into a command, positionals and a `--flag[=value]` map. */
@@ -214,153 +215,6 @@ async function runMigrate(options = {}) {
 	console.info(changed.length ? `Updated ${changed.length} file(s): uploads are now referenced as ${UPLOADS_PREFIX}<file>` : "Nothing to migrate — the content is already in the current format");
 	return changed;
 }
-/** Normalize a host argument to an origin (`https://example.com`, no trailing slash or path). */
-function hostOrigin(host) {
-	const value = host ?? process.env.MECHANICA_HOST ?? "https://mechanica.jt3.ru";
-	return new URL(/^https?:\/\//.test(value) ? value : `https://${value}`).origin;
-}
-/** Where access tokens are kept: one file per user, outside any project. */
-function credentialsFile() {
-	return join(process.env.MECHANICA_CONFIG_DIR ?? join(os.homedir(), ".mechanica"), "credentials.json");
-}
-async function readAll() {
-	try {
-		const parsed = JSON.parse(await readFile(credentialsFile(), "utf-8"));
-		return parsed && typeof parsed === "object" ? parsed : {};
-	} catch {
-		return {};
-	}
-}
-/**
-* The access token for a platform origin: `MECHANICA_TOKEN` (CI) wins over the
-* one `mechanica login` saved.
-*/
-async function getToken(origin) {
-	if (process.env.MECHANICA_TOKEN) return process.env.MECHANICA_TOKEN;
-	return (await readAll())[origin] ?? null;
-}
-/** Remember the token for an origin, in a file only the user can read. */
-async function saveToken(origin, token) {
-	const file = credentialsFile();
-	const all = await readAll();
-	all[origin] = token;
-	await mkdir(join(file, ".."), { recursive: true });
-	await writeFile(file, JSON.stringify(all, null, 2) + "\n", { mode: 384 });
-	await chmod(file, 384).catch(() => {});
-	return file;
-}
-//#endregion
-//#region src/cli/platform/api.ts
-/** A failed platform request: the HTTP status plus the message the platform gave. */
-var PlatformError = class extends Error {
-	status;
-	constructor(status, message) {
-		super(message);
-		this.status = status;
-	}
-};
-/** The platform answers errors as plain text or as `{ error: { field: { message } } }`. */
-function errorMessage(status, text) {
-	try {
-		const error = JSON.parse(text)?.error;
-		if (typeof error === "string") return error;
-		if (error && typeof error === "object") {
-			const messages = Object.values(error).map((item) => item?.message).filter((message) => typeof message === "string");
-			if (messages.length) return messages.join("; ");
-		}
-	} catch {}
-	return text.trim() || `Request failed (${status})`;
-}
-/** One request to the platform API; resolves with the parsed JSON body (or null). */
-async function request(origin, method, path, options = {}) {
-	const headers = {};
-	if (options.token) headers.authorization = `Bearer ${options.token}`;
-	if (options.raw) headers["content-type"] = "application/octet-stream";
-	else if (options.body !== void 0) headers["content-type"] = "application/json";
-	let response;
-	try {
-		response = await fetch(origin + path, {
-			method,
-			headers,
-			body: options.raw ?? (options.body !== void 0 ? JSON.stringify(options.body) : void 0)
-		});
-	} catch (error) {
-		throw new PlatformError(0, `Could not reach ${origin} (${error.message})`);
-	}
-	const text = await response.text();
-	if (!response.ok) throw new PlatformError(response.status, errorMessage(response.status, text));
-	return text ? JSON.parse(text) : null;
-}
-/** The saved token for `origin`, or an error telling the user to log in. */
-async function requireToken(origin) {
-	const token = await getToken(origin);
-	if (!token) throw new Error(`Not logged in to ${origin} — run \`mechanica login\` first`);
-	return token;
-}
-/** The name of the git remote `mechanica link` manages. */
-var REMOTE_NAME = "mechanica";
-/**
-* Split a site's git remote URL (`https://host/git/<slug>.git`) into the
-* platform origin and the slug; null for a URL that is not one of ours.
-*/
-function parseRemoteUrl(url) {
-	try {
-		const parsed = new URL(url);
-		const match = /^\/git\/([a-z0-9][a-z0-9-]*[a-z0-9])\.git\/?$/.exec(parsed.pathname);
-		if (!match || !/^https?:$/.test(parsed.protocol)) return null;
-		return {
-			origin: parsed.origin,
-			slug: match[1]
-		};
-	} catch {
-		return null;
-	}
-}
-//#endregion
-//#region src/cli/platform/git.ts
-/**
-* Environment that makes git send the access token to one origin only, as HTTP
-* Basic credentials. Passed through `GIT_CONFIG_*` variables so the token never
-* appears on a command line (visible to other processes) or in the repo config.
-*/
-function gitAuthEnv(origin, token) {
-	const basic = Buffer.from(`mechanica:${token}`).toString("base64");
-	return {
-		GIT_CONFIG_COUNT: "1",
-		GIT_CONFIG_KEY_0: `http.${origin}/.extraHeader`,
-		GIT_CONFIG_VALUE_0: `Authorization: Basic ${basic}`,
-		GIT_TERMINAL_PROMPT: "0"
-	};
-}
-/** Run git in `cwd` and collect its output; never throws on a non-zero exit. */
-function git(cwd, args, env = {}) {
-	return new Promise((resolve, reject) => {
-		const child = spawn("git", args, {
-			cwd,
-			env: {
-				...process.env,
-				...env
-			},
-			windowsHide: true
-		});
-		let stdout = "";
-		let stderr = "";
-		child.stdout.on("data", (chunk) => stdout += chunk);
-		child.stderr.on("data", (chunk) => stderr += chunk);
-		child.on("error", (error) => reject(error.code === "ENOENT" ? /* @__PURE__ */ new Error("git is not installed (or not on PATH)") : error));
-		child.on("close", (code) => resolve({
-			code: code ?? 1,
-			stdout: stdout.trim(),
-			stderr: stderr.trim()
-		}));
-	});
-}
-/** Like {@link git}, but a non-zero exit throws with git's own message. */
-async function gitOk(cwd, args, env = {}) {
-	const result = await git(cwd, args, env);
-	if (result.code !== 0) throw new Error(result.stderr || result.stdout || `git ${args[0]} failed`);
-	return result.stdout;
-}
 //#endregion
 //#region src/cli/platform/link.ts
 /**
@@ -413,8 +267,36 @@ async function runLink(slug, options) {
 		site.gitUrl
 	]);
 	console.info(`Linked to ${site.slug} (${site.gitUrl})`);
+	await ignoreUploads(cwd);
 	console.info("Commit your work, then run `mechanica push` to deploy it.");
 }
+/** What a linked project keeps out of git: uploads live on the platform. */
+var UPLOAD_IGNORES = [".mech/assets/", ".mech/images.json"];
+/**
+* A linked project's uploads live on the platform, not in git: `push` sends
+* the files, the dev server fetches the ones made online. Make git ignore the
+* local copies, so a fetched file is never an uncommitted change. Uploads that
+* are already committed stay committed (git keeps tracking them) and keep
+* working — the hint says how to move them over.
+*/
+async function ignoreUploads(cwd) {
+	const file = join(cwd, ".gitignore");
+	const current = await readFile(file, "utf-8").catch(() => "");
+	const lines = new Set(current.split(/\r?\n/).map((line) => line.trim()));
+	const missing = UPLOAD_IGNORES.filter((entry) => !lines.has(entry) && !lines.has(entry.replace(/\/$/, "")));
+	if (missing.length) {
+		const block = `${current && !current.endsWith("\n") ? "\n" : ""}\n# Uploads live on the platform (mechanica push sends them, the dev server fetches them)\n${missing.join("\n")}\n`;
+		await appendFile(file, block);
+		console.info(`Added ${missing.join(" and ")} to .gitignore — uploads are kept by the platform, not by git.`);
+	}
+	const tracked = await git(cwd, [
+		"ls-files",
+		"--",
+		".mech/assets",
+		".mech/images.json"
+	]);
+	if (tracked.code === 0 && tracked.stdout) console.info("Uploads already committed in this repository keep working. To move them to the platform:\n  git rm -r --cached .mech/assets .mech/images.json && git commit -m \"Uploads live on the platform\"");
+}
 //#endregion
 //#region src/cli/platform/login.ts
 /** Ask one line on the terminal; with `hidden`, the typed characters are not echoed. */
@@ -451,11 +333,14 @@ async function runLogin(options) {
 	if (!token) {
 		if (!process.stdin.isTTY) throw new Error("No terminal to ask for credentials — pass --token <access token>");
 		console.info(`Signing in to ${origin}`);
+		const login = await prompt("Email: ");
+		const password = await prompt("Password: ", true);
+		const session = await request(origin, "POST", "/api/account/login", { body: {
+			login,
+			password
+		} });
 		token = (await request(origin, "POST", "/api/account/tokens", {
-			token: (await request(origin, "POST", "/api/account/login", { body: {
-				login: await prompt("Email: "),
-				password: await prompt("Password: ", true)
-			} })).accessToken,
+			token: session.accessToken,
 			body: { name: `CLI on ${os.hostname()}` }
 		})).token;
 	}
@@ -528,7 +413,8 @@ var AUTO_DEPLOY_WAIT_MS = 1e4;
 * `mechanica push`: publish the committed project to the platform.
 *
 *   1. bring in what was published online since the last pull (`pull --rebase`),
-*   2. `git push` the commits to the site's repository,
+*   2. send the uploads the platform lacks (they are not in git), then `git push`
+*      the commits to the site's repository,
 *   3. if the code changed, build locally and upload the bundle for that commit
 *      (content-only pushes reuse the bundle already there — no build at all),
 *   4. wait for the deploy and report it.
@@ -574,6 +460,11 @@ async function runPush() {
 		], 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.`);
 	}
+	await pushUploads(cwd, {
+		...link,
+		uuid: site.uuid,
+		token
+	});
 	const head = await gitOk(cwd, ["rev-parse", "HEAD"]);
 	console.info(`Pushing ${head.slice(0, 8)} to ${link.slug}…`);
 	const pushed = await git(cwd, [
@@ -1324,6 +1215,10 @@ Usage:
                             previews) for .mech/assets into .mech/images.json —
                             for pages authored without the browser editor
                             (needs the optional sharp dependency; --force redoes all)
+  mechanica assets pull     Download the site's uploads this project lacks into
+                            .mech/assets (the dev server fetches them one by one
+                            on demand; this gets all of them — for working offline
+                            or a local export)
   mechanica migrate         Bring .mech content up to the current format: uploads
                             are referenced as /media/<file> (was /@mechanica/assets/)
 `;
@@ -1339,6 +1234,10 @@ async function run(argv) {
 			assetsUrl: str(flags["assets-url"])
 		});
 		case "images": return runImages({ force: flags.force === true });
+		case "assets":
+			if (args[0] !== "pull") throw new Error("Usage: mechanica assets pull");
+			await runAssetsPull();
+			return;
 		case "migrate":
 			await runMigrate();
 			return;

package/dist/editor.js

@@ -3355,6 +3355,10 @@ var saveQueue = createSaveQueue({
 		version: pageVersion
 	})
 });
+window.__MECHANICA_EDITOR_API__ = {
+	hasUnsaved: () => saveQueue.hasUnsaved(),
+	flush: () => saveQueue.flush()
+};
 window.addEventListener("beforeunload", (event) => {
 	if (saveQueue.flushOnUnload()) return;
 	event.preventDefault();

package/dist/export.js

@@ -1,4 +1,4 @@
-import { E as listPages, F as setPageCodec, J as updateImageManifest, K as readImageManifest, Q as hasSharp, S as getPagePath, V as assetFileOf, W as isDerivedAsset, Z as analyzeImageBuffer, d as readFoldersData, f as readSiteData, i as toBlockMeta, p as readSiteLocaleOverride, r as composedBlockMeta, t as buildRichTextCodec, u as readFolderData } from "./chunks/rich-text-codec-D8JAuJIS.js";
+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 { 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";
@@ -435,12 +435,26 @@ async function exportProject(cwd, ssr, options = {}) {
 		onFile,
 		pageLinks
 	};
+	const unclaimed = /* @__PURE__ */ new Map();
+	for (const name of await readdir(join(cwd, ".mech/assets")).catch(() => [])) {
+		const spellings = [
+			name,
+			encodeURI(name),
+			encodeURIComponent(name)
+		].map((spelled) => UPLOADS_PREFIX$1 + spelled);
+		unclaimed.set(name, [...new Set(spellings)]);
+	}
 	const written = [];
 	const writePage = async (path, html) => {
 		const dir = path === "/" ? exportDir : join(exportDir, path);
 		await mkdir(dir, { recursive: true });
 		await writeFile(join(dir, "index.html"), html);
 		written.push(path);
+		for (const [name, addresses] of unclaimed) {
+			if (!addresses.some((address) => html.includes(address))) continue;
+			referenced.add(name);
+			unclaimed.delete(name);
+		}
 	};
 	const templateHandlesPagination = index.includes("page.pagination");
 	const pageNames = new Map(defaultPages.map((page) => [page.logicalPath, page.name ?? (page.logicalPath === "/" ? "Home" : page.logicalPath.split("/").pop())]));

package/dist/plugin.js

@@ -1,6 +1,7 @@
-import { a as collectGeneratedPages, n as configureSite, r as indexGeneratedPages, t as buildSiteManifest } from "./chunks/site-ONN3eU9_.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-CSZY47h6.js";
-import { H as fsAssetStore, X as wasRecentlyMutated, k as pageUrlOf } from "./chunks/rich-text-codec-D8JAuJIS.js";
+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 { t as BLOCKS_MANIFEST_FILE } from "./chunks/page-assets-DsJXmoDs.js";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, relative } from "node:path";
@@ -955,6 +956,12 @@ function mechanica(options = {}) {
 	let blocksDir = "";
 	let widgetsDir = "";
 	let mechDir = "";
+	let uploadStore = null;
+	let uploadsCached = null;
+	const uploads = () => uploadStore ??= withRemoteAssets(fsAssetStore(mechDir), remoteAssetsFor(root), { cache: () => uploadsCached ??= uploadsIgnored(root).then((ignored) => {
+		if (!ignored) console.info("[mechanica] Uploads made online are fetched from the platform on every start: add `.mech/assets/` and `.mech/images.json` to .gitignore (`mechanica link` does it) to keep them locally.");
+		return ignored;
+	}) });
 	let composedDir = "";
 	let composerFilePath = "";
 	let composerSpecifier = "";
@@ -1231,7 +1238,10 @@ function mechanica(options = {}) {
 		configureServer(server) {
 			server.middlewares.use("/@mechanica/preview", createPreviewMiddleware());
 			server.middlewares.use("/@mechanica/composer", createComposerMiddleware());
-			const service = createEditorService(mechDir, { site: () => loadSite(server) });
+			const service = createEditorService(mechDir, {
+				site: () => loadSite(server),
+				assets: uploads()
+			});
 			server.middlewares.use("/@mechanica", toNodeMiddleware(service));
 			server.middlewares.use(UPLOADS_PREFIX.replace(/\/$/, ""), toAssetMiddleware(service));
 			if (server.httpServer && !server.httpServer.listening) server.httpServer.once("listening", () => void loadSite(server));
@@ -1307,7 +1317,7 @@ function mechanica(options = {}) {
 				const withEditor = !url.searchParams.has("mechanica-shot");
 				if (ctx.server) await loadSite(ctx.server);
 				const generated = (await loadGeneratedIndex()).byServed.get(urlPath);
-				const state = await fillStateImages(mechDir, fsAssetStore(mechDir), generated ? buildGeneratedState(mechDir, generated, locales) : buildPageState(mechDir, urlPath, locales));
+				const state = await fillStateImages(mechDir, uploads(), generated ? buildGeneratedState(mechDir, generated, locales) : buildPageState(mechDir, urlPath, locales));
 				return renderEditablePage(html, state, {
 					site: {
 						url: options.siteUrl,

package/dist/server.js

@@ -1,5 +1,5 @@
-import { i as readSiteManifest, n as configureSite, t as buildSiteManifest } from "./chunks/site-ONN3eU9_.js";
-import { a as renderEditablePage, i as readEditorTemplate, n as toNodeMiddleware, r as createEditorService, t as toAssetMiddleware } from "./chunks/node-adapter-CSZY47h6.js";
-import { B as memoryContentFiles, H as fsAssetStore, O as pageOfFile, W as isDerivedAsset, Y as uploadName, z as fsContentFiles } from "./chunks/rich-text-codec-D8JAuJIS.js";
+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 { 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 };
+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 };

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

@@ -0,0 +1,51 @@
+import { type ImageManifestEntry, type RemoteAssets } from '../../server/assets-store';
+/** A site this project can talk to: where it is, and as whom. */
+export interface SiteLink {
+    origin: string;
+    slug: string;
+    uuid: string;
+    token: string;
+}
+/** An upload as the platform lists it. */
+export interface RemoteAsset extends ImageManifestEntry {
+    name: string;
+    size: number;
+    hash: string;
+}
+/**
+ * The site this project is linked to (the `mechanica` git remote) with the
+ * saved token for it — or null when it is not linked, not logged in, or the
+ * account has no access to the site. Never throws: an unlinked project is the
+ * normal case for the dev server.
+ */
+export declare function resolveLink(cwd: string): Promise<SiteLink | null>;
+/** The uploads the platform's store holds for the site. */
+export declare const listRemoteAssets: (link: SiteLink) => Promise<RemoteAsset[]>;
+/** One upload's bytes from the platform, or null when it has none of that name. */
+export declare function downloadRemoteAsset(link: SiteLink, name: string): Promise<Uint8Array | null>;
+/**
+ * Send the platform the uploads this project has and it lacks — the files in
+ * `.mech/assets` that are not committed (committed ones travel with git) — with
+ * what `.mech/images.json` knows about them. Returns the names sent.
+ */
+export declare function pushUploads(cwd: string, link: SiteLink, log?: (message: string) => void): Promise<string[]>;
+/**
+ * Whether git ignores the project's uploads directory — i.e. whether a file
+ * fetched into it stays out of `git status`. Decides if the dev server may
+ * keep what it fetches (see `withRemoteAssets`).
+ */
+export declare function uploadsIgnored(cwd: string): Promise<boolean>;
+/**
+ * The platform's uploads as the dev server sees them: resolved lazily, once —
+ * a project that is not linked (or is offline) simply has none.
+ */
+export declare function remoteAssetsFor(cwd: string): RemoteAssets;
+/**
+ * `mechanica assets pull` — download every upload the platform has and this
+ * project lacks into `.mech/assets`, with its image info. What the dev server
+ * does one file at a time, for all of them: before an offline session, a local
+ * `mechanica export`, or leaving the platform. Returns the names downloaded.
+ */
+export declare function runAssetsPull(options?: {
+    cwd?: string;
+}): Promise<string[]>;

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

@@ -9,3 +9,11 @@ export declare function runLink(slug: string | undefined, options: {
     create?: boolean;
     name?: string;
 }): Promise<void>;
+/**
+ * A linked project's uploads live on the platform, not in git: `push` sends
+ * the files, the dev server fetches the ones made online. Make git ignore the
+ * local copies, so a fetched file is never an uncommitted change. Uploads that
+ * are already committed stay committed (git keeps tracking them) and keep
+ * working — the hint says how to move them over.
+ */
+export declare function ignoreUploads(cwd: string): Promise<void>;

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

@@ -2,7 +2,8 @@
  * `mechanica push`: publish the committed project to the platform.
  *
  *   1. bring in what was published online since the last pull (`pull --rebase`),
- *   2. `git push` the commits to the site's repository,
+ *   2. send the uploads the platform lacks (they are not in git), then `git push`
+ *      the commits to the site's repository,
  *   3. if the code changed, build locally and upload the bundle for that commit
  *      (content-only pushes reuse the bundle already there — no build at all),
  *   4. wait for the deploy and report it.

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

@@ -84,3 +84,34 @@ export declare function listUploads(assets: AssetStore): Promise<{
     name: string;
     src: string;
 }[]>;
+/**
+ * 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
+ * until something asks for them.
+ */
+export interface RemoteAssets {
+    /** An upload's bytes with what is known about it as an image; null when there is no such upload. */
+    fetch(name: string): Promise<{
+        data: Uint8Array;
+        info?: ImageManifestEntry;
+    } | null>;
+    /** The names of the uploads kept there. */
+    list(): Promise<string[]>;
+}
+export interface RemoteAssetsOptions {
+    /**
+     * Whether a fetched upload is written into the local store. When it is not,
+     * the upload is fetched once per process and served from memory — for a
+     * project whose uploads directory is under version control, where a file
+     * appearing in it would be an uncommitted change.
+     */
+    cache?: boolean | (() => boolean | Promise<boolean>);
+}
+/**
+ * A store that falls back to {@link RemoteAssets} for what the local one lacks:
+ * an upload made in a hosted editor shows up in the dev server the first time a
+ * page asks for it, and (when `cache` allows) stays in the project's directory.
+ * Everything written goes to the local store; a remote failure is a miss, never
+ * an error — the dev server works offline with what it has.
+ */
+export declare function withRemoteAssets(local: AssetStore, remote: RemoteAssets, options?: RemoteAssetsOptions): AssetStore;

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, uploadName, isDerivedAsset, type AssetStore, type ImageManifest, type ImageManifestEntry, } from './assets-store';
+export { fsAssetStore, withRemoteAssets, 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.3",
+  "version": "2.1.0-beta.5",
   "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.3",
+    "mechanica-shared": "2.1.0-beta.5",
     "@vue/compiler-sfc": "^3.5.38",
     "compact-json-schema": "^0.1.5",
     "estree-walker": "^3.0.3",

package/dist/types/vite/dev/middleware.d.ts

@@ -1,11 +0,0 @@
-import type { Connect } from 'vite';
-import { type EditorServiceOptions } from '../../server/service';
-export type { BlockListing } from '../../server/service';
-export type DevMiddlewareOptions = EditorServiceOptions;
-/**
- * The `/@mechanica` dev middleware: the site's editor API (`src/server` —
- * page CRUD, asset upload/serve, folder list, query resolution) over the local
- * `.mech` store, mounted on Vite's connect stack. Mounted under the
- * `/@mechanica` prefix, so `req.url` here is already prefix-stripped.
- */
-export declare function createDevMiddleware(mechDir: string, options?: DevMiddlewareOptions): Connect.NextHandleFunction;