mechanica 2.1.0-beta.4 → 2.1.0-beta.6

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-nujjbCx8.js

@@ -0,0 +1,322 @@
+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";
+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-BJbGKMgx.js → node-adapter-CSkDXYGO.js}

@@ -1,7 +1,7 @@
-import { n as configureSite, r as indexGeneratedPages } from "./site-DHrH4i9x.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-DcgyZKq_.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-DcgyZKq_.js → rich-text-codec-BSD35k2U.js}

@@ -273,6 +273,143 @@ 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;
+/**
+* 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 +1271,4 @@ function findRichTextProps(props) {
 	return found;
 }
 //#endregion
-export { hasSharp 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, analyzeImageBuffer 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, wasRecentlyMutated as Z, deletePage as _, folderOf as a, fillContentDefaults as b, mergeLocaleSiteData as c, readFoldersData as d, isRasterImage 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, 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-DHrH4i9x.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-DcgyZKq_.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";