@maizzle/framework 6.0.0-rc.9 → 6.0.1

package/dist/{serve.mjs → serve.js}

@@ -1,28 +1,49 @@
-import { __toESM } from "./_virtual/_rolldown/runtime.mjs";
-import { resolveConfig } from "./config/index.mjs";
-import { runTransformers } from "./transformers/index.mjs";
-import { createRenderer } from "./render/createRenderer.mjs";
-import { createPlaintext } from "./plaintext.mjs";
-import { require_picomatch } from "./node_modules/picomatch/index.mjs";
-import { serveCompatibility } from "./server/compatibility.mjs";
-import { serveLint } from "./server/linter.mjs";
-import { sendEmail } from "./server/email.mjs";
+import { resolveConfig } from "./config/index.js";
+import { EventManager } from "./events/index.js";
+import { normalizeComponentSources } from "./utils/componentSources.js";
+import { createRenderer } from "./render/createRenderer.js";
+import { runTransformers } from "./transformers/index.js";
+import { createPlaintext } from "./plaintext.js";
+import { stripForHtml, stripForPlaintext } from "./utils/output-markers.js";
+import { _setCurrentTemplate } from "./composables/useCurrentTemplate.js";
+import { cloneConfig } from "./utils/cloneConfig.js";
+import { setActiveRenderer } from "./render/active.js";
+import { serveLint } from "./server/linter.js";
+import { serveCompatibility } from "./server/compatibility.js";
+import { sendEmail } from "./server/email.js";
+import { createWatchedFileMatcher } from "./utils/watchPaths.js";
 import { createRequire } from "node:module";
 import { readFileSync } from "node:fs";
-import { basename, dirname, resolve } from "node:path";
-import { glob } from "tinyglobby";
+import { basename, dirname, parse, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { glob } from "tinyglobby";
 import { createLogger, createServer } from "vite";
 import vue from "@vitejs/plugin-vue";
+import { renderUnicodeCompact } from "uqr";
 import tailwindcss from "@tailwindcss/vite";
 import { createHighlighter } from "shiki";
-
 //#region src/serve.ts
-var import_picomatch = /* @__PURE__ */ __toESM(require_picomatch(), 1);
 const devUIDir = resolve(dirname(fileURLToPath(import.meta.url)), "server/ui");
 const require = createRequire(import.meta.url);
-const frameworkNodeModules = resolve(dirname(require.resolve("vue/package.json")), "..");
-const vuePkgDir = dirname(require.resolve("vue/package.json"));
+const pkg = (name) => {
+	const resolved = require.resolve(name).replace(/\\/g, "/");
+	const marker = `node_modules/${name}`;
+	const idx = resolved.lastIndexOf(marker);
+	return resolved.slice(0, idx + marker.length);
+};
+/**
+* Resolve a package's ESM entry via its `exports` map. Aliasing to the
+* package directory bypasses `exports` (it only keys off the bare name),
+* so directory resolution can fall back to a UMD/CJS bundle — which Vite 8
+* flags `needsInterop` and then default-imports, breaking ESM-only deps
+* like culori (named exports, no default). Point the alias at the real
+* ESM entry instead.
+*/
+const pkgEsmEntry = (name) => {
+	const dir = pkg(name);
+	const pj = JSON.parse(readFileSync(resolve(dir, "package.json"), "utf-8"));
+	return resolve(dir, pj.exports?.["."]?.import ?? pj.module ?? pj.main);
+};
 /**
 * Start the Maizzle dev server.
 *
@@ -35,20 +56,29 @@ const vuePkgDir = dirname(require.resolve("vue/package.json"));
 async function serve(options = {}) {
 	const start = performance.now();
 	let config = await resolveConfig(options.config);
-	const port = config.server?.port ?? 3e3;
+	const port = options.port ?? config.server?.port ?? 3e3;
 	let renderer = await createRenderer({
 		dts: true,
 		markdown: config.markdown,
 		root: config.root,
-		componentDirs: [config.components?.source ?? []].flat(),
+		componentDirs: normalizeComponentSources(config.components?.source, process.cwd()),
 		vite: config.vite
 	});
+	/**
+	* Register so user-land render() calls reuse this renderer instead of
+	* spinning up another Vite SSR server (which collides when the host
+	* app is itself a Vite dev process — e.g. TanStack Start).
+	*/
+	setActiveRenderer(renderer);
+	const events = new EventManager();
+	events.registerConfig(config);
+	await events.fireBeforeCreate({ config });
 	const server = await createServer({
 		configFile: false,
 		plugins: [
 			vue(),
 			tailwindcss(),
-			maizzleDevPlugin(config, renderer, options.config)
+			maizzleDevPlugin(config, renderer, events, options.config)
 		],
 		resolve: {
 			dedupe: ["vue"],
@@ -59,40 +89,25 @@ async function serve(options = {}) {
 				},
 				{
 					find: "vue",
-					replacement: resolve(vuePkgDir, "dist/vue.runtime.esm-bundler.js")
-				},
-				{
-					find: "vue-router",
-					replacement: resolve(frameworkNodeModules, "vue-router")
-				},
-				{
-					find: "reka-ui",
-					replacement: resolve(frameworkNodeModules, "reka-ui")
-				},
-				{
-					find: "@vueuse/core",
-					replacement: resolve(frameworkNodeModules, "@vueuse/core")
+					replacement: resolve(pkg("vue"), "dist/vue.runtime.esm-bundler.js")
 				},
 				{
-					find: "@vueuse/shared",
-					replacement: resolve(frameworkNodeModules, "@vueuse/shared")
+					find: "culori",
+					replacement: pkgEsmEntry("culori")
 				},
-				{
-					find: "lucide-vue-next",
-					replacement: resolve(frameworkNodeModules, "lucide-vue-next")
-				},
-				{
-					find: "class-variance-authority",
-					replacement: resolve(frameworkNodeModules, "class-variance-authority")
-				},
-				{
-					find: "clsx",
-					replacement: resolve(frameworkNodeModules, "clsx")
-				},
-				{
-					find: "tailwind-merge",
-					replacement: resolve(frameworkNodeModules, "tailwind-merge")
-				}
+				...[
+					"vue-router",
+					"reka-ui",
+					"@vueuse/core",
+					"@vueuse/shared",
+					"@lucide/vue",
+					"class-variance-authority",
+					"clsx",
+					"tailwind-merge"
+				].map((name) => ({
+					find: name,
+					replacement: pkg(name)
+				}))
 			]
 		},
 		cacheDir: resolve(devUIDir, ".vite"),
@@ -101,13 +116,14 @@ async function serve(options = {}) {
 			include: [
 				"vue",
 				"vue-router",
-				"lucide-vue-next",
+				"@lucide/vue",
 				"@vueuse/core",
 				"@vueuse/shared",
 				"reka-ui",
 				"class-variance-authority",
 				"clsx",
-				"tailwind-merge"
+				"tailwind-merge",
+				"culori"
 			]
 		},
 		server: {
@@ -117,13 +133,25 @@ async function serve(options = {}) {
 				process.cwd(),
 				config.root ?? process.cwd(),
 				devUIDir,
-				frameworkNodeModules
+				...[
+					"vue",
+					"vue-router",
+					"reka-ui",
+					"@vueuse/core",
+					"@vueuse/shared",
+					"@lucide/vue",
+					"class-variance-authority",
+					"clsx",
+					"tailwind-merge",
+					"culori"
+				].map(pkg)
 			] }
 		},
 		customLogger: customLogger()
 	});
 	const originalClose = server.close.bind(server);
 	server.close = async () => {
+		setActiveRenderer(null);
 		await renderer.close();
 		return originalClose();
 	};
@@ -136,13 +164,18 @@ async function serve(options = {}) {
 /**
 * Internal Vite plugin that adds Maizzle middleware and file watching to the dev UI server.
 */
-function maizzleDevPlugin(config, renderer, configInput) {
+function maizzleDevPlugin(config, renderer, events, configInput) {
 	return {
 		name: "maizzle:dev",
 		enforce: "pre",
 		hotUpdate: {
 			order: "pre",
 			handler({ file }) {
+				/**
+				* Prevent Tailwind/Vue from triggering a full reload for email template
+				* files. Maizzle handles these via custom HMR events in the
+				* watcher below.
+				*/
 				if (isTemplateFile(file)) return [];
 			}
 		},
@@ -156,62 +189,96 @@ function maizzleDevPlugin(config, renderer, configInput) {
 			];
 			const userWatchPaths = config.server?.watch ?? [];
 			const watchPaths = [...defaultWatchPaths, ...userWatchPaths];
-			const isWatchedFile = (0, import_picomatch.default)(watchPaths);
+			const isWatchedFile = createWatchedFileMatcher(watchPaths, process.cwd());
 			for (const watchPath of watchPaths) server.watcher.add(watchPath);
-			server.watcher.on("add", async (file) => {
+			/**
+			* Serialize watcher work onto one chain. The change handler closes and
+			* recreates the renderer across awaits; without serialization a second
+			* event firing mid-reload closes a stale renderer and leaks the new one.
+			* Errors are caught so one failed task doesn't break the chain.
+			*/
+			let watcherChain = Promise.resolve();
+			const enqueue = (task) => {
+				watcherChain = watcherChain.then(task).catch((err) => {
+					console.error("[maizzle] watcher task failed:", err);
+				});
+				return watcherChain;
+			};
+			server.watcher.on("add", (file) => enqueue(async () => {
 				if (isTemplateFile(file)) {
 					await renderer.invalidateAll();
+					bumpGeneration();
 					server.ws.send({
 						type: "custom",
 						event: "maizzle:templates-changed"
 					});
 				}
-			});
-			server.watcher.on("unlink", async (file) => {
+			}));
+			server.watcher.on("unlink", (file) => enqueue(async () => {
 				if (isTemplateFile(file)) {
 					await renderer.invalidateAll();
+					bumpGeneration();
 					server.ws.send({
 						type: "custom",
 						event: "maizzle:templates-changed"
 					});
 				}
-			});
-			server.watcher.on("change", async (file) => {
+			}));
+			server.watcher.on("change", (file) => enqueue(async () => {
 				if (isWatchedFile(file)) {
 					config = await resolveConfig(configInput);
+					events.clear();
+					events.registerConfig(config);
 					await renderer.close();
 					renderer = await createRenderer({
 						dts: true,
 						markdown: config.markdown,
 						root: config.root,
-						componentDirs: [config.components?.source ?? []].flat(),
+						componentDirs: normalizeComponentSources(config.components?.source, process.cwd()),
 						vite: config.vite
 					});
+					setActiveRenderer(renderer);
+					/**
+					* Push UI-relevant config bits so the dev UI reacts to live edits
+					* without a page reload. Uses the same shape as the initial
+					* inject.
+					*/
+					server.ws.send({
+						type: "custom",
+						event: "maizzle:config-updated",
+						data: buildUiConfig(config)
+					});
 				}
+				/**
+				* Invalidate all renderer modules so component and config changes
+				* are picked up on the next render (Tailwind recompiles with
+				* fresh content).
+				*/
 				await renderer.invalidateAll();
+				bumpGeneration();
 				if (isTemplateFile(file) || isWatchedFile(file)) server.ws.send({
 					type: "custom",
 					event: "maizzle:template-updated",
 					data: { file }
 				});
-			});
+			}));
 			server.middlewares.use(async (req, res, next) => {
 				const url = req.url || "/";
 				if (url === "/__maizzle/templates") return serveTemplateList(config, res);
-				if (url.startsWith("/__maizzle/render/")) return await serveRenderedTemplate(url, config, renderer, res);
-				if (url.startsWith("/__maizzle/source/")) return await serveHighlightedSource(url, config, renderer, res);
-				if (url === "/__maizzle/compatibility" && req.method === "POST") return await serveCompatibility(req, res);
-				if (url.startsWith("/__maizzle/lint/")) return serveLint(url, res);
+				if (url.startsWith("/__maizzle/render/")) return await serveRenderedTemplate(url, config, renderer, events, res);
+				if (url.startsWith("/__maizzle/source/")) return await serveHighlightedSource(url, config, renderer, events, res);
+				if (url.startsWith("/__maizzle/compatibility/")) return await serveCompatibility(url, res, config, normalizeComponentSources(config.components?.source, process.cwd()));
+				if (url.startsWith("/__maizzle/lint/")) return await serveLint(url, res, config, normalizeComponentSources(config.components?.source, process.cwd()));
 				if (url.startsWith("/__maizzle/vue-source/")) return await serveVueSource(url, config, res);
-				if (url.startsWith("/__maizzle/plaintext/")) return await servePlaintext(url, config, renderer, res);
-				if (url.startsWith("/__maizzle/stats/")) return await serveStats(url, config, renderer, res);
-				if (url.startsWith("/__maizzle/email/") && req.method === "POST") return await serveEmailEndpoint(url, req, res, config, renderer);
+				if (url.startsWith("/__maizzle/plaintext/")) return await servePlaintext(url, config, renderer, events, res);
+				if (url.startsWith("/__maizzle/stats/")) return await serveStats(url, config, renderer, events, res);
+				if (url.startsWith("/__maizzle/email/") && req.method === "POST") return await serveEmailEndpoint(url, req, res, config, renderer, events);
 				if (url === "/__maizzle/email-config") return serveEmailConfig(config, res);
 				next();
 			});
 			return () => {
 				server.middlewares.use(async (req, res, next) => {
-					if (isNavigationRequest(req)) return await serveDevUI(server, res, req.url || "/");
+					if (isNavigationRequest(req)) return await serveDevUI(server, res, req.url || "/", config);
 					next();
 				});
 			};
@@ -225,10 +292,20 @@ function isNavigationRequest(req) {
 	const accept = req.headers?.accept || "";
 	return req.method === "GET" && accept.includes("text/html");
 }
-async function serveDevUI(server, res, url) {
+/**
+* Shape exposed to the dev UI both at initial HTML load (as
+* `window.__MAIZZLE_CONFIG__`) and on the `maizzle:config-updated` HMR event.
+* Add UI-visible config bits here; consumers on both ends pick up automatically.
+*/
+function buildUiConfig(config) {
+	return { checks: config.server?.checks ?? true };
+}
+async function serveDevUI(server, res, url, config) {
 	let indexHtml = readFileSync(resolve(devUIDir, "index.html"), "utf-8");
 	indexHtml = indexHtml.replace("./main.ts", `/@fs/${resolve(devUIDir, "main.ts")}`);
 	indexHtml = indexHtml.replace("./favicon.svg", `/@fs/${resolve(devUIDir, "favicon.svg")}`);
+	const configScript = `<script>window.__MAIZZLE_CONFIG__ = ${JSON.stringify(buildUiConfig(config))};<\/script>`;
+	indexHtml = indexHtml.replace("</head>", `${configScript}</head>`);
 	const transformed = await server.transformIndexHtml(url, indexHtml);
 	res.setHeader("Content-Type", "text/html");
 	res.end(transformed);
@@ -243,9 +320,77 @@ async function serveTemplateList(config, res) {
 	res.end(JSON.stringify(data));
 }
 /**
+* Render-result memo for the dev server. A single template save makes the
+* browser fire several endpoint requests in parallel (render, source, stats,
+* plaintext, email) that each need the same SSR render + transformer output.
+* Keying the in-flight Promise by `${generation}:${path}` collapses those into
+* one render and dedupes concurrent requests. The watcher bumps the generation
+* (and clears the cache) on every file/config change, so results never go
+* stale. Each endpoint applies its own tail step (doctype prepend, strip,
+* highlight, …) on top of `rawHtml`, keeping output byte-identical.
+*/
+let renderGeneration = 0;
+const renderCache = /* @__PURE__ */ new Map();
+function bumpGeneration() {
+	renderGeneration++;
+	renderCache.clear();
+}
+function getRendered(absolutePath, config, renderer, events) {
+	const key = `${renderGeneration}:${absolutePath}`;
+	let promise = renderCache.get(key);
+	if (!promise) {
+		promise = (async () => {
+			_setCurrentTemplate(parse(absolutePath));
+			try {
+				/**
+				* Mirror the build's per-template event pipeline (see buildTemplate)
+				* so dev preview fires the same beforeRender / afterRender /
+				* afterTransform hooks and matches production output. Clone config so
+				* beforeRender mutations stay scoped to this render.
+				*/
+				const renderConfig = cloneConfig(config);
+				const template = {
+					source: readFileSync(absolutePath, "utf-8"),
+					path: parse(absolutePath)
+				};
+				const originalSource = template.source;
+				await events.fireBeforeRender({
+					config: renderConfig,
+					template
+				});
+				const rendered = await renderer.render(absolutePath, renderConfig, template.source !== originalSource ? { source: template.source } : void 0);
+				for (const { name, handler } of rendered.sfcEventHandlers) events.on(name, handler);
+				const templateConfig = rendered.templateConfig;
+				let html = await events.fireAfterRender({
+					config: templateConfig,
+					template,
+					html: rendered.html
+				});
+				const doctype = rendered.doctype ?? templateConfig.doctype ?? "<!DOCTYPE html>";
+				if (templateConfig.useTransformers !== false) html = await runTransformers(html, templateConfig, absolutePath, doctype, rendered.tailwindBlocks);
+				return {
+					rawHtml: await events.fireAfterTransform({
+						config: templateConfig,
+						template,
+						html
+					}),
+					doctype,
+					templateConfig,
+					rendered
+				};
+			} finally {
+				_setCurrentTemplate(void 0);
+				events.clearSfcHandlers();
+			}
+		})();
+		renderCache.set(key, promise);
+	}
+	return promise;
+}
+/**
 * SSR render a .vue template using the Renderer (not the dev UI server).
 */
-async function serveRenderedTemplate(url, config, renderer, res) {
+async function serveRenderedTemplate(url, config, renderer, events, res) {
 	const templateSlug = url.replace("/__maizzle/render/", "").replace(/\?.*$/, "");
 	const match = (await glob(config.content ?? ["emails/**/*.vue"])).find((t) => t.replace(/\.(vue|md)$/, "") === templateSlug);
 	if (!match) {
@@ -253,17 +398,13 @@ async function serveRenderedTemplate(url, config, renderer, res) {
 		res.end("Template not found");
 		return;
 	}
+	const absolutePath = resolve(match);
 	try {
-		const absolutePath = resolve(match);
-		await renderer.invalidateAll();
-		const rendered = await renderer.render(absolutePath, config);
-		let html = rendered.html;
-		const templateConfig = rendered.templateConfig;
-		const doctype = rendered.doctype ?? templateConfig.doctype ?? "<!DOCTYPE html>";
-		html = await runTransformers(html, templateConfig, absolutePath, doctype);
-		html = `${doctype}\n${html}`;
+		const { rawHtml, doctype } = await getRendered(absolutePath, config, renderer, events);
+		let html = rawHtml;
+		if (doctype) html = `${doctype}\n${html}`;
 		res.setHeader("Content-Type", "text/html");
-		res.end(html);
+		res.end(stripForHtml(html));
 	} catch (error) {
 		res.statusCode = 500;
 		res.end(`<pre>${error.stack || error.message}</pre>`);
@@ -277,7 +418,7 @@ async function getHighlighter() {
 	});
 	return highlighter;
 }
-async function serveHighlightedSource(url, config, renderer, res) {
+async function serveHighlightedSource(url, config, renderer, events, res) {
 	const templateSlug = url.replace("/__maizzle/source/", "").replace(/\?.*$/, "");
 	const match = (await glob(config.content ?? ["emails/**/*.vue"])).find((t) => t.replace(/\.(vue|md)$/, "") === templateSlug);
 	if (!match) {
@@ -285,15 +426,10 @@ async function serveHighlightedSource(url, config, renderer, res) {
 		res.end("Template not found");
 		return;
 	}
+	const absolutePath = resolve(match);
 	try {
-		const absolutePath = resolve(match);
-		await renderer.invalidateAll();
-		const rendered = await renderer.render(absolutePath, config);
-		let html = rendered.html;
-		const templateConfig = rendered.templateConfig;
-		const doctype = rendered.doctype ?? templateConfig.doctype ?? "<!DOCTYPE html>";
-		html = await runTransformers(html, templateConfig, absolutePath, doctype);
-		html = `${doctype}\n${html}`;
+		const { rawHtml, doctype } = await getRendered(absolutePath, config, renderer, events);
+		const html = stripForHtml(doctype ? `${doctype}\n${rawHtml}` : rawHtml);
 		const highlighted = (await getHighlighter()).codeToHtml(html, {
 			lang: "html",
 			theme: "laserwave",
@@ -333,7 +469,7 @@ async function serveVueSource(url, config, res) {
 		res.end(`<pre>${error.stack || error.message}</pre>`);
 	}
 }
-async function servePlaintext(url, config, renderer, res) {
+async function servePlaintext(url, config, renderer, events, res) {
 	const templateSlug = url.replace("/__maizzle/plaintext/", "").replace(/\?.*$/, "");
 	const match = (await glob(config.content ?? ["emails/**/*.vue"])).find((t) => t.replace(/\.(vue|md)$/, "") === templateSlug);
 	if (!match) {
@@ -341,15 +477,10 @@ async function servePlaintext(url, config, renderer, res) {
 		res.end("Template not found");
 		return;
 	}
+	const absolutePath = resolve(match);
 	try {
-		const absolutePath = resolve(match);
-		await renderer.invalidateAll();
-		const rendered = await renderer.render(absolutePath, config);
-		let html = rendered.html;
-		const templateConfig = rendered.templateConfig;
-		const doctype = rendered.doctype ?? templateConfig.doctype ?? "<!DOCTYPE html>";
-		html = await runTransformers(html, templateConfig, absolutePath, doctype);
-		const plaintext = createPlaintext(html);
+		const { rawHtml } = await getRendered(absolutePath, config, renderer, events);
+		const plaintext = createPlaintext(stripForPlaintext(rawHtml));
 		res.setHeader("Content-Type", "text/plain");
 		res.end(plaintext);
 	} catch (error) {
@@ -378,7 +509,7 @@ function humanFileSize(bytes, si = false, dp = 2) {
 	} while (Math.round(Math.abs(bytes) * r) / r >= threshold && u < units.length - 1);
 	return bytes.toFixed(dp) + " " + units[u];
 }
-async function serveStats(url, config, renderer, res) {
+async function serveStats(url, config, renderer, events, res) {
 	const templateSlug = url.replace("/__maizzle/stats/", "").replace(/\?.*$/, "");
 	const match = (await glob(config.content ?? ["emails/**/*.vue"])).find((t) => t.replace(/\.(vue|md)$/, "") === templateSlug);
 	if (!match) {
@@ -386,15 +517,11 @@ async function serveStats(url, config, renderer, res) {
 		res.end(JSON.stringify({ error: "Template not found" }));
 		return;
 	}
+	const absolutePath = resolve(match);
 	try {
-		const absolutePath = resolve(match);
-		await renderer.invalidateAll();
-		const rendered = await renderer.render(absolutePath, config);
-		let html = rendered.html;
-		const templateConfig = rendered.templateConfig;
-		const doctype = rendered.doctype ?? templateConfig.doctype ?? "<!DOCTYPE html>";
-		html = await runTransformers(html, templateConfig, absolutePath, doctype);
-		const sizeBytes = Buffer.byteLength(html, "utf-8");
+		const { rawHtml } = await getRendered(absolutePath, config, renderer, events);
+		const html = stripForHtml(rawHtml);
+		const sizeBytes = new TextEncoder().encode(html).length;
 		const totalImages = (html.match(/<img\b[^>]*>/gi) || []).length + (html.match(/url\s*\([^)]+\)/gi) || []).length;
 		const links = (html.match(/<a\b[^>]*href\s*=/gi) || []).length;
 		res.setHeader("Content-Type", "application/json");
@@ -411,7 +538,7 @@ async function serveStats(url, config, renderer, res) {
 		res.end(JSON.stringify({ error: error.message }));
 	}
 }
-async function serveEmailEndpoint(url, req, res, config, renderer) {
+async function serveEmailEndpoint(url, req, res, config, renderer, events) {
 	const templateSlug = url.replace("/__maizzle/email/", "").replace(/\?.*$/, "");
 	const match = (await glob(config.content ?? ["emails/**/*.vue"])).find((t) => t.replace(/\.(vue|md)$/, "") === templateSlug);
 	if (!match) {
@@ -443,16 +570,12 @@ async function serveEmailEndpoint(url, req, res, config, renderer) {
 		}));
 		return;
 	}
+	const absolutePath = resolve(match);
 	try {
-		const absolutePath = resolve(match);
-		await renderer.invalidateAll();
-		const rendered = await renderer.render(absolutePath, config);
-		let html = rendered.html;
-		const templateConfig = rendered.templateConfig;
-		const doctype = rendered.doctype ?? templateConfig.doctype ?? "<!DOCTYPE html>";
-		html = await runTransformers(html, templateConfig, absolutePath, doctype);
-		html = `${doctype}\n${html}`;
-		const text = createPlaintext(html);
+		const { rawHtml, doctype, templateConfig } = await getRendered(absolutePath, config, renderer, events);
+		let html = doctype ? `${doctype}\n${rawHtml}` : rawHtml;
+		const text = createPlaintext(stripForPlaintext(html));
+		html = stripForHtml(html);
 		const result = await sendEmail({
 			to: payload.to,
 			subject: payload.subject,
@@ -482,6 +605,12 @@ function serveEmailConfig(config, res) {
 function printBanner(server, startupTime) {
 	const info = server.config.logger.info;
 	const time = startupTime ?? server._maizzleStartupTime;
+	const networkUrl = server.resolvedUrls?.network[0];
+	if (networkUrl) {
+		const qr = renderUnicodeCompact(networkUrl, { border: 1 });
+		info("");
+		info(qr.split("\n").map((line) => `  ${line}`).join("\n"));
+	}
 	info("");
 	info(`  \x1b[32m\x1b[1mMAIZZLE\x1b[0m\x1b[32m v6.0.0\x1b[0m  \x1b[2mready in\x1b[0m \x1b[1m${time}\x1b[0m ms`);
 	info("");
@@ -497,7 +626,7 @@ function customLogger() {
 	};
 	return logger;
 }
-
 //#endregion
 export { printBanner, serve };
-//# sourceMappingURL=serve.mjs.map
+
+//# sourceMappingURL=serve.js.map