fundus 0.0.2

package/dist/runtime/kind-handlers.js

@@ -0,0 +1,86 @@
+import { resolveRetainedSource } from "./preload-registry.js";
+//#region src/kind-handlers.ts
+/** The playable URL hosts feed to their own audio engine. */
+function audioSourceOf(entry) {
+	return resolveRetainedSource(entry.src);
+}
+/** Entry kinds whose delivered file is an image the browser can pre-decode. */
+const IMAGE_BACKED_KINDS = new Set(["image", "slice"]);
+/**
+* Entry kinds whose delivered file is retained as an object URL by
+* `preload()` while held. A chroma-key-video's own `src` is a video file, so
+* it retains too; its inlined mask/fallback entries are `image` kind and
+* follow the image handler via the source walk.
+*/
+const RETAINED_KINDS = new Set([
+	"video",
+	"chroma-key-video",
+	"audio"
+]);
+/**
+* Whether a source of `kind` decodes under the given per-kind preload options
+* (options are namespaced per plugin type, like `plugins.<type>` in
+* the config). Image-backed kinds decode by default; each kind opts out
+* independently (`{ image: { decode: false } }` leaves slices decoding).
+*/
+function shouldDecode(kind, options) {
+	if (!IMAGE_BACKED_KINDS.has(kind)) return false;
+	return options[kind]?.decode ?? true;
+}
+/** Fetch a source, throwing a uniform error on a non-OK response. */
+async function fetchCompletely(url) {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Preloading "${url}" failed: ${response.status} ${response.statusText}.`);
+	return response;
+}
+/**
+* The image-backed strategy (image, slice): fetch the full file, then decode
+* by default. Decoding goes via an HTMLImageElement where a DOM exists (the
+* browser serves the bytes from cache); headless environments (Node tests,
+* SSR) skip decoding. Nothing to release — the browser cache owns the bytes.
+*/
+function imageBackedHandler(kind) {
+	return { async preload(url, options) {
+		await (await fetchCompletely(url)).arrayBuffer();
+		if (shouldDecode(kind, options) && typeof globalThis.Image === "function") {
+			const image = new globalThis.Image();
+			image.src = url;
+			await image.decode();
+		}
+		return {};
+	} };
+}
+/**
+* The retained-media strategy (video, chroma-key-video, audio): fetch the
+* full file and retain it as an object URL so later playback does not touch
+* the network. Release revokes the URL, freeing the
+* retained memory. Environments without object URLs (SSR) still fetch fully
+* but retain nothing.
+*/
+const retainedMediaHandler = {
+	async preload(url) {
+		const blob = await (await fetchCompletely(url)).blob();
+		if (typeof URL.createObjectURL !== "function") return {};
+		return { objectUrl: URL.createObjectURL(blob) };
+	},
+	release(resources) {
+		if (resources.objectUrl !== void 0 && typeof URL.revokeObjectURL === "function") URL.revokeObjectURL(resources.objectUrl);
+	}
+};
+/** Fallback for kinds without a registered handler: plain full fetch. */
+const unknownKindHandler = { async preload(url) {
+	await (await fetchCompletely(url)).arrayBuffer();
+	return {};
+} };
+/** The statically registered first-party handlers. */
+const handlerByKind = new Map([
+	["image", imageBackedHandler("image")],
+	["slice", imageBackedHandler("slice")],
+	...[...RETAINED_KINDS].map((kind) => [kind, retainedMediaHandler])
+]);
+/** The runtime handler owning `kind`'s preload/release strategy (fallback for unknown kinds). */
+function runtimeHandlerFor(kind) {
+	return handlerByKind.get(kind) ?? unknownKindHandler;
+}
+//#endregion
+export { RETAINED_KINDS, audioSourceOf, runtimeHandlerFor, shouldDecode };

package/dist/runtime/manifest.d.ts

@@ -0,0 +1,60 @@
+import { ManifestEntry, PreloadOptions } from "#fundus/core";
+
+//#region src/manifest.d.ts
+/** One deliverable file of an entry: its URL and the owning entry's kind. */
+interface EntrySource {
+  url: string;
+  kind: string;
+}
+/**
+ * Collect every deliverable URL of an entry, including the entries codegen
+ * inlined in place of asset references: any nested object carrying
+ * a string `kind` is an entry, and its `src` (when present) is a source.
+ * Generic by design: adding a kind does not change preload orchestration.
+ */
+declare function collectEntrySources(entry: ManifestEntry): EntrySource[];
+declare class Manifest {
+  #private;
+  constructor(entries: Record<string, ManifestEntry>);
+  /**
+   * Fetch every deliverable file of this manifest up front — including the
+   * reference closure, which codegen inlined into the entries — and decode
+   * image-backed entries. Options are namespaced per asset kind, mirroring
+   * `plugins.<type>` in the config: `{ image: { decode: false } }`
+   * skips decoding for image entries only; slices keep decoding unless
+   * `slice: { decode: false }` is passed too. An option applies to every
+   * entry of its kind, inlined reference entries included.
+   *
+   * Idempotent and concurrent-safe: one in-flight promise per manifest; a
+   * second call joins it (or resolves immediately once done), and URLs shared
+   * by several entries are fetched once. Sharing goes further than this
+   * manifest: every URL is acquired through the module-wide refcounted
+   * registry, so a URL another manifest already preloaded (or is preloading)
+   * is never fetched again — this manifest just takes a hold on it. A failed
+   * preload rolls back this manifest's holds and clears the in-flight state
+   * so it can be retried. A joined call's options are ignored: options apply
+   * per preload run (the first call after construction or `release()`).
+   */
+  preload(options?: PreloadOptions): Promise<void>;
+  /**
+   * Drop this manifest's holds on everything it preloaded. Assets shared
+   * with another preloaded manifest stay fully alive for that holder; assets
+   * nobody holds anymore are disposed via their kind's release strategy
+   * (retained media object URLs are revoked, freeing the memory). Consumers
+   * of a fully released source fall back to its network URL.
+   *
+   * Safe in every state: before or without `preload()` it is a no-op, and
+   * calling it while a `preload()` is still in flight drops the holds
+   * without cancelling — when the in-flight load completes unheld, the
+   * registry disposes it immediately (no leak). Afterwards the manifest's
+   * preload state is reset, so a later `preload()` re-acquires from scratch.
+   */
+  release(): void;
+}
+/**
+ * Construct a manifest whose entries are direct readonly properties:
+ * `mainCatalog.navigationPanel` is fully typed, and a typo is a compile error.
+ */
+declare function createManifest<T extends Record<string, ManifestEntry>>(entries: T): Manifest & Readonly<T>;
+//#endregion
+export { EntrySource, Manifest, collectEntrySources, createManifest };

package/dist/runtime/manifest.js

@@ -0,0 +1,117 @@
+import { acquireSource, releaseSource } from "./preload-registry.js";
+//#region src/manifest.ts
+/**
+* Collect every deliverable URL of an entry, including the entries codegen
+* inlined in place of asset references: any nested object carrying
+* a string `kind` is an entry, and its `src` (when present) is a source.
+* Generic by design: adding a kind does not change preload orchestration.
+*/
+function collectEntrySources(entry) {
+	const sources = [];
+	visit(entry);
+	return sources;
+	function visit(value) {
+		if (Array.isArray(value)) {
+			for (const element of value) visit(element);
+			return;
+		}
+		if (typeof value !== "object" || value === null) return;
+		const record = value;
+		if (typeof record.kind === "string" && typeof record.src === "string") sources.push({
+			url: record.src,
+			kind: record.kind
+		});
+		for (const nested of Object.values(record)) visit(nested);
+	}
+}
+var Manifest = class {
+	#entries;
+	#preloading = null;
+	/**
+	* URLs this manifest currently holds in the module-wide registry (each
+	* held at most once — the registry's reference count counts holding
+	* manifests, not preload calls). Replaced wholesale by `release()`: an
+	* in-flight preload run keeps operating on the set object it captured, so
+	* a release during the run (which drains that set) turns the run's own
+	* failure rollback into a no-op instead of a double release.
+	*/
+	#heldUrls = /* @__PURE__ */ new Set();
+	constructor(entries) {
+		for (const key of Object.keys(entries)) if (key in this) throw new Error(`Manifest entry id "${key}" collides with a Manifest member.`);
+		Object.assign(this, entries);
+		this.#entries = entries;
+	}
+	/**
+	* Fetch every deliverable file of this manifest up front — including the
+	* reference closure, which codegen inlined into the entries — and decode
+	* image-backed entries. Options are namespaced per asset kind, mirroring
+	* `plugins.<type>` in the config: `{ image: { decode: false } }`
+	* skips decoding for image entries only; slices keep decoding unless
+	* `slice: { decode: false }` is passed too. An option applies to every
+	* entry of its kind, inlined reference entries included.
+	*
+	* Idempotent and concurrent-safe: one in-flight promise per manifest; a
+	* second call joins it (or resolves immediately once done), and URLs shared
+	* by several entries are fetched once. Sharing goes further than this
+	* manifest: every URL is acquired through the module-wide refcounted
+	* registry, so a URL another manifest already preloaded (or is preloading)
+	* is never fetched again — this manifest just takes a hold on it. A failed
+	* preload rolls back this manifest's holds and clears the in-flight state
+	* so it can be retried. A joined call's options are ignored: options apply
+	* per preload run (the first call after construction or `release()`).
+	*/
+	preload(options = {}) {
+		if (!this.#preloading) {
+			const tracked = this.#preloadAll(options, this.#heldUrls).catch((cause) => {
+				if (this.#preloading === tracked) this.#preloading = null;
+				throw cause;
+			});
+			this.#preloading = tracked;
+		}
+		return this.#preloading;
+	}
+	/**
+	* Drop this manifest's holds on everything it preloaded. Assets shared
+	* with another preloaded manifest stay fully alive for that holder; assets
+	* nobody holds anymore are disposed via their kind's release strategy
+	* (retained media object URLs are revoked, freeing the memory). Consumers
+	* of a fully released source fall back to its network URL.
+	*
+	* Safe in every state: before or without `preload()` it is a no-op, and
+	* calling it while a `preload()` is still in flight drops the holds
+	* without cancelling — when the in-flight load completes unheld, the
+	* registry disposes it immediately (no leak). Afterwards the manifest's
+	* preload state is reset, so a later `preload()` re-acquires from scratch.
+	*/
+	release() {
+		const held = this.#heldUrls;
+		this.#heldUrls = /* @__PURE__ */ new Set();
+		this.#preloading = null;
+		for (const url of held) releaseSource(url);
+		held.clear();
+	}
+	async #preloadAll(options, held) {
+		const kindByUrl = /* @__PURE__ */ new Map();
+		for (const entry of Object.values(this.#entries)) for (const source of collectEntrySources(entry)) if (!kindByUrl.has(source.url)) kindByUrl.set(source.url, source.kind);
+		const acquisitions = [];
+		for (const [url, kind] of kindByUrl) {
+			held.add(url);
+			acquisitions.push(acquireSource(url, kind, options));
+		}
+		const failure = (await Promise.allSettled(acquisitions)).find((outcome) => outcome.status === "rejected");
+		if (failure) {
+			for (const url of held) releaseSource(url);
+			held.clear();
+			throw failure.reason;
+		}
+	}
+};
+/**
+* Construct a manifest whose entries are direct readonly properties:
+* `mainCatalog.navigationPanel` is fully typed, and a typo is a compile error.
+*/
+function createManifest(entries) {
+	return new Manifest(entries);
+}
+//#endregion
+export { Manifest, collectEntrySources, createManifest };

package/dist/runtime/observe-border-box-size.d.ts

@@ -0,0 +1,5 @@
+//#region src/observe-border-box-size.d.ts
+/** Observe an element's layout border-box size in whole CSS pixels. */
+declare function observeBorderBoxSize(element: HTMLElement, onSize: (width: number, height: number) => void): () => void;
+//#endregion
+export { observeBorderBoxSize };

package/dist/runtime/observe-border-box-size.js

@@ -0,0 +1,12 @@
+//#region src/observe-border-box-size.ts
+/** Observe an element's layout border-box size in whole CSS pixels. */
+function observeBorderBoxSize(element, onSize) {
+	const observer = new ResizeObserver((entries) => {
+		const size = entries[0]?.borderBoxSize?.[0];
+		onSize(Math.round(size?.inlineSize ?? element.offsetWidth), Math.round(size?.blockSize ?? element.offsetHeight));
+	});
+	observer.observe(element);
+	return () => observer.disconnect();
+}
+//#endregion
+export { observeBorderBoxSize };

package/dist/runtime/preload-registry.d.ts

@@ -0,0 +1,26 @@
+import { PreloadOptions } from "#fundus/core";
+
+//#region src/preload-registry.d.ts
+/**
+ * Acquire one hold on `url` for a manifest: increments the reference count
+ * immediately, then loads via the kind handler unless the URL is already
+ * loaded (resolves at once) or in flight (joins the pending load). A failed
+ * load clears the in-flight state so the URL stays retryable; the caller
+ * rolls back its own hold via `releaseSource`.
+ */
+declare function acquireSource(url: string, kind: string, options: PreloadOptions): Promise<void>;
+/**
+ * Drop one hold on `url`. At zero holds the kind handler's release strategy
+ * runs (object URL revoked) and the entry is cleared — unless the load is
+ * still in flight, in which case its completion disposes. Releasing an
+ * unknown URL is a no-op.
+ */
+declare function releaseSource(url: string): void;
+/**
+ * The retained object URL of a source while some manifest holds it, or the
+ * source itself when not (or no longer) preloaded — after a full release a
+ * consumer falls back to the network URL and simply streams.
+ */
+declare function resolveRetainedSource(url: string): string;
+//#endregion
+export { acquireSource, releaseSource, resolveRetainedSource };

package/dist/runtime/preload-registry.js

@@ -0,0 +1,68 @@
+import { runtimeHandlerFor } from "./kind-handlers.js";
+//#region src/preload-registry.ts
+const registryByUrl = /* @__PURE__ */ new Map();
+/**
+* Acquire one hold on `url` for a manifest: increments the reference count
+* immediately, then loads via the kind handler unless the URL is already
+* loaded (resolves at once) or in flight (joins the pending load). A failed
+* load clears the in-flight state so the URL stays retryable; the caller
+* rolls back its own hold via `releaseSource`.
+*/
+function acquireSource(url, kind, options) {
+	let entry = registryByUrl.get(url);
+	if (!entry) {
+		entry = {
+			kind,
+			referenceCount: 0,
+			pending: null,
+			resources: null
+		};
+		registryByUrl.set(url, entry);
+	}
+	entry.referenceCount += 1;
+	if (entry.resources !== null) return Promise.resolve();
+	let pending = entry.pending;
+	if (!pending) {
+		const acquired = entry;
+		pending = runtimeHandlerFor(kind).preload(url, options).then((resources) => {
+			acquired.pending = null;
+			if (acquired.referenceCount === 0) {
+				runtimeHandlerFor(acquired.kind).release?.(resources);
+				registryByUrl.delete(url);
+				return;
+			}
+			acquired.resources = resources;
+		}, (cause) => {
+			acquired.pending = null;
+			if (acquired.referenceCount === 0) registryByUrl.delete(url);
+			throw cause;
+		});
+		acquired.pending = pending;
+	}
+	return pending;
+}
+/**
+* Drop one hold on `url`. At zero holds the kind handler's release strategy
+* runs (object URL revoked) and the entry is cleared — unless the load is
+* still in flight, in which case its completion disposes. Releasing an
+* unknown URL is a no-op.
+*/
+function releaseSource(url) {
+	const entry = registryByUrl.get(url);
+	if (!entry) return;
+	if (entry.referenceCount > 0) entry.referenceCount -= 1;
+	if (entry.referenceCount > 0) return;
+	if (entry.pending) return;
+	if (entry.resources !== null) runtimeHandlerFor(entry.kind).release?.(entry.resources);
+	registryByUrl.delete(url);
+}
+/**
+* The retained object URL of a source while some manifest holds it, or the
+* source itself when not (or no longer) preloaded — after a full release a
+* consumer falls back to the network URL and simply streams.
+*/
+function resolveRetainedSource(url) {
+	return registryByUrl.get(url)?.resources?.objectUrl ?? url;
+}
+//#endregion
+export { acquireSource, releaseSource, resolveRetainedSource };

package/dist/start-Bhnqt9Dc.js

@@ -0,0 +1,279 @@
+import { r as assertSafeRelativeFilePath, t as FundusOperations, w as loadConfig } from "./operations-DYM-5KVl.js";
+import { readFile, stat } from "node:fs/promises";
+import { extname, join, resolve, sep } from "node:path";
+import { existsSync } from "node:fs";
+import { createServer } from "node:http";
+//#region src/server.ts
+/**
+* The local Fundus HTTP server: REST under `/api/`, raw and proxy files under
+* `/files/`, and the prebuilt editor SPA at `/` when its build is available.
+*/
+const CONTENT_TYPES = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".webp": "image/webp",
+	".gif": "image/gif",
+	".avif": "image/avif",
+	".svg": "image/svg+xml",
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".ico": "image/x-icon",
+	".woff2": "font/woff2",
+	".mp4": "video/mp4",
+	".m4v": "video/mp4",
+	".mov": "video/quicktime",
+	".webm": "video/webm",
+	".mp3": "audio/mpeg",
+	".wav": "audio/wav",
+	".m4a": "audio/mp4",
+	".ogg": "audio/ogg",
+	".flac": "audio/flac"
+};
+function contentTypeFor(fileName) {
+	return CONTENT_TYPES[extname(fileName).toLowerCase()] ?? "application/octet-stream";
+}
+function errorResponse(cause, status) {
+	const body = { error: { message: cause instanceof Error ? cause.message : String(cause) } };
+	return Response.json(body, { status });
+}
+/**
+* Parse a single-range HTTP `Range: bytes=…` header against a known size.
+* Returns the inclusive `[start, end]` byte range, `null` when there is no (or
+* an unhandled multi-)range header — serve the whole file — or `'unsatisfiable'`
+* when the header is syntactically a range but falls outside the file (→ 416).
+* Only the single-range forms browsers actually send while seeking are handled:
+* `bytes=start-end`, `bytes=start-`, and the `bytes=-suffix` tail form.
+*/
+function parseByteRange(rangeHeader, size) {
+	if (!rangeHeader) return null;
+	const match = /^bytes=(\d*)-(\d*)$/.exec(rangeHeader.trim());
+	if (!match || match[1] === "" && match[2] === "") return null;
+	if (size === 0) return "unsatisfiable";
+	let start;
+	let end;
+	if (match[1] === "") {
+		const suffix = Number(match[2]);
+		start = Math.max(0, size - suffix);
+		end = size - 1;
+	} else {
+		start = Number(match[1]);
+		end = match[2] === "" ? size - 1 : Math.min(Number(match[2]), size - 1);
+	}
+	if (start > end || start >= size) return "unsatisfiable";
+	return {
+		start,
+		end
+	};
+}
+async function serveSingleFile(directory, fileName, request) {
+	try {
+		assertSafeRelativeFilePath(fileName);
+	} catch (cause) {
+		return errorResponse(cause, 400);
+	}
+	const filePath = join(directory, fileName);
+	if (!existsSync(filePath)) return errorResponse(/* @__PURE__ */ new Error(`File "${fileName}" not found.`), 404);
+	const bytes = new Uint8Array(await readFile(filePath));
+	const size = bytes.byteLength;
+	const headers = {
+		"Content-Type": contentTypeFor(fileName),
+		"Cache-Control": "no-store",
+		"Accept-Ranges": "bytes"
+	};
+	const range = parseByteRange(request.headers.get("Range"), size);
+	if (range === "unsatisfiable") return new Response(null, {
+		status: 416,
+		headers: {
+			...headers,
+			"Content-Range": `bytes */${size}`
+		}
+	});
+	if (range) {
+		const slice = bytes.subarray(range.start, range.end + 1);
+		return new Response(slice, {
+			status: 206,
+			headers: {
+				...headers,
+				"Content-Range": `bytes ${range.start}-${range.end}/${size}`,
+				"Content-Length": String(slice.byteLength)
+			}
+		});
+	}
+	return new Response(bytes, { headers: {
+		...headers,
+		"Content-Length": String(size)
+	} });
+}
+function startServer(options) {
+	const operations = new FundusOperations(options.config);
+	const editorBuildDirectory = options.editorBuildDirectory ?? null;
+	async function serveEditor(pathname) {
+		if (editorBuildDirectory) {
+			const relative = pathname === "/" ? "index.html" : pathname.slice(1);
+			const buildRoot = resolve(editorBuildDirectory);
+			const filePath = resolve(buildRoot, relative);
+			if ((filePath === buildRoot || filePath.startsWith(`${buildRoot}${sep}`)) && !relative.includes("..")) {
+				if ((await stat(filePath).catch(() => null))?.isFile()) {
+					const bytes = await readFile(filePath);
+					return new Response(new Uint8Array(bytes), { headers: { "Content-Type": contentTypeFor(filePath) } });
+				}
+			}
+			const fallbackPath = join(editorBuildDirectory, "200.html");
+			if (existsSync(fallbackPath)) {
+				const bytes = await readFile(fallbackPath);
+				return new Response(new Uint8Array(bytes), { headers: { "Content-Type": "text/html; charset=utf-8" } });
+			}
+		}
+		return errorResponse(/* @__PURE__ */ new Error("The prebuilt Fundus editor is unavailable."), 500);
+	}
+	async function handle(request) {
+		const pathname = new URL(request.url).pathname;
+		const method = request.method.toUpperCase();
+		try {
+			if (pathname === "/api/state" && method === "GET") return Response.json(await operations.state());
+			if (pathname === "/api/assets" && method === "POST") {
+				const formData = await request.formData();
+				const file = formData.get("file");
+				const type = formData.get("type");
+				const id = formData.get("id");
+				const folder = formData.get("folder");
+				if (!(file instanceof File)) return errorResponse(/* @__PURE__ */ new Error("Multipart field \"file\" must be a file."), 400);
+				if (typeof type !== "string" || typeof id !== "string") return errorResponse(/* @__PURE__ */ new Error("Multipart fields \"type\" and \"id\" are required."), 400);
+				const bytes = new Uint8Array(await file.arrayBuffer());
+				if (folder !== null && typeof folder !== "string") return errorResponse(/* @__PURE__ */ new Error("Multipart field \"folder\" must be a string."), 400);
+				return Response.json(await operations.ingest({
+					fileName: file.name,
+					bytes,
+					type,
+					id,
+					folder: folder ?? ""
+				}));
+			}
+			if (pathname === "/api/assets/move" && method === "POST") {
+				const body = await request.json();
+				if (!Array.isArray(body.assetIds) || body.assetIds.some((id) => typeof id !== "string") || typeof body.folder !== "string") return errorResponse(/* @__PURE__ */ new Error("\"assetIds\" must be an array of strings and \"folder\" must be a string."), 400);
+				return Response.json(await operations.moveAssets(body.assetIds, body.folder));
+			}
+			if (pathname === "/api/assets/delete" && method === "POST") {
+				const body = await request.json();
+				if (!Array.isArray(body.assetIds) || body.assetIds.some((id) => typeof id !== "string")) return errorResponse(/* @__PURE__ */ new Error("\"assetIds\" must be an array of strings."), 400);
+				return Response.json(await operations.deleteAssets(body.assetIds));
+			}
+			const assetMatch = pathname.match(/^\/api\/assets\/([^/]+)$/);
+			if (assetMatch) {
+				const id = decodeURIComponent(assetMatch[1]);
+				if (method === "PATCH") {
+					const body = await request.json();
+					return Response.json(await operations.patchAsset(id, body));
+				}
+				if (method === "DELETE") return Response.json(await operations.deleteAsset(id));
+			}
+			if (pathname === "/api/manifests" && method === "POST") {
+				const body = await request.json();
+				if (typeof body.name !== "string") return errorResponse(/* @__PURE__ */ new Error("\"name\" must be a string."), 400);
+				return Response.json(await operations.createManifest(body.name));
+			}
+			if (pathname === "/api/folders" && method === "POST") {
+				const body = await request.json();
+				if (typeof body.path !== "string") return errorResponse(/* @__PURE__ */ new Error("\"path\" must be a string."), 400);
+				return Response.json(await operations.createFolder(body.path));
+			}
+			const folderMatch = pathname.match(/^\/api\/folders\/([^/]+)$/);
+			if (folderMatch) {
+				const folder = decodeURIComponent(folderMatch[1]);
+				if (method === "PATCH") {
+					const body = await request.json();
+					if (body.name === void 0 === (body.parent === void 0)) return errorResponse(/* @__PURE__ */ new Error("Provide exactly one of \"name\" or \"parent\"."), 400);
+					if (body.name !== void 0) {
+						if (typeof body.name !== "string") return errorResponse(/* @__PURE__ */ new Error("\"name\" must be a string."), 400);
+						return Response.json(await operations.renameFolder(folder, body.name));
+					}
+					if (typeof body.parent !== "string") return errorResponse(/* @__PURE__ */ new Error("\"parent\" must be a string."), 400);
+					return Response.json(await operations.moveFolder(folder, body.parent));
+				}
+				if (method === "DELETE") return Response.json(await operations.deleteFolder(folder));
+			}
+			const manifestMatch = pathname.match(/^\/api\/manifests\/([^/]+)$/);
+			if (manifestMatch) {
+				const name = decodeURIComponent(manifestMatch[1]);
+				if (method === "PATCH") {
+					const body = await request.json();
+					return Response.json(await operations.patchManifest(name, body));
+				}
+				if (method === "DELETE") return Response.json(await operations.deleteManifest(name));
+			}
+			const rawMatch = pathname.match(/^\/files\/raw\/(.+)$/);
+			if (rawMatch && method === "GET") return serveSingleFile(options.config.rawDir, decodeURIComponent(rawMatch[1]), request);
+			const proxyMatch = pathname.match(/^\/files\/proxy\/(.+)$/);
+			if (proxyMatch && method === "GET") return serveSingleFile(options.config.proxyDir, decodeURIComponent(proxyMatch[1]), request);
+			if (pathname.startsWith("/api/") || pathname.startsWith("/files/")) return errorResponse(/* @__PURE__ */ new Error(`No route for ${method} ${pathname}.`), 404);
+			return serveEditor(pathname);
+		} catch (cause) {
+			return errorResponse(cause, 400);
+		}
+	}
+	const server = createServer(async (incoming, outgoing) => {
+		try {
+			await writeWebResponse(outgoing, await handle(await nodeRequestToWebRequest(incoming, options.port)));
+		} catch (cause) {
+			await writeWebResponse(outgoing, errorResponse(cause, 500));
+		}
+	});
+	server.listen(options.port);
+	const address = server.address();
+	return {
+		port: typeof address === "object" && address ? address.port : options.port,
+		stop: () => {
+			server.close();
+			server.closeAllConnections();
+		}
+	};
+}
+async function nodeRequestToWebRequest(request, fallbackPort) {
+	const host = request.headers.host ?? `localhost:${fallbackPort}`;
+	const method = request.method ?? "GET";
+	const body = method === "GET" || method === "HEAD" ? void 0 : request;
+	return new Request(`http://${host}${request.url ?? "/"}`, {
+		method,
+		headers: request.headers,
+		body,
+		duplex: body ? "half" : void 0
+	});
+}
+async function writeWebResponse(response, webResponse) {
+	response.statusCode = webResponse.status;
+	webResponse.headers.forEach((value, name) => response.setHeader(name, value));
+	if (!webResponse.body) {
+		response.end();
+		return;
+	}
+	response.end(Buffer.from(await webResponse.arrayBuffer()));
+}
+//#endregion
+//#region src/start.ts
+/**
+* `fundus start` serves the prebuilt editor and API for a host project.
+*/
+async function runStart(projectRoot) {
+	const apiPort = Number(process.env.FUNDUS_API_PORT) || 5176;
+	const config = await loadConfig(projectRoot);
+	const editorBuildDirectory = join(import.meta.dirname, "editor");
+	if (!existsSync(join(editorBuildDirectory, "200.html"))) throw new Error(`The prebuilt Fundus editor is missing from ${editorBuildDirectory}. Reinstall the fundus package or report a packaging error.`);
+	const server = startServer({
+		config,
+		port: apiPort,
+		editorBuildDirectory
+	});
+	console.log(`fundus editor: http://localhost:${server.port}  (project: ${projectRoot})`);
+	const stop = () => {
+		server.stop();
+		process.exit(0);
+	};
+	process.on("SIGINT", stop);
+	process.on("SIGTERM", stop);
+}
+//#endregion
+export { runStart as t };

package/dist/start-D2IXOrni.js

@@ -0,0 +1,2 @@
+import { t as runStart } from "./start-Bhnqt9Dc.js";
+export { runStart };