mosage 0.1.0 → 0.8.0

package/dist/config-DPm1BBAb.js

@@ -0,0 +1,2619 @@
+import { a as defaultDesign, n as DiagramSyntaxError, r as parseDelimited, t as compileDiagram } from "./diagram-xlVDekYk.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync, readFileSync } from "node:fs";
+import fs from "node:fs/promises";
+import tailwindcss from "@tailwindcss/vite";
+import react from "@vitejs/plugin-react";
+import fg from "fast-glob";
+import { loadConfigFromFile, normalizePath } from "vite";
+import { parse } from "@babel/parser";
+import { randomUUID } from "node:crypto";
+//#region src/vite/mosage-plugin.ts
+const DOC_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+const CONFIG_FILE = "mosage.config.ts";
+const DOCS_VMOD = "virtual:mosage/docs";
+const CONFIG_VMOD = "virtual:mosage/config";
+const FOLDERS_VMOD = "virtual:mosage/folders";
+async function readFoldersManifest(file) {
+	try {
+		const parsed = JSON.parse(await fs.readFile(file, "utf8"));
+		return {
+			folders: Array.isArray(parsed.folders) ? parsed.folders : [],
+			assignments: parsed.assignments && typeof parsed.assignments === "object" ? parsed.assignments : {}
+		};
+	} catch (err) {
+		if (err.code === "ENOENT") return {
+			folders: [],
+			assignments: {}
+		};
+		throw err;
+	}
+}
+function resolved$1(id) {
+	return `\0${id}`;
+}
+async function findDocs(userCwd, docsDir) {
+	const abs = path.resolve(userCwd, docsDir);
+	if (!existsSync(abs)) return [];
+	return (await fg("*/index.{tsx,jsx,ts,js}", {
+		cwd: abs,
+		absolute: true,
+		onlyFiles: true
+	})).sort();
+}
+function toId(absFile, docsRoot) {
+	return path.relative(docsRoot, absFile).split(path.sep)[0];
+}
+const META_CREATED_AT_RE = /(?:^|[\s,{])createdAt\s*:\s*['"]([^'"]+)['"]/;
+const META_THEME_RE = /(?:^|[\s,{])theme\s*:\s*['"]([^'"]+)['"]/;
+/**
+* Reads `meta` with a brace-matched regex instead of parsing: the plugin runs on
+* every discovery pass, and the two fields it needs (sort order, theme back-link)
+* are contractually string literals.
+*/
+function extractMeta(src) {
+	const empty = {
+		theme: null,
+		createdAt: null
+	};
+	const metaStart = src.search(/export\s+const\s+meta\b/);
+	if (metaStart === -1) return empty;
+	const openBrace = src.indexOf("{", src.indexOf("=", metaStart));
+	if (openBrace === -1) return empty;
+	let depth = 0;
+	let closeBrace = -1;
+	for (let i = openBrace; i < src.length; i++) {
+		const ch = src[i];
+		if (ch === "{") depth++;
+		else if (ch === "}") {
+			depth--;
+			if (depth === 0) {
+				closeBrace = i;
+				break;
+			}
+		}
+	}
+	if (closeBrace === -1) return empty;
+	const body = src.slice(openBrace + 1, closeBrace);
+	return {
+		theme: body.match(META_THEME_RE)?.[1] ?? null,
+		createdAt: body.match(META_CREATED_AT_RE)?.[1] ?? null
+	};
+}
+function parseCreatedAtMs(iso) {
+	if (!iso) return null;
+	const ms = Date.parse(iso);
+	return Number.isFinite(ms) ? ms : null;
+}
+async function readMeta(abs) {
+	try {
+		return extractMeta(await fs.readFile(abs, "utf8"));
+	} catch {
+		return {
+			theme: null,
+			createdAt: null
+		};
+	}
+}
+const warnedInvalidDocIds = /* @__PURE__ */ new Set();
+async function generateDocsModule(files, docsRoot, isDev) {
+	const scanned = await Promise.all(files.map(async (abs) => {
+		const meta = await readMeta(abs);
+		return {
+			id: toId(abs, docsRoot),
+			importPath: isDev ? `@fs/${normalizePath(abs).replace(/^\/+/, "")}` : abs,
+			theme: meta.theme,
+			createdAt: parseCreatedAtMs(meta.createdAt)
+		};
+	}));
+	const entries = scanned.filter((e) => DOC_ID_RE.test(e.id));
+	const ignored = scanned.filter((e) => !DOC_ID_RE.test(e.id)).map((e) => e.id);
+	const ids = JSON.stringify(entries.map((e) => e.id).sort());
+	const createdAtMap = {};
+	const themesMap = {};
+	for (const e of entries) {
+		if (e.createdAt !== null) createdAtMap[e.id] = e.createdAt;
+		if (e.theme) themesMap[e.id] = e.theme;
+	}
+	const importTokens = JSON.stringify(Object.fromEntries(entries.map((e) => [e.id, 0])));
+	const devRuntime = isDev ? `
+const docImportTokens = ${importTokens};
+if (import.meta.hot) {
+  import.meta.hot.on('mosage:doc-changed', (data) => {
+    const ids = Array.isArray(data?.docIds) ? data.docIds : data?.docId ? [data.docId] : [];
+    const token = Date.now();
+    for (const id of ids) {
+      if (Object.prototype.hasOwnProperty.call(docImportTokens, id)) docImportTokens[id] = token;
+    }
+  });
+}
+` : "";
+	const cases = entries.map((e) => {
+		const importExpr = isDev ? `import(/* @vite-ignore */ import.meta.env.BASE_URL + ${JSON.stringify(`${e.importPath}?t=`)} + docImportTokens[${JSON.stringify(e.id)}])` : `import(${JSON.stringify(e.importPath)})`;
+		return `    case ${JSON.stringify(e.id)}: return ${importExpr};`;
+	}).join("\n");
+	return {
+		code: `// virtual:mosage/docs — generated
+export const docIds = ${ids};
+export const docCreatedAt = ${JSON.stringify(createdAtMap)};
+export const docThemes = ${JSON.stringify(themesMap)};
+${devRuntime}
+
+export async function loadDoc(id) {
+  switch (id) {
+${cases}
+    default: throw new Error('Document not found: ' + id);
+  }
+}
+`,
+		ignored
+	};
+}
+function mosagePlugin(opts) {
+	const { userCwd, config, coreVersion } = opts;
+	const docsDir = config.docsDir ?? "docs";
+	const docsRoot = path.resolve(userCwd, docsDir);
+	const foldersManifestPath = path.join(docsRoot, ".folders.json");
+	let isDev = false;
+	const docIdForEntry = (p) => {
+		const rel = path.relative(docsRoot, p);
+		if (rel.startsWith("..") || path.isAbsolute(rel)) return null;
+		const parts = rel.split(path.sep);
+		if (parts.length !== 2) return null;
+		if (!/^index\.(tsx|jsx|ts|js)$/.test(parts[1])) return null;
+		return parts[0];
+	};
+	let docChangeTimer = null;
+	const pendingDocChanges = /* @__PURE__ */ new Set();
+	const queueDocChanged = (server, id) => {
+		pendingDocChanges.add(id);
+		if (docChangeTimer) clearTimeout(docChangeTimer);
+		docChangeTimer = setTimeout(() => {
+			docChangeTimer = null;
+			const mod = server.moduleGraph.getModuleById(resolved$1(DOCS_VMOD));
+			if (mod) server.moduleGraph.invalidateModule(mod);
+			const docIds = Array.from(pendingDocChanges);
+			pendingDocChanges.clear();
+			server.ws.send({
+				type: "custom",
+				event: "mosage:doc-changed",
+				data: { docIds }
+			});
+		}, 100);
+	};
+	return {
+		name: "mosage",
+		config(_c, env) {
+			isDev = env.command === "serve";
+			return { server: { fs: { allow: [userCwd] } } };
+		},
+		resolveId(id) {
+			if (id === DOCS_VMOD) return resolved$1(DOCS_VMOD);
+			if (id === CONFIG_VMOD) return resolved$1(CONFIG_VMOD);
+			if (id === FOLDERS_VMOD) return resolved$1(FOLDERS_VMOD);
+			return null;
+		},
+		async load(id) {
+			if (id === resolved$1(DOCS_VMOD)) {
+				const { code, ignored } = await generateDocsModule(await findDocs(userCwd, docsDir), docsRoot, isDev);
+				for (const docId of ignored) {
+					if (warnedInvalidDocIds.has(docId)) continue;
+					warnedInvalidDocIds.add(docId);
+					this.warn(`Ignoring document folder "${docId}": ids must match ${DOC_ID_RE} (letters, digits, "-", "_"). Rename it under "${docsDir}/" to a kebab-case id so it shows up.`);
+				}
+				return code;
+			}
+			if (id === resolved$1(CONFIG_VMOD)) {
+				const userBuild = config.build ?? {};
+				const build = isDev ? {
+					showDocBrowser: true,
+					allowHtmlExport: true
+				} : {
+					showDocBrowser: userBuild.showDocBrowser ?? true,
+					allowHtmlExport: userBuild.allowHtmlExport ?? true
+				};
+				return `export default ${JSON.stringify({
+					...config,
+					build,
+					version: coreVersion
+				})};\n`;
+			}
+			if (id === resolved$1(FOLDERS_VMOD)) {
+				const manifest = await readFoldersManifest(foldersManifestPath);
+				return `export default ${JSON.stringify(manifest)};\n`;
+			}
+			return null;
+		},
+		handleHotUpdate(ctx) {
+			const docId = docIdForEntry(ctx.file);
+			if (!docId) return;
+			queueDocChanged(ctx.server, docId);
+			return [];
+		},
+		configureServer(server) {
+			const isDocEntry = (p) => docIdForEntry(p) !== null;
+			let reloadTimer = null;
+			const reload = () => {
+				if (reloadTimer) clearTimeout(reloadTimer);
+				reloadTimer = setTimeout(() => {
+					reloadTimer = null;
+					const mod = server.moduleGraph.getModuleById(resolved$1(DOCS_VMOD));
+					if (mod) server.moduleGraph.invalidateModule(mod);
+					server.ws.send({ type: "full-reload" });
+				}, 150);
+			};
+			server.watcher.add(docsRoot);
+			server.watcher.on("add", (p) => {
+				if (isDocEntry(p)) reload();
+			});
+			server.watcher.on("unlink", (p) => {
+				if (isDocEntry(p)) reload();
+			});
+			server.watcher.on("unlinkDir", (p) => {
+				if (path.dirname(p) === docsRoot) reload();
+			});
+			let foldersTimer = null;
+			const foldersChanged = () => {
+				if (foldersTimer) clearTimeout(foldersTimer);
+				foldersTimer = setTimeout(() => {
+					foldersTimer = null;
+					const mod = server.moduleGraph.getModuleById(resolved$1(FOLDERS_VMOD));
+					if (mod) server.moduleGraph.invalidateModule(mod);
+					server.ws.send({
+						type: "custom",
+						event: "mosage:files-changed",
+						data: {}
+					});
+				}, 100);
+			};
+			server.watcher.add(foldersManifestPath);
+			for (const event of [
+				"add",
+				"change",
+				"unlink"
+			]) server.watcher.on(event, (p) => {
+				if (p === foldersManifestPath) foldersChanged();
+			});
+		}
+	};
+}
+async function loadUserConfig(userCwd) {
+	const file = path.join(userCwd, CONFIG_FILE);
+	if (!existsSync(file)) return {};
+	return (await loadConfigFromFile({
+		command: "serve",
+		mode: "development"
+	}, file, userCwd, "silent"))?.config ?? {};
+}
+//#endregion
+//#region src/files/assets.ts
+const GLOBAL_SCOPE = "@global";
+const ASSET_FORBIDDEN_RE = /[\x00-\x1F\x7F/\\:*?"<>|]/;
+const MIME_BY_EXT = {
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	svg: "image/svg+xml",
+	webp: "image/webp",
+	avif: "image/avif",
+	ico: "image/x-icon",
+	pdf: "application/pdf",
+	woff: "font/woff",
+	woff2: "font/woff2",
+	ttf: "font/ttf",
+	otf: "font/otf",
+	csv: "text/csv; charset=utf-8",
+	json: "application/json",
+	txt: "text/plain; charset=utf-8",
+	md: "text/markdown; charset=utf-8"
+};
+function mimeForFilename(name) {
+	const dot = name.lastIndexOf(".");
+	if (dot < 0) return "application/octet-stream";
+	return MIME_BY_EXT[name.slice(dot + 1).toLowerCase()] ?? "application/octet-stream";
+}
+function assetCreatedAt(birthtimeMs, mtimeMs) {
+	return Number.isFinite(birthtimeMs) && birthtimeMs > 0 ? birthtimeMs : mtimeMs;
+}
+function validateAssetName(v) {
+	if (typeof v !== "string") return null;
+	const trimmed = v.trim();
+	if (trimmed.length < 1 || trimmed.length > 120) return null;
+	if (ASSET_FORBIDDEN_RE.test(trimmed)) return null;
+	if (trimmed.startsWith(".") || trimmed.startsWith("~")) return null;
+	if (trimmed === ".." || trimmed.split(/[/\\]/).includes("..")) return null;
+	const dot = trimmed.lastIndexOf(".");
+	if (dot <= 0 || dot === trimmed.length - 1) return null;
+	return trimmed;
+}
+function resolveAssetsDir(docsRoot, docId) {
+	if (!DOC_ID_RE.test(docId)) return null;
+	const docDir = path.resolve(docsRoot, docId);
+	if (!docDir.startsWith(docsRoot + path.sep)) return null;
+	const assetsDir = path.resolve(docDir, "assets");
+	if (assetsDir !== path.join(docDir, "assets")) return null;
+	return assetsDir;
+}
+function resolveScopedAssetsDir(docsRoot, globalAssetsRoot, scope) {
+	if (scope === "@global") return globalAssetsRoot;
+	return resolveAssetsDir(docsRoot, scope);
+}
+function resolveScopedAssetFile(docsRoot, globalAssetsRoot, scope, filename) {
+	if (!validateAssetName(filename)) return null;
+	const dir = resolveScopedAssetsDir(docsRoot, globalAssetsRoot, scope);
+	if (!dir) return null;
+	const file = path.resolve(dir, filename);
+	if (!file.startsWith(dir + path.sep)) return null;
+	return file;
+}
+/** How a document imports an asset — the string we look for when counting usages. */
+function assetImportPath(scope, filename) {
+	return scope === "@global" ? `@assets/${filename}` : `./assets/${filename}`;
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Counts references to an asset in a document's source. Matches the quoted path
+* in both import statements and `new URL('./assets/x.png', import.meta.url)`,
+* which is every form the authoring skill sanctions.
+*/
+function countAssetUsages(source, importPath) {
+	const quoted = new RegExp(`(['"\`])${escapeRegExp(importPath)}\\1`, "g");
+	return source.match(quoted)?.length ?? 0;
+}
+function findReferencedAssets(source, importPaths) {
+	return importPaths.filter((p) => countAssetUsages(source, p) > 0);
+}
+//#endregion
+//#region src/http/request-guard.ts
+function firstHeaderValue(value) {
+	if (Array.isArray(value)) return value[0] ?? null;
+	return value ?? null;
+}
+function headerValue(req, name) {
+	return firstHeaderValue(req.headers[name.toLowerCase()])?.trim() ?? null;
+}
+function firstCommaToken(value) {
+	if (!value) return null;
+	const [first] = value.split(",", 1);
+	return first?.trim() || null;
+}
+function requestProto(req) {
+	const forwarded = firstCommaToken(headerValue(req, "x-forwarded-proto"))?.toLowerCase();
+	if (forwarded === "http" || forwarded === "https") return forwarded;
+	return "encrypted" in req.socket && req.socket.encrypted ? "https" : "http";
+}
+function normalizedOrigin(origin) {
+	try {
+		const url = new URL(origin);
+		return `${url.protocol}//${url.host}`.toLowerCase();
+	} catch {
+		return null;
+	}
+}
+/**
+* The dev server writes to the user's filesystem, so every mutating endpoint is
+* guarded against a page on another origin driving it through the browser.
+*/
+function validateMutationRequest(req, opts = {}) {
+	if (opts.requireJsonBody) {
+		if (!(headerValue(req, "content-type")?.toLowerCase())?.startsWith("application/json")) return {
+			ok: false,
+			status: 415,
+			error: "content-type must be application/json"
+		};
+	}
+	if (firstCommaToken(headerValue(req, "sec-fetch-site"))?.toLowerCase() === "cross-site") return {
+		ok: false,
+		status: 403,
+		error: "cross-site request blocked"
+	};
+	const originRaw = headerValue(req, "origin");
+	if (!originRaw) return { ok: true };
+	if (originRaw.toLowerCase() === "null") return {
+		ok: false,
+		status: 403,
+		error: "opaque origin is not allowed"
+	};
+	const actualOrigin = normalizedOrigin(originRaw);
+	if (!actualOrigin) return {
+		ok: false,
+		status: 403,
+		error: "invalid origin header"
+	};
+	const host = firstCommaToken(headerValue(req, "x-forwarded-host")) ?? headerValue(req, "host");
+	if (!host) return {
+		ok: false,
+		status: 400,
+		error: "missing host header"
+	};
+	if (actualOrigin !== `${requestProto(req)}://${host}`.toLowerCase()) return {
+		ok: false,
+		status: 403,
+		error: "origin mismatch"
+	};
+	return { ok: true };
+}
+//#endregion
+//#region src/vite/routes/context.ts
+function makeContext(opts) {
+	const userCwd = opts.userCwd;
+	const docsDir = opts.docsDir ?? "docs";
+	const assetsDir = opts.assetsDir ?? "assets";
+	const docsRoot = path.resolve(userCwd, docsDir);
+	return {
+		userCwd,
+		docsDir,
+		docsRoot,
+		globalAssetsRoot: path.resolve(userCwd, assetsDir),
+		manifestPath: path.join(docsRoot, ".folders.json"),
+		coreVersion: opts.coreVersion,
+		...opts.serverOrigin !== void 0 ? { serverOrigin: opts.serverOrigin } : {}
+	};
+}
+async function readBody(req) {
+	return await new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (c) => chunks.push(c));
+		req.on("end", () => {
+			const raw = Buffer.concat(chunks).toString("utf8");
+			if (!raw) return resolve({});
+			try {
+				resolve(JSON.parse(raw));
+			} catch (e) {
+				reject(e);
+			}
+		});
+		req.on("error", reject);
+	});
+}
+function json(res, status, body) {
+	res.statusCode = status;
+	res.setHeader("content-type", "application/json");
+	res.end(JSON.stringify(body));
+}
+const ENTRY_NAMES$1 = [
+	"index.tsx",
+	"index.jsx",
+	"index.ts",
+	"index.js"
+];
+/** Absolute path of a document's entry file, or null when the id is unusable. */
+function resolveDocPath(userCwd, docsDir, docId) {
+	if (!DOC_ID_RE.test(docId)) return null;
+	const docsRoot = path.resolve(userCwd, docsDir);
+	const full = path.resolve(docsRoot, docId, ENTRY_NAMES$1[0]);
+	if (!full.startsWith(docsRoot + path.sep)) return null;
+	return full;
+}
+/** The entry file that actually exists on disk for a document, or null. */
+function resolveDocEntry(docsRoot, docId) {
+	if (!DOC_ID_RE.test(docId)) return null;
+	const docDir = path.resolve(docsRoot, docId);
+	if (!docDir.startsWith(docsRoot + path.sep)) return null;
+	for (const name of ENTRY_NAMES$1) {
+		const candidate = path.join(docDir, name);
+		if (existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+//#endregion
+//#region src/vite/routes/assets.ts
+async function listDocIds$1(docsRoot) {
+	try {
+		return (await fs.readdir(docsRoot, { withFileTypes: true })).filter((e) => e.isDirectory() && DOC_ID_RE.test(e.name)).map((e) => e.name);
+	} catch {
+		return [];
+	}
+}
+async function readDocSource(docsRoot, docId) {
+	const entry = resolveDocEntry(docsRoot, docId);
+	if (!entry) return null;
+	try {
+		return await fs.readFile(entry, "utf8");
+	} catch {
+		return null;
+	}
+}
+function registerAssetRoutes(server, ctx) {
+	server.middlewares.use("/__assets", async (req, res, next) => {
+		const url = new URL(req.url ?? "/", "http://local");
+		const method = req.method ?? "GET";
+		try {
+			const listMatch = url.pathname.match(/^\/([^/]+)\/?$/);
+			const fileMatch = url.pathname.match(/^\/([^/]+)\/([^/]+)$/);
+			const usagesMatch = url.pathname.match(/^\/([^/]+)\/([^/]+)\/usages$/);
+			if (usagesMatch && method === "GET") {
+				const scope = decodeURIComponent(usagesMatch[1]);
+				const filename = decodeURIComponent(usagesMatch[2]);
+				if (!validateAssetName(filename)) return json(res, 400, { error: "invalid path" });
+				const isGlobal = scope === GLOBAL_SCOPE;
+				if (!isGlobal && !DOC_ID_RE.test(scope)) return json(res, 400, { error: "invalid scope" });
+				const importPath = assetImportPath(scope, filename);
+				const docIds = isGlobal ? await listDocIds$1(ctx.docsRoot) : [scope];
+				const usages = [];
+				let totalCount = 0;
+				for (const docId of docIds) {
+					const source = await readDocSource(ctx.docsRoot, docId);
+					if (source === null) continue;
+					const count = countAssetUsages(source, importPath);
+					if (count > 0) {
+						usages.push({
+							docId,
+							count
+						});
+						totalCount += count;
+					}
+				}
+				return json(res, 200, {
+					usages,
+					totalCount
+				});
+			}
+			if (listMatch && method === "GET") {
+				const scope = decodeURIComponent(listMatch[1]);
+				const scopedDir = resolveScopedAssetsDir(ctx.docsRoot, ctx.globalAssetsRoot, scope);
+				if (!scopedDir) return json(res, 400, { error: "invalid scope" });
+				let entries;
+				try {
+					entries = await fs.readdir(scopedDir);
+				} catch (err) {
+					if (err.code === "ENOENT") return json(res, 200, { assets: [] });
+					throw err;
+				}
+				const assets = [];
+				for (const name of entries) {
+					if (!validateAssetName(name)) continue;
+					const stat = await fs.stat(path.join(scopedDir, name));
+					if (!stat.isFile()) continue;
+					assets.push({
+						name,
+						size: stat.size,
+						createdAt: assetCreatedAt(stat.birthtimeMs, stat.mtimeMs),
+						mtime: stat.mtimeMs,
+						mime: mimeForFilename(name),
+						url: `/__assets/${encodeURIComponent(scope)}/${encodeURIComponent(name)}`,
+						importPath: assetImportPath(scope, name),
+						unused: true
+					});
+				}
+				assets.sort((a, b) => a.name.localeCompare(b.name));
+				if (assets.length > 0) {
+					const scanIds = scope === "@global" ? await listDocIds$1(ctx.docsRoot) : [scope];
+					const pathToAsset = new Map(assets.map((a) => [a.importPath, a]));
+					const paths = assets.map((a) => a.importPath);
+					for (const docId of scanIds) {
+						const source = await readDocSource(ctx.docsRoot, docId);
+						if (source === null) continue;
+						for (const p of findReferencedAssets(source, paths)) {
+							const asset = pathToAsset.get(p);
+							if (asset) asset.unused = false;
+						}
+					}
+				}
+				return json(res, 200, { assets });
+			}
+			if (fileMatch) {
+				const scope = decodeURIComponent(fileMatch[1]);
+				const filename = decodeURIComponent(fileMatch[2]);
+				const file = resolveScopedAssetFile(ctx.docsRoot, ctx.globalAssetsRoot, scope, filename);
+				if (!file) return json(res, 400, { error: "invalid path" });
+				if (method === "GET") try {
+					const buf = await fs.readFile(file);
+					res.statusCode = 200;
+					res.setHeader("content-type", mimeForFilename(filename));
+					res.setHeader("cache-control", "no-store");
+					res.end(buf);
+					return;
+				} catch (err) {
+					if (err.code === "ENOENT") return json(res, 404, { error: "asset not found" });
+					throw err;
+				}
+				if (method === "POST") {
+					const requestCheck = validateMutationRequest(req);
+					if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+					const overwrite = url.searchParams.get("overwrite") === "1";
+					const lenHeader = req.headers["content-length"];
+					const len = typeof lenHeader === "string" ? Number(lenHeader) : NaN;
+					if (Number.isFinite(len) && len > 26214400) return json(res, 413, { error: "file too large" });
+					if (!overwrite) try {
+						await fs.access(file);
+						return json(res, 409, { error: "asset exists" });
+					} catch {}
+					const scopedDir = resolveScopedAssetsDir(ctx.docsRoot, ctx.globalAssetsRoot, scope);
+					if (!scopedDir) return json(res, 400, { error: "invalid scope" });
+					await fs.mkdir(scopedDir, { recursive: true });
+					const chunks = [];
+					let total = 0;
+					let oversized = false;
+					await new Promise((resolve, reject) => {
+						req.on("data", (c) => {
+							total += c.length;
+							if (total > 26214400) {
+								oversized = true;
+								req.destroy();
+								return;
+							}
+							chunks.push(c);
+						});
+						req.on("end", () => resolve());
+						req.on("error", reject);
+					});
+					if (oversized) return json(res, 413, { error: "file too large" });
+					await fs.writeFile(file, Buffer.concat(chunks));
+					const stat = await fs.stat(file);
+					return json(res, 200, {
+						ok: true,
+						name: filename,
+						size: stat.size,
+						createdAt: assetCreatedAt(stat.birthtimeMs, stat.mtimeMs),
+						mtime: stat.mtimeMs,
+						mime: mimeForFilename(filename),
+						url: `/__assets/${encodeURIComponent(scope)}/${encodeURIComponent(filename)}`,
+						importPath: assetImportPath(scope, filename)
+					});
+				}
+				if (method === "PATCH") {
+					const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+					if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+					const target = validateAssetName((await readBody(req)).name);
+					if (!target) return json(res, 400, { error: "invalid name" });
+					if (target === filename) return json(res, 200, {
+						ok: true,
+						name: filename
+					});
+					const dest = resolveScopedAssetFile(ctx.docsRoot, ctx.globalAssetsRoot, scope, target);
+					if (!dest) return json(res, 400, { error: "invalid name" });
+					try {
+						await fs.access(dest);
+						return json(res, 409, { error: "target exists" });
+					} catch {}
+					try {
+						await fs.rename(file, dest);
+					} catch (err) {
+						if (err.code === "ENOENT") return json(res, 404, { error: "asset not found" });
+						throw err;
+					}
+					return json(res, 200, {
+						ok: true,
+						name: target
+					});
+				}
+				if (method === "DELETE") {
+					const requestCheck = validateMutationRequest(req);
+					if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+					try {
+						await fs.unlink(file);
+					} catch (err) {
+						if (err.code === "ENOENT") return json(res, 404, { error: "asset not found" });
+						throw err;
+					}
+					return json(res, 200, { ok: true });
+				}
+			}
+			return next();
+		} catch (err) {
+			json(res, 500, { error: String(err.message ?? err) });
+		}
+	});
+}
+//#endregion
+//#region src/editing/doc-ops.ts
+function parseSource$2(source) {
+	try {
+		return parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"],
+			errorRecovery: true
+		});
+	} catch {
+		return null;
+	}
+}
+function programBody$1(ast) {
+	return ast.program?.body ?? [];
+}
+function metaObjectOf(node) {
+	if (node.type !== "ExportNamedDeclaration") return null;
+	const decl = node.declaration;
+	if (decl?.type !== "VariableDeclaration") return null;
+	const declarations = decl.declarations ?? [];
+	for (const d of declarations) {
+		const id = d.id;
+		if (id?.type !== "Identifier" || id.name !== "meta") continue;
+		let init = d.init;
+		if (!init) return null;
+		if (init.type === "TSSatisfiesExpression" || init.type === "TSAsExpression") {
+			const expr = init.expression;
+			if (expr) init = expr;
+		}
+		return init.type === "ObjectExpression" ? init : null;
+	}
+	return null;
+}
+function findMetaObject(ast) {
+	for (const node of programBody$1(ast)) {
+		const object = metaObjectOf(node);
+		if (object) return object;
+	}
+	return null;
+}
+function jsString$1(value) {
+	return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, " ")}'`;
+}
+function validateDocTitle(v) {
+	if (typeof v !== "string") return null;
+	const trimmed = v.trim();
+	if (trimmed.length < 1 || trimmed.length > 120) return null;
+	return trimmed;
+}
+/**
+* Rewrites `meta.title` in place, adding the property when the meta object
+* exists without one. Returns null when there is no meta object to edit —
+* the caller reports that rather than inventing an export.
+*/
+function setMetaTitle(source, title) {
+	const ast = parseSource$2(source);
+	if (!ast) return null;
+	const object = findMetaObject(ast);
+	if (!object) return null;
+	const properties = object.properties ?? [];
+	for (const prop of properties) {
+		if (prop.type !== "ObjectProperty") continue;
+		const p = prop;
+		if (p.computed) continue;
+		if ((p.key.type === "Identifier" ? p.key.name : p.key.value) !== "title") continue;
+		return source.slice(0, p.value.start) + jsString$1(title) + source.slice(p.value.end);
+	}
+	const open = object.start + 1;
+	const inserted = source.slice(open, object.end - 1).trim() === "" ? `\n  title: ${jsString$1(title)},\n` : `\n  title: ${jsString$1(title)},`;
+	return source.slice(0, open) + inserted + source.slice(open);
+}
+function readMetaTitle(source) {
+	const ast = parseSource$2(source);
+	if (!ast) return null;
+	const object = findMetaObject(ast);
+	if (!object) return null;
+	const properties = object.properties ?? [];
+	for (const prop of properties) {
+		if (prop.type !== "ObjectProperty") continue;
+		const p = prop;
+		if (p.computed) continue;
+		if ((p.key.type === "Identifier" ? p.key.name : p.key.value) !== "title") continue;
+		if (p.value.type !== "StringLiteral") return null;
+		return typeof p.value.value === "string" ? p.value.value : null;
+	}
+	return null;
+}
+/** `q3-review` → `q3-review-copy`, `q3-review-copy` → `q3-review-copy-2`, … */
+function nextCopyId(baseId, taken) {
+	const stem = baseId.replace(/-copy(-\d+)?$/, "");
+	let candidate = `${stem}-copy`;
+	let n = 2;
+	while (taken.has(candidate)) {
+		candidate = `${stem}-copy-${n}`;
+		n++;
+	}
+	return candidate;
+}
+function copyTitle(title) {
+	return /\(copy( \d+)?\)$/.test(title) ? title : `${title} (copy)`;
+}
+//#endregion
+//#region src/files/folders.ts
+const FOLDER_ID_RE = /^f-[a-f0-9]{8}$/;
+const COLOR_RE = /^#[0-9a-fA-F]{6}$/;
+function emptyManifest() {
+	return {
+		folders: [],
+		assignments: {}
+	};
+}
+async function readManifest(file) {
+	try {
+		const raw = await fs.readFile(file, "utf8");
+		const parsed = JSON.parse(raw);
+		return {
+			folders: Array.isArray(parsed.folders) ? parsed.folders : [],
+			assignments: parsed.assignments && typeof parsed.assignments === "object" ? parsed.assignments : {}
+		};
+	} catch (err) {
+		if (err.code === "ENOENT") return emptyManifest();
+		throw err;
+	}
+}
+async function writeManifest(file, manifest) {
+	await fs.mkdir(path.dirname(file), { recursive: true });
+	await fs.writeFile(file, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+}
+function newFolderId() {
+	return `f-${randomUUID().replace(/-/g, "").slice(0, 8)}`;
+}
+function validateName(v) {
+	if (typeof v !== "string") return null;
+	const trimmed = v.trim();
+	if (trimmed.length < 1 || trimmed.length > 40) return null;
+	return trimmed;
+}
+function validateReorder(v, current) {
+	if (!Array.isArray(v) || v.length !== current.length) return null;
+	const known = new Set(current.map((f) => f.id));
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const id of v) {
+		if (typeof id !== "string" || !FOLDER_ID_RE.test(id)) return null;
+		if (!known.has(id) || seen.has(id)) return null;
+		seen.add(id);
+		out.push(id);
+	}
+	return out;
+}
+function validateIcon(v) {
+	if (!v || typeof v !== "object") return null;
+	const icon = v;
+	if (icon.type === "emoji") {
+		if (typeof icon.value !== "string") return null;
+		if (icon.value.length < 1 || icon.value.length > 8) return null;
+		return {
+			type: "emoji",
+			value: icon.value
+		};
+	}
+	if (icon.type === "color") {
+		if (typeof icon.value !== "string" || !COLOR_RE.test(icon.value)) return null;
+		return {
+			type: "color",
+			value: icon.value
+		};
+	}
+	return null;
+}
+//#endregion
+//#region src/ops/documents.ts
+/**
+* Operations shared by the dev API and the CLI. Everything here takes an
+* `ApiContext` and touches disk directly — no HTTP, so a command and a browser
+* calling `/__docs` end up in exactly the same code.
+*/
+var OpsError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+		this.name = "OpsError";
+	}
+};
+const ENTRY_NAMES = [
+	"index.tsx",
+	"index.jsx",
+	"index.ts",
+	"index.js"
+];
+function docDir(ctx, docId) {
+	if (!DOC_ID_RE.test(docId)) throw new OpsError(400, `invalid document id: ${docId}`);
+	const dir = path.resolve(ctx.docsRoot, docId);
+	if (!dir.startsWith(ctx.docsRoot + path.sep)) throw new OpsError(400, `invalid document id: ${docId}`);
+	return dir;
+}
+function resolveEntry(ctx, docId) {
+	const dir = docDir(ctx, docId);
+	for (const name of ENTRY_NAMES) {
+		const file = path.join(dir, name);
+		if (existsSync(file)) return file;
+	}
+	return null;
+}
+async function listDocIds(ctx) {
+	try {
+		return (await fs.readdir(ctx.docsRoot, { withFileTypes: true })).filter((e) => e.isDirectory() && DOC_ID_RE.test(e.name)).map((e) => e.name).sort();
+	} catch {
+		return [];
+	}
+}
+async function createDocument(ctx, docId, source) {
+	const dir = docDir(ctx, docId);
+	if (existsSync(dir)) throw new OpsError(409, `document already exists: ${docId}`);
+	await fs.mkdir(dir, { recursive: true });
+	const entry = path.join(dir, "index.tsx");
+	await fs.writeFile(entry, source, "utf8");
+	return {
+		id: docId,
+		entry: path.relative(ctx.userCwd, entry)
+	};
+}
+async function renameDocument(ctx, docId, rawTitle) {
+	const title = validateDocTitle(rawTitle);
+	if (!title) throw new OpsError(400, "invalid title");
+	const entry = resolveEntry(ctx, docId);
+	if (!entry) throw new OpsError(404, `document not found: ${docId}`);
+	const source = await fs.readFile(entry, "utf8");
+	const next = setMetaTitle(source, title);
+	if (next === null) throw new OpsError(422, "document has no `export const meta` object to rename");
+	if (next !== source) await fs.writeFile(entry, next, "utf8");
+	return {
+		id: docId,
+		title
+	};
+}
+async function duplicateDocument(ctx, docId, newId) {
+	const dir = docDir(ctx, docId);
+	if (!existsSync(dir)) throw new OpsError(404, `document not found: ${docId}`);
+	const taken = new Set(await listDocIds(ctx));
+	let targetId;
+	if (newId) {
+		if (!DOC_ID_RE.test(newId)) throw new OpsError(400, `invalid newId: ${newId}`);
+		if (taken.has(newId)) throw new OpsError(409, `document already exists: ${newId}`);
+		targetId = newId;
+	} else targetId = nextCopyId(docId, taken);
+	await fs.cp(dir, docDir(ctx, targetId), { recursive: true });
+	const entry = resolveEntry(ctx, targetId);
+	if (entry) {
+		const source = await fs.readFile(entry, "utf8");
+		const renamed = setMetaTitle(source, copyTitle(readMetaTitle(source) ?? docId));
+		if (renamed && renamed !== source) await fs.writeFile(entry, renamed, "utf8");
+	}
+	const manifest = await readManifest(ctx.manifestPath);
+	const folderId = manifest.assignments[docId];
+	if (folderId) {
+		manifest.assignments[targetId] = folderId;
+		await writeManifest(ctx.manifestPath, manifest);
+	}
+	return { id: targetId };
+}
+async function deleteDocument(ctx, docId) {
+	const dir = docDir(ctx, docId);
+	if (!existsSync(dir)) throw new OpsError(404, `document not found: ${docId}`);
+	await fs.rm(dir, {
+		recursive: true,
+		force: true
+	});
+	const manifest = await readManifest(ctx.manifestPath);
+	if (manifest.assignments[docId]) {
+		delete manifest.assignments[docId];
+		await writeManifest(ctx.manifestPath, manifest);
+	}
+}
+//#endregion
+//#region src/vite/routes/docs.ts
+function registerDocRoutes(server, ctx) {
+	server.middlewares.use("/__docs", async (req, res, next) => {
+		const url = new URL(req.url ?? "/", "http://local");
+		const method = req.method ?? "GET";
+		try {
+			const duplicateMatch = url.pathname.match(/^\/([^/]+)\/duplicate$/);
+			const idMatch = url.pathname.match(/^\/([^/]+)$/);
+			if (duplicateMatch && method === "POST") {
+				const requestCheck = validateMutationRequest(req);
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				const docId = decodeURIComponent(duplicateMatch[1]);
+				const body = await readBody(req).catch(() => ({}));
+				return json(res, 200, {
+					ok: true,
+					docId: (await duplicateDocument(ctx, docId, typeof body.newId === "string" && body.newId !== "" ? body.newId : void 0)).id
+				});
+			}
+			if (idMatch) {
+				const docId = decodeURIComponent(idMatch[1]);
+				if (method === "PATCH") {
+					const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+					if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+					return json(res, 200, {
+						ok: true,
+						title: (await renameDocument(ctx, docId, (await readBody(req)).title)).title
+					});
+				}
+				if (method === "DELETE") {
+					const requestCheck = validateMutationRequest(req);
+					if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+					await deleteDocument(ctx, docId);
+					return json(res, 200, { ok: true });
+				}
+			}
+			next();
+		} catch (err) {
+			if (err instanceof OpsError) return json(res, err.status, { error: err.message });
+			json(res, 500, { error: String(err.message ?? err) });
+		}
+	});
+}
+//#endregion
+//#region src/editing/babel-walk.ts
+function parseSource$1(code) {
+	try {
+		return parse(code, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"],
+			errorRecovery: true
+		});
+	} catch {
+		return null;
+	}
+}
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+/** Depth-first walk over every node; the visitor decides what it cares about. */
+function walkAst(node, visit) {
+	if (Array.isArray(node)) {
+		for (const child of node) walkAst(child, visit);
+		return;
+	}
+	if (!isNode(node)) return;
+	visit(node);
+	for (const key of Object.keys(node)) {
+		if (key === "loc" || key === "leadingComments" || key === "trailingComments") continue;
+		walkAst(node[key], visit);
+	}
+}
+function walkJsx(ast, visit) {
+	walkAst(ast, (node) => {
+		if (node.type === "JSXElement") visit(node);
+	});
+}
+/**
+* The JSX element whose opening tag starts at this source position.
+*
+* The match is exact on both line and column. Anything looser can resolve to a
+* different element on the same line, and this location decides where an edit
+* gets written — a near miss silently rewrites the wrong text.
+*/
+function findJsxAt(ast, line, column) {
+	let found = null;
+	walkJsx(ast, (node) => {
+		if (found) return;
+		const start = node.loc?.start;
+		if (start && start.line === line && start.column === column) found = node;
+	});
+	return found;
+}
+/**
+* Every JSX element that starts on a line, nearest column first.
+*
+* Columns cannot be trusted for locations derived from React's `_debugSource`:
+* injecting the loc attribute shifts the columns of anything later on the same
+* line, so the offset differs per element. The line survives that, so callers
+* scan the line and pick by content instead.
+*/
+function findJsxOnLine(ast, line, column) {
+	const hits = [];
+	walkJsx(ast, (node) => {
+		const start = node.loc?.start;
+		if (!start || start.line !== line) return;
+		hits.push({
+			node,
+			distance: Math.abs(start.column - column)
+		});
+	});
+	return hits.sort((a, b) => a.distance - b.distance).map((hit) => hit.node);
+}
+//#endregion
+//#region src/editing/comments.ts
+const MARKER_RE = /\{\/\*\s*@doc-comment\s+id="(c-[a-f0-9]+)"\s+ts="([^"]+)"\s+text="([A-Za-z0-9_-]+={0,2})"\s*\*\/\}/;
+function b64urlEncode(value) {
+	return Buffer.from(value, "utf8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function b64urlDecode(value) {
+	const pad = value.length % 4 === 0 ? "" : "=".repeat(4 - value.length % 4);
+	return Buffer.from(value.replace(/-/g, "+").replace(/_/g, "/") + pad, "base64").toString("utf8");
+}
+function parseMarkers(source) {
+	const comments = [];
+	source.split("\n").forEach((line, index) => {
+		const match = MARKER_RE.exec(line);
+		if (!match) return;
+		const [, id, ts, payload] = match;
+		try {
+			const decoded = JSON.parse(b64urlDecode(payload));
+			comments.push({
+				id,
+				line: index + 1,
+				ts,
+				note: decoded.note,
+				hint: decoded.hint
+			});
+		} catch {}
+	});
+	return comments;
+}
+function newCommentId() {
+	return `c-${randomUUID().replace(/-/g, "").slice(0, 8)}`;
+}
+function markerFor(id, ts, note, hint) {
+	return `{/* @doc-comment id="${id}" ts="${ts}" text="${b64urlEncode(JSON.stringify(hint ? {
+		note,
+		hint
+	} : { note }))}" */}`;
+}
+function markerPattern(id) {
+	return `\\{\\/\\*\\s*@doc-comment\\s+id="${id}"\\s+ts="[^"]+"\\s+text="[A-Za-z0-9_\\-]+={0,2}"\\s*\\*\\/\\}`;
+}
+/**
+* Removes a marker and the whitespace the insertion added — whichever side it
+* landed on — so deleting a comment restores the file byte for byte.
+*/
+function removeMarker(source, id) {
+	const pattern = markerPattern(id);
+	for (const re of [
+		new RegExp(`[ \\t]*${pattern}\\n`),
+		new RegExp(`\\n[ \\t]*${pattern}`),
+		new RegExp(pattern)
+	]) if (re.test(source)) return source.replace(re, "");
+	return null;
+}
+function indentOfLine(source, offset) {
+	const lineStart = source.lastIndexOf("\n", offset - 1) + 1;
+	return /^[ \t]*/.exec(source.slice(lineStart, offset))?.[0] ?? "";
+}
+/**
+* Splices the marker in as the **first child** of the target element. A
+* JSX-comment token outside a JSX child position parses as an empty object
+* literal and breaks the surrounding expression, so this never puts one before
+* an element.
+*/
+function insertMarker(source, target, note, hint) {
+	const ast = parseSource$1(source);
+	if (!ast) return null;
+	const element = findJsxAt(ast, target.line, target.column);
+	if (!element) return null;
+	const opening = element.openingElement;
+	if (!opening) return null;
+	if (opening.selfClosing === true) return null;
+	const offset = opening.end;
+	const id = newCommentId();
+	const marker = markerFor(id, (/* @__PURE__ */ new Date()).toISOString(), note, hint);
+	const indent = indentOfLine(source, element.start ?? offset);
+	return {
+		source: `${source.slice(0, offset)}\n${indent}  ${marker}${source.slice(offset)}`,
+		id
+	};
+}
+//#endregion
+//#region src/editing/edit-ops.ts
+function escapeJsxText(text) {
+	return text.replace(/[{}<>]/g, (char) => `{'${char}'}`);
+}
+function normalizeText(value) {
+	return value.replace(/\s+/g, " ").trim();
+}
+function isAstNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function jsxChildren(element) {
+	return element.children ?? [];
+}
+function labelOf(node) {
+	if (node.type === "JSXExpressionContainer") return "{…}";
+	if (node.type === "JSXElement") return `<${(node.openingElement?.name)?.name ?? "element"}>`;
+	return "…";
+}
+/** Text written straight into the JSX. Its surrounding whitespace is indentation, so the slot excludes it. */
+function literalSlot(node) {
+	const raw = node.value;
+	const leading = (raw.match(/^\s*/)?.[0] ?? "").length;
+	const trailing = (raw.match(/\s*$/)?.[0] ?? "").length;
+	return {
+		value: raw.trim(),
+		start: node.start + leading,
+		end: node.end - trailing,
+		escape: escapeJsxText
+	};
+}
+/** `name="…"` at a call site. Only the quote in use has to be escaped. */
+function attributeSlot(node, source) {
+	const quote = source[node.start] ?? "\"";
+	const entity = quote === "\"" ? "&quot;" : "&apos;";
+	return {
+		value: node.value,
+		start: node.start + 1,
+		end: node.end - 1,
+		escape: (text) => text.split(quote).join(entity)
+	};
+}
+/** A plain string in an array or object literal — a JS string, not JSX. */
+function stringSlot(node, source) {
+	const quote = source[node.start] ?? "'";
+	return {
+		value: node.value,
+		start: node.start + 1,
+		end: node.end - 1,
+		escape: (text) => text.split("\\").join("\\\\").split(quote).join(`\\${quote}`)
+	};
+}
+/**
+* A code block is written `<Code>{`docs/…`}</Code>` — the words are a template
+* literal, not JSX text. Nothing has to be traced to reach them, so they are a
+* slot wherever they appear: as a child of the element, or as the children one
+* call site handed a helper.
+*/
+function expressionSlot(child, source) {
+	if (child.type !== "JSXExpressionContainer") return null;
+	const expression = child.expression;
+	if (expression?.type === "StringLiteral") return stringSlot(expression, source);
+	if (expression?.type !== "TemplateLiteral") return null;
+	if ((expression.expressions ?? []).length > 0) return null;
+	const quasis = expression.quasis ?? [];
+	const raw = (quasis[0]?.value)?.raw ?? "";
+	if (quasis.length !== 1) return null;
+	return {
+		value: raw,
+		start: expression.start + 1,
+		end: expression.end - 1,
+		escape: (text) => text.split("\\").join("\\\\").split("`").join("\\`").split("${").join("\\${")
+	};
+}
+function identifierName(child) {
+	if (child.type !== "JSXExpressionContainer") return null;
+	const expression = child.expression;
+	if (expression?.type !== "Identifier") return null;
+	return expression.name ?? null;
+}
+/** The chain of nodes from the program down to this element — its scopes, in order. */
+function pathTo(ast, element) {
+	let found = null;
+	const visit = (node, trail) => {
+		if (found) return;
+		const here = [...trail, node];
+		if (node === element) {
+			found = here;
+			return;
+		}
+		for (const key of Object.keys(node)) {
+			if (key === "loc") continue;
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const child of value) if (isAstNode(child)) visit(child, here);
+			} else if (isAstNode(value)) visit(value, here);
+		}
+	};
+	visit(ast, []);
+	return found;
+}
+function propNames(declarator) {
+	const pattern = (declarator.init?.params)?.[0];
+	if (pattern?.type !== "ObjectPattern") return [];
+	return (pattern.properties ?? []).map((property) => property.key?.name ?? "").filter((name) => name !== "");
+}
+/** The component this element belongs to, and the props it declares. */
+function componentScope(path) {
+	for (let index = path.length - 1; index >= 0; index--) {
+		const node = path[index];
+		if (node?.type !== "VariableDeclarator") continue;
+		const name = node.id?.name;
+		const props = propNames(node);
+		if (name !== void 0 && props.length > 0) return {
+			name,
+			props
+		};
+	}
+	return null;
+}
+/** The `xs.map(entry => …)` this element is rendered inside, if any. */
+function mapScope(path) {
+	for (let index = path.length - 1; index >= 1; index--) {
+		const arrow = path[index];
+		const call = path[index - 1];
+		if (arrow?.type !== "ArrowFunctionExpression" || call?.type !== "CallExpression") continue;
+		const callee = call.callee;
+		if (callee?.type !== "MemberExpression") continue;
+		if (callee.property?.name !== "map") continue;
+		const object = callee.object;
+		const pattern = (arrow.params ?? [])[0];
+		if (object?.type !== "Identifier" || !pattern) continue;
+		return {
+			pattern,
+			array: object.name
+		};
+	}
+	return null;
+}
+function patternNames(pattern) {
+	if (pattern.type === "Identifier") return [pattern.name];
+	if (pattern.type === "ArrayPattern") return (pattern.elements ?? []).filter((element) => element?.type === "Identifier").map((element) => element.name);
+	if (pattern.type === "ObjectPattern") return (pattern.properties ?? []).map((property) => property.value?.name ?? "").filter((name) => name !== "");
+	return [];
+}
+/** Destructure one array entry the way the map callback does. */
+function entryBindings(pattern, entry, source) {
+	if (pattern.type === "Identifier") {
+		if (entry.type !== "StringLiteral") return null;
+		return /* @__PURE__ */ new Map([[pattern.name, stringSlot(entry, source)]]);
+	}
+	const bindings = /* @__PURE__ */ new Map();
+	if (pattern.type === "ArrayPattern") {
+		if (entry.type !== "ArrayExpression") return null;
+		const values = entry.elements ?? [];
+		const targets = pattern.elements ?? [];
+		for (let index = 0; index < targets.length; index++) {
+			const target = targets[index];
+			if (!target) continue;
+			const value = values[index];
+			if (target.type !== "Identifier" || value?.type !== "StringLiteral") return null;
+			bindings.set(target.name, stringSlot(value, source));
+		}
+		return bindings.size > 0 ? bindings : null;
+	}
+	if (pattern.type === "ObjectPattern") {
+		if (entry.type !== "ObjectExpression") return null;
+		for (const property of pattern.properties ?? []) {
+			const key = property.key?.name ?? "";
+			const local = property.value?.name ?? "";
+			if (key === "" || local === "") return null;
+			const value = (entry.properties ?? []).find((candidate) => candidate.key?.name === key || candidate.key?.value === key)?.value;
+			if (value?.type !== "StringLiteral") return null;
+			bindings.set(local, stringSlot(value, source));
+		}
+		return bindings.size > 0 ? bindings : null;
+	}
+	return null;
+}
+/**
+* Two call sites of the same component render different words, and only what
+* is on screen can say which one was clicked — without it a save rewrites
+* whichever came first in the file. An entry that cannot be told apart from
+* its neighbours is therefore not editable at all.
+*/
+function fits(bindings, shown) {
+	if (shown === void 0) return true;
+	const visible = normalizeText(shown);
+	const values = [...bindings.values()].map((slot) => normalizeText(slot.value));
+	if (values.join("") === "") return false;
+	return values.every((value) => visible.includes(value));
+}
+function tagName(node) {
+	return (node.openingElement?.name)?.name;
+}
+/**
+* `<Section name="主旨">…</Section>` puts its words between the tags rather
+* than in an attribute. Only a lone run of text qualifies: anything nested
+* would be flattened into a string and lost on the first save.
+*/
+function childrenSlot(node, source) {
+	const children = jsxChildren(node).filter((child) => child.type !== "JSXText" || child.value.trim() !== "");
+	const only = children[0];
+	if (children.length !== 1 || !only) return null;
+	if (only.type === "JSXText") return literalSlot(only);
+	return expressionSlot(only, source);
+}
+function callSiteBindings(node, wanted, source) {
+	const attributes = node.openingElement?.attributes ?? [];
+	const bindings = /* @__PURE__ */ new Map();
+	for (const name of wanted) {
+		if (name === "children") {
+			const slot = childrenSlot(node, source);
+			if (!slot) return null;
+			bindings.set(name, slot);
+			continue;
+		}
+		const value = attributes.find((candidate) => candidate.name?.name === name)?.value;
+		if (value?.type !== "StringLiteral") return null;
+		bindings.set(name, attributeSlot(value, source));
+	}
+	return bindings;
+}
+function propBindings(ctx, component, wanted) {
+	const matches = [];
+	walkJsx(ctx.ast, (node) => {
+		if (tagName(node) !== component) return;
+		const bindings = callSiteBindings(node, wanted, ctx.source);
+		if (bindings && fits(bindings, ctx.shown)) matches.push(bindings);
+	});
+	return matches.length === 1 ? matches[0] ?? null : null;
+}
+/** Every array literal that could be the one being mapped over. */
+function arrayCandidates(ctx, name, component) {
+	const found = [];
+	walkAst(ctx.ast, (node) => {
+		if (node.type === "VariableDeclarator") {
+			const id = node.id;
+			const init = node.init;
+			if (id?.type === "Identifier" && id.name === name && init?.type === "ArrayExpression") found.push(init);
+			return;
+		}
+		if (node.type !== "JSXElement" || component === null || tagName(node) !== component) return;
+		const attributes = node.openingElement.attributes ?? [];
+		for (const attribute of attributes) {
+			if (attribute.name?.name !== name) continue;
+			const value = attribute.value;
+			if (value?.type !== "JSXExpressionContainer") continue;
+			const expression = value.expression;
+			if (expression?.type === "ArrayExpression") found.push(expression);
+		}
+	});
+	return found;
+}
+function mapBindings(ctx, scope, component, wanted) {
+	const matches = [];
+	for (const array of arrayCandidates(ctx, scope.array, component)) for (const entry of array.elements ?? []) {
+		if (!entry) continue;
+		const bindings = entryBindings(scope.pattern, entry, ctx.source);
+		if (!bindings || !wanted.every((name) => bindings.has(name))) continue;
+		if (fits(bindings, ctx.shown)) matches.push(bindings);
+	}
+	return matches.length === 1 ? matches[0] ?? null : null;
+}
+function bindingsFor(ctx, element, names) {
+	const path = pathTo(ctx.ast, element);
+	if (!path) return null;
+	const map = mapScope(path);
+	const component = componentScope(path);
+	const mapped = map ? patternNames(map.pattern) : [];
+	const bindings = /* @__PURE__ */ new Map();
+	const fromMap = names.filter((name) => mapped.includes(name));
+	if (map && fromMap.length > 0) {
+		const entry = mapBindings(ctx, map, component?.name ?? null, fromMap);
+		if (entry) for (const name of fromMap) {
+			const slot = entry.get(name);
+			if (slot) bindings.set(name, slot);
+		}
+	}
+	const fromProps = names.filter((name) => !mapped.includes(name) && (component?.props.includes(name) ?? false));
+	if (component && fromProps.length > 0) {
+		const call = propBindings(ctx, component.name, fromProps);
+		if (call) for (const [name, slot] of call) bindings.set(name, slot);
+	}
+	return bindings.size > 0 ? bindings : null;
+}
+/** The element's children, each resolved to a writable slot or left as markup. */
+function resolve$1(element, ctx) {
+	const children = jsxChildren(element);
+	const names = children.map((child) => identifierName(child)).filter((name) => name !== null);
+	const bindings = ctx && names.length > 0 ? bindingsFor(ctx, element, names) : null;
+	const parts = [];
+	const slots = [];
+	const take = (slot) => {
+		parts.push({
+			kind: "text",
+			index: slots.length,
+			value: slot.value
+		});
+		slots.push(slot);
+	};
+	for (const child of children) {
+		if (child.type === "JSXText") {
+			if (child.value.trim() !== "") take(literalSlot(child));
+			continue;
+		}
+		const name = identifierName(child);
+		const slot = (name === null ? void 0 : bindings?.get(name)) ?? (ctx ? expressionSlot(child, ctx.source) ?? void 0 : void 0);
+		if (slot) take(slot);
+		else parts.push({
+			kind: "markup",
+			label: labelOf(child)
+		});
+	}
+	return {
+		parts,
+		slots
+	};
+}
+function describe(element, ctx) {
+	const { parts } = resolve$1(element, ctx);
+	const texts = parts.filter((part) => part.kind === "text");
+	if (texts.length === 0) return {
+		editable: false,
+		text: "",
+		parts,
+		reason: parts.some((part) => part.kind === "markup" && part.label === "{…}") ? "text is produced by code — edit whatever feeds it" : "element has no text of its own"
+	};
+	return {
+		editable: true,
+		text: texts.map((part) => part.value).join(" "),
+		parts
+	};
+}
+/**
+* Picks the element an inspector click meant.
+*
+* Coordinates alone are not enough: fallback candidates come from React's
+* `_debugSource`, whose columns drift once the loc-tag transform has widened
+* the line. The rendered text the user is looking at is the tiebreaker — an
+* element only wins if its source text is part of what is on screen.
+*/
+function resolveTextTarget(source, candidates, expected) {
+	const ast = parseSource$1(source);
+	if (!ast) return null;
+	const ctx = {
+		ast,
+		source,
+		shown: expected
+	};
+	const shown = expected ? normalizeText(expected) : null;
+	const matches = (info) => {
+		if (!shown) return true;
+		const runs = info.parts.filter((part) => part.kind === "text");
+		if (runs.length === 0) return false;
+		return runs.every((part) => part.kind === "text" && shown.includes(normalizeText(part.value)));
+	};
+	for (const candidate of candidates) {
+		const exact = findJsxAt(ast, candidate.line, candidate.column);
+		if (exact) {
+			const info = describe(exact, ctx);
+			if (info.editable && matches(info)) return {
+				...info,
+				...candidate
+			};
+		}
+		if (!shown) continue;
+		for (const node of findJsxOnLine(ast, candidate.line, candidate.column)) {
+			const info = describe(node, ctx);
+			const start = node.loc?.start;
+			if (!info.editable || !matches(info) || !start) continue;
+			return {
+				...info,
+				line: start.line,
+				column: start.column
+			};
+		}
+	}
+	const first = candidates[0];
+	if (!first) return null;
+	const clicked = findJsxAt(ast, first.line, first.column);
+	return clicked ? {
+		...describe(clicked, ctx),
+		...first
+	} : null;
+}
+/**
+* Replaces one text run of an element, leaving its markup and every other run
+* untouched. `expected` is the text the caller believes is there; a mismatch
+* means the source moved under us and the write is refused.
+*/
+function replaceTextAt(source, target, text, opts = {}) {
+	const ast = parseSource$1(source);
+	if (!ast) return {
+		ok: false,
+		status: 422,
+		error: "could not parse document source"
+	};
+	const element = findJsxAt(ast, target.line, target.column);
+	if (!element) return {
+		ok: false,
+		status: 404,
+		error: "no element at that source location"
+	};
+	const { slots } = resolve$1(element, {
+		ast,
+		source,
+		shown: opts.shown
+	});
+	if (slots.length === 0) return {
+		ok: false,
+		status: 422,
+		error: "element has no text to replace"
+	};
+	const slot = slots[opts.index ?? 0];
+	if (!slot) return {
+		ok: false,
+		status: 404,
+		error: "no such text run in this element"
+	};
+	if (opts.expected !== void 0 && normalizeText(slot.value) !== normalizeText(opts.expected)) return {
+		ok: false,
+		status: 409,
+		error: "source changed since this was opened — reselect it"
+	};
+	return {
+		ok: true,
+		source: source.slice(0, slot.start) + slot.escape(text) + source.slice(slot.end)
+	};
+}
+//#endregion
+//#region src/vite/routes/edit.ts
+function readLoc(body) {
+	const { docId, line, column } = body;
+	if (typeof docId !== "string") return null;
+	if (typeof line !== "number" || typeof column !== "number") return null;
+	return {
+		docId,
+		line,
+		column
+	};
+}
+function registerEditRoutes(server, ctx) {
+	const entryFor = (docId) => resolveDocEntry(ctx.docsRoot, docId);
+	server.middlewares.use("/__edit", async (req, res, next) => {
+		const url = new URL(req.url ?? "/", "http://local");
+		const method = req.method ?? "GET";
+		try {
+			if (method === "GET" && url.pathname === "/text") {
+				const docId = url.searchParams.get("docId") ?? "";
+				const entry = entryFor(docId);
+				const locs = (url.searchParams.get("locs") ?? "").split(",").map((pair) => pair.split(":").map(Number)).filter(([line, column]) => Number.isFinite(line) && Number.isFinite(column)).map(([line, column]) => ({
+					line,
+					column
+				}));
+				if (!entry || locs.length === 0) return json(res, 400, { error: "invalid target" });
+				const resolved = resolveTextTarget(await fs.readFile(entry, "utf8"), locs, url.searchParams.get("shown") ?? void 0);
+				if (!resolved) return json(res, 404, { error: "element not found" });
+				return json(res, 200, resolved);
+			}
+			if (method === "PUT" && url.pathname === "/text") {
+				const check = validateMutationRequest(req, { requireJsonBody: true });
+				if (!check.ok) return json(res, check.status, { error: check.error });
+				const body = await readBody(req);
+				const loc = readLoc(body);
+				const text = body.text;
+				if (!loc || typeof text !== "string") return json(res, 400, { error: "invalid payload" });
+				const entry = entryFor(loc.docId);
+				if (!entry) return json(res, 404, { error: "document not found" });
+				const source = await fs.readFile(entry, "utf8");
+				const result = replaceTextAt(source, loc, text, {
+					index: typeof body.index === "number" ? body.index : void 0,
+					expected: typeof body.expected === "string" ? body.expected : void 0,
+					shown: typeof body.shown === "string" ? body.shown : void 0
+				});
+				if (!result.ok) return json(res, result.status, { error: result.error });
+				if (result.source !== source) await fs.writeFile(entry, result.source, "utf8");
+				return json(res, 200, { ok: true });
+			}
+			if (method === "POST" && url.pathname === "/comment") {
+				const check = validateMutationRequest(req, { requireJsonBody: true });
+				if (!check.ok) return json(res, check.status, { error: check.error });
+				const body = await readBody(req);
+				const loc = readLoc(body);
+				const note = body.note;
+				if (!loc || typeof note !== "string" || note.trim() === "") return json(res, 400, { error: "invalid payload" });
+				const entry = entryFor(loc.docId);
+				if (!entry) return json(res, 404, { error: "document not found" });
+				const inserted = insertMarker(await fs.readFile(entry, "utf8"), loc, note.trim(), typeof body.hint === "string" ? body.hint : void 0);
+				if (!inserted) return json(res, 422, { error: "cannot anchor a comment here — pick the surrounding element" });
+				await fs.writeFile(entry, inserted.source, "utf8");
+				return json(res, 200, {
+					ok: true,
+					id: inserted.id
+				});
+			}
+			return next();
+		} catch (err) {
+			json(res, 500, { error: String(err.message ?? err) });
+		}
+	});
+	server.middlewares.use("/__comments", async (req, res, next) => {
+		const url = new URL(req.url ?? "/", "http://local");
+		const method = req.method ?? "GET";
+		const docId = url.searchParams.get("docId") ?? "";
+		const entry = entryFor(docId);
+		try {
+			if (method === "GET") {
+				if (!entry) return json(res, 200, { comments: [] });
+				return json(res, 200, { comments: parseMarkers(await fs.readFile(entry, "utf8")) });
+			}
+			if (method === "DELETE") {
+				const check = validateMutationRequest(req);
+				if (!check.ok) return json(res, check.status, { error: check.error });
+				const id = url.searchParams.get("id") ?? "";
+				if (!entry || !/^c-[a-f0-9]+$/.test(id)) return json(res, 400, { error: "invalid id" });
+				const next = removeMarker(await fs.readFile(entry, "utf8"), id);
+				if (next === null) return json(res, 404, { error: "comment not found" });
+				await fs.writeFile(entry, next, "utf8");
+				return json(res, 200, { ok: true });
+			}
+			return next();
+		} catch (err) {
+			json(res, 500, { error: String(err.message ?? err) });
+		}
+	});
+}
+//#endregion
+//#region src/vite/routes/folders.ts
+function registerFolderRoutes(server, ctx) {
+	server.middlewares.use("/__folders", async (req, res, next) => {
+		const url = new URL(req.url ?? "/", "http://local");
+		const method = req.method ?? "GET";
+		try {
+			if (method === "GET" && url.pathname === "/") return json(res, 200, await readManifest(ctx.manifestPath));
+			if (method === "POST" && url.pathname === "/") {
+				const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				const body = await readBody(req);
+				const name = validateName(body.name);
+				if (!name) return json(res, 400, { error: "invalid name" });
+				const icon = validateIcon(body.icon);
+				if (!icon) return json(res, 400, { error: "invalid icon" });
+				const manifest = await readManifest(ctx.manifestPath);
+				const folder = {
+					id: newFolderId(),
+					name,
+					icon
+				};
+				manifest.folders.push(folder);
+				await writeManifest(ctx.manifestPath, manifest);
+				return json(res, 200, folder);
+			}
+			if (method === "PUT" && url.pathname === "/assign") {
+				const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				const body = await readBody(req);
+				if (typeof body.docId !== "string" || !DOC_ID_RE.test(body.docId)) return json(res, 400, { error: "invalid docId" });
+				const docId = body.docId;
+				let folderId;
+				if (body.folderId === null) folderId = null;
+				else if (typeof body.folderId === "string" && FOLDER_ID_RE.test(body.folderId)) folderId = body.folderId;
+				else return json(res, 400, { error: "invalid folderId" });
+				const manifest = await readManifest(ctx.manifestPath);
+				if (folderId && !manifest.folders.some((f) => f.id === folderId)) return json(res, 404, { error: "folder not found" });
+				if (folderId === null) delete manifest.assignments[docId];
+				else manifest.assignments[docId] = folderId;
+				await writeManifest(ctx.manifestPath, manifest);
+				return json(res, 200, { ok: true });
+			}
+			if (method === "PUT" && url.pathname === "/reorder") {
+				const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				const body = await readBody(req);
+				const manifest = await readManifest(ctx.manifestPath);
+				const ids = validateReorder(body.ids, manifest.folders);
+				if (!ids) return json(res, 400, { error: "invalid ids" });
+				const byId = new Map(manifest.folders.map((f) => [f.id, f]));
+				manifest.folders = ids.map((id) => byId.get(id));
+				await writeManifest(ctx.manifestPath, manifest);
+				return json(res, 200, { ok: true });
+			}
+			const idMatch = url.pathname.match(/^\/([^/]+)$/);
+			if (idMatch) {
+				const id = idMatch[1];
+				if (!FOLDER_ID_RE.test(id)) return json(res, 400, { error: "invalid id" });
+				if (method === "PATCH") {
+					const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+					if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+					const body = await readBody(req);
+					const manifest = await readManifest(ctx.manifestPath);
+					const folder = manifest.folders.find((f) => f.id === id);
+					if (!folder) return json(res, 404, { error: "folder not found" });
+					if (body.name !== void 0) {
+						const name = validateName(body.name);
+						if (!name) return json(res, 400, { error: "invalid name" });
+						folder.name = name;
+					}
+					if (body.icon !== void 0) {
+						const icon = validateIcon(body.icon);
+						if (!icon) return json(res, 400, { error: "invalid icon" });
+						folder.icon = icon;
+					}
+					await writeManifest(ctx.manifestPath, manifest);
+					return json(res, 200, folder);
+				}
+				if (method === "DELETE") {
+					const requestCheck = validateMutationRequest(req);
+					if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+					const manifest = await readManifest(ctx.manifestPath);
+					const before = manifest.folders.length;
+					manifest.folders = manifest.folders.filter((f) => f.id !== id);
+					if (manifest.folders.length === before) return json(res, 404, { error: "folder not found" });
+					for (const [docId, folderId] of Object.entries(manifest.assignments)) if (folderId === id) delete manifest.assignments[docId];
+					await writeManifest(ctx.manifestPath, manifest);
+					return json(res, 200, { ok: true });
+				}
+			}
+			next();
+		} catch (err) {
+			json(res, 500, { error: String(err.message ?? err) });
+		}
+	});
+}
+//#endregion
+//#region src/vite/api-plugin.ts
+function apiPlugin(opts) {
+	return {
+		name: "mosage:api",
+		apply: "serve",
+		configureServer(server) {
+			const ctx = makeContext(opts);
+			registerAssetRoutes(server, ctx);
+			registerFolderRoutes(server, ctx);
+			registerDocRoutes(server, ctx);
+			registerEditRoutes(server, ctx);
+		}
+	};
+}
+//#endregion
+//#region src/vite/current-plugin.ts
+const TEXT_SNIPPET_MAX = 120;
+function parseSelection(raw) {
+	if (raw == null || typeof raw !== "object") return null;
+	const sel = raw;
+	if (typeof sel.line !== "number" || !Number.isFinite(sel.line)) return null;
+	if (typeof sel.column !== "number" || !Number.isFinite(sel.column)) return null;
+	const tagName = typeof sel.tagName === "string" ? sel.tagName.toLowerCase().slice(0, 32) : "unknown";
+	const text = typeof sel.text === "string" ? sel.text.replace(/\s+/g, " ").trim().slice(0, TEXT_SNIPPET_MAX) : "";
+	return {
+		line: Math.max(1, Math.floor(sel.line)),
+		column: Math.max(0, Math.floor(sel.column)),
+		tagName,
+		text
+	};
+}
+/**
+* Writes `node_modules/.mosage/current.json` whenever the viewer navigates or
+* the inspector picks an element, so an agent can resolve "this page" without
+* asking. Dev only — a static build has no cursor to report.
+*/
+function currentPlugin(opts) {
+	const userCwd = opts.userCwd;
+	const docsDir = opts.docsDir ?? "docs";
+	const outDir = path.join(userCwd, "node_modules", ".mosage");
+	const outFile = path.join(outDir, "current.json");
+	const tmpFile = `${outFile}.tmp`;
+	let cached = null;
+	return {
+		name: "mosage:current",
+		apply: "serve",
+		configureServer(server) {
+			server.ws.on("mosage:current", async (raw) => {
+				const next = cached ? { ...cached } : {
+					docId: "",
+					pageIndex: 0,
+					pageNumber: 1,
+					totalPages: 1,
+					docTitle: "",
+					pagePath: "",
+					selection: null
+				};
+				if (typeof raw?.docId === "string") {
+					if (!DOC_ID_RE.test(raw.docId)) return;
+					const totalPages = typeof raw.totalPages === "number" && Number.isFinite(raw.totalPages) && raw.totalPages > 0 ? Math.floor(raw.totalPages) : 1;
+					const rawIndex = typeof raw.pageIndex === "number" && Number.isFinite(raw.pageIndex) ? Math.floor(raw.pageIndex) : 0;
+					const pageIndex = Math.max(0, Math.min(totalPages - 1, rawIndex));
+					const docTitle = typeof raw.docTitle === "string" ? raw.docTitle : raw.docId;
+					const pagePath = path.join(docsDir, raw.docId, "index.tsx").split(path.sep).join("/");
+					if (cached?.docId !== raw.docId || cached?.pageIndex !== pageIndex) next.selection = null;
+					next.docId = raw.docId;
+					next.pageIndex = pageIndex;
+					next.pageNumber = pageIndex + 1;
+					next.totalPages = totalPages;
+					next.docTitle = docTitle;
+					next.pagePath = pagePath;
+				}
+				if ("selection" in raw) next.selection = parseSelection(raw.selection);
+				if (!next.docId) return;
+				cached = next;
+				const body = {
+					...next,
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				try {
+					await fs.mkdir(outDir, { recursive: true });
+					await fs.writeFile(tmpFile, `${JSON.stringify(body, null, 2)}\n`, "utf8");
+					await fs.rename(tmpFile, outFile);
+				} catch {}
+			});
+		}
+	};
+}
+//#endregion
+//#region src/vite/data-plugin.ts
+const DATA_RE = /\.(csv|tsv)$/i;
+/**
+* Makes `import rows from './data/q3.csv'` an array of objects at build time.
+*
+* Fetching data at render time is not an option here: the flow packer measures
+* the real DOM to decide where pages break, and both exporters serialize what
+* is on screen. Data that arrives a tick later arrives after the layout is
+* already decided. Resolving it as a module keeps a table's numbers as
+* synchronous as the prose around them, in the dev server and in a static build
+* alike.
+*
+* `?raw` and `?url` are left to Vite.
+*/
+function dataPlugin() {
+	return {
+		name: "mosage:data",
+		enforce: "pre",
+		async load(id) {
+			const [file, query] = id.split("?");
+			if (query !== void 0) return null;
+			if (!DATA_RE.test(file)) return null;
+			let text;
+			try {
+				text = await fs.readFile(file, "utf8");
+			} catch {
+				return null;
+			}
+			const table = parseDelimited(text, { delimiter: /\.tsv$/i.test(file) ? "	" : "," });
+			return [
+				`export const columns = ${JSON.stringify(table.columns)};`,
+				`export const rows = ${JSON.stringify(table.rows)};`,
+				"export default rows;"
+			].join("\n");
+		}
+	};
+}
+//#endregion
+//#region src/vite/design-plugin.ts
+function parseSource(source) {
+	try {
+		return parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"],
+			errorRecovery: true
+		});
+	} catch {
+		return null;
+	}
+}
+function programBody(ast) {
+	return ast.program?.body ?? [];
+}
+function designObjectOf(node) {
+	let varDecl = null;
+	if (node.type === "VariableDeclaration") varDecl = node;
+	else if (node.type === "ExportNamedDeclaration") {
+		const decl = node.declaration;
+		if (decl?.type === "VariableDeclaration") varDecl = decl;
+	}
+	if (!varDecl) return null;
+	const declarations = varDecl.declarations ?? [];
+	for (const d of declarations) {
+		const id = d.id;
+		if (id?.type !== "Identifier" || id.name !== "design") continue;
+		const init = d.init;
+		if (!init) return "unsupported";
+		let inner = init;
+		if (inner.type === "TSSatisfiesExpression" || inner.type === "TSAsExpression") {
+			const expr = inner.expression;
+			if (expr) inner = expr;
+		}
+		if (inner.type !== "ObjectExpression") return "unsupported";
+		return {
+			decl: node,
+			object: inner
+		};
+	}
+	return null;
+}
+function findDesign(ast) {
+	for (const node of programBody(ast)) {
+		const hit = designObjectOf(node);
+		if (hit === null) continue;
+		if (hit === "unsupported") return null;
+		return {
+			loc: {
+				declStart: hit.decl.start,
+				declEnd: hit.decl.end,
+				objectStart: hit.object.start,
+				objectEnd: hit.object.end
+			},
+			object: hit.object
+		};
+	}
+	return null;
+}
+function literalToValue(node) {
+	switch (node.type) {
+		case "StringLiteral": return node.value;
+		case "NumericLiteral": return node.value;
+		case "BooleanLiteral": return node.value;
+		case "NullLiteral": return null;
+		case "UnaryExpression": {
+			const op = node.operator;
+			const arg = node.argument;
+			const v = literalToValue(arg);
+			if (op === "-" && typeof v === "number") return -v;
+			if (op === "+" && typeof v === "number") return v;
+			throw new Error(`unsupported unary operator ${op}`);
+		}
+		case "TemplateLiteral": {
+			const quasis = node.quasis;
+			if (node.expressions.length > 0) throw new Error("template literal has expressions");
+			const value = quasis[0].value;
+			return value.cooked ?? value.raw;
+		}
+		case "ObjectExpression": {
+			const properties = node.properties;
+			const out = {};
+			for (const prop of properties) {
+				if (prop.type !== "ObjectProperty") throw new Error("object has spread or method");
+				const p = prop;
+				if (p.computed) throw new Error("object has computed key");
+				let key;
+				if (p.key.type === "Identifier" && typeof p.key.name === "string") key = p.key.name;
+				else if (p.key.type === "StringLiteral" && typeof p.key.value === "string") key = p.key.value;
+				else throw new Error("unsupported object key");
+				out[key] = literalToValue(p.value);
+			}
+			return out;
+		}
+		default: throw new Error(`unsupported node type ${node.type}`);
+	}
+}
+function isPlainObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function mergeDesign(base, patch) {
+	const out = JSON.parse(JSON.stringify(base));
+	const apply = (target, src) => {
+		for (const [k, v] of Object.entries(src)) if (isPlainObject(v) && isPlainObject(target[k])) apply(target[k], v);
+		else target[k] = v;
+	};
+	if (isPlainObject(patch)) apply(out, patch);
+	return out;
+}
+function indent(level) {
+	return "  ".repeat(level);
+}
+function jsString(s) {
+	return `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n")}'`;
+}
+function isValidIdentifier(name) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+}
+function serializeValue(value, level) {
+	if (value === null) return "null";
+	if (typeof value === "string") return jsString(value);
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error("non-finite number");
+		return String(value);
+	}
+	if (typeof value === "boolean") return value ? "true" : "false";
+	if (isPlainObject(value)) {
+		const entries = Object.entries(value);
+		if (entries.length === 0) return "{}";
+		const childIndent = indent(level + 1);
+		return `{\n${entries.map(([k, v]) => {
+			const key = isValidIdentifier(k) ? k : jsString(k);
+			return `${childIndent}${key}: ${serializeValue(v, level + 1)},`;
+		}).join("\n")}\n${indent(level)}}`;
+	}
+	throw new Error(`unsupported value type ${typeof value}`);
+}
+function serializeDesign(design) {
+	return serializeValue(design, 0);
+}
+function parseDocDesign(source) {
+	const ast = parseSource(source);
+	if (!ast) return {
+		ok: false,
+		exists: true,
+		error: "could not parse document source"
+	};
+	const found = findDesign(ast);
+	if (!found) {
+		if (programBody(ast).some((node) => designObjectOf(node) !== null)) return {
+			ok: false,
+			exists: true,
+			error: "design has an unsupported initializer"
+		};
+		return {
+			ok: false,
+			exists: false
+		};
+	}
+	let value;
+	try {
+		value = literalToValue(found.object);
+	} catch (err) {
+		return {
+			ok: false,
+			exists: true,
+			error: err.message
+		};
+	}
+	return {
+		ok: true,
+		design: mergeDesign(defaultDesign, value),
+		loc: found.loc
+	};
+}
+function findImports(ast) {
+	const out = [];
+	for (const node of programBody(ast)) {
+		if (node.type !== "ImportDeclaration") continue;
+		const src = node.source?.value;
+		if (typeof src !== "string") continue;
+		out.push({
+			node,
+			source: src,
+			specifiers: node.specifiers ?? []
+		});
+	}
+	return out;
+}
+function ensureDesignSystemImport(source, ast) {
+	const imports = findImports(ast);
+	const coreImport = imports.find((imp) => imp.source === "mosage");
+	if (coreImport) {
+		if (coreImport.specifiers.some((spec) => {
+			if (spec.type !== "ImportSpecifier") return false;
+			return spec.imported?.name === "DesignSystem";
+		})) return source;
+		const node = coreImport.node;
+		const braceClose = source.slice(node.start, node.end).lastIndexOf("}");
+		if (braceClose === -1) return source;
+		const absoluteBrace = node.start + braceClose;
+		const insertText = coreImport.specifiers.length > 0 ? ", type DesignSystem" : "type DesignSystem";
+		return source.slice(0, absoluteBrace) + insertText + source.slice(absoluteBrace);
+	}
+	const stmt = `import type { DesignSystem } from 'mosage';\n`;
+	if (imports.length > 0) {
+		const insertAt = imports[imports.length - 1].node.end;
+		const trail = source[insertAt] === "\n" ? "" : "\n";
+		return `${source.slice(0, insertAt)}\n${stmt.slice(0, -1)}${trail}${source.slice(insertAt)}`;
+	}
+	return `${stmt}\n${source}`;
+}
+function findInsertionPoint(source, ast) {
+	const imports = findImports(ast);
+	if (imports.length === 0) return 0;
+	let off = imports[imports.length - 1].node.end;
+	while (off < source.length && source[off] !== "\n") off++;
+	if (off < source.length) off++;
+	return off;
+}
+function applyDesignWrite(source, next) {
+	let body;
+	try {
+		body = serializeDesign(next);
+	} catch (err) {
+		return {
+			ok: false,
+			status: 422,
+			error: `serialize failed: ${err.message}`
+		};
+	}
+	const ast = parseSource(source);
+	if (!ast) return {
+		ok: false,
+		status: 422,
+		error: "could not parse document source"
+	};
+	const found = findDesign(ast);
+	if (found) return {
+		ok: true,
+		source: source.slice(0, found.loc.objectStart) + body + source.slice(found.loc.objectEnd),
+		created: false
+	};
+	const withImport = ensureDesignSystemImport(source, ast);
+	const ast2 = parseSource(withImport);
+	if (!ast2) return {
+		ok: false,
+		status: 422,
+		error: "failed to re-parse after adding import"
+	};
+	const insertAt = findInsertionPoint(withImport, ast2);
+	const block = `\nexport const design: DesignSystem = ${body};\n`;
+	return {
+		ok: true,
+		source: withImport.slice(0, insertAt) + block + withImport.slice(insertAt),
+		created: true
+	};
+}
+function designPlugin(opts) {
+	const userCwd = opts.userCwd;
+	const docsDir = opts.docsDir ?? "docs";
+	return {
+		name: "mosage:design",
+		apply: "serve",
+		configureServer(server) {
+			server.middlewares.use("/__design", async (req, res, next) => {
+				const url = new URL(req.url ?? "/", "http://local");
+				const method = req.method ?? "GET";
+				const docId = url.searchParams.get("docId") ?? "";
+				const file = resolveDocPath(userCwd, docsDir, docId);
+				if (!file) return json(res, 400, { error: "invalid docId" });
+				try {
+					if (method === "GET" && url.pathname === "/") {
+						let source;
+						try {
+							source = await fs.readFile(file, "utf8");
+						} catch {
+							return json(res, 404, { error: "document not found" });
+						}
+						const parsed = parseDocDesign(source);
+						if (parsed.ok) return json(res, 200, {
+							design: parsed.design,
+							exists: true,
+							warning: null
+						});
+						if (parsed.exists === false) return json(res, 200, {
+							design: defaultDesign,
+							exists: false,
+							warning: null
+						});
+						return json(res, 200, {
+							design: defaultDesign,
+							exists: true,
+							warning: parsed.error
+						});
+					}
+					if (method === "PUT" && url.pathname === "/") {
+						const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+						if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+						const patch = (await readBody(req)).patch;
+						if (!patch || typeof patch !== "object") return json(res, 400, { error: "missing patch object" });
+						let source;
+						try {
+							source = await fs.readFile(file, "utf8");
+						} catch {
+							return json(res, 404, { error: "document not found" });
+						}
+						const parsed = parseDocDesign(source);
+						if (!parsed.ok && parsed.exists) return json(res, 422, { error: parsed.error });
+						const merged = mergeDesign(parsed.ok ? parsed.design : defaultDesign, patch);
+						const written = applyDesignWrite(source, merged);
+						if (!written.ok) return json(res, written.status, { error: written.error });
+						if (written.source !== source) await fs.writeFile(file, written.source, "utf8");
+						return json(res, 200, {
+							ok: true,
+							design: merged,
+							created: written.created
+						});
+					}
+					if (method === "POST" && url.pathname === "/reset") {
+						const requestCheck = validateMutationRequest(req);
+						if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+						let source;
+						try {
+							source = await fs.readFile(file, "utf8");
+						} catch {
+							return json(res, 404, { error: "document not found" });
+						}
+						const written = applyDesignWrite(source, defaultDesign);
+						if (!written.ok) return json(res, written.status, { error: written.error });
+						if (written.source !== source) await fs.writeFile(file, written.source, "utf8");
+						return json(res, 200, {
+							ok: true,
+							design: defaultDesign,
+							created: written.created
+						});
+					}
+					return next();
+				} catch (err) {
+					json(res, 500, { error: String(err.message ?? err) });
+				}
+			});
+		}
+	};
+}
+//#endregion
+//#region src/vite/diagram-plugin.ts
+const DIAGRAM_RE = /\.(mmd|mermaid)$/i;
+/**
+* Makes `import chart from './architecture.mmd'` a themed SVG at build time.
+*
+* The same rule as `data-plugin` applies, and for the same reason: the flow
+* packer measures the real DOM to decide where pages break, so a drawing that
+* renders a tick later renders after the layout is decided. Compiling in the
+* plugin also means no diagram library reaches the browser bundle — the SVG
+* arrives as text, already sized.
+*
+* `?raw` and `?url` are left to Vite.
+*/
+function diagramPlugin() {
+	return {
+		name: "mosage:diagram",
+		enforce: "pre",
+		async load(id) {
+			const [file, query] = id.split("?");
+			if (query !== void 0) return null;
+			if (!DIAGRAM_RE.test(file)) return null;
+			let text;
+			try {
+				text = await fs.readFile(file, "utf8");
+			} catch {
+				return null;
+			}
+			try {
+				const suffix = path.basename(file).replace(/[^a-zA-Z0-9]/g, "");
+				const compiled = compileDiagram(text, { idSuffix: suffix });
+				return [
+					`export const svg = ${JSON.stringify(compiled.svg)};`,
+					`export const width = ${compiled.width};`,
+					`export const height = ${compiled.height};`,
+					"export default { svg, width, height };"
+				].join("\n");
+			} catch (err) {
+				if (err instanceof DiagramSyntaxError) this.error(`${path.relative(process.cwd(), file)}: ${err.message}`);
+				throw err;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/vite/loc-tags-plugin.ts
+const FORWARDING_COMPONENTS = /* @__PURE__ */ new Set(["ImagePlaceholder"]);
+function taggableName(opening) {
+	const name = opening.name;
+	if (name?.type !== "JSXIdentifier" || typeof name.name !== "string") return null;
+	if (/^[a-z]/.test(name.name) || FORWARDING_COMPONENTS.has(name.name)) return name.name;
+	return null;
+}
+function alreadyTagged(opening) {
+	return (opening.attributes ?? []).some((attr) => {
+		if (attr.type !== "JSXAttribute") return false;
+		return attr.name?.name === "data-od-loc";
+	});
+}
+function injectLocTags(code) {
+	const ast = parseSource$1(code);
+	if (!ast) return null;
+	const insertions = [];
+	walkJsx(ast, (node) => {
+		const opening = node.openingElement;
+		if (!opening || !node.loc) return;
+		if (!taggableName(opening) || alreadyTagged(opening)) return;
+		const nameNode = opening.name;
+		insertions.push({
+			offset: nameNode.end,
+			text: ` data-od-loc="${node.loc.start.line}:${node.loc.start.column}"`
+		});
+	});
+	if (insertions.length === 0) return null;
+	insertions.sort((a, b) => b.offset - a.offset);
+	let next = code;
+	for (const insertion of insertions) next = next.slice(0, insertion.offset) + insertion.text + next.slice(insertion.offset);
+	return next;
+}
+function isDocSourceFile(id, docsRootPosix) {
+	const filePath = id.split(/[?#]/)[0].replace(/\\/g, "/");
+	if (!filePath.startsWith(`${docsRootPosix}/`)) return false;
+	if (!filePath.endsWith(".tsx")) return false;
+	if (filePath.endsWith(".d.ts") || filePath.endsWith(".test.tsx")) return false;
+	return filePath.slice(docsRootPosix.length + 1).includes("/");
+}
+function locTagsPlugin(opts) {
+	const docsRoot = path.resolve(opts.userCwd, opts.docsDir ?? "docs").replace(/\\/g, "/");
+	return {
+		name: "mosage:loc-tags",
+		apply: "serve",
+		enforce: "pre",
+		transform(code, id) {
+			if (!isDocSourceFile(id, docsRoot)) return null;
+			const next = injectLocTags(code);
+			return next === null ? null : {
+				code: next,
+				map: null
+			};
+		}
+	};
+}
+//#endregion
+//#region src/vite/themes-plugin.ts
+const THEMES_VMOD = "virtual:mosage/themes";
+function resolved(id) {
+	return `\0${id}`;
+}
+const FM_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+function parseFrontmatter(raw, themeId) {
+	const match = raw.match(FM_RE);
+	const fmText = match ? match[1] : "";
+	const body = match ? match[2] : raw;
+	const data = {};
+	for (const line of fmText.split(/\r?\n/)) {
+		const m = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
+		if (!m) continue;
+		let value = m[2].trim();
+		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		data[m[1]] = value;
+	}
+	return {
+		fm: {
+			name: data.name || themeId,
+			description: data.description || "",
+			pageSize: data.pageSize || "",
+			mode: data.mode || ""
+		},
+		body: body.trim()
+	};
+}
+async function findThemes(userCwd, themesDir) {
+	const abs = path.resolve(userCwd, themesDir);
+	if (!existsSync(abs)) return [];
+	return (await fg("*.md", {
+		cwd: abs,
+		absolute: true,
+		onlyFiles: true
+	})).sort();
+}
+async function readTheme(mdAbs, themesRoot) {
+	const id = path.basename(mdAbs, ".md");
+	const { fm, body } = parseFrontmatter(await fs.readFile(mdAbs, "utf8"), id);
+	let demoAbs = null;
+	for (const cand of [
+		`${id}.demo.tsx`,
+		`${id}.demo.jsx`,
+		`${id}.demo.ts`,
+		`${id}.demo.js`
+	]) {
+		const p = path.join(themesRoot, cand);
+		if (existsSync(p)) {
+			demoAbs = p;
+			break;
+		}
+	}
+	return {
+		id,
+		frontmatter: fm,
+		body,
+		demoAbs
+	};
+}
+function generateThemesModule(themes, isDev) {
+	const meta = themes.map((t) => ({
+		id: t.id,
+		name: t.frontmatter.name,
+		description: t.frontmatter.description,
+		pageSize: t.frontmatter.pageSize,
+		mode: t.frontmatter.mode,
+		body: t.body,
+		hasDemo: t.demoAbs !== null
+	}));
+	const cases = themes.flatMap((t) => {
+		const abs = t.demoAbs;
+		if (!abs) return [];
+		const importPath = isDev ? `@fs/${normalizePath(abs).replace(/^\/+/, "")}` : abs;
+		const importExpr = isDev ? `import(/* @vite-ignore */ import.meta.env.BASE_URL + ${JSON.stringify(importPath)})` : `import(${JSON.stringify(importPath)})`;
+		return [`    case ${JSON.stringify(t.id)}: return ${importExpr};`];
+	}).join("\n");
+	return `// virtual:mosage/themes — generated
+export const themes = ${JSON.stringify(meta)};
+
+export async function loadThemeDemo(id) {
+  switch (id) {
+${cases}
+    default: throw new Error('Theme demo not found: ' + id);
+  }
+}
+`;
+}
+function themesPlugin(opts) {
+	const { userCwd, config } = opts;
+	const themesDir = config.themesDir ?? "themes";
+	const themesRoot = path.resolve(userCwd, themesDir);
+	let isDev = false;
+	return {
+		name: "mosage:themes",
+		config(_c, env) {
+			isDev = env.command === "serve";
+		},
+		resolveId(id) {
+			if (id === THEMES_VMOD) return resolved(THEMES_VMOD);
+			return null;
+		},
+		async load(id) {
+			if (id !== resolved(THEMES_VMOD)) return null;
+			const files = await findThemes(userCwd, themesDir);
+			return generateThemesModule(await Promise.all(files.map((f) => readTheme(f, themesRoot))), isDev);
+		},
+		configureServer(server) {
+			const isThemeFile = (p) => {
+				const rel = path.relative(themesRoot, p);
+				if (rel.startsWith("..") || path.isAbsolute(rel)) return false;
+				if (rel.includes(path.sep)) return false;
+				return /\.(md|demo\.(tsx|jsx|ts|js))$/.test(rel);
+			};
+			let reloadTimer = null;
+			const reload = () => {
+				if (reloadTimer) clearTimeout(reloadTimer);
+				reloadTimer = setTimeout(() => {
+					reloadTimer = null;
+					const mod = server.moduleGraph.getModuleById(resolved(THEMES_VMOD));
+					if (mod) server.moduleGraph.invalidateModule(mod);
+					server.ws.send({ type: "full-reload" });
+				}, 150);
+			};
+			server.watcher.add(themesRoot);
+			for (const event of [
+				"add",
+				"unlink",
+				"change"
+			]) server.watcher.on(event, (p) => {
+				if (isThemeFile(p)) reload();
+			});
+		}
+	};
+}
+//#endregion
+//#region src/vite/config.ts
+function findPackageRoot(fromFile) {
+	let dir = path.dirname(fromFile);
+	while (dir !== path.dirname(dir)) {
+		if (existsSync(path.join(dir, "package.json"))) return dir;
+		dir = path.dirname(dir);
+	}
+	throw new Error(`Could not find package.json walking up from ${fromFile}`);
+}
+const PKG_ROOT = findPackageRoot(fileURLToPath(import.meta.url));
+const APP_ROOT = path.join(PKG_ROOT, "src", "app");
+function readCoreVersion() {
+	try {
+		const raw = readFileSync(path.join(PKG_ROOT, "package.json"), "utf8");
+		return JSON.parse(raw).version ?? "0.0.0";
+	} catch {
+		return "0.0.0";
+	}
+}
+const CORE_VERSION = readCoreVersion();
+async function createViteConfig(opts) {
+	const userCwd = path.resolve(opts.userCwd);
+	const config = opts.config ?? await loadUserConfig(userCwd);
+	const docsDir = config.docsDir ?? "docs";
+	const assetsDir = config.assetsDir ?? "assets";
+	const docsAbs = path.resolve(userCwd, docsDir);
+	const themesAbs = path.resolve(userCwd, config.themesDir ?? "themes");
+	const assetsAbs = path.resolve(userCwd, assetsDir);
+	return {
+		base: config.base ?? "/",
+		root: APP_ROOT,
+		configFile: false,
+		envDir: userCwd,
+		plugins: [
+			dataPlugin(),
+			diagramPlugin(),
+			locTagsPlugin({
+				userCwd,
+				docsDir
+			}),
+			react(),
+			tailwindcss(),
+			mosagePlugin({
+				userCwd,
+				config,
+				coreVersion: CORE_VERSION
+			}),
+			themesPlugin({
+				userCwd,
+				config
+			}),
+			designPlugin({
+				userCwd,
+				docsDir
+			}),
+			apiPlugin({
+				userCwd,
+				docsDir,
+				assetsDir,
+				coreVersion: CORE_VERSION
+			}),
+			...opts.headless ? [] : [currentPlugin({
+				userCwd,
+				docsDir
+			})]
+		],
+		resolve: { alias: {
+			"@": APP_ROOT,
+			"@assets": assetsAbs
+		} },
+		optimizeDeps: {
+			entries: [path.join(APP_ROOT, "main.tsx")],
+			include: [
+				"react",
+				"react-dom",
+				"react-dom/client",
+				"react-router-dom",
+				"next-themes",
+				"lucide-react",
+				"clsx",
+				"tailwind-merge"
+			],
+			esbuildOptions: { plugins: [{
+				name: "mosage:virtual-externals",
+				setup(build) {
+					build.onResolve({ filter: /^virtual:mosage\// }, (args) => ({
+						path: args.path,
+						external: true
+					}));
+				}
+			}] }
+		},
+		server: {
+			port: config.port ?? 5273,
+			...config.allowedHosts !== void 0 ? { allowedHosts: config.allowedHosts } : {},
+			fs: { allow: [
+				APP_ROOT,
+				userCwd,
+				docsAbs,
+				themesAbs,
+				assetsAbs
+			] }
+		},
+		build: {
+			outDir: path.resolve(userCwd, "dist"),
+			emptyOutDir: true
+		}
+	};
+}
+//#endregion
+export { resolveEntry as a, DOC_ID_RE as c, listDocIds as i, loadUserConfig as l, OpsError as n, makeContext as o, createDocument as r, validateAssetName as s, createViteConfig as t, mosagePlugin as u };