mechanica 2.0.2 → 2.1.0-beta.1

package/dist/chunks/node-adapter-4eD9p0iP.js

@@ -0,0 +1,699 @@
+import { n as configureSite, r as indexGeneratedPages } from "./site-DR_X2rzc.js";
+import { A as savePage, B as saveDerivedAsset, C as listFolders, D as pageVersion, G as writeFileAtomic, N as setPageDraft, O as readPage, P as translationsOf, R as listImages, T as movePage, U as markMutated, V as saveUpload, _ as deletePage, a as folderOf, b as fillContentDefaults, c as mergeLocaleSiteData, f as readSiteData, g as createTranslation, h as createPage, k as renamePage, l as mergeSiteData, m as PageExistsError, o as mergeFolderData, s as mergeLocaleFolderData, u as readFolderData, v as deleteTranslation, w as listPages, x as fillImageMeta, y as duplicatePage } from "./rich-text-codec--Nssj0Nn.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";
+import { parseComposedBlock, serializeComposedBlock } from "mechanica-shared/block-format";
+import { Readable } from "node:stream";
+import { createHash } from "node:crypto";
+//#region src/vite/collect-composed.ts
+/** Filename suffix for composed-block documents under `<mech>/blocks`. */
+var COMPOSED_EXT = ".block.yml";
+/** List `*.block.yml` files directly under `dir`, in stable (sorted) order. */
+function listComposedFiles(dir) {
+	try {
+		return readdirSync(dir).filter((name) => name.endsWith(COMPOSED_EXT)).sort().map((name) => join(dir, name));
+	} catch {
+		return [];
+	}
+}
+/**
+* Read and parse every composed-block definition under `dir`
+* (`<mech>/blocks`). A malformed file is skipped (reported via `onError`) so one
+* bad block never breaks the whole set. The id defaults to the filename base.
+*/
+function loadComposedDefinitions(dir, onError) {
+	const defs = [];
+	for (const file of listComposedFiles(dir)) try {
+		defs.push(parseComposedBlock(readFileSync(file, "utf-8"), basename(file, COMPOSED_EXT)));
+	} catch (error) {
+		onError?.(file, error);
+	}
+	return defs;
+}
+/**
+* Generate the `virtual:mechanica/composed` module source: the parsed
+* definitions baked in as a JSON literal (they are data, never imports). Loaded
+* by the client/SSR/preview entries, which register them into the block set.
+*/
+function collectComposed(dir, onError) {
+	const defs = loadComposedDefinitions(dir, onError);
+	return `export const composedList = ${JSON.stringify(defs)}\n`;
+}
+//#endregion
+//#region src/server/query-dev.ts
+/**
+* The dev server's {@link QuerySource}: pages come live from the `.mech`
+* store; `useFetch` URLs are fetched server-side (no CORS, matching how the
+* export resolves them at build time). `generated` pages (plugin `generatePages`)
+* are merged into the page listing so `usePages()` sees them, like the export.
+*/
+function devQuerySource(mechDir, generated) {
+	return {
+		listPages: (options) => listPages(mechDir, {
+			...options,
+			generated
+		}),
+		fetchJson: async ({ url, ...init }) => {
+			const res = await fetch(url, init);
+			if (!res.ok) throw new Error(`${url} responded ${res.status}`);
+			return res.json();
+		}
+	};
+}
+/**
+* Resolve a dev-mode query key against the local `.mech` store. Keys are of the
+* form `"<type>.<json-args>"` (the same encoding the runtime composables use);
+* `context.page` selects the chunk of a paginated query.
+*/
+function resolveDevQuery(mechDir, key, context = {}, generated) {
+	return resolveQueryKey(devQuerySource(mechDir, generated), key, context);
+}
+//#endregion
+//#region src/server/page-state.ts
+/**
+* Recognize a paginated variant URL (`/blog/2`): no page file of its own, a
+* numeric tail ≥ 2, and an existing base page. Returns the base path + number.
+* Checked against the default-locale (base) files — pagination structure is
+* defined by the logical page, and variant URLs never have their own file.
+*/
+function paginatedVariantOf(mechDir, urlPath) {
+	const match = urlPath.match(/^(.*)\/(\d+)$/);
+	if (!match) return null;
+	const page = Number(match[2]);
+	if (page < 2) return null;
+	if (pageVersion(mechDir, urlPath) != null) return null;
+	const basePath = match[1] || "/";
+	if (pageVersion(mechDir, basePath) == null) return null;
+	return {
+		basePath,
+		page
+	};
+}
+/**
+* The dev state for a page: effective data resolved site < folder < page, plus
+* the scope buckets the editor edits, and the page's on-disk version for
+* optimistic-concurrency saves. Injected as `window.state` on page load and
+* served by `GET /@mechanica/state` when the editor refreshes after an
+* external change.
+*
+* A paginated variant URL (`/blog/2`) serves its base page's state with
+* `page.pagination` set — `page.path` stays the base path, so editing the
+* variant edits (and saves to) the real page.
+*
+* A locale-prefixed URL (`/ru/about`) serves that page's translation: the
+* prefix is stripped to the logical path, `page.locale`/`page.locales` are set,
+* and the version targets the translation file. When no translation exists the
+* default-locale content renders as a fallback (`page.localeFallback`).
+*/
+function buildPageState(mechDir, urlPath, config) {
+	const { locale, path: localePathStripped } = parseLocalePath(urlPath, config);
+	const variant = paginatedVariantOf(mechDir, localePathStripped);
+	const pagePath = variant?.basePath ?? localePathStripped;
+	const localeCode = !config || locale === config.default ? void 0 : locale;
+	let fallback = false;
+	let page = readPage(mechDir, pagePath, localeCode);
+	let layout = page.layout;
+	if (localeCode) {
+		const hasTranslation = pageVersion(mechDir, pagePath, localeCode) != null;
+		const hasBase = pageVersion(mechDir, pagePath) != null;
+		if (!hasTranslation) {
+			page = readPage(mechDir, pagePath);
+			fallback = true;
+			layout = page.layout;
+		} else if (hasBase) {
+			const base = readPage(mechDir, pagePath);
+			layout = base.layout;
+			const merged = mergeTranslation({
+				content: base.content ?? [],
+				data: base.data ?? {},
+				meta: base.meta ?? {}
+			}, {
+				content: page.content ?? [],
+				data: page.data ?? {},
+				meta: page.meta ?? {}
+			});
+			page = {
+				...page,
+				content: merged.content,
+				data: merged.data,
+				meta: merged.meta
+			};
+		}
+	}
+	const content = page.content ?? [];
+	fillContentDefaults(mechDir, content);
+	fillImageMeta(mechDir, content);
+	let baseContent;
+	if (localeCode && pageVersion(mechDir, pagePath) != null) {
+		const base = readPage(mechDir, pagePath).content ?? [];
+		fillContentDefaults(mechDir, base);
+		fillImageMeta(mechDir, base);
+		baseContent = base;
+	}
+	const folder = folderOf(mechDir, pagePath);
+	const siteData = readSiteData(mechDir, localeCode);
+	const folderData = readFolderData(mechDir, folder, localeCode);
+	const pageData = page.data ?? {};
+	const pageMeta = {
+		path: pagePath,
+		meta: page.meta ?? {}
+	};
+	if (layout) pageMeta.layout = layout;
+	if (variant) pageMeta.pagination = { page: variant.page };
+	if (config) {
+		pageMeta.locale = locale;
+		pageMeta.locales = translationsOf(mechDir, pagePath, config);
+		if (fallback) pageMeta.localeFallback = true;
+	}
+	return {
+		content,
+		data: {
+			...siteData,
+			...folderData,
+			...pageData
+		},
+		siteData,
+		folderData,
+		pageData,
+		folder,
+		page: pageMeta,
+		version: pageVersion(mechDir, pagePath, localeCode),
+		...config ? { locales: config } : {},
+		...baseContent ? { baseContent } : {}
+	};
+}
+/**
+* The dev state for a programmatically generated page ({@link VirtualPage}) —
+* the file-free counterpart of {@link buildPageState}. It replicates the same
+* shape (content with block-prop defaults + image meta filled, the
+* site‹folder‹page data merge, and `page.locale`/`page.locales`), but reads its
+* content/data/meta from the baked page rather than a `.page.md`. `version` is
+* null and `generated` is set, so the editor treats it as read-only and never
+* queues a save against a file that doesn't exist.
+*/
+function buildGeneratedState(mechDir, vp, config) {
+	const content = vp.content ?? [];
+	fillContentDefaults(mechDir, content);
+	fillImageMeta(mechDir, content);
+	const localeCode = !config || !vp.locale || vp.locale === config.default ? void 0 : vp.locale;
+	const folder = folderOf(mechDir, vp.path);
+	const siteData = readSiteData(mechDir, localeCode);
+	const folderData = readFolderData(mechDir, folder, localeCode);
+	const pageData = vp.data ?? {};
+	const pageMeta = {
+		path: vp.path,
+		meta: vp.meta ?? {}
+	};
+	if (vp.layout) pageMeta.layout = vp.layout;
+	if (config) {
+		pageMeta.locale = vp.locale ?? config.default;
+		pageMeta.locales = vp.locales ?? [config.default];
+	}
+	return {
+		content,
+		data: {
+			...siteData,
+			...folderData,
+			...pageData
+		},
+		siteData,
+		folderData,
+		pageData,
+		folder,
+		page: pageMeta,
+		version: null,
+		generated: true,
+		...config ? { locales: config } : {}
+	};
+}
+//#endregion
+//#region src/server/composed-store.ts
+/**
+* CRUD for composed blocks under `<mech>/blocks/<id>.block.yml`. Mirrors
+* `pages-store`: atomic writes, own-write marking (so the watcher tells the
+* composer's own saves from external edits), and content-hash versioning for
+* optimistic-concurrency saves (a 409 when the file changed under the editor).
+* See PLAN.md § 5.1.
+*/
+/** The directory composed blocks live in. */
+function composedDirOf(mechDir) {
+	return join(mechDir, "blocks");
+}
+var fileOf = (mechDir, id) => join(composedDirOf(mechDir), `${id}${COMPOSED_EXT}`);
+var hash = (text) => createHash("sha1").update(text).digest("hex").slice(0, 16);
+/** Thrown by {@link createComposedBlock} when the id is already taken. */
+var ComposedBlockExistsError = class ComposedBlockExistsError extends Error {
+	id;
+	constructor(id) {
+		super(`Composed block already exists: ${id}`);
+		this.id = id;
+		this.name = "ComposedBlockExistsError";
+		Object.setPrototypeOf(this, ComposedBlockExistsError.prototype);
+	}
+};
+/** List every composed block (summaries), skipping malformed files. */
+function listComposedBlocks(mechDir) {
+	return loadComposedDefinitions(composedDirOf(mechDir)).map((def) => ({
+		id: def.id,
+		name: def.name,
+		icon: def.icon,
+		category: def.category
+	}));
+}
+/** Read one composed block plus its on-disk version, or `null` when absent. */
+function readComposedBlock(mechDir, id) {
+	const file = fileOf(mechDir, id);
+	if (!fs.existsSync(file)) return null;
+	const text = fs.readFileSync(file, "utf-8");
+	return {
+		def: parseComposedBlock(text, id),
+		version: hash(text)
+	};
+}
+/** A composed block's current on-disk version (content hash), or `null`. */
+function composedVersion(mechDir, id) {
+	const file = fileOf(mechDir, id);
+	if (!fs.existsSync(file)) return null;
+	return hash(fs.readFileSync(file, "utf-8"));
+}
+var writeDef = (mechDir, id, def) => {
+	const file = fileOf(mechDir, id);
+	writeFileAtomic(file, serializeComposedBlock({
+		...def,
+		id
+	}));
+	return hash(fs.readFileSync(file, "utf-8"));
+};
+/** Create a new composed block; throws {@link ComposedBlockExistsError} if taken. */
+function createComposedBlock(mechDir, def) {
+	if (fs.existsSync(fileOf(mechDir, def.id))) throw new ComposedBlockExistsError(def.id);
+	return { version: writeDef(mechDir, def.id, def) };
+}
+/** Overwrite a composed block's definition; returns the new on-disk version. */
+function saveComposedBlock(mechDir, id, def) {
+	return { version: writeDef(mechDir, id, def) };
+}
+/** Delete a composed block. Returns whether it existed. */
+function deleteComposedBlock(mechDir, id) {
+	const file = fileOf(mechDir, id);
+	if (!fs.existsSync(file)) return false;
+	fs.rmSync(file);
+	markMutated(file);
+	return true;
+}
+//#endregion
+//#region src/server/editor-page.ts
+/**
+* Turn the site's `index.html` into an editable page: resolve the `{{ … }}`
+* head placeholders against the page's data — the same pass the export runs —
+* and inject `window.state` at the top of `<body>`, ahead of any module script.
+* One function for every host: the dev server feeds it the source `index.html`,
+* a hosted editor the built `dist/mechanica-editor/index.html`.
+*/
+function renderEditablePage(html, state, options = {}) {
+	const templated = passDataToHTML(html, {
+		...state.data,
+		site: {
+			url: options.site?.url,
+			name: options.site?.name
+		},
+		page: state.page
+	});
+	const inject = [
+		...options.hostConfig ? [`<script>window.__MECHANICA_EDITOR__=${serializeState(options.hostConfig)}<\/script>`] : [],
+		`<script>window.state=${serializeState(state)}<\/script>`,
+		...options.scripts ? [options.scripts] : []
+	].join("\n");
+	return templated.replace("<body>", `<body>\n${inject}`);
+}
+/**
+* The page template of an editor build (`mechanica build --editor`), or null
+* when `distDir` holds none. Its sibling files in `dist/mechanica-editor/` are
+* the static root of the editing origin.
+*/
+function readEditorTemplate(distDir) {
+	const file = join(distDir, EDITOR_DIST_DIR, "index.html");
+	return fs.existsSync(file) ? fs.readFileSync(file, "utf-8") : null;
+}
+//#endregion
+//#region src/server/service.ts
+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.
+*/
+function serveFile(dir, relative, headers = {}) {
+	let decoded;
+	try {
+		decoded = decodeURIComponent(relative);
+	} catch {
+		return new Response("Bad request", { status: 400 });
+	}
+	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()];
+	return new Response(Readable.toWeb(fs.createReadStream(file)), { headers: {
+		...type ? { "content-type": type } : {},
+		...headers
+	} });
+}
+/** A safe composed-block id — a filename component, never a path (no traversal). */
+function isValidId(id) {
+	return /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(id);
+}
+/** Validate an incoming composed-block definition; returns a field-error map or null. */
+function validateComposed(def) {
+	if (!def || typeof def !== "object") return { def: "Invalid definition" };
+	const d = def;
+	if (typeof d.id !== "string" || !isValidId(d.id)) return { id: "A valid id is required" };
+	if (typeof d.name !== "string" || d.name === "") return { name: "A name is required" };
+	if (d.template !== void 0 && !Array.isArray(d.template)) return { template: "template must be a list" };
+	return null;
+}
+/** Create the editor API over a site's `.mech` directory. */
+function createEditorService(mechDir, options = {}) {
+	let configured = null;
+	let generatedIndex = null;
+	const currentSite = async () => {
+		if (!options.site) return null;
+		const manifest = typeof options.site === "function" ? await options.site() : options.site;
+		if (manifest !== configured) {
+			configureSite(mechDir, manifest);
+			generatedIndex = indexGeneratedPages(manifest);
+			configured = manifest;
+		}
+		return manifest;
+	};
+	const route = async (request) => {
+		const site = await currentSite();
+		const config = site?.locales ?? null;
+		const gen = site ? generatedIndex : null;
+		/** Resolve a `locale` query param to a variant code (undefined = base/default). */
+		const variantCode = (raw) => config && raw && raw !== config.default && config.all.includes(raw) ? raw : void 0;
+		const url = new URL(request.url);
+		const { pathname } = url;
+		const query = url.searchParams;
+		const method = request.method;
+		const body = () => request.json();
+		/** The rejection for a mutation targeting a file-less generated page, if it is one. */
+		const generatedGuard = (path) => path && gen?.logical.has(path) ? json({ error: "This page is generated and read-only" }, 409) : null;
+		if (pathname.startsWith("/assets/")) return serveFile(resolve(mechDir, "assets"), pathname.slice(8));
+		if (pathname.startsWith("/thumbs/")) return serveFile(resolve(mechDir, "thumbs"), pathname.slice(8), { "cache-control": "no-cache" });
+		if (pathname === "/images" && method === "GET") return json(listImages(mechDir));
+		if (pathname === "/folders" && method === "GET") return json(listFolders(mechDir));
+		if (pathname === "/query" && method === "GET") {
+			const key = query.get("q");
+			if (!key) return json({ error: "Missing query key" }, 400);
+			return json(await resolveDevQuery(mechDir, key, {
+				page: Number(query.get("page") ?? "") || void 0,
+				locale: variantCode(query.get("locale"))
+			}, gen?.pages));
+		}
+		if (pathname === "/upload" && method === "POST") {
+			const bytes = Buffer.from(await request.arrayBuffer());
+			const header = request.headers.get("x-file-name") ?? "file";
+			let name = header;
+			try {
+				name = decodeURIComponent(header);
+			} catch {}
+			if (request.headers.get("x-derived-asset")) return json(await saveDerivedAsset(mechDir, name, bytes));
+			return json(await saveUpload(mechDir, name, bytes));
+		}
+		if (pathname === "/state" && method === "GET") {
+			const pathParam = query.get("path");
+			if (!pathParam) return json({ error: "Missing path" }, 400);
+			const generated = gen?.byServed.get(pathParam);
+			if (generated) return json(buildGeneratedState(mechDir, generated, config));
+			return json(buildPageState(mechDir, pathParam, config));
+		}
+		if (pathname === "/pages" && method === "GET") return json(listPages(mechDir, {
+			...config ? { locales: config } : {},
+			generated: gen?.pages
+		}));
+		if (pathname === "/blocks" && method === "GET") {
+			if (!site) return json({ error: "Block listing unavailable" }, 503);
+			return json(site.blocks.map(({ id, name, hidden }) => ({
+				id,
+				name,
+				hidden
+			})));
+		}
+		if (pathname === "/pages" && method === "DELETE") {
+			const pathParam = query.get("path");
+			if (!pathParam) return json({ error: "Missing path" }, 400);
+			return generatedGuard(pathParam) ?? json({ success: deletePage(mechDir, pathParam) });
+		}
+		if (pathname === "/pages/draft" && method === "POST") {
+			const pathParam = query.get("path");
+			if (!pathParam) return json({ error: "Missing path" }, 400);
+			const blocked = generatedGuard(pathParam);
+			if (blocked) return blocked;
+			const { draft } = await body();
+			setPageDraft(mechDir, pathParam, draft === true, variantCode(query.get("locale")));
+			return json({
+				success: true,
+				draft: draft === true
+			});
+		}
+		if (pathname === "/pages/translation" && method === "POST") {
+			const pathParam = query.get("path");
+			const locale = query.get("locale");
+			if (!pathParam || !locale) return json({ error: "Missing path or locale" }, 400);
+			const blocked = generatedGuard(pathParam);
+			if (blocked) return blocked;
+			if (!config || locale === config.default || !config.all.includes(locale)) return json({ error: "Unknown locale" }, 400);
+			try {
+				createTranslation(mechDir, pathParam, locale);
+				return json({ success: true });
+			} catch (error) {
+				if (error instanceof PageExistsError) return json({ error: "Translation already exists" }, 400);
+				throw error;
+			}
+		}
+		if (pathname === "/pages/translation" && method === "DELETE") {
+			const pathParam = query.get("path");
+			const locale = query.get("locale");
+			if (!pathParam || !locale) return json({ error: "Missing path or locale" }, 400);
+			return generatedGuard(pathParam) ?? json({ success: deleteTranslation(mechDir, pathParam, locale) });
+		}
+		if (pathname === "/pages/duplicate" && method === "POST") {
+			const pathParam = query.get("path");
+			if (!pathParam) return json({ error: "Missing path" }, 400);
+			const blocked = generatedGuard(pathParam);
+			if (blocked) return blocked;
+			const input = await body();
+			if (!input.path || !input.name) return json({ error: "path and name are required" }, 400);
+			try {
+				return json(duplicatePage(mechDir, pathParam, input));
+			} catch (error) {
+				if (error instanceof PageExistsError) return json({ error: { path: "Page already exists" } }, 400);
+				throw error;
+			}
+		}
+		if (pathname === "/pages" && method === "POST") {
+			const input = await body();
+			const pathParam = query.get("path");
+			if (pathParam) {
+				const blocked = generatedGuard(pathParam);
+				if (blocked) return blocked;
+				try {
+					const path = typeof input.path === "string" && input.path.trim() && input.path.trim() !== pathParam ? movePage(mechDir, pathParam, input.path).path : pathParam;
+					if (input.name) renamePage(mechDir, path, input.name);
+					return json({
+						success: true,
+						path
+					});
+				} catch (error) {
+					if (error instanceof PageExistsError) return json({ error: { path: "Page already exists" } }, 400);
+					throw error;
+				}
+			}
+			if (!input.path || !input.name) return json({ error: "path and name are required" }, 400);
+			if (config) {
+				const first = `${typeof input.folderId === "string" ? `${input.folderId}/` : ""}${String(input.path).trim()}`.replace(/^\/+/, "").split("/")[0];
+				if (first && first !== config.default && config.all.includes(first)) return json({ error: { path: `"/${first}" is reserved for the ${first} locale` } }, 400);
+			}
+			try {
+				return json(createPage(mechDir, input));
+			} catch (error) {
+				if (error instanceof PageExistsError) return json({ error: { path: "Page already exists" } }, 400);
+				throw error;
+			}
+		}
+		if (pathname === "/save" && method === "POST") {
+			const pathParam = query.get("path");
+			if (!pathParam) return json({ error: "Missing path" }, 400);
+			const blocked = generatedGuard(pathParam);
+			if (blocked) return blocked;
+			const locale = variantCode(query.get("locale"));
+			const save = await body();
+			if (!save.force && typeof save.version === "string") {
+				const current = pageVersion(mechDir, pathParam, locale);
+				if (current != null && current !== save.version) return json({
+					error: "conflict",
+					version: current
+				}, 409);
+			}
+			const folder = folderOf(mechDir, pathParam);
+			const version = savePage(mechDir, pathParam, {
+				content: save.content,
+				data: save.pageData ?? {},
+				layout: save.layout
+			}, locale);
+			const siteI18n = save.siteDataI18n ?? {};
+			const folderI18n = save.folderDataI18n ?? {};
+			if (locale) {
+				mergeSiteData(mechDir, save.siteData ?? {});
+				mergeFolderData(mechDir, folder, save.folderData ?? {});
+				mergeLocaleSiteData(mechDir, locale, siteI18n);
+				mergeLocaleFolderData(mechDir, locale, folder, folderI18n);
+			} else {
+				mergeSiteData(mechDir, {
+					...save.siteData ?? {},
+					...siteI18n
+				});
+				mergeFolderData(mechDir, folder, {
+					...save.folderData ?? {},
+					...folderI18n
+				});
+			}
+			return json({
+				success: true,
+				version
+			});
+		}
+		if (pathname === "/composed" && method === "GET") return json(listComposedBlocks(mechDir));
+		if (pathname === "/composed/get" && method === "GET") {
+			const id = query.get("id");
+			if (!id || !isValidId(id)) return json({ error: "Missing or invalid id" }, 400);
+			const result = readComposedBlock(mechDir, id);
+			return result ? json(result) : json({ error: "not found" }, 404);
+		}
+		if (pathname === "/composed/create" && method === "POST") {
+			const def = await body();
+			const invalid = validateComposed(def);
+			if (invalid) return json({ error: invalid }, 400);
+			if (site?.blocks.some((block) => block.id === def.id)) return json({ error: { id: "A block with this id already exists" } }, 400);
+			try {
+				return json({
+					success: true,
+					...createComposedBlock(mechDir, def)
+				});
+			} catch (error) {
+				if (error instanceof ComposedBlockExistsError) return json({ error: { id: "A block with this id already exists" } }, 400);
+				throw error;
+			}
+		}
+		if (pathname === "/composed/save" && method === "POST") {
+			const id = query.get("id");
+			if (!id || !isValidId(id)) return json({ error: "Missing or invalid id" }, 400);
+			const save = await body();
+			const invalid = validateComposed(save.def);
+			if (invalid) return json({ error: invalid }, 400);
+			if (!save.force && typeof save.version === "string") {
+				const current = composedVersion(mechDir, id);
+				if (current != null && current !== save.version) return json({
+					error: "conflict",
+					version: current
+				}, 409);
+			}
+			return json({
+				success: true,
+				...saveComposedBlock(mechDir, id, save.def)
+			});
+		}
+		if (pathname === "/composed/delete" && method === "POST") {
+			const id = query.get("id");
+			if (!id || !isValidId(id)) return json({ error: "Missing or invalid id" }, 400);
+			return json({ success: deleteComposedBlock(mechDir, id) });
+		}
+		return null;
+	};
+	return {
+		async handle(request) {
+			try {
+				return await route(request);
+			} catch (error) {
+				return json({ error: String(error) }, 500);
+			}
+		},
+		async page(urlPath) {
+			if (!options.editorHtml) return null;
+			const site = await currentSite();
+			const template = typeof options.editorHtml === "function" ? await options.editorHtml() : options.editorHtml;
+			const generated = site ? generatedIndex?.byServed.get(urlPath) : void 0;
+			const locales = site?.locales ?? null;
+			const html = renderEditablePage(template, generated ? buildGeneratedState(mechDir, generated, locales) : buildPageState(mechDir, urlPath, locales), {
+				site: site?.site,
+				hostConfig: options.hostConfig
+			});
+			return new Response(html, { headers: {
+				"content-type": "text/html; charset=utf-8",
+				"cache-control": "no-store"
+			} });
+		}
+	};
+}
+//#endregion
+//#region src/server/node-adapter.ts
+function readBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (chunk) => chunks.push(chunk));
+		req.on("end", () => resolve(Buffer.concat(chunks)));
+		req.on("error", reject);
+	});
+}
+/**
+* Mount an {@link EditorService} on a Node HTTP stack. Mount it under the API
+* prefix (`app.use('/@mechanica', …)`) — connect strips the prefix, so
+* `req.url` arrives relative, which is what the service expects. Routes the
+* service doesn't own fall through to `next()`.
+*/
+function toNodeMiddleware(service) {
+	return (req, res, next) => {
+		(async () => {
+			const method = req.method ?? "GET";
+			const headers = new Headers();
+			for (const [name, value] of Object.entries(req.headers)) if (value != null) headers.set(name, Array.isArray(value) ? value.join(", ") : value);
+			const hasBody = method !== "GET" && method !== "HEAD";
+			const request = new Request(new URL(req.url ?? "/", "http://localhost"), {
+				method,
+				headers,
+				body: hasBody ? new Uint8Array(await readBody(req)) : void 0
+			});
+			const response = await service.handle(request);
+			if (!response) return next();
+			res.statusCode = response.status;
+			response.headers.forEach((value, name) => res.setHeader(name, value));
+			if (response.body) for await (const chunk of response.body) res.write(chunk);
+			res.end();
+		})().catch(next);
+	};
+}
+//#endregion
+export { buildGeneratedState as a, collectComposed as c, renderEditablePage as i, loadComposedDefinitions as l, createEditorService as n, buildPageState as o, readEditorTemplate as r, COMPOSED_EXT as s, toNodeMiddleware as t };