@samva/vite 0.1.0

package/dist/index.js

@@ -0,0 +1,760 @@
+import { a as discoverTemplateFiles, r as resolveThemePath, t as ThemeState } from "./theme-CfJe8s3k.js";
+import { compileSourcePreview, emitModulePreview } from "./emit.js";
+import { existsSync } from "node:fs";
+import { readFile, realpath, rename, writeFile } from "node:fs/promises";
+import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Predicate, Result } from "effect";
+import { createServerModuleRunner, loadEnv } from "vite";
+import { createHash, randomUUID } from "node:crypto";
+import { variableReferences } from "@samva/markup/interpolate";
+import { applyOps } from "@samva/markup/ops";
+//#region src/editor-store.ts
+const noop = () => {};
+const hashSource = (source) => createHash("sha256").update(source, "utf8").digest("hex").slice(0, 16);
+const deriveName = (id) => {
+	return id.slice(id.lastIndexOf("/") + 1).replace(/\.(?:samva|tsx)$/, "");
+};
+const kindForId = (id) => {
+	if (id.endsWith(".samva")) return "samva";
+	if (id.endsWith(".tsx")) return "tsx";
+};
+const within = (child, parent) => child === parent || child.startsWith(parent + sep);
+const flattenCompiledDiagnostics = (template) => {
+	if (template.compiled.channel === "email") return [...template.diagnostics, ...template.compiled.bases.flatMap((base) => base.diagnostics ?? [])];
+	return [...template.diagnostics, ...template.compiled.diagnostics ?? []];
+};
+const diagnostic = (file, severity, code, message, span) => ({
+	file,
+	severity,
+	code,
+	message,
+	span
+});
+/**
+* Enforces the TSX file contract after Vite evaluates the module. Named exports
+* are deliberately never inspected or invoked; only `default` can be a template.
+*/
+const evaluateDefaultExport = (id, name, moduleExports, compile) => {
+	const preview = emitModulePreview(name, moduleExports, compile);
+	const template = preview.templates[0];
+	if (template === void 0) return {
+		ok: false,
+		diagnostics: preview.diagnostics.map((problem) => diagnostic(id, problem.code === "missing-default-export" ? "warning" : "error", problem.code, problem.message, problem.span))
+	};
+	if (!template.ok || template.source === void 0) {
+		const problems = flattenCompiledDiagnostics(template);
+		return {
+			ok: false,
+			diagnostics: problems.length > 0 ? problems.map((problem) => diagnostic(id, "error", problem.code, problem.message, problem.span)) : [diagnostic(id, "error", "invalid-default-export", "The default-exported template could not emit valid SML.")]
+		};
+	}
+	return {
+		ok: true,
+		source: template.source,
+		channel: template.channel,
+		variables: template.variables
+	};
+};
+var EditorFileStore = class {
+	dir;
+	evaluateTsx;
+	compile;
+	realDir;
+	loaded = false;
+	initialLoad;
+	entries = /* @__PURE__ */ new Map();
+	diagnostics = /* @__PURE__ */ new Map();
+	currentRev = /* @__PURE__ */ new Map();
+	writing = /* @__PURE__ */ new Set();
+	saveChain = /* @__PURE__ */ new Map();
+	session = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Set();
+	catalogListeners = /* @__PURE__ */ new Set();
+	constructor(templatesDir, options = {}) {
+		this.dir = templatesDir;
+		this.evaluateTsx = options.evaluateTsx;
+		this.compile = options.compile ?? (() => void 0);
+	}
+	async resolvePath(id) {
+		if (kindForId(id) === void 0 || id.includes("\0")) return void 0;
+		const full = resolve(this.dir, id);
+		if (!within(full, this.dir)) return void 0;
+		const realDir = await this.resolveRealDir();
+		if (realDir === void 0) return void 0;
+		const real = await realpath(full).catch(() => void 0);
+		if (real === void 0 || !within(real, realDir)) return void 0;
+		return real;
+	}
+	async resolveRealDir() {
+		if (this.realDir === void 0) this.realDir = await realpath(this.dir).catch(() => void 0);
+		return this.realDir;
+	}
+	idFor(path) {
+		const full = isAbsolute(path) ? path : join(this.dir, path);
+		if (!within(full, this.dir)) return void 0;
+		const rel = full.slice(this.dir.length + 1).split("\\").join("/");
+		return kindForId(rel) === void 0 ? void 0 : rel;
+	}
+	async load(file) {
+		const path = await this.resolvePath(file.id);
+		if (path === void 0) return { diagnostics: [diagnostic(file.id, "error", "template-unavailable", "Template file is missing or resolves outside the configured templates directory.")] };
+		const authoredSource = await readFile(path, "utf8").catch(() => void 0);
+		if (authoredSource === void 0) return { diagnostics: [diagnostic(file.id, "error", "template-read-error", "Template file could not be read.")] };
+		const name = this.session.get(file.id)?.name ?? deriveName(file.id);
+		if (file.kind === "samva") {
+			const preview = compileSourcePreview(name, authoredSource, this.compile());
+			if (!preview.ok) {
+				const problems = flattenCompiledDiagnostics(preview);
+				const previous = this.entries.get(file.id);
+				const diagnostics = problems.map((problem) => diagnostic(file.id, "error", problem.code, problem.message, problem.span));
+				if (previous?.template.sourceKind !== "samva") return { diagnostics };
+				const rev = hashSource(authoredSource);
+				return {
+					entry: {
+						...previous,
+						template: {
+							...previous.template,
+							name
+						},
+						source: authoredSource,
+						rev,
+						variables: [...variableReferences(authoredSource)].sort().map((variableName) => ({
+							name: variableName,
+							required: false
+						}))
+					},
+					diagnostics
+				};
+			}
+			const rev = hashSource(authoredSource);
+			return {
+				entry: {
+					template: {
+						id: file.id,
+						name,
+						channel: preview.channel,
+						sourceKind: "samva",
+						access: "editable"
+					},
+					source: authoredSource,
+					rev,
+					variables: [...variableReferences(authoredSource)].sort().map((variableName) => ({
+						name: variableName,
+						required: false
+					}))
+				},
+				diagnostics: []
+			};
+		}
+		if (this.evaluateTsx === void 0) return { diagnostics: [diagnostic(file.id, "error", "tsx-evaluator-unavailable", "TSX templates require the Vite evaluator.")] };
+		const evaluated = await this.evaluateTsx(path, file.id, name, this.compile()).catch((cause) => ({
+			ok: false,
+			diagnostics: [diagnostic(file.id, "error", "module-load-error", cause instanceof Error ? cause.message : String(cause))]
+		}));
+		if (!evaluated.ok) return { diagnostics: evaluated.diagnostics };
+		const rev = hashSource(evaluated.source);
+		return {
+			entry: {
+				template: {
+					id: file.id,
+					name,
+					channel: evaluated.channel,
+					sourceKind: "tsx",
+					access: "readonly"
+				},
+				source: evaluated.source,
+				authoredSource,
+				rev,
+				variables: evaluated.variables.map((variable) => ({
+					name: variable.name,
+					required: variable.required
+				}))
+			},
+			diagnostics: []
+		};
+	}
+	catalogSnapshot() {
+		return {
+			templates: [...this.entries.values()].map((entry) => entry.template).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0),
+			diagnostics: [...this.diagnostics.values()].flat()
+		};
+	}
+	ensureLoaded() {
+		if (this.loaded) return Promise.resolve(this.catalogSnapshot());
+		if (this.initialLoad !== void 0) return this.initialLoad;
+		const loading = this.rebuild(false);
+		this.initialLoad = loading;
+		loading.then(() => {
+			if (this.initialLoad === loading) this.initialLoad = void 0;
+		}, () => {
+			if (this.initialLoad === loading) this.initialLoad = void 0;
+		});
+		return loading;
+	}
+	async rebuild(emitDocuments) {
+		const previous = new Map(this.entries);
+		const files = await discoverTemplateFiles(this.dir);
+		const loaded = await Promise.all(files.map(async (file) => [file.id, await this.load(file)]));
+		this.entries.clear();
+		this.diagnostics.clear();
+		for (const [id, result] of loaded) {
+			if (result.entry !== void 0) {
+				this.entries.set(id, result.entry);
+				this.currentRev.set(id, result.entry.rev);
+			} else this.currentRev.delete(id);
+			if (result.diagnostics.length > 0) this.diagnostics.set(id, result.diagnostics);
+		}
+		this.loaded = true;
+		if (emitDocuments) for (const [id, entry] of this.entries) {
+			const before = previous.get(id);
+			if (before === void 0 || before.source !== entry.source || before.authoredSource !== entry.authoredSource) this.publish({
+				id,
+				rev: entry.rev,
+				source: entry.source,
+				authoredSource: entry.authoredSource
+			});
+		}
+		for (const listener of this.catalogListeners) listener();
+		return this.catalogSnapshot();
+	}
+	async catalog() {
+		return this.ensureLoaded();
+	}
+	/** Re-evaluate discovery and every TSX entry after template/dependency/theme HMR. */
+	async refreshAll(options = {}) {
+		const loading = this.initialLoad;
+		if (loading !== void 0) await loading;
+		else if (!this.loaded) return this.ensureLoaded();
+		return this.rebuild(options.documents ?? true);
+	}
+	/** Recompile one changed editable file without re-evaluating unrelated TSX modules. */
+	async refreshSamva(id) {
+		if (kindForId(id) !== "samva") return this.catalog();
+		if (!this.loaded) return this.ensureLoaded();
+		const result = await this.load({
+			id,
+			path: join(this.dir, id),
+			kind: "samva"
+		});
+		if (result.entry !== void 0) {
+			this.entries.set(id, result.entry);
+			this.currentRev.set(id, result.entry.rev);
+		} else {
+			this.entries.delete(id);
+			this.currentRev.delete(id);
+		}
+		if (result.diagnostics.length > 0) this.diagnostics.set(id, result.diagnostics);
+		else this.diagnostics.delete(id);
+		for (const listener of this.catalogListeners) listener();
+		return this.catalogSnapshot();
+	}
+	async list() {
+		return (await this.catalog()).templates;
+	}
+	async open(id) {
+		if (!this.loaded) await this.ensureLoaded();
+		const entry = this.entries.get(id);
+		if (entry === void 0) return void 0;
+		const meta = this.session.get(id);
+		const fields = {
+			id: null,
+			name: meta?.name ?? entry.template.name,
+			channel: entry.template.channel,
+			source: entry.source,
+			rev: entry.rev,
+			variables: entry.variables,
+			metadata: meta?.metadata ?? {}
+		};
+		if (entry.template.sourceKind === "tsx") return {
+			...fields,
+			origin: {
+				kind: "tsx",
+				file: id,
+				authoredSource: entry.authoredSource ?? ""
+			},
+			access: {
+				kind: "readonly",
+				reason: "TSX templates are code-authored. Edit the default export in your code editor."
+			}
+		};
+		return {
+			...fields,
+			origin: {
+				kind: "samva",
+				file: id
+			},
+			access: { kind: "editable" }
+		};
+	}
+	async save(id, update, client) {
+		if (kindForId(id) === "tsx") return {
+			ok: false,
+			error: "TSX templates are read-only; edit the default export in source."
+		};
+		const path = await this.resolvePath(id);
+		if (path === void 0 || kindForId(id) !== "samva") return {
+			ok: false,
+			error: "template not found"
+		};
+		if (update.kind === "metadata") {
+			const prev = this.session.get(id) ?? { metadata: {} };
+			const next = {
+				name: update.patch.name ?? prev.name,
+				metadata: {
+					fromDefault: update.patch.fromDefault === void 0 ? prev.metadata.fromDefault : update.patch.fromDefault ?? void 0,
+					replyToDefault: update.patch.replyToDefault === void 0 ? prev.metadata.replyToDefault : update.patch.replyToDefault ?? void 0
+				}
+			};
+			this.session.set(id, next);
+			const entry = this.entries.get(id);
+			if (entry !== void 0 && next.name !== void 0) {
+				this.entries.set(id, {
+					...entry,
+					template: {
+						...entry.template,
+						name: next.name
+					}
+				});
+				for (const listener of this.catalogListeners) listener();
+			}
+			const current = await readFile(path, "utf8").catch(() => void 0);
+			return {
+				ok: true,
+				rev: current === void 0 ? this.currentRev.get(id) ?? "" : hashSource(current)
+			};
+		}
+		return this.withLock(id, () => this.commit(id, path, update, client));
+	}
+	async commit(id, path, update, client) {
+		const current = await readFile(path, "utf8").catch(() => void 0);
+		if (current === void 0) return {
+			ok: false,
+			error: "template not found"
+		};
+		const actualRev = hashSource(current);
+		if (update.baseRev !== actualRev) return {
+			ok: false,
+			conflict: {
+				expectedRev: update.baseRev,
+				actualRev
+			}
+		};
+		let nextSource;
+		if (update.kind === "ops") {
+			const applied = applyOps(current, [...update.ops]);
+			if (Result.isFailure(applied)) return {
+				ok: false,
+				error: applied.failure.message
+			};
+			nextSource = applied.success.source;
+		} else nextSource = update.source;
+		const rev = hashSource(nextSource);
+		this.writing.add(id);
+		try {
+			const temp = join(dirname(path), `.${randomUUID()}.samva.tmp`);
+			await writeFile(temp, nextSource, "utf8");
+			await rename(temp, path);
+			await this.refreshSamva(id);
+		} finally {
+			this.writing.delete(id);
+		}
+		this.publish({
+			id,
+			rev,
+			source: nextSource,
+			sourceClient: client
+		});
+		return {
+			ok: true,
+			rev
+		};
+	}
+	withLock(id, run) {
+		const next = (this.saveChain.get(id) ?? Promise.resolve()).then(run, run);
+		this.saveChain.set(id, next.then(noop, noop));
+		return next;
+	}
+	async handleFileChange(path) {
+		const id = this.idFor(path);
+		if (id === void 0 || kindForId(id) !== "samva") return void 0;
+		if (this.writing.has(id)) return void 0;
+		const real = await this.resolvePath(id);
+		if (real === void 0) return void 0;
+		const source = await readFile(real, "utf8").catch(() => void 0);
+		if (source === void 0) return void 0;
+		const rev = hashSource(source);
+		if (rev === this.currentRev.get(id)) return void 0;
+		this.currentRev.set(id, rev);
+		const previous = this.entries.get(id);
+		if (previous !== void 0) this.entries.set(id, {
+			...previous,
+			source,
+			rev,
+			variables: [...variableReferences(source)].sort().map((name) => ({
+				name,
+				required: false
+			}))
+		});
+		const change = {
+			id,
+			rev,
+			source,
+			sourceClient: void 0
+		};
+		this.publish(change);
+		return change;
+	}
+	publish(change) {
+		for (const listener of this.listeners) listener(change);
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	subscribeCatalog(listener) {
+		this.catalogListeners.add(listener);
+		return () => this.catalogListeners.delete(listener);
+	}
+};
+//#endregion
+//#region src/editor.ts
+const DEFAULT_ROUTE = "/";
+const MODULE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".cjs",
+	".css",
+	".cts",
+	".js",
+	".json",
+	".jsx",
+	".mjs",
+	".mts",
+	".ts",
+	".tsx"
+]);
+const packagedEditorDir = fileURLToPath(new URL("./editor/", import.meta.url));
+const EDITOR_DIR = existsSync(packagedEditorDir) ? packagedEditorDir : fileURLToPath(new URL("../dist/editor/", import.meta.url));
+const MIME = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".svg": "image/svg+xml",
+	".json": "application/json",
+	".map": "application/json",
+	".ico": "image/x-icon",
+	".png": "image/png",
+	".woff2": "font/woff2"
+};
+/** Normalize + validate the mount route: absolute, root allowed, no trailing slash. */
+const normalizeRoute = (raw) => {
+	const route = raw === "/" ? "/" : raw.replace(/\/+$/, "");
+	if (!route.startsWith("/") || route === "" || route.includes("//") || route.includes("?") || route.includes("#")) throw new Error(`samvaEditor: \`route\` must be an absolute URL path (received ${JSON.stringify(raw)})`);
+	return route;
+};
+const sendJson = (res, status, body) => {
+	res.statusCode = status;
+	res.setHeader("content-type", "application/json");
+	res.end(JSON.stringify(body));
+};
+/** Serve a file under the built editor dir; returns false (untouched res) if absent/outside. */
+const serveStatic = async (res, filePath) => {
+	const resolved = resolve(filePath);
+	const root = EDITOR_DIR.replace(/\/$/, "");
+	if (resolved !== root && !resolved.startsWith(`${root}/`)) return false;
+	const body = await readFile(resolved).catch(() => void 0);
+	if (body === void 0) return false;
+	res.statusCode = 200;
+	res.setHeader("content-type", MIME[extname(resolved)] ?? "application/octet-stream");
+	res.end(body);
+	return true;
+};
+const VITE_INTERNAL_PREFIXES = [
+	"/@vite/",
+	"/@id/",
+	"/@fs/",
+	"/@react-refresh",
+	"/__vite",
+	"/node_modules/.vite/"
+];
+const isViteInternalPath = (pathname) => VITE_INTERNAL_PREFIXES.some((prefix) => pathname === prefix.replace(/\/$/, "") || pathname.startsWith(prefix));
+const hasFileExtension = (pathname) => extname(pathname) !== "";
+const underRoute = (route, pathname) => route === "/" || pathname === route || pathname.startsWith(`${route}/`);
+const childRoute = (route, child) => route === "/" ? `/${child}` : `${route}/${child}`;
+const readBody = (req) => new Promise((done, fail) => {
+	let data = "";
+	req.on("data", (chunk) => {
+		data += chunk;
+	});
+	req.on("end", () => done(data));
+	req.on("error", fail);
+});
+const createSseClient = (res, docId, clientId) => {
+	let pending;
+	let draining = false;
+	const flush = () => {
+		if (pending === void 0) {
+			draining = false;
+			return;
+		}
+		const frame = pending;
+		pending = void 0;
+		if (res.write(frame)) flush();
+		else draining = true;
+	};
+	res.on("drain", flush);
+	return {
+		res,
+		docId,
+		clientId,
+		push(payload) {
+			const frame = `event: samva:change\ndata: ${JSON.stringify(payload)}\n\n`;
+			if (draining) {
+				pending = frame;
+				return;
+			}
+			if (!res.write(frame)) draining = true;
+		}
+	};
+};
+const samvaEditor = (options = {}) => {
+	const route = normalizeRoute(options.route ?? DEFAULT_ROUTE);
+	const apiPrefix = childRoute(route, "api");
+	let root = process.cwd();
+	let templatesDir = resolve(root, options.templatesDir ?? "emails");
+	let theme = new ThemeState(resolveThemePath(root, options.theme));
+	let store = new EditorFileStore(templatesDir, { compile: () => theme.applyTo(options.compile) });
+	let authenticated = false;
+	const clients = /* @__PURE__ */ new Set();
+	const catalogClients = /* @__PURE__ */ new Set();
+	let refreshTail = Promise.resolve();
+	const queueStoreRefresh = (server, run) => {
+		refreshTail = refreshTail.then(run, run).catch((cause) => {
+			server.config.logger.error(`samvaEditor refresh failed: ${cause instanceof Error ? cause.message : String(cause)}`);
+		});
+		return refreshTail;
+	};
+	const queueRefresh = (server, documents) => queueStoreRefresh(server, () => store.refreshAll({ documents }));
+	return {
+		name: "samva-editor",
+		config() {
+			return {
+				oxc: { jsx: {
+					runtime: "automatic",
+					importSource: "@samva/markup"
+				} },
+				optimizeDeps: { exclude: ["@samva/markup"] }
+			};
+		},
+		configResolved(resolved) {
+			root = resolved.root;
+			templatesDir = isAbsolute(options.templatesDir ?? "") ? options.templatesDir : resolve(root, options.templatesDir ?? "emails");
+			theme = new ThemeState(resolveThemePath(root, options.theme));
+			store = new EditorFileStore(templatesDir, { compile: () => theme.applyTo(options.compile) });
+			const env = loadEnv(resolved.mode, root, "");
+			authenticated = Boolean(env.SAMVA_API_KEY);
+		},
+		async configureServer(server) {
+			await theme.refresh();
+			const evaluator = createServerModuleRunner(server.environments.ssr, { hmr: false });
+			store = new EditorFileStore(templatesDir, {
+				compile: () => theme.applyTo(options.compile),
+				evaluateTsx: async (path, id, name, compile) => {
+					const moduleExports = await evaluator.import(path);
+					return evaluateDefaultExport(id, name, moduleExports, compile);
+				}
+			});
+			server.watcher.add(templatesDir);
+			if (theme.themePath !== void 0) server.watcher.add(theme.themePath);
+			const refreshTheme = () => {
+				theme.refresh().then(() => queueRefresh(server, false));
+			};
+			const refreshTsxDependents = (path, shapeChange) => {
+				const ssr = server.environments.ssr;
+				if (ssr === void 0) return;
+				const changedModules = ssr.moduleGraph.getModulesByFile(path) ?? /* @__PURE__ */ new Set();
+				const directTemplate = path.endsWith(".tsx") && store.idFor(path) !== void 0;
+				const potentialModuleShapeChange = shapeChange && changedModules.size === 0 && MODULE_EXTENSIONS.has(extname(path));
+				if (!directTemplate && changedModules.size === 0 && !potentialModuleShapeChange) return;
+				queueStoreRefresh(server, async () => {
+					const invalidated = /* @__PURE__ */ new Set();
+					const collectImporters = (module) => {
+						if (invalidated.has(module)) return;
+						invalidated.add(module);
+						for (const importer of module.importers) collectImporters(importer);
+					};
+					for (const module of changedModules) collectImporters(module);
+					if (shapeChange) ssr.moduleGraph.invalidateAll();
+					else for (const module of invalidated) ssr.moduleGraph.invalidateModule(module);
+					evaluator.evaluatedModules.clear();
+					return store.refreshAll({ documents: true });
+				});
+			};
+			const onChange = (path) => {
+				if (theme.themePath !== void 0 && path === theme.themePath) {
+					refreshTheme();
+					return;
+				}
+				if (path.endsWith(".samva")) {
+					store.handleFileChange(path).then((change) => {
+						if (change !== void 0) queueStoreRefresh(server, () => store.refreshSamva(change.id));
+					});
+					return;
+				}
+				refreshTsxDependents(path, false);
+			};
+			const onCatalogShape = (path) => {
+				if (theme.themePath !== void 0 && path === theme.themePath) {
+					refreshTheme();
+					return;
+				}
+				if (store.idFor(path)?.endsWith(".samva")) {
+					queueRefresh(server, true);
+					return;
+				}
+				refreshTsxDependents(path, true);
+			};
+			server.watcher.on("change", onChange);
+			server.watcher.on("add", onCatalogShape);
+			server.watcher.on("unlink", onCatalogShape);
+			const unsubscribe = store.subscribe((change) => {
+				server.ws.send({
+					type: "custom",
+					event: "samva:document",
+					data: change
+				});
+				for (const client of clients) {
+					if (client.docId !== change.id) continue;
+					const origin = change.sourceClient !== void 0 && change.sourceClient === client.clientId ? "self" : "external";
+					client.push({
+						id: change.id,
+						rev: change.rev,
+						source: change.source,
+						authoredSource: change.authoredSource,
+						origin
+					});
+				}
+			});
+			const unsubscribeCatalog = store.subscribeCatalog(() => {
+				for (const res of catalogClients) res.write("event: samva:catalog\ndata: refresh\n\n");
+				server.ws.send({
+					type: "custom",
+					event: "samva:catalog"
+				});
+			});
+			let cleaned = false;
+			const cleanup = () => {
+				if (cleaned) return;
+				cleaned = true;
+				server.watcher.off("change", onChange);
+				server.watcher.off("add", onCatalogShape);
+				server.watcher.off("unlink", onCatalogShape);
+				server.watcher.off("close", cleanup);
+				server.httpServer?.off("close", cleanup);
+				unsubscribe();
+				unsubscribeCatalog();
+				evaluator.close();
+				for (const client of clients) client.res.end();
+				clients.clear();
+				for (const res of catalogClients) res.end();
+				catalogClients.clear();
+			};
+			server.httpServer?.once("close", cleanup);
+			server.watcher.once("close", cleanup);
+			const handler = (req, res, next) => {
+				const url = req.url ?? "";
+				const pathname = url.split("?")[0] || "/";
+				const query = new URLSearchParams(url.split("?")[1] ?? "");
+				const apiRequest = pathname === apiPrefix || pathname.startsWith(`${apiPrefix}/`);
+				if (!apiRequest && !underRoute(route, pathname)) return next();
+				if (!apiRequest && route === "/" && isViteInternalPath(pathname)) return next();
+				(async () => {
+					if (pathname === `${apiPrefix}/capabilities`) return sendJson(res, 200, { authenticated });
+					if (pathname === `${apiPrefix}/templates`) {
+						const catalog = await store.catalog();
+						const themeFile = theme.themePath === void 0 ? void 0 : relative(root, theme.themePath);
+						const themeDiagnostics = theme.current().diagnostics.map((item) => ({
+							file: themeFile ?? "theme.css",
+							severity: "error",
+							code: item.code,
+							message: item.message,
+							span: item.span
+						}));
+						return sendJson(res, 200, {
+							templates: catalog.templates,
+							diagnostics: [...catalog.diagnostics, ...themeDiagnostics],
+							theme: {
+								file: themeFile,
+								tokens: theme.current().tokens
+							},
+							compile: theme.applyTo(options.compile)
+						});
+					}
+					if (pathname === `${apiPrefix}/document`) {
+						const id = query.get("id");
+						if (!id) return sendJson(res, 400, { error: "missing id" });
+						if (req.method === "POST") {
+							const raw = await readBody(req);
+							let update;
+							try {
+								update = JSON.parse(raw);
+							} catch {
+								return sendJson(res, 400, { error: "malformed JSON body" });
+							}
+							if (!Predicate.isObject(update)) return sendJson(res, 400, { error: "malformed JSON body" });
+							const outcome = await store.save(id, update, query.get("client") ?? void 0);
+							if (outcome.ok) return sendJson(res, 200, { rev: outcome.rev });
+							if ("conflict" in outcome) return sendJson(res, 409, outcome.conflict);
+							return sendJson(res, 422, { error: outcome.error });
+						}
+						const snapshot = await store.open(id);
+						if (snapshot === void 0) return sendJson(res, 404, { error: "template not found" });
+						return sendJson(res, 200, snapshot);
+					}
+					if (pathname === `${apiPrefix}/events`) {
+						const id = query.get("id");
+						if (!id) return sendJson(res, 400, { error: "missing id" });
+						res.statusCode = 200;
+						res.setHeader("content-type", "text/event-stream");
+						res.setHeader("cache-control", "no-cache");
+						res.setHeader("connection", "keep-alive");
+						res.write(": connected\n\n");
+						const client = createSseClient(res, id, query.get("client") ?? void 0);
+						clients.add(client);
+						req.on("close", () => clients.delete(client));
+						return;
+					}
+					if (pathname === `${apiPrefix}/catalog-events`) {
+						res.statusCode = 200;
+						res.setHeader("content-type", "text/event-stream");
+						res.setHeader("cache-control", "no-cache");
+						res.setHeader("connection", "keep-alive");
+						res.write(": connected\n\n");
+						catalogClients.add(res);
+						req.on("close", () => catalogClients.delete(res));
+						return;
+					}
+					if (apiRequest) return sendJson(res, 404, { error: "not found" });
+					if (route !== "/" && pathname === route) {
+						res.statusCode = 302;
+						res.setHeader("location", `${route}/`);
+						res.end();
+						return;
+					}
+					const rel = route === "/" ? pathname.replace(/^\//, "") : pathname.slice(route.length).replace(/^\//, "");
+					if (await serveStatic(res, join(EDITOR_DIR, rel === "" ? "index.html" : rel))) return;
+					const assetPrefix = childRoute(route, "assets");
+					if (hasFileExtension(pathname) || pathname === assetPrefix || pathname.startsWith(`${assetPrefix}/`)) return next();
+					if (await serveStatic(res, join(EDITOR_DIR, "index.html"))) return;
+					return next();
+				})().catch((error) => {
+					sendJson(res, 500, { error: error instanceof Error ? error.message : String(error) });
+				});
+			};
+			server.middlewares.use(handler);
+		}
+	};
+};
+//#endregion
+export { samvaEditor };
+
+//# sourceMappingURL=index.js.map