@autono/open-pages 0.8.0 → 0.9.0

package/dist/{config-D_U_aCQz.js → config-CYLBzMMb.js}

@@ -1,18 +1,278 @@
-import { n as PKG_ROOT, r as readCoreVersion, t as APP_ROOT } from "./version-DZrXLoAD.js";
 import { n as defaultDesign } from "./design-Cpqx7SJs.js";
 import { c as localOpenPagesCommand, i as formatCommand, l as runCommand, n as detectPackageManager, o as invalidateLatestCache, r as fetchLatest, s as isOutdated, u as updateCommandFor } from "./update-package-GaNsVdr8.js";
-import { a as openPagesPlugin, c as resolvePageEntry, d as validatePageName, i as loadUserConfig, l as rmPageDir, o as PAGE_ID_RE, r as invalidatePagesModule, s as duplicatePageDir, u as updateMetaTitleInSource } from "./open-pages-plugin-C8cFhMB9.js";
+import { createRequire } from "node:module";
 import path from "node:path";
-import { existsSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import fs from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import tailwindcss from "@tailwindcss/vite";
 import react from "@vitejs/plugin-react";
-import { normalizePath, searchForWorkspaceRoot } from "vite";
+import { loadConfigFromFile, normalizePath, searchForWorkspaceRoot } from "vite";
 import { parse } from "@babel/parser";
 import * as t from "@babel/types";
 import { isJSXElement, isJSXFragment } from "@babel/types";
 import fg from "fast-glob";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/editing/page-ops.ts
+const PAGE_ID_RE = /^[a-z0-9_-]+$/i;
+function validatePageName(v) {
+	if (typeof v !== "string") return null;
+	const trimmed = v.trim();
+	if (trimmed.length < 1 || trimmed.length > 80) return null;
+	return trimmed;
+}
+function unwrapExpression(node) {
+	let current = node;
+	while (current && (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression")) current = current.expression;
+	return current;
+}
+function readMetaTitleInSource(source) {
+	let ast;
+	try {
+		ast = parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"],
+			errorRecovery: true
+		});
+	} catch {
+		return { kind: "unsupported" };
+	}
+	const body = ast.program?.body ?? [];
+	for (const stmt of body) {
+		if (stmt.type !== "ExportNamedDeclaration") continue;
+		const decl = stmt.declaration;
+		if (!decl || decl.type !== "VariableDeclaration") continue;
+		const declarations = decl.declarations ?? [];
+		for (const d of declarations) {
+			const id = d.id;
+			if (!id || id.type !== "Identifier" || id.name !== "meta") continue;
+			const init = unwrapExpression(d.init);
+			if (!init || init.type !== "ObjectExpression") return { kind: "unsupported" };
+			const properties = init.properties ?? [];
+			for (const property of properties) {
+				if (property.type !== "ObjectProperty" || property.computed) continue;
+				const key = property.key;
+				if ((key?.type === "Identifier" ? key.name : key?.type === "StringLiteral" ? key.value : void 0) !== "title") continue;
+				const value = property.value;
+				if (value?.type === "StringLiteral" && typeof value.value === "string") return {
+					kind: "found",
+					title: value.value
+				};
+				if (value?.type === "TemplateLiteral") {
+					const expressions = value.expressions ?? [];
+					const firstValue = (value.quasis ?? [])[0]?.value;
+					const cooked = firstValue?.cooked;
+					const raw = firstValue?.raw;
+					if (expressions.length === 0 && typeof (cooked ?? raw) === "string") return {
+						kind: "found",
+						title: cooked ?? raw
+					};
+				}
+				return { kind: "unsupported" };
+			}
+			return { kind: "missing" };
+		}
+	}
+	return { kind: "missing" };
+}
+async function rmPageDir(pagesRoot, pageId) {
+	if (!PAGE_ID_RE.test(pageId)) return false;
+	const dir = path.resolve(pagesRoot, pageId);
+	if (!dir.startsWith(pagesRoot + path.sep)) return false;
+	try {
+		await fs.rm(dir, {
+			recursive: true,
+			force: true
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function duplicatePageDir(pagesRoot, pageId, desiredId) {
+	if (!PAGE_ID_RE.test(pageId)) return {
+		ok: false,
+		status: 400,
+		error: "invalid pageId"
+	};
+	const root = path.resolve(pagesRoot);
+	const srcDir = path.resolve(root, pageId);
+	if (!srcDir.startsWith(root + path.sep)) return {
+		ok: false,
+		status: 400,
+		error: "invalid pageId"
+	};
+	try {
+		await fs.access(path.join(srcDir, "index.tsx"));
+	} catch {
+		return {
+			ok: false,
+			status: 404,
+			error: "page not found"
+		};
+	}
+	let newId;
+	if (desiredId !== void 0) {
+		if (!PAGE_ID_RE.test(desiredId)) return {
+			ok: false,
+			status: 400,
+			error: "invalid newId"
+		};
+		newId = desiredId;
+		const dstDir = path.resolve(root, newId);
+		if (!dstDir.startsWith(root + path.sep)) return {
+			ok: false,
+			status: 400,
+			error: "invalid newId"
+		};
+		try {
+			await fs.access(dstDir);
+			return {
+				ok: false,
+				status: 409,
+				error: "page already exists"
+			};
+		} catch {}
+	} else {
+		let suffix = 1;
+		while (true) {
+			newId = suffix === 1 ? `${pageId}-copy` : `${pageId}-copy-${suffix}`;
+			try {
+				await fs.access(path.resolve(root, newId));
+				suffix++;
+			} catch {
+				break;
+			}
+		}
+	}
+	const dstDir = path.resolve(root, newId);
+	if (!dstDir.startsWith(root + path.sep)) return {
+		ok: false,
+		status: 400,
+		error: "invalid newId"
+	};
+	const srcEntry = path.join(srcDir, "index.tsx");
+	let copiedEntrySource;
+	try {
+		const source = await fs.readFile(srcEntry, "utf8");
+		const metaTitle = readMetaTitleInSource(source);
+		if (metaTitle.kind === "unsupported") return {
+			ok: false,
+			status: 422,
+			error: "could not update copied page title"
+		};
+		const updated = updateMetaTitleInSource(source, `${metaTitle.kind === "found" ? metaTitle.title : pageId} (copy)`);
+		if (updated === null) return {
+			ok: false,
+			status: 422,
+			error: "could not update copied page title"
+		};
+		copiedEntrySource = updated;
+	} catch {
+		return {
+			ok: false,
+			status: 404,
+			error: "page not found"
+		};
+	}
+	try {
+		await fs.cp(srcDir, dstDir, {
+			recursive: true,
+			errorOnExist: true,
+			force: false
+		});
+		await fs.writeFile(path.join(dstDir, "index.tsx"), copiedEntrySource, "utf8");
+		return {
+			ok: true,
+			pageId: newId
+		};
+	} catch (err) {
+		if (err.code === "EEXIST") return {
+			ok: false,
+			status: 409,
+			error: "page already exists"
+		};
+		return {
+			ok: false,
+			status: 500,
+			error: String(err.message ?? err)
+		};
+	}
+}
+function resolvePageEntry(pagesRoot, pageId) {
+	if (!PAGE_ID_RE.test(pageId)) return null;
+	const dir = path.resolve(pagesRoot, pageId);
+	if (!dir.startsWith(pagesRoot + path.sep)) return null;
+	return path.join(dir, "index.tsx");
+}
+function escapeSingleQuoted(s) {
+	return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+/**
+* Rewrite (or insert) the `title` field in the page module's `export const meta`.
+*
+* Strategy:
+*   1. Find `export const meta` and brace-match its object literal.
+*   2. If the object already has a `title: '...'` entry, replace the literal.
+*   3. If the object exists but has no title, inject a new `title: '...'` line
+*      as the first property (preserving the author's surrounding indentation).
+*   4. If there is no `meta` export at all, insert a fresh one right before
+*      `export default`.
+*
+* Returns the rewritten source, or `null` if the file shape was too surprising
+* to touch safely (e.g. `export default` missing when we'd need to inject meta).
+*/
+function updateMetaTitleInSource(source, title) {
+	const newLiteral = `'${escapeSingleQuoted(title)}'`;
+	const metaStart = source.search(/export\s+const\s+meta\b/);
+	if (metaStart !== -1) {
+		const eqIdx = source.indexOf("=", metaStart);
+		if (eqIdx === -1) return null;
+		const openBrace = source.indexOf("{", eqIdx);
+		if (openBrace === -1) return null;
+		let depth = 0;
+		let closeBrace = -1;
+		for (let i = openBrace; i < source.length; i++) {
+			const ch = source[i];
+			if (ch === "{") depth++;
+			else if (ch === "}") {
+				depth--;
+				if (depth === 0) {
+					closeBrace = i;
+					break;
+				}
+			}
+		}
+		if (closeBrace === -1) return null;
+		const body = source.slice(openBrace + 1, closeBrace);
+		const titleRe = /(^|[\s,{])(title\s*:\s*)(['"`])((?:\\.|(?!\3).)*)\3/;
+		const match = body.match(titleRe);
+		if (match) {
+			const newBody = body.replace(titleRe, `${match[1]}${match[2]}${newLiteral}`);
+			return source.slice(0, openBrace + 1) + newBody + source.slice(closeBrace);
+		}
+		const firstIndentMatch = body.match(/\n([ \t]+)\S/);
+		const insertion = `\n${firstIndentMatch ? firstIndentMatch[1] : "  "}title: ${newLiteral}${body.replace(/^\s*\n?/, "").trim().length > 0 ? "," : ""}`;
+		return source.slice(0, openBrace + 1) + insertion + body + source.slice(closeBrace);
+	}
+	const exportDefaultIdx = source.search(/export\s+default\b/);
+	if (exportDefaultIdx === -1) return null;
+	const insertion = `export const meta: PageMeta = { title: ${newLiteral} };\n\n`;
+	return source.slice(0, exportDefaultIdx) + insertion + source.slice(exportDefaultIdx);
+}
+//#endregion
 //#region src/editing/babel-walk.ts
 const SKIP_KEYS = /* @__PURE__ */ new Set([
 	"loc",
@@ -1452,12 +1712,15 @@ function validateIcon(v) {
 function makeContext(opts) {
 	const userCwd = opts.userCwd;
 	const pagesDir = opts.pagesDir ?? "pages";
+	const emailsDir = opts.emailsDir ?? "emails";
 	const assetsDir = opts.assetsDir ?? "assets";
 	const pagesRoot = path.resolve(userCwd, pagesDir);
 	return {
 		userCwd,
 		pagesDir,
 		pagesRoot,
+		emailsDir,
+		emailsRoot: path.resolve(userCwd, emailsDir),
 		globalAssetsRoot: path.resolve(userCwd, assetsDir),
 		manifestPath: foldersManifestPath(pagesRoot),
 		coreVersion: opts.coreVersion
@@ -1494,6 +1757,10 @@ function resolvePagePath(userCwd, pagesDir, pageId) {
 function resolvePageEntryPath(ctx, pageId) {
 	return resolvePagePath(ctx.userCwd, ctx.pagesDir, pageId);
 }
+/** The `index.tsx` a comment marker lands in: a page entry, or an email entry. */
+function resolveCommentEntryPath(ctx, id, target) {
+	return resolvePagePath(ctx.userCwd, target === "email" ? ctx.emailsDir : ctx.pagesDir, id);
+}
 //#endregion
 //#region src/vite/routes/assets.ts
 function registerAssetRoutes(server, ctx) {
@@ -1774,13 +2041,16 @@ function offsetToLine(source, offset) {
 }
 //#endregion
 //#region src/vite/routes/comments.ts
+function parseTarget(raw) {
+	return raw === "email" ? "email" : "page";
+}
 function registerCommentRoutes(server, ctx) {
 	server.middlewares.use("/__comments", async (req, res, next) => {
 		const url = new URL(req.url ?? "/", "http://local");
 		const method = req.method ?? "GET";
 		try {
 			if (method === "GET" && url.pathname === "/") {
-				const file = resolvePageEntryPath(ctx, url.searchParams.get("pageId") ?? "");
+				const file = resolveCommentEntryPath(ctx, url.searchParams.get("pageId") ?? "", parseTarget(url.searchParams.get("target")));
 				if (!file) return json(res, 400, { error: "invalid pageId" });
 				let source;
 				try {
@@ -1794,7 +2064,7 @@ function registerCommentRoutes(server, ctx) {
 				const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
 				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
 				const body = await readBody(req);
-				const file = resolvePageEntryPath(ctx, body.pageId ?? "");
+				const file = resolveCommentEntryPath(ctx, body.pageId ?? "", parseTarget(body.target));
 				if (!file) return json(res, 400, { error: "invalid pageId" });
 				if (!body.line || body.line < 1) return json(res, 400, { error: "invalid line" });
 				if (!body.text || typeof body.text !== "string") return json(res, 400, { error: "missing text" });
@@ -1825,7 +2095,7 @@ function registerCommentRoutes(server, ctx) {
 				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
 				const id = url.pathname.slice(1);
 				if (!/^c-[a-f0-9]+$/.test(id)) return json(res, 400, { error: "invalid id" });
-				const file = resolvePageEntryPath(ctx, url.searchParams.get("pageId") ?? "");
+				const file = resolveCommentEntryPath(ctx, url.searchParams.get("pageId") ?? "", parseTarget(url.searchParams.get("target")));
 				if (!file) return json(res, 400, { error: "invalid pageId" });
 				let source;
 				try {
@@ -2159,6 +2429,417 @@ function registerGfontsRoutes(server) {
 	});
 }
 //#endregion
+//#region src/vite/open-pages-plugin.ts
+const CONFIG_FILE = "open-pages.config.ts";
+const PAGES_VMOD = "virtual:open-pages/pages";
+const CONFIG_VMOD = "virtual:open-pages/config";
+const FOLDERS_VMOD = "virtual:open-pages/folders";
+const PAGES_CSS_VMOD = "virtual:open-pages/pages.css";
+const WORKSPACE_SOURCE_DIRS = [
+	"ui",
+	"lib",
+	"hooks"
+];
+const ENTRY_GLOB$1 = "*/index.{tsx,jsx,ts,js,html}";
+const REACT_ENTRY_RE = /^index\.(tsx|jsx|ts|js)$/;
+async function readFoldersManifest(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 {
+			folders: [],
+			assignments: {}
+		};
+		throw err;
+	}
+}
+function resolved$2(id) {
+	return `\0${id}`;
+}
+function invalidatePagesModule(server) {
+	const mod = server.moduleGraph.getModuleById(resolved$2(PAGES_VMOD));
+	if (mod) server.moduleGraph.invalidateModule(mod);
+	server.ws.send({ type: "full-reload" });
+}
+/**
+* Every `pages/<id>/index.*` entry. A folder with both a React entry and an
+* `index.html` is a React page — the HTML is then a plain asset of the page.
+*/
+async function findPages(userCwd, pagesDir) {
+	const abs = path.resolve(userCwd, pagesDir);
+	if (!existsSync(abs)) return [];
+	const hits = await fg(ENTRY_GLOB$1, {
+		cwd: abs,
+		absolute: true,
+		onlyFiles: true
+	});
+	const byId = /* @__PURE__ */ new Map();
+	for (const file of hits.sort()) {
+		const [id, name] = path.relative(abs, file).split(path.sep);
+		const kind = REACT_ENTRY_RE.test(name) ? "react" : "html";
+		const existing = byId.get(id);
+		if (!existing || existing.kind === "html" && kind === "react") byId.set(id, {
+			id,
+			kind,
+			file
+		});
+	}
+	return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+const META_THEME_RE = /(?:^|[\s,{])theme\s*:\s*['"]([^'"]+)['"]/;
+const META_CREATED_AT_RE = /(?:^|[\s,{])createdAt\s*:\s*['"]([^'"]+)['"]/;
+const META_TITLE_RE = /(?:^|[\s,{])title\s*:\s*['"]([^'"]+)['"]/;
+const HTML_TITLE_RE = /<title[^>]*>([^<]*)<\/title>/i;
+const EMPTY_META$1 = {
+	title: null,
+	theme: null,
+	createdAt: null
+};
+/** The text between the braces of `export const meta = { … }`, or null. */
+function metaObjectBody(src) {
+	const metaStart = src.search(/export\s+const\s+meta\b/);
+	if (metaStart === -1) return null;
+	const eqIdx = src.indexOf("=", metaStart);
+	if (eqIdx === -1) return null;
+	const openBrace = src.indexOf("{", eqIdx);
+	if (openBrace === -1) return null;
+	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 null;
+	return src.slice(openBrace + 1, closeBrace);
+}
+function extractMeta(src) {
+	const body = metaObjectBody(src);
+	if (body === null) return EMPTY_META$1;
+	return {
+		title: body.match(META_TITLE_RE)?.[1] ?? null,
+		theme: body.match(META_THEME_RE)?.[1] ?? null,
+		createdAt: body.match(META_CREATED_AT_RE)?.[1] ?? null
+	};
+}
+function extractHtmlMeta(src) {
+	return {
+		title: (src.match(HTML_TITLE_RE)?.[1]?.trim() ?? null) || null,
+		theme: null,
+		createdAt: null
+	};
+}
+async function readPageMeta(entry) {
+	try {
+		const src = await fs.readFile(entry.file, "utf8");
+		return entry.kind === "html" ? extractHtmlMeta(src) : extractMeta(src);
+	} catch {
+		return EMPTY_META$1;
+	}
+}
+function parseCreatedAtMs(iso) {
+	if (!iso) return null;
+	const ms = Date.parse(iso);
+	return Number.isFinite(ms) ? ms : null;
+}
+const warnedInvalidPageIds = /* @__PURE__ */ new Set();
+async function generatePagesModule(entries, isDev) {
+	const scanned = await Promise.all(entries.map(async (entry) => {
+		const importPath = isDev ? `@fs/${normalizePath(entry.file).replace(/^\/+/, "")}` : entry.file;
+		const meta = await readPageMeta(entry);
+		return {
+			...entry,
+			importPath,
+			meta,
+			createdAt: parseCreatedAtMs(meta.createdAt)
+		};
+	}));
+	const valid = scanned.filter((e) => PAGE_ID_RE.test(e.id));
+	const ignored = scanned.filter((e) => !PAGE_ID_RE.test(e.id)).map((e) => e.id);
+	const kinds = {};
+	const themesMap = {};
+	const createdAtMap = {};
+	for (const e of valid) {
+		kinds[e.id] = e.kind;
+		if (e.meta.theme) themesMap[e.id] = e.meta.theme;
+		if (e.createdAt !== null) createdAtMap[e.id] = e.createdAt;
+	}
+	const importTokens = JSON.stringify(Object.fromEntries(valid.filter((e) => e.kind === "react").map((e) => [e.id, 0])));
+	const devRuntime = isDev ? `
+const pageImportTokens = ${importTokens};
+if (import.meta.hot) {
+  import.meta.hot.on('open-pages:page-changed', (data) => {
+    const ids = Array.isArray(data?.pageIds) ? data.pageIds : data?.pageId ? [data.pageId] : [];
+    const token = Date.now();
+    for (const id of ids) {
+      if (Object.prototype.hasOwnProperty.call(pageImportTokens, id)) pageImportTokens[id] = token;
+    }
+  });
+}
+` : "";
+	const cases = valid.map((e) => {
+		if (e.kind === "html") {
+			const mod = { meta: { title: e.meta.title ?? e.id } };
+			return `    case ${JSON.stringify(e.id)}: return Promise.resolve(${JSON.stringify(mod)});`;
+		}
+		const importExpr = isDev ? `import(/* @vite-ignore */ import.meta.env.BASE_URL + ${JSON.stringify(`${e.importPath}?t=`)} + pageImportTokens[${JSON.stringify(e.id)}])` : `import(${JSON.stringify(e.importPath)})`;
+		return `    case ${JSON.stringify(e.id)}: return ${importExpr};`;
+	}).join("\n");
+	return {
+		code: `// virtual:open-pages/pages — generated
+export const pageIds = ${JSON.stringify(valid.map((e) => e.id))};
+export const pageKinds = ${JSON.stringify(kinds)};
+export const pageThemes = ${JSON.stringify(themesMap)};
+export const pageCreatedAt = ${JSON.stringify(createdAtMap)};
+${devRuntime}
+
+export async function loadPage(id) {
+  switch (id) {
+${cases}
+    default: throw new Error('Page not found: ' + id);
+  }
+}
+`,
+		ignored
+	};
+}
+/**
+* Tailwind for page source. The workspace UI has its own stylesheet rooted
+* at the core app; pages live in the user's project, so they get a generated
+* stylesheet whose `@source` points at their directories. Written under
+* node_modules so Tailwind resolves `tailwindcss` from the workspace.
+*/
+function pagesCssFile(userCwd) {
+	return path.join(userCwd, "node_modules", ".open-pages", "pages.css");
+}
+/**
+* The workspace's own stylesheet when it has one (the shadcn `tailwind.css`
+* entry from components.json, default `styles/globals.css`) — it carries the
+* theme tokens every installed component reads. Falls back to the generated
+* file for workspaces scaffolded without one.
+*/
+function workspaceCssFile(userCwd) {
+	let rel = "styles/globals.css";
+	try {
+		const cfg = JSON.parse(readFileSync(path.join(userCwd, "components.json"), "utf8"));
+		if (typeof cfg.tailwind?.css === "string" && cfg.tailwind.css) rel = cfg.tailwind.css;
+	} catch {}
+	const abs = path.resolve(userCwd, rel);
+	return existsSync(abs) ? abs : null;
+}
+const TAILWIND_CSS = normalizePath(createRequire(import.meta.url).resolve("tailwindcss/index.css"));
+function writePagesCss(userCwd, sources) {
+	const file = pagesCssFile(userCwd);
+	const lines = [`@import ${JSON.stringify(TAILWIND_CSS)} source(none);`];
+	for (const dir of sources) lines.push(`@source ${JSON.stringify(normalizePath(dir))};`);
+	mkdirSync(path.dirname(file), { recursive: true });
+	writeFileSync(file, `${lines.join("\n")}\n`, "utf8");
+	return file;
+}
+function rewriteHtmlUrls(html, pageDir) {
+	const prefix = `/@fs/${normalizePath(pageDir).replace(/^\/+/, "")}/`;
+	return html.replace(/(\s(?:src|href)=)(["'])(?!\/|[a-z][a-z0-9+.-]*:|#|\2)(?:\.\/)?([^"']+)\2/gi, (_m, attr, quote, rel) => `${attr}${quote}${prefix}${rel}${quote}`);
+}
+function pagesSignature(entries) {
+	return entries.map((e) => `${e.id}:${e.kind}:${e.file}`).join(",");
+}
+function openPagesPlugin(opts) {
+	const { userCwd, config, coreVersion } = opts;
+	const pagesDir = config.pagesDir ?? "pages";
+	const themesDir = config.themesDir ?? "themes";
+	const pagesRoot = path.resolve(userCwd, pagesDir);
+	const themesRoot = path.resolve(userCwd, themesDir);
+	const foldersManifestPath = path.join(pagesRoot, ".folders.json");
+	let isDev = false;
+	let cssFile = "";
+	let generatedSignature = "";
+	const pageIdForEntry = (p) => {
+		const rel = path.relative(pagesRoot, p);
+		if (rel.startsWith("..") || path.isAbsolute(rel)) return null;
+		const parts = rel.split(path.sep);
+		if (parts.length !== 2) return null;
+		if (REACT_ENTRY_RE.test(parts[1])) return {
+			id: parts[0],
+			kind: "react"
+		};
+		if (parts[1] === "index.html") return {
+			id: parts[0],
+			kind: "html"
+		};
+		return null;
+	};
+	let pageChangeTimer = null;
+	const pendingPageChanges = /* @__PURE__ */ new Set();
+	const queuePageChanged = (server, id) => {
+		pendingPageChanges.add(id);
+		if (pageChangeTimer) clearTimeout(pageChangeTimer);
+		pageChangeTimer = setTimeout(() => {
+			pageChangeTimer = null;
+			const mod = server.moduleGraph.getModuleById(resolved$2(PAGES_VMOD));
+			if (mod) server.moduleGraph.invalidateModule(mod);
+			const pageIds = Array.from(pendingPageChanges);
+			pendingPageChanges.clear();
+			server.ws.send({
+				type: "custom",
+				event: "open-pages:page-changed",
+				data: { pageIds }
+			});
+		}, 100);
+	};
+	return {
+		name: "open-pages",
+		config(_c, env) {
+			isDev = env.command === "serve";
+			cssFile = workspaceCssFile(userCwd) ?? writePagesCss(userCwd, [
+				pagesRoot,
+				themesRoot,
+				...WORKSPACE_SOURCE_DIRS.map((d) => path.join(userCwd, d))
+			]);
+			return { server: { fs: { allow: [userCwd] } } };
+		},
+		resolveId(id) {
+			if (id === PAGES_VMOD) return resolved$2(PAGES_VMOD);
+			if (id === CONFIG_VMOD) return resolved$2(CONFIG_VMOD);
+			if (id === FOLDERS_VMOD) return resolved$2(FOLDERS_VMOD);
+			if (id === PAGES_CSS_VMOD) return cssFile;
+			return null;
+		},
+		async load(id) {
+			if (id === resolved$2(PAGES_VMOD)) {
+				const entries = await findPages(userCwd, pagesDir);
+				generatedSignature = pagesSignature(entries);
+				const { code, ignored } = await generatePagesModule(entries, isDev);
+				for (const pageId of ignored) {
+					if (warnedInvalidPageIds.has(pageId)) continue;
+					warnedInvalidPageIds.add(pageId);
+					this.warn(`Ignoring page folder "${pageId}": page ids must match ${PAGE_ID_RE} (lowercase/uppercase letters, digits, "-", "_"). Rename the folder under "${pagesDir}/" to a kebab-case id so it appears in the browser and can be moved into folders.`);
+				}
+				return code;
+			}
+			if (id === resolved$2(CONFIG_VMOD)) {
+				const userBuild = config.build ?? {};
+				const buildResolved = isDev ? {
+					showPageBrowser: true,
+					showPageUi: true
+				} : {
+					showPageBrowser: userBuild.showPageBrowser ?? true,
+					showPageUi: userBuild.showPageUi ?? true
+				};
+				const resolvedConfig = {
+					...config,
+					build: buildResolved,
+					version: coreVersion
+				};
+				return `export default ${JSON.stringify(resolvedConfig)};\n`;
+			}
+			if (id === resolved$2(FOLDERS_VMOD)) {
+				const manifest = await readFoldersManifest(foldersManifestPath);
+				return `export default ${JSON.stringify(manifest)};\n`;
+			}
+			return null;
+		},
+		handleHotUpdate(ctx) {
+			const entry = pageIdForEntry(ctx.file);
+			if (!entry) return;
+			queuePageChanged(ctx.server, entry.id);
+			return [];
+		},
+		configureServer(server) {
+			let reloadTimer = null;
+			const reload = () => {
+				if (reloadTimer) clearTimeout(reloadTimer);
+				reloadTimer = setTimeout(async () => {
+					reloadTimer = null;
+					try {
+						if (pagesSignature(await findPages(userCwd, pagesDir)) === generatedSignature) return;
+					} catch (err) {
+						server.config.logger.error(`[open-pages] failed to rescan pages: ${err}`, { error: err instanceof Error ? err : void 0 });
+					}
+					invalidatePagesModule(server);
+				}, 150);
+			};
+			const isPageDir = (p) => path.dirname(p) === pagesRoot;
+			if (existsSync(pagesRoot)) server.watcher.add(pagesRoot);
+			server.watcher.on("add", (p) => {
+				if (pageIdForEntry(p)) reload();
+			});
+			server.watcher.on("unlink", (p) => {
+				if (pageIdForEntry(p)) reload();
+			});
+			server.watcher.on("addDir", (p) => {
+				if (isPageDir(p)) reload();
+			});
+			server.watcher.on("unlinkDir", (p) => {
+				if (isPageDir(p)) reload();
+			});
+			server.watcher.on("change", (p) => {
+				const entry = pageIdForEntry(p);
+				if (entry?.kind === "html") queuePageChanged(server, entry.id);
+			});
+			let foldersTimer = null;
+			const invalidateFolders = () => {
+				if (foldersTimer) clearTimeout(foldersTimer);
+				foldersTimer = setTimeout(() => {
+					foldersTimer = null;
+					const mod = server.moduleGraph.getModuleById(resolved$2(FOLDERS_VMOD));
+					if (mod) server.moduleGraph.invalidateModule(mod);
+				}, 100);
+			};
+			server.watcher.add(foldersManifestPath);
+			server.watcher.on("change", (p) => {
+				if (p === foldersManifestPath) invalidateFolders();
+			});
+			server.watcher.on("add", (p) => {
+				if (p === foldersManifestPath) invalidateFolders();
+			});
+			server.watcher.on("unlink", (p) => {
+				if (p === foldersManifestPath) invalidateFolders();
+			});
+			server.middlewares.use("/__page", async (req, res, next) => {
+				const m = new URL(req.url ?? "/", "http://local").pathname.match(/^\/([^/]+)\/(?:index\.html)?$/);
+				if (!m || (req.method ?? "GET") !== "GET") return next();
+				const pageId = decodeURIComponent(m[1]);
+				if (!PAGE_ID_RE.test(pageId)) return next();
+				const pageDir = path.join(pagesRoot, pageId);
+				const file = path.join(pageDir, "index.html");
+				let raw;
+				try {
+					raw = await fs.readFile(file, "utf8");
+				} catch {
+					return next();
+				}
+				try {
+					const html = await server.transformIndexHtml(`/__page/${pageId}/index.html`, rewriteHtmlUrls(raw, pageDir), req.originalUrl);
+					res.statusCode = 200;
+					res.setHeader("content-type", "text/html");
+					res.end(html);
+				} catch (err) {
+					next(err);
+				}
+			});
+		}
+	};
+}
+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/vite/routes/pages.ts
 function registerPageRoutes(server, ctx) {
 	server.middlewares.use("/__pages", async (req, res, next) => {
@@ -2194,8 +2875,7 @@ function registerPageRoutes(server, ctx) {
 			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 name = validatePageName(body.name);
+				const name = validatePageName((await readBody(req)).name);
 				if (!name) return json(res, 400, { error: "invalid name" });
 				const entry = resolvePageEntry(ctx.pagesRoot, pageId);
 				if (!entry) return json(res, 400, { error: "invalid pageId" });
@@ -2415,6 +3095,7 @@ function parseSelection(raw) {
 function currentPlugin(opts) {
 	const userCwd = opts.userCwd;
 	const pagesDir = opts.pagesDir ?? "pages";
+	const emailsDir = opts.emailsDir ?? "emails";
 	const outDir = path.join(userCwd, "node_modules", ".open-pages");
 	const outFile = path.join(outDir, "current.json");
 	const tmpFile = `${outFile}.tmp`;
@@ -2434,10 +3115,11 @@ function currentPlugin(opts) {
 				if (typeof raw?.pageId === "string") {
 					if (!PAGE_ID_RE.test(raw.pageId)) return;
 					const pageTitle = typeof raw.pageTitle === "string" ? raw.pageTitle : raw.pageId;
-					const view = raw.view === "assets" ? "assets" : "pages";
-					const entry = existsSync(path.join(userCwd, pagesDir, raw.pageId, "index.tsx")) ? "index.tsx" : "index.html";
-					const pagePath = path.join(pagesDir, raw.pageId, entry).split(path.sep).join("/");
-					if (cached?.pageId !== raw.pageId) next.selection = null;
+					const view = raw.view === "assets" ? "assets" : raw.view === "emails" ? "emails" : "pages";
+					const dir = view === "emails" ? emailsDir : pagesDir;
+					const entry = view === "emails" || existsSync(path.join(userCwd, pagesDir, raw.pageId, "index.tsx")) ? "index.tsx" : "index.html";
+					const pagePath = path.join(dir, raw.pageId, entry).split(path.sep).join("/");
+					if (cached?.pageId !== raw.pageId || cached?.view !== view) next.selection = null;
 					next.pageId = raw.pageId;
 					next.pageTitle = pageTitle;
 					next.view = view;
@@ -2842,6 +3524,350 @@ function designPlugin(opts) {
 	};
 }
 //#endregion
+//#region src/vite/emails-plugin.ts
+const EMAILS_VMOD = "virtual:open-pages/emails";
+const ENTRY_GLOB = "*/index.{tsx,jsx}";
+const ENTRY_RE = /^index\.(tsx|jsx)$/;
+const EMAIL_LOC_ATTR_RE = / data-op-loc="\d+:\d+"/g;
+function resolved$1(id) {
+	return `\0${id}`;
+}
+function invalidateEmailsModule(server) {
+	const mod = server.moduleGraph.getModuleById(resolved$1(EMAILS_VMOD));
+	if (mod) server.moduleGraph.invalidateModule(mod);
+	server.ws.send({ type: "full-reload" });
+}
+async function findEmails(userCwd, emailsDir) {
+	const abs = path.resolve(userCwd, emailsDir);
+	if (!existsSync(abs)) return [];
+	const hits = await fg(ENTRY_GLOB, {
+		cwd: abs,
+		absolute: true,
+		onlyFiles: true
+	});
+	const byId = /* @__PURE__ */ new Map();
+	for (const file of hits.sort()) {
+		const id = path.relative(abs, file).split(path.sep)[0];
+		if (!byId.has(id) && PAGE_ID_RE.test(id)) byId.set(id, {
+			id,
+			file
+		});
+	}
+	return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+const EMPTY_META = {
+	title: null,
+	subject: null,
+	description: null,
+	createdAt: null
+};
+function metaField(body, key) {
+	return body.match(new RegExp(`(?:^|[\\s,{])${key}\\s*:\\s*['"]([^'"]+)['"]`))?.[1] ?? null;
+}
+function extractEmailMeta(src) {
+	const body = metaObjectBody(src);
+	if (body === null) return EMPTY_META;
+	return {
+		title: metaField(body, "title"),
+		subject: metaField(body, "subject"),
+		description: metaField(body, "description"),
+		createdAt: metaField(body, "createdAt")
+	};
+}
+async function generateEmailsModule(entries) {
+	const meta = {};
+	const createdAt = {};
+	for (const entry of entries) {
+		let extracted = EMPTY_META;
+		try {
+			extracted = extractEmailMeta(await fs.readFile(entry.file, "utf8"));
+		} catch {}
+		meta[entry.id] = {
+			title: extracted.title ?? entry.id,
+			subject: extracted.subject,
+			description: extracted.description
+		};
+		const ms = extracted.createdAt ? Date.parse(extracted.createdAt) : NaN;
+		if (Number.isFinite(ms)) createdAt[entry.id] = ms;
+	}
+	return `// virtual:open-pages/emails — generated
+export const emailIds = ${JSON.stringify(entries.map((e) => e.id))};
+export const emailMeta = ${JSON.stringify(meta)};
+export const emailCreatedAt = ${JSON.stringify(createdAt)};
+`;
+}
+function emailsSignature(entries) {
+	return entries.map((e) => `${e.id}:${e.file}`).join(",");
+}
+function unresolvedClasses(html) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const match of html.matchAll(/\sclass="([^"]*)"/g)) for (const name of match[1].split(/\s+/)) if (name && !name.includes(":")) seen.add(name);
+	return [...seen].sort();
+}
+const runtimes = /* @__PURE__ */ new Map();
+function workspaceRuntime(userCwd) {
+	let cached = runtimes.get(userCwd);
+	if (!cached) {
+		cached = (async () => {
+			const require = createRequire(path.join(userCwd, "package.json"));
+			let reactPath;
+			let reactEmailPath;
+			try {
+				reactPath = require.resolve("react");
+				reactEmailPath = require.resolve("react-email");
+			} catch {
+				throw new Error("Emails need the `react-email` package in this workspace. Install it with your package manager (for example `npm install react-email`), then reload.");
+			}
+			const react = await import(pathToFileURL(reactPath).href);
+			const reactEmail = await import(pathToFileURL(reactEmailPath).href);
+			const createElement = react.createElement ?? react.default?.createElement;
+			const render = reactEmail.render ?? reactEmail.default?.render;
+			if (!createElement || !render) throw new Error("Could not load `react` and `react-email` from this workspace.");
+			return {
+				createElement,
+				render
+			};
+		})();
+		runtimes.set(userCwd, cached);
+		cached.catch(() => runtimes.delete(userCwd));
+	}
+	return cached;
+}
+async function renderEmail(server, userCwd, entry) {
+	const runtime = await workspaceRuntime(userCwd);
+	const mod = await server.ssrLoadModule(entry.file);
+	if (typeof mod.default !== "function") throw new Error(`emails/${entry.id}/index.tsx must default-export a component. Got: ${typeof mod.default}`);
+	const element = runtime.createElement(mod.default);
+	const [html, text] = await Promise.all([runtime.render(element, { pretty: true }), runtime.render(element, { plainText: true })]);
+	return {
+		html,
+		text,
+		title: mod.meta?.title ?? entry.id,
+		subject: mod.meta?.subject ?? null,
+		unresolved: unresolvedClasses(html)
+	};
+}
+function stripLocTags(html) {
+	return html.replace(EMAIL_LOC_ATTR_RE, "");
+}
+const EMAIL_THEME_FILE_RE = /(^|\/)components\/email\/email-theme\.(ts|tsx|js|jsx|mjs)$/;
+const CREATE_CONFIG_RE = /export\s+const\s+createEmailTailwindConfig\s*=/;
+const EMAIL_THEME_ALIASES = `
+export const createEmailTailwindConfig = (theme) =>
+  __openPagesAliasEmailTheme(__openPagesCreateEmailTailwindConfig(theme), theme);
+
+function __openPagesAliasEmailTheme(config, theme) {
+  if (!config || typeof config !== 'object' || !theme || typeof theme !== 'object') return config;
+  const extend = (config.theme ??= {}).extend ??= {};
+  const colors = (extend.colors ??= {});
+  const aliases = {
+    background: theme.colorBackground,
+    'background-muted': theme.colorBackgroundMuted,
+    foreground: theme.colorText,
+    'foreground-muted': theme.colorTextMuted,
+    primary: theme.colorPrimary,
+    'primary-fg': theme.colorPrimaryForeground,
+    border: theme.colorBorder,
+  };
+  for (const [name, value] of Object.entries(aliases)) {
+    if (!(name in colors) && typeof value === 'string') colors[name] = value;
+  }
+  const maxWidth = (extend.maxWidth ??= {});
+  if (!('container' in maxWidth) && typeof theme.containerWidth === 'string') {
+    maxWidth.container = theme.containerWidth;
+  }
+  return config;
+}
+`;
+function isEmailThemeModule(id, userCwd) {
+	const file = id.split(/[?#]/)[0].replace(/\\/g, "/");
+	const root = userCwd.replace(/\\/g, "/");
+	return file.startsWith(`${root}/`) && EMAIL_THEME_FILE_RE.test(file.slice(root.length + 1));
+}
+function aliasEmailThemeModule(code) {
+	if (!CREATE_CONFIG_RE.test(code)) return null;
+	return code.replace(CREATE_CONFIG_RE, "const __openPagesCreateEmailTailwindConfig =") + EMAIL_THEME_ALIASES;
+}
+function injectBeforeBodyEnd(html, snippet) {
+	const idx = html.lastIndexOf("</body>");
+	return idx === -1 ? html + snippet : html.slice(0, idx) + snippet + html.slice(idx);
+}
+function errorDocument(message) {
+	return `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Email error</title></head><body style="margin:0"><pre style="margin:0;padding:16px 20px;font:12px/1.5 ui-monospace,SFMono-Regular,Menlo,monospace;color:#b91c1c;background:#fef2f2;white-space:pre-wrap">${message.replace(/&/g, "&amp;").replace(/</g, "&lt;")}</pre></body></html>`;
+}
+function emailsPlugin(opts) {
+	const { userCwd, config } = opts;
+	const emailsDir = config.emailsDir ?? "emails";
+	const emailsRoot = path.resolve(userCwd, emailsDir);
+	let generatedSignature = "";
+	const emailIdForFile = (p) => {
+		const rel = path.relative(emailsRoot, p);
+		if (rel.startsWith("..") || path.isAbsolute(rel)) return null;
+		const [id] = rel.split(path.sep);
+		return id && PAGE_ID_RE.test(id) ? id : null;
+	};
+	const isEntryFile = (p) => {
+		const parts = path.relative(emailsRoot, p).split(path.sep);
+		return parts.length === 2 && ENTRY_RE.test(parts[1]);
+	};
+	const emailsImporting = (modules) => {
+		const ids = /* @__PURE__ */ new Set();
+		const seen = /* @__PURE__ */ new Set();
+		const queue = [...modules];
+		while (queue.length) {
+			const mod = queue.pop();
+			if (!mod || seen.has(mod)) continue;
+			seen.add(mod);
+			if (mod.file) {
+				const id = emailIdForFile(mod.file);
+				if (id && isEntryFile(mod.file)) ids.add(id);
+			}
+			for (const importer of mod.importers) queue.push(importer);
+		}
+		return ids;
+	};
+	let changeTimer = null;
+	const pendingChanges = /* @__PURE__ */ new Set();
+	const queueEmailChanged = (server, ids) => {
+		for (const id of ids) pendingChanges.add(id);
+		if (changeTimer) clearTimeout(changeTimer);
+		changeTimer = setTimeout(() => {
+			changeTimer = null;
+			const emailIds = Array.from(pendingChanges);
+			pendingChanges.clear();
+			if (emailIds.length === 0) return;
+			server.ws.send({
+				type: "custom",
+				event: "open-pages:email-changed",
+				data: { emailIds }
+			});
+		}, 100);
+	};
+	return {
+		name: "open-pages:emails",
+		resolveId(id) {
+			return id === "virtual:open-pages/emails" ? resolved$1(EMAILS_VMOD) : null;
+		},
+		async load(id) {
+			if (id !== resolved$1("virtual:open-pages/emails")) return null;
+			const entries = await findEmails(userCwd, emailsDir);
+			generatedSignature = emailsSignature(entries);
+			return generateEmailsModule(entries);
+		},
+		transform(code, id) {
+			if (!isEmailThemeModule(id, userCwd)) return null;
+			const next = aliasEmailThemeModule(code);
+			return next === null ? null : {
+				code: next,
+				map: null
+			};
+		},
+		hotUpdate({ file, modules, server }) {
+			if (this.environment.name !== "ssr") return;
+			const ids = emailsImporting(modules);
+			const direct = emailIdForFile(file);
+			if (direct) ids.add(direct);
+			if (ids.size === 0) return;
+			queueEmailChanged(server, ids);
+			return [];
+		},
+		configureServer(server) {
+			let reloadTimer = null;
+			const rescan = () => {
+				if (reloadTimer) clearTimeout(reloadTimer);
+				reloadTimer = setTimeout(async () => {
+					reloadTimer = null;
+					try {
+						if (emailsSignature(await findEmails(userCwd, emailsDir)) === generatedSignature) return;
+					} catch (err) {
+						server.config.logger.error(`[open-pages] failed to rescan emails: ${err}`, { error: err instanceof Error ? err : void 0 });
+					}
+					invalidateEmailsModule(server);
+				}, 150);
+			};
+			if (existsSync(emailsRoot)) server.watcher.add(emailsRoot);
+			const onEntryEvent = (p) => {
+				if (emailIdForFile(p) && isEntryFile(p)) rescan();
+			};
+			server.watcher.on("add", onEntryEvent);
+			server.watcher.on("unlink", onEntryEvent);
+			server.watcher.on("addDir", (p) => {
+				if (path.dirname(p) === emailsRoot) rescan();
+			});
+			server.watcher.on("unlinkDir", (p) => {
+				if (path.dirname(p) === emailsRoot) rescan();
+			});
+			server.watcher.on("change", (p) => {
+				if (!emailIdForFile(p) || !isEntryFile(p)) return;
+				const mod = server.moduleGraph.getModuleById(resolved$1(EMAILS_VMOD));
+				if (mod) server.moduleGraph.invalidateModule(mod);
+			});
+			server.middlewares.use("/__email", async (req, res, next) => {
+				const url = new URL(req.url ?? "/", "http://local");
+				const m = url.pathname.match(/^\/([^/]+)\/(index\.html|index\.txt|index\.json)$/);
+				if (!m || (req.method ?? "GET") !== "GET") return next();
+				const emailId = decodeURIComponent(m[1]);
+				if (!PAGE_ID_RE.test(emailId)) return next();
+				const entry = (await findEmails(userCwd, emailsDir)).find((e) => e.id === emailId);
+				if (!entry) {
+					res.statusCode = 404;
+					res.setHeader("content-type", "text/plain; charset=utf-8");
+					res.end(`Email not found: ${emailId}`);
+					return;
+				}
+				const wantText = m[2] === "index.txt";
+				const wantJson = m[2] === "index.json";
+				const raw = url.searchParams.has("raw");
+				try {
+					const rendered = await renderEmail(server, userCwd, entry);
+					if (rendered.unresolved.length > 0) server.config.logger.warn(`[open-pages] email "${emailId}": ${rendered.unresolved.length} Tailwind ${rendered.unresolved.length === 1 ? "class" : "classes"} did not compile to inline styles: ${rendered.unresolved.join(" ")}`);
+					res.statusCode = 200;
+					res.setHeader("cache-control", "no-store");
+					if (wantJson) {
+						res.setHeader("content-type", "application/json");
+						res.end(JSON.stringify({
+							title: rendered.title,
+							subject: rendered.subject,
+							unresolved: rendered.unresolved
+						}));
+						return;
+					}
+					if (wantText) {
+						res.setHeader("content-type", "text/plain; charset=utf-8");
+						res.end(rendered.text);
+						return;
+					}
+					res.setHeader("content-type", "text/html; charset=utf-8");
+					if (raw) {
+						res.end(stripLocTags(rendered.html));
+						return;
+					}
+					const script = `<script type="module" src="${server.config.base}frame/email-inspect.ts"><\/script>`;
+					res.end(injectBeforeBodyEnd(rendered.html, script));
+				} catch (err) {
+					const message = err instanceof Error ? err.stack ?? err.message : String(err);
+					server.config.logger.error(`[open-pages] email "${emailId}" failed to render:\n${message}`);
+					res.statusCode = 500;
+					res.setHeader("cache-control", "no-store");
+					if (wantJson) {
+						res.setHeader("content-type", "application/json");
+						res.end(JSON.stringify({ error: message }));
+						return;
+					}
+					if (wantText) {
+						res.setHeader("content-type", "text/plain; charset=utf-8");
+						res.end(message);
+						return;
+					}
+					const script = `<script type="module" src="${server.config.base}frame/email-inspect.ts"><\/script>`;
+					res.setHeader("content-type", "text/html; charset=utf-8");
+					res.end(injectBeforeBodyEnd(errorDocument(message), script));
+				}
+			});
+		}
+	};
+}
+//#endregion
 //#region src/vite/loc-tags-plugin.ts
 const UNTAGGABLE_COMPONENTS = /* @__PURE__ */ new Set([
 	"Fragment",
@@ -2891,13 +3917,13 @@ function isPageSourceFile(id, docsRootPosix) {
 	return filePath.slice(docsRootPosix.length + 1).includes("/");
 }
 function locTagsPlugin(opts) {
-	const pagesRoot = path.resolve(opts.userCwd, opts.pagesDir ?? "pages").replace(/\\/g, "/");
+	const roots = [opts.pagesDir ?? "pages", opts.emailsDir ?? "emails"].map((dir) => path.resolve(opts.userCwd, dir).replace(/\\/g, "/"));
 	return {
 		name: "open-pages:loc-tags",
 		apply: opts.apply ?? "serve",
 		enforce: "pre",
 		transform(code, id) {
-			if (!isPageSourceFile(id, pagesRoot)) return null;
+			if (!roots.some((root) => isPageSourceFile(id, root))) return null;
 			const next = injectLocTags(code);
 			if (next === null) return null;
 			return {
@@ -3075,12 +4101,38 @@ function themesPlugin(opts) {
 	};
 }
 //#endregion
+//#region src/vite/version.ts
+var version_exports = /* @__PURE__ */ __exportAll({
+	APP_ROOT: () => APP_ROOT,
+	PKG_ROOT: () => PKG_ROOT,
+	readCoreVersion: () => readCoreVersion
+});
+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";
+	}
+}
+//#endregion
 //#region src/vite/config.ts
 const CORE_VERSION = readCoreVersion();
 async function createViteConfig(opts) {
 	const userCwd = path.resolve(opts.userCwd);
 	const config = opts.config ?? await loadUserConfig(userCwd);
 	const pagesDir = config.pagesDir ?? "pages";
+	const emailsDir = config.emailsDir ?? "emails";
 	const themesDir = config.themesDir ?? "themes";
 	const assetsDir = config.assetsDir ?? "assets";
 	const pagesAbs = path.resolve(userCwd, pagesDir);
@@ -3094,7 +4146,8 @@ async function createViteConfig(opts) {
 		plugins: [
 			locTagsPlugin({
 				userCwd,
-				pagesDir
+				pagesDir,
+				emailsDir
 			}),
 			react(),
 			tailwindcss(),
@@ -3107,16 +4160,22 @@ async function createViteConfig(opts) {
 				userCwd,
 				config
 			}),
+			emailsPlugin({
+				userCwd,
+				config
+			}),
 			designPlugin({ userCwd }),
 			apiPlugin({
 				userCwd,
 				pagesDir,
+				emailsDir,
 				assetsDir,
 				coreVersion: CORE_VERSION
 			}),
 			currentPlugin({
 				userCwd,
-				pagesDir
+				pagesDir,
+				emailsDir
 			})
 		],
 		resolve: { alias: {
@@ -3183,4 +4242,4 @@ async function createViteConfig(opts) {
 	};
 }
 //#endregion
-export { DEV_SUPERVISED_ENV as n, createViteConfig as t };
+export { renderEmail as a, extractMeta as c, openPagesPlugin as d, findEmails as i, findPages as l, readCoreVersion as n, stripLocTags as o, version_exports as r, DEV_SUPERVISED_ENV as s, createViteConfig as t, loadUserConfig as u };