@samva/vite 0.7.0 → 0.9.0

package/dist/editor-Cow7zZ_9.js

@@ -0,0 +1,780 @@
+import { E as projectPath, O as templateDirectories, T as isWithin, c as restoreBase, d as emailCompatibility, h as renderEmailFixtures, i as loadProject, k as isObject, m as renderChannelFixture, o as compileBase, v as createBrandResolver, w as isProjectFile } from "./project-Cp8qb3s0.js";
+import { existsSync } from "node:fs";
+import { open, readFile, realpath, rename, rm, stat } from "node:fs/promises";
+import { isIP } from "node:net";
+import { extname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadEnv } from "vite";
+import { createHash, randomUUID } from "node:crypto";
+import { renderIrPreview } from "@samva/markup/preview";
+/** The refusal both the store and the dev-server route return for an oversized entry. */
+const EDITOR_SOURCE_TOO_LARGE_MESSAGE = `Authored source exceeds the 1 MiB limit.`;
+const hashSource = (source) => createHash("sha256").update(source, "utf8").digest("hex").slice(0, 16);
+const deriveName = (path) => path.slice(path.lastIndexOf("/") + 1).replace(/\.tsx$/, "");
+/** The document id for one channel of an entry. Email is the entry's own path. */
+const documentId = (entryPath, channel) => channel === "email" ? entryPath : `${entryPath}#${channel}`;
+const catalogFinding = (file, item) => ({
+	file,
+	severity: item.severity,
+	code: item.code,
+	message: item.message
+});
+/** A template's input contract is a JSON Schema, so its variables are that schema's top-level properties. */
+const variablesOf = (schema) => {
+	const properties = schema["properties"];
+	if (!isObject(properties)) return [];
+	const required = schema["required"];
+	const names = Array.isArray(required) ? required : [];
+	return Object.entries(properties).map(([name, property]) => {
+		const examples = isObject(property) ? property["examples"] : void 0;
+		const example = Array.isArray(examples) ? examples[0] : void 0;
+		return {
+			name,
+			required: names.includes(name),
+			...typeof example === "string" ? { sample: example } : {}
+		};
+	});
+};
+const chooseFixture = (fixtures, wanted) => wanted !== void 0 && fixtures.includes(wanted) ? wanted : fixtures[0] ?? null;
+/** One preview render of the viewed fixture, or null when the renderer refuses it. */
+const previewRender = (entry, fixture, revision, assetBase) => {
+	try {
+		const preview = renderIrPreview(entry.ir, entry.fixtures[fixture]);
+		return {
+			revision,
+			subject: preview.subject,
+			...preview.preheader === void 0 ? {} : { preheader: preview.preheader },
+			html: restoreBase(preview.html, assetBase),
+			text: preview.text,
+			selections: preview.selections
+		};
+	} catch {
+		return null;
+	}
+};
+/** Everything one channel of one entry shows, computed once per compile. */
+const buildChannel = (entry, channel, assetBase) => {
+	const fixtures = Object.keys(entry.fixtures);
+	if (channel === "email") {
+		const delivered = renderEmailFixtures(entry);
+		const diagnostics = [...entry.diagnostics, ...delivered.flatMap((result) => result.diagnostics)];
+		const incompatibilities = emailCompatibility(entry, delivered);
+		return {
+			identity: JSON.stringify({
+				diagnostics,
+				incompatibilities,
+				fixtures: delivered.map((result) => ({
+					fixture: result.fixture,
+					subject: result.rendered?.subject ?? null,
+					preheader: result.rendered?.preheader ?? null,
+					html: result.rendered?.html ?? null,
+					text: result.rendered?.text ?? null
+				}))
+			}),
+			content: (revision, wanted) => {
+				const fixture = chooseFixture(fixtures, wanted);
+				return {
+					channel: "email",
+					preview: { status: "current" },
+					fixtures,
+					fixture,
+					render: fixture === null ? null : previewRender(entry, fixture, revision, assetBase),
+					diagnostics,
+					incompatibilities
+				};
+			}
+		};
+	}
+	const rendered = fixtures.map((fixture) => ({
+		fixture,
+		result: renderChannelFixture(entry, channel, fixture)
+	}));
+	const diagnostics = [...entry.diagnostics, ...rendered.flatMap(({ result }) => result.ok ? [] : result.diagnostics)];
+	return {
+		identity: JSON.stringify({
+			diagnostics,
+			rendered
+		}),
+		content: (revision, wanted) => {
+			const fixture = chooseFixture(fixtures, wanted);
+			const result = rendered.find((item) => item.fixture === fixture)?.result;
+			return {
+				channel,
+				preview: { status: "current" },
+				fixtures,
+				fixture,
+				render: result?.ok !== true ? null : result.channel === "sms" ? {
+					revision,
+					text: result.text
+				} : {
+					revision,
+					...result.message
+				},
+				diagnostics
+			};
+		}
+	};
+};
+/** Two builds of one document differ when what the editor shows differs. */
+const moved = (before, entry) => {
+	if (before === void 0) return true;
+	if (before.rev !== entry.rev || before.authoredSource !== entry.authoredSource) return true;
+	return before.content.fixture !== entry.content.fixture;
+};
+var EditorFileStore = class {
+	projectOptions;
+	options;
+	root;
+	loaded = false;
+	mutationQueue = Promise.resolve();
+	serialize(operation) {
+		const running = this.mutationQueue.then(operation, operation);
+		this.mutationQueue = running.catch(() => void 0);
+		return running;
+	}
+	initialLoad;
+	project;
+	entries = /* @__PURE__ */ new Map();
+	catalogDiagnostics = [];
+	fixtures = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Set();
+	catalogListeners = /* @__PURE__ */ new Set();
+	constructor(options = {}) {
+		this.options = options;
+		this.projectOptions = {
+			...options,
+			assetBase: compileBase(options.assetBase)
+		};
+		this.root = resolve(options.root ?? process.cwd());
+	}
+	/** The bytes of an imported asset from the latest compile, by its content-addressed file name. */
+	asset(fileName) {
+		const project = this.project;
+		const entry = project?.catalog.assets.find((asset) => asset.fileName === fileName);
+		const bytes = entry === void 0 ? void 0 : project?.files[entry.path];
+		return entry === void 0 || bytes === void 0 || typeof bytes === "string" ? void 0 : {
+			contentType: entry.contentType,
+			bytes
+		};
+	}
+	/** The directories the store scans, for a host that watches them. */
+	directories() {
+		return templateDirectories(this.root, this.projectOptions.dir);
+	}
+	async resolvePath(entryPath) {
+		if (!entryPath.endsWith(".tsx") || entryPath.includes("\0")) return void 0;
+		const full = resolve(this.root, entryPath);
+		const dirs = await this.directories();
+		if (!dirs.some((dir) => isWithin(full, dir))) return void 0;
+		const real = await realpath(full).catch(() => void 0);
+		if (real === void 0) return void 0;
+		return (await Promise.all(dirs.map((dir) => realpath(dir).catch(() => void 0)))).some((dir) => dir !== void 0 && isWithin(real, dir)) ? real : void 0;
+	}
+	/** The entry path of an absolute file path, when a template entry could live there. */
+	entryPathFor(path) {
+		const full = isAbsolute(path) ? path : join(this.root, path);
+		const relative = projectPath(this.root, full);
+		if (!relative.endsWith(".tsx") || relative.startsWith("..")) return void 0;
+		return this.project?.catalog.templates.some((entry) => entry.entryPath === relative) === true || this.project?.catalog.failures.some((entry) => entry.entryPath === relative) === true ? relative : void 0;
+	}
+	build(entry, channel, authoredSource, id, fixture) {
+		const built = buildChannel(entry, channel, this.options.assetBase);
+		const rev = hashSource(authoredSource + built.identity);
+		const content = built.content(rev, fixture);
+		return {
+			template: {
+				id,
+				name: deriveName(entry.entryPath),
+				channel,
+				sourceKind: "tsx"
+			},
+			file: entry.entryPath,
+			content,
+			authoredSource,
+			rev,
+			variables: variablesOf(entry.ir.schema),
+			compiled: entry
+		};
+	}
+	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.catalogDiagnostics]
+		};
+	}
+	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 project = await loadProject(this.projectOptions, this.options.brands);
+		this.project = project;
+		this.options.onProject?.(project);
+		this.entries.clear();
+		this.catalogDiagnostics.length = 0;
+		this.catalogDiagnostics.push(...project.diagnostics.map((item) => catalogFinding("", item)));
+		for (const compiled of project.catalog.templates) {
+			const source = project.files[compiled.entryPath];
+			const authoredSource = typeof source === "string" ? source : "";
+			for (const channel of compiled.channels) {
+				const id = documentId(compiled.entryPath, channel);
+				this.entries.set(id, this.build(compiled, channel, authoredSource, id, this.fixtures.get(id)));
+			}
+		}
+		for (const failed of project.catalog.failures) {
+			const source = project.files[failed.entryPath];
+			const authoredSource = typeof source === "string" ? source : "";
+			this.catalogDiagnostics.push(...failed.diagnostics.map((item) => catalogFinding(failed.entryPath, item)));
+			for (const [id, before] of previous) {
+				if (before.file !== failed.entryPath) continue;
+				this.entries.set(id, {
+					...before,
+					content: {
+						...before.content,
+						fixtures: [],
+						fixture: null,
+						render: null,
+						diagnostics: failed.diagnostics
+					},
+					authoredSource,
+					rev: hashSource(authoredSource + JSON.stringify(failed.diagnostics)),
+					variables: [],
+					compiled: void 0
+				});
+			}
+		}
+		this.loaded = true;
+		if (emitDocuments) {
+			for (const [id, entry] of this.entries) if (moved(previous.get(id), entry)) this.publishEntry(id, entry);
+		}
+		for (const listener of this.catalogListeners) listener();
+		return this.catalogSnapshot();
+	}
+	async catalog() {
+		return this.ensureLoaded();
+	}
+	/**
+	* Recompile the project after a template, partial, theme or asset changed.
+	* `changed` names the file whose change asked for this refresh.
+	*
+	* This store writes template files itself, so an editor save comes back as a
+	* change event indistinguishable from an author's own edit in another program.
+	* Recompiling for it would republish the document with no client attached,
+	* which is exactly how a foreign edit reaches the editor. A changed file that
+	* still holds the bytes the current compile read is already built, so there is
+	* nothing to publish and nothing to rebuild. Every other path is a real change.
+	*/
+	async refreshAll(options = {}) {
+		const loading = this.initialLoad;
+		if (loading !== void 0) await loading;
+		else if (!this.loaded) return this.ensureLoaded();
+		return this.serialize(async () => await this.alreadyBuilt(options.changed) ? this.catalogSnapshot() : this.rebuild(options.documents ?? true));
+	}
+	/** True when `path` still holds the exact bytes the latest compile read from it. */
+	async alreadyBuilt(path) {
+		if (path === void 0 || this.project === void 0) return false;
+		const full = isAbsolute(path) ? path : join(this.root, path);
+		const found = this.project.files[projectPath(this.root, full)];
+		if (found === void 0) return false;
+		const known = typeof found === "string" ? Buffer.from(found, "utf8") : found;
+		const disk = await readFile(full).catch(() => void 0);
+		if (disk === void 0) return false;
+		return Buffer.from(known).equals(disk);
+	}
+	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;
+		return {
+			id: null,
+			name: entry.template.name,
+			rev: entry.rev,
+			variables: entry.variables,
+			metadata: {},
+			...entry.content,
+			origin: {
+				kind: "tsx",
+				file: entry.file,
+				authoredSource: entry.authoredSource
+			},
+			access: { kind: "editable" }
+		};
+	}
+	/**
+	* Serialize editor saves and atomically replace the complete entry after a fresh disk check.
+	* Arbitrary external writers do not participate in this queue: the final check and rename
+	* are not a filesystem compare-and-swap, so authors must resolve overlapping saves externally.
+	*/
+	async saveSource(id, baseRev, authoredSource, client) {
+		if (Buffer.byteLength(authoredSource, "utf8") > 1048576) return {
+			ok: false,
+			kind: "refused",
+			error: EDITOR_SOURCE_TOO_LARGE_MESSAGE
+		};
+		await this.ensureLoaded();
+		return this.serialize(async () => {
+			const entry = this.entries.get(id);
+			const path = entry === void 0 ? void 0 : await this.resolvePath(entry.file);
+			if (entry === void 0 || path === void 0) return {
+				ok: false,
+				kind: "missing",
+				error: "Template not found."
+			};
+			const disk = await readFile(path, "utf8");
+			if (entry.rev !== baseRev || disk !== entry.authoredSource) {
+				await this.rebuild(true);
+				return {
+					ok: false,
+					kind: "conflict",
+					error: "Source changed on disk. Reload before saving.",
+					actualRev: this.entries.get(id)?.rev ?? entry.rev
+				};
+			}
+			const temporary = `${path}.${randomUUID()}.tmp`;
+			const mode = (await stat(path)).mode;
+			const file = await open(temporary, "wx", mode);
+			try {
+				await file.writeFile(authoredSource, "utf8");
+				await file.chmod(mode);
+				await file.sync();
+				await file.close();
+				if (await readFile(path, "utf8") !== disk) {
+					await this.rebuild(true);
+					return {
+						ok: false,
+						kind: "conflict",
+						error: "Source changed on disk. Reload before saving.",
+						actualRev: this.entries.get(id)?.rev ?? entry.rev
+					};
+				}
+				await rename(temporary, path);
+			} finally {
+				await file.close().finally(() => rm(temporary, { force: true }));
+			}
+			const previous = new Map(this.entries);
+			await this.rebuild(false);
+			for (const [changedId, changed] of this.entries) if (moved(previous.get(changedId), changed)) this.publishEntry(changedId, changed, changedId === id ? client : void 0);
+			const saved = this.entries.get(id);
+			return saved === void 0 ? {
+				ok: false,
+				kind: "missing",
+				error: "The saved entry is no longer discoverable."
+			} : {
+				ok: true,
+				rev: saved.rev
+			};
+		});
+	}
+	/**
+	* Show another declared fixture of a document. It re-renders the same
+	* compile, so the revision does not move; the resulting document reaches every
+	* watcher on the change stream, attributed to the client that asked.
+	*
+	* It runs in the mutation queue for the same reason a save does: the viewed
+	* fixture is part of the entry, and a rebuild that straddled the switch would
+	* take its own snapshot from before it and its render from after it, then
+	* publish the difference with no client.
+	*/
+	async viewFixture(id, fixture, client) {
+		if (!this.loaded) await this.ensureLoaded();
+		return this.serialize(async () => {
+			const entry = this.entries.get(id);
+			if (entry === void 0) return {
+				ok: false,
+				kind: "missing",
+				error: "template not found"
+			};
+			if (!entry.content.fixtures.includes(fixture) || entry.compiled === void 0) return {
+				ok: false,
+				kind: "refused",
+				error: `Template declares no fixture named ${JSON.stringify(fixture)}.`
+			};
+			const next = this.build(entry.compiled, entry.template.channel, entry.authoredSource, id, fixture);
+			this.fixtures.set(id, fixture);
+			this.entries.set(id, next);
+			this.publishEntry(id, next, client);
+			return { ok: true };
+		});
+	}
+	publishEntry(id, entry, client) {
+		const change = {
+			id,
+			rev: entry.rev,
+			authoredSource: entry.authoredSource,
+			...client === void 0 ? {} : { sourceClient: client },
+			...entry.content
+		};
+		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 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 isLoopbackHostname = (hostname) => {
+	const normalized = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+	if (normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "::1") return true;
+	if (isIP(normalized) !== 4) return false;
+	return normalized.split(".")[0] === "127";
+};
+const isLoopbackAddress = (address) => {
+	if (address === void 0) return false;
+	const normalized = address.startsWith("::ffff:") ? address.slice(7) : address;
+	return isLoopbackHostname(normalized);
+};
+const isTrustedSourceSave = (req) => {
+	if (!isLoopbackAddress(req.socket.remoteAddress)) return false;
+	const origin = req.headers.origin;
+	if (origin === void 0) return false;
+	try {
+		const parsed = new URL(origin);
+		return (parsed.protocol === "http:" || parsed.protocol === "https:") && parsed.username === "" && parsed.password === "" && isLoopbackHostname(parsed.hostname);
+	} catch {
+		return false;
+	}
+};
+const MAX_BODY_BYTES = 6295552;
+var EditorBodyTooLarge = class extends Error {};
+const readBody = (req) => new Promise((done, fail) => {
+	const chunks = [];
+	let bytes = 0;
+	req.on("data", (chunk) => {
+		bytes += chunk.length;
+		if (bytes > MAX_BODY_BYTES) {
+			chunks.length = 0;
+			fail(new EditorBodyTooLarge("Request body exceeds the editor limit."));
+			return;
+		}
+		chunks.push(chunk);
+	});
+	req.on("end", () => done(Buffer.concat(chunks).toString("utf8")));
+	req.on("error", fail);
+	req.on("aborted", () => fail(/* @__PURE__ */ new Error("Request body aborted.")));
+});
+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 store = new EditorFileStore({ root });
+	let authenticated = false;
+	let env = {};
+	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;
+	};
+	return {
+		name: "samva-editor",
+		config(user) {
+			return user.server?.host === void 0 ? { server: {
+				host: "127.0.0.1",
+				allowedHosts: ["localhost", ".localhost"]
+			} } : {};
+		},
+		configResolved(resolved) {
+			root = resolve(resolved.root, options.projectRoot ?? ".");
+			env = loadEnv(resolved.mode, root, "");
+			authenticated = Boolean(env.SAMVA_API_KEY);
+		},
+		async configureServer(server) {
+			const brands = createBrandResolver({
+				root,
+				env
+			});
+			let brandReport = "";
+			const reportBrand = (resolution) => {
+				const text = resolution.ok ? resolution.warnings.map((warning) => warning.message).join("\n") : resolution.message;
+				if (text === brandReport) return;
+				brandReport = text;
+				if (text === "") return;
+				if (resolution.ok) server.config.logger.warn(`samvaEditor: ${text}`);
+				else server.config.logger.error(`samvaEditor: ${text}`);
+			};
+			store = new EditorFileStore({
+				root,
+				dir: options.templatesDir,
+				theme: options.theme,
+				assetBase: childRoute(apiPrefix, "assets"),
+				brands,
+				onProject: (project) => reportBrand(project.brand)
+			});
+			server.watcher.add(root);
+			let burst = /* @__PURE__ */ new Set();
+			let burstQueued = false;
+			const relevant = (path) => {
+				const relative = projectPath(root, path);
+				if (relative.startsWith("..") || relative === ".samva") return false;
+				if (relative.startsWith(`.samva/`)) return false;
+				if (relative.split("/").includes("node_modules")) return false;
+				return isProjectFile(relative);
+			};
+			const onFileEvent = (path) => {
+				if (!relevant(path)) return;
+				burst.add(path);
+				if (burstQueued) return;
+				burstQueued = true;
+				queueStoreRefresh(server, async () => {
+					const paths = burst;
+					burst = /* @__PURE__ */ new Set();
+					burstQueued = false;
+					const only = paths.size === 1 ? [...paths][0] : void 0;
+					return store.refreshAll({
+						documents: true,
+						changed: only
+					});
+				});
+			};
+			server.watcher.on("change", onFileEvent);
+			server.watcher.on("add", onFileEvent);
+			server.watcher.on("unlink", onFileEvent);
+			const unsubscribe = store.subscribe((change) => {
+				const { sourceClient, ...document } = change;
+				server.ws.send({
+					type: "custom",
+					event: "samva:document",
+					data: document
+				});
+				for (const client of clients) {
+					if (client.docId !== change.id) continue;
+					const origin = sourceClient !== void 0 && sourceClient === client.clientId ? "self" : "external";
+					client.push({
+						...document,
+						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", onFileEvent);
+				server.watcher.off("add", onFileEvent);
+				server.watcher.off("unlink", onFileEvent);
+				server.watcher.off("close", cleanup);
+				server.httpServer?.off("close", cleanup);
+				unsubscribe();
+				unsubscribeCatalog();
+				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();
+						return sendJson(res, 200, {
+							templates: catalog.templates,
+							diagnostics: catalog.diagnostics
+						});
+					}
+					if (pathname === `${apiPrefix}/document`) {
+						const id = query.get("id");
+						if (!id) return sendJson(res, 400, { error: "missing id" });
+						if (req.method === "POST") {
+							if (!isTrustedSourceSave(req)) return sendJson(res, 403, { error: "Source saves require the editor origin." });
+							let body;
+							try {
+								body = JSON.parse(await readBody(req));
+							} catch (error) {
+								if (error instanceof EditorBodyTooLarge) return sendJson(res, 413, { error: error.message });
+								return sendJson(res, 400, { error: "malformed JSON body" });
+							}
+							if (!isObject(body) || body["kind"] !== "authoredSource" || typeof body["baseRev"] !== "string" || typeof body["authoredSource"] !== "string") return sendJson(res, 400, { error: "Expected a revision-bound authored source update." });
+							if (Buffer.byteLength(body["authoredSource"], "utf8") > 1048576) return sendJson(res, 413, { error: EDITOR_SOURCE_TOO_LARGE_MESSAGE });
+							const outcome = await store.saveSource(id, body["baseRev"], body["authoredSource"], query.get("client") ?? void 0);
+							if (outcome.ok) return sendJson(res, 200, { rev: outcome.rev });
+							return sendJson(res, outcome.kind === "conflict" ? 409 : outcome.kind === "missing" ? 404 : 422, outcome);
+						}
+						if (req.method !== "GET") return sendJson(res, 405, { error: "Use GET or POST." });
+						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}/fixture`) {
+						const id = query.get("id");
+						if (!id) return sendJson(res, 400, { error: "missing id" });
+						if (req.method !== "POST") return sendJson(res, 405, { error: "viewing a fixture is a POST" });
+						const raw = await readBody(req);
+						let body;
+						try {
+							body = JSON.parse(raw);
+						} catch {
+							return sendJson(res, 400, { error: "malformed JSON body" });
+						}
+						if (!isObject(body) || typeof body["fixture"] !== "string") return sendJson(res, 400, { error: "malformed JSON body" });
+						const outcome = await store.viewFixture(id, body["fixture"], query.get("client") ?? void 0);
+						if (outcome.ok) return sendJson(res, 200, {});
+						return sendJson(res, outcome.kind === "missing" ? 404 : 422, { error: outcome.error });
+					}
+					if (pathname.startsWith(`${apiPrefix}/assets/`)) {
+						const asset = store.asset(pathname.slice(`${apiPrefix}/assets/`.length));
+						if (asset === void 0) return sendJson(res, 404, { error: "asset not found" });
+						res.statusCode = 200;
+						res.setHeader("content-type", asset.contentType);
+						res.end(Buffer.from(asset.bytes));
+						return;
+					}
+					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, error instanceof EditorBodyTooLarge ? 413 : 500, { error: error instanceof Error ? error.message : String(error) });
+				});
+			};
+			server.middlewares.use(handler);
+		}
+	};
+};
+//#endregion
+export { samvaEditor as t };
+
+//# sourceMappingURL=editor-Cow7zZ_9.js.map