@aerobuilt/core 0.2.10 → 0.3.0

package/dist/vite/index.mjs

@@ -0,0 +1,1890 @@
+import { a as isDynamicRoutePattern, i as expandRoutePattern, n as resolvePageName, o as toPosix, s as toPosixRelative, t as pagePathToKey } from "../routing-Bai79LCq.mjs";
+import { a as compileInterpolationFromSegments, i as isDirectiveAttr, o as tokenizeCurlyInterpolation, t as analyzeBuildScript } from "../build-script-analysis-Bd9EyItC.mjs";
+import { loadTsconfigAliases, mergeWithDefaultAliases } from "../utils/aliases.mjs";
+import { redirectsToRouteRules } from "../utils/redirects.mjs";
+import { createRequire } from "node:module";
+import { ViteImageOptimizer } from "vite-plugin-image-optimizer";
+import { nitro } from "nitro/vite";
+import { parseHTML } from "linkedom";
+import path from "path";
+import path$1 from "node:path";
+import { minify } from "html-minifier-next";
+import fs, { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createServer } from "vite";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+//#region src/utils/parse.ts
+/**
+* General-purpose expression parsing utilities.
+*/
+/**
+* Extract top-level property keys from an object-literal expression string.
+*
+* @param expr - e.g. `{ title: expr, id: 42 }` or `{ config }` (shorthand).
+* @returns e.g. `['title', 'id']` or `['config']`. Does not support spread; callers must handle `...obj` separately.
+*/
+function extractObjectKeys(expr) {
+	let inner = expr.trim();
+	while (inner.startsWith("{") && inner.endsWith("}")) inner = inner.slice(1, -1).trim();
+	if (!inner) return [];
+	const keys = [];
+	let depth = 0;
+	let current = "";
+	for (let i = 0; i < inner.length; i++) {
+		const char = inner[i];
+		if (char === "{" || char === "[" || char === "(") {
+			depth++;
+			current += char;
+		} else if (char === "}" || char === "]" || char === ")") {
+			depth--;
+			current += char;
+		} else if (char === "," && depth === 0) {
+			const key = extractKeyFromEntry(current.trim());
+			if (key) keys.push(key);
+			current = "";
+		} else current += char;
+	}
+	const lastKey = extractKeyFromEntry(current.trim());
+	if (lastKey) keys.push(lastKey);
+	return keys;
+}
+/** Extract key from one property entry: `key: value` → key, shorthand `ident` → ident; returns null for spread or invalid. */
+function extractKeyFromEntry(entry) {
+	if (!entry) return null;
+	if (entry.startsWith("...")) return null;
+	const colonIdx = entry.indexOf(":");
+	if (colonIdx > 0) return entry.slice(0, colonIdx).trim();
+	if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(entry)) return entry;
+	return null;
+}
+
+//#endregion
+//#region src/vite/defaults.ts
+/** Virtual URL prefix for extracted client scripts (e.g. `/@aero/client/client/pages/home.js`). Root-relative; no filesystem path. */
+const CLIENT_SCRIPT_PREFIX = "/@aero/client/";
+/**
+* Virtual URL for one client script. Single script uses `.js`, multiple use `.0.js`, `.1.js`, etc.
+* Use this in the Vite transform and static build so URL generation is consistent.
+*/
+function getClientScriptVirtualUrl(baseName, index, total) {
+	const suffix = total === 1 ? ".js" : `.${index}.js`;
+	return CLIENT_SCRIPT_PREFIX + baseName + suffix;
+}
+/** Virtual module ID requested by the app; resolved to `RESOLVED_*` so `load()` can re-export from the real runtime instance. */
+const RUNTIME_INSTANCE_MODULE_ID = "virtual:aero/runtime-instance";
+/** Resolved ID (with `\0` prefix) so Vite treats it as an internal module. */
+const RESOLVED_RUNTIME_INSTANCE_MODULE_ID = "\0virtual:aero/runtime-instance";
+/** Prefix for virtual empty-CSS modules used when Vite requests .html?html-proxy&inline-css (Aero .html are JS, not HTML with styles). */
+const AERO_EMPTY_INLINE_CSS_PREFIX = "\0aero:empty-inline-css:";
+/** Prefix for virtual HTML template modules. Resolving .html to this id returns compiled JS so vite:build-html never sees raw/compiled HTML. */
+const AERO_HTML_VIRTUAL_PREFIX = "\0aero-html:";
+/** Default directory names: client source, server (Nitro), dist output. */
+const DEFAULT_DIRS = {
+	client: "client",
+	server: "server",
+	dist: "dist"
+};
+/** Default API route prefix (e.g. `/api`). */
+const DEFAULT_API_PREFIX = "/api";
+/** HTML attributes scanned for absolute URLs during static build rewrite (href, src, hx-*, action). */
+const LINK_ATTRS = [
+	"href",
+	"src",
+	"action",
+	"hx-get",
+	"hx-post",
+	"hx-put",
+	"hx-patch",
+	"hx-delete"
+];
+/** URLs matching this regex are not rewritten (external, protocol, hash, etc.). */
+const SKIP_PROTOCOL_REGEX = /^(?:https?:\/\/|\/\/|mailto:|tel:|data:|javascript:|#|blob:|file:\/\/)/i;
+function getServerDir(dirs) {
+	return dirs?.server ?? DEFAULT_DIRS.server;
+}
+/**
+* Resolve optional user dir overrides with defaults (DEFAULT_DIRS).
+*
+* @param dirs - Optional partial AeroDirs (e.g. `{ dist: 'build' }` or `{ server: 'server' }`).
+* @returns ResolvedAeroDirs with all keys set.
+*/
+function resolveDirs(dirs) {
+	return {
+		client: dirs?.client ?? DEFAULT_DIRS.client,
+		server: getServerDir(dirs),
+		dist: dirs?.dist ?? DEFAULT_DIRS.dist
+	};
+}
+
+//#endregion
+//#region src/compiler/constants.ts
+/**
+* Shared constants for the Aero compiler (parser, codegen, helpers).
+*
+* @remarks
+* Attribute names are used with optional `data-` prefix (e.g. `data-each`). Script taxonomy uses
+* `is:build`, `is:inline`, `is:blocking`; default scripts are treated as client (virtual module).
+*/
+/** Prefix for data attributes (e.g. `data-each` → ATTR_PREFIX + ATTR_EACH). */
+const ATTR_PREFIX = "data-";
+/** Attribute for spreading props onto a component: `data-props` or `data-props="{ ... }"`. */
+const ATTR_PROPS = "props";
+/** Attribute for iteration: `data-each="{ item in items }"`. */
+const ATTR_EACH = "each";
+const ATTR_IF = "if";
+const ATTR_ELSE_IF = "else-if";
+const ATTR_ELSE = "else";
+/** Slot name (on `<slot>` or content). */
+const ATTR_NAME = "name";
+const ATTR_SLOT = "slot";
+/** Script runs at build time; extracted and becomes render function body. */
+const ATTR_IS_BUILD = "is:build";
+/** Script left in template in place; not extracted. */
+const ATTR_IS_INLINE = "is:inline";
+/** Script hoisted to head; extracted. */
+const ATTR_IS_BLOCKING = "is:blocking";
+/** Script/style receives data from template: `pass:data="{ config }"` or `pass:data="{ ...theme }"`. */
+const ATTR_PASS_DATA = "pass:data";
+/** Script external source (HTML attribute). */
+const ATTR_SRC = "src";
+const TAG_SLOT = "slot";
+/** Default slot name when no name is given. */
+const SLOT_NAME_DEFAULT = "default";
+/** Matches `item in items` for data-each (captures: loop variable, iterable expression). */
+const EACH_REGEX = /^(\w+)\s+in\s+(.+)$/;
+/** Matches tag names ending with `-component` or `-layout`. */
+const COMPONENT_SUFFIX_REGEX = /-(component|layout)$/;
+/** Self-closing tag: `<tag ... />`. */
+const SELF_CLOSING_TAG_REGEX = /<([a-z0-9-]+)([^>]*?)\/>/gi;
+const SELF_CLOSING_TAIL_REGEX = /\/>$/;
+/** HTML void elements that have no closing tag. */
+const VOID_TAGS = new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+
+//#endregion
+//#region src/compiler/parser.ts
+/** Serialize element attributes to a string, excluding given names (case-insensitive). Values are XML-escaped. */
+function getAttrsString(element, exclude) {
+	const parts = [];
+	const attrs = element.attributes;
+	if (!attrs) return "";
+	const excludeLower = new Set([...exclude].map((s) => s.toLowerCase()));
+	for (let i = 0; i < attrs.length; i++) {
+		const a = attrs[i];
+		if (!a || excludeLower.has(a.name.toLowerCase())) continue;
+		const escaped = a.value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+		parts.push(`${a.name}="${escaped}"`);
+	}
+	return parts.join(" ").trim();
+}
+/** True if element is inside SVG or MathML (foreign content). */
+function isInForeignNamespace(el) {
+	let parent = el.parentElement;
+	while (parent) {
+		const tag = parent.tagName?.toLowerCase();
+		if (tag === "svg" || tag === "math") return true;
+		parent = parent.parentElement;
+	}
+	return false;
+}
+/** True if element is inside <head>. */
+function isInHead(el) {
+	let parent = el.parentElement;
+	while (parent) {
+		if (parent.tagName?.toLowerCase() === "head") return true;
+		parent = parent.parentElement;
+	}
+	return false;
+}
+/** Collect all <script> elements in document order that are not inside SVG/MathML. */
+function collectScriptElements(doc) {
+	const scripts = [];
+	const walk = (node) => {
+		if (node.nodeType === 1) {
+			const el = node;
+			if (el.tagName?.toLowerCase() === "script") {
+				if (!isInForeignNamespace(el)) scripts.push(el);
+				return;
+			}
+		}
+		for (let i = 0; i < node.childNodes.length; i++) walk(node.childNodes[i]);
+	};
+	walk(doc);
+	return scripts;
+}
+/**
+* Parse HTML and extract Aero script blocks; return build script, client/inline/blocking script arrays, and template.
+*
+* @remarks
+* DOM-first approach: parse full document with linkedom, walk script elements (skipping SVG/MathML),
+* classify by attributes (is:build, is:inline, is:blocking, src, pass:data), mutate DOM (remove/replace),
+* then serialize to produce template. Scripts inside HTML comments are not in the DOM and are left in place.
+* BOM is stripped first.
+*
+* @param html - Full template HTML (may include BOM).
+* @returns ParseResult with buildScript, clientScripts, inlineScripts, blockingScripts, and template (script blocks removed/replaced).
+*/
+function parse(html) {
+	html = html.replace(/^\uFEFF/, "");
+	html = html.replace(SELF_CLOSING_TAG_REGEX, (match, tagName, attrs) => {
+		const tag = String(tagName).toLowerCase();
+		if (VOID_TAGS.has(tag)) return match;
+		return `<${tagName}${attrs}></${tagName}>`;
+	});
+	const isFullDocument = /<\s*html[\s>]/i.test(html);
+	let doc;
+	if (isFullDocument) doc = parseHTML(html).document;
+	else doc = parseHTML(`<html><head></head><body>${html}</body></html>`).document;
+	const buildContent = [];
+	const clientScripts = [];
+	const inlineScripts = [];
+	const blockingScripts = [];
+	const scriptElements = collectScriptElements(doc);
+	const toRemove = [];
+	for (const scriptEl of scriptElements) {
+		const inHead = isInHead(scriptEl);
+		const hasBuild = scriptEl.hasAttribute(ATTR_IS_BUILD);
+		const hasInline = scriptEl.hasAttribute(ATTR_IS_INLINE);
+		const hasBlocking = scriptEl.hasAttribute(ATTR_IS_BLOCKING);
+		const src = scriptEl.getAttribute(ATTR_SRC) ?? "";
+		const passData = scriptEl.getAttribute(ATTR_PASS_DATA) ?? void 0;
+		const attrsExcludeTaxonomy = new Set([
+			ATTR_IS_BUILD,
+			ATTR_IS_INLINE,
+			ATTR_IS_BLOCKING
+		]);
+		let cleanedAttrs = getAttrsString(scriptEl, attrsExcludeTaxonomy);
+		if (!hasInline && !inHead) cleanedAttrs = getAttrsString(scriptEl, new Set([...attrsExcludeTaxonomy, ATTR_PASS_DATA]));
+		cleanedAttrs = cleanedAttrs.replace(/\s+/g, " ").trim();
+		const content = (scriptEl.textContent ?? "").trim();
+		if (hasBuild) {
+			buildContent.push(content);
+			toRemove.push(scriptEl);
+			continue;
+		}
+		if (hasInline) {
+			inlineScripts.push({
+				attrs: cleanedAttrs,
+				content,
+				passDataExpr: passData
+			});
+			scriptEl.removeAttribute(ATTR_IS_INLINE);
+			continue;
+		}
+		if (hasBlocking) {
+			blockingScripts.push({
+				attrs: cleanedAttrs,
+				content,
+				passDataExpr: passData
+			});
+			toRemove.push(scriptEl);
+			continue;
+		}
+		if (src) {
+			const isLocal = !src.startsWith("http://") && !src.startsWith("https://");
+			const hasType = scriptEl.hasAttribute("type");
+			if (isLocal && !hasType) {
+				scriptEl.setAttribute("type", "module");
+				scriptEl.removeAttribute("defer");
+			}
+			continue;
+		}
+		if (inHead && scriptEl.attributes.length > 0) continue;
+		clientScripts.push({
+			attrs: cleanedAttrs,
+			content,
+			passDataExpr: passData,
+			injectInHead: inHead
+		});
+		toRemove.push(scriptEl);
+	}
+	for (const el of toRemove) el.remove();
+	const buildScript = buildContent.length > 0 ? { content: buildContent.join("\n") } : null;
+	let template;
+	if (isFullDocument) template = doc.documentElement ? doc.documentElement.outerHTML : String(doc);
+	else template = doc.body ? doc.body.innerHTML : "";
+	return {
+		buildScript,
+		clientScripts,
+		inlineScripts,
+		blockingScripts,
+		template: template.trim()
+	};
+}
+
+//#endregion
+//#region src/compiler/helpers.ts
+/**
+* Helpers for the Aero codegen: interpolation, attributes, slots, and render-function emission.
+*
+* @remarks
+* Used by `codegen.ts` to compile `{ expr }` to template literals, build props/slots code, and emit
+* the top-level render wrapper.
+*/
+/**
+* Validate that a value is a single well-formed braced expression using the same tokenizer as
+* attribute interpolation. Used for pass:data (and optionally other braced directives); emission
+* stays expression-passthrough.
+*
+* @param value - Raw attribute value (e.g. pass:data value).
+* @param options - Optional directive and tagName for error message.
+* @returns Trimmed value (including braces).
+* @throws If value is not exactly one interpolation segment spanning the whole trimmed string.
+*/
+function validateSingleBracedExpression(value, options = {}) {
+	const trimmed = value.trim();
+	const segments = tokenizeCurlyInterpolation(trimmed, { attributeMode: true });
+	if (!(segments.length === 1 && segments[0].kind === "interpolation" && segments[0].start === 0 && segments[0].end === trimmed.length)) {
+		const directive = options.directive ?? "directive";
+		const tagName = options.tagName ?? "element";
+		throw new Error(`Directive \`${directive}\` on <${tagName}> must use a braced expression, e.g. ${directive}="{ expression }".`);
+	}
+	return trimmed;
+}
+/**
+* Compile text for use inside a template literal; replaces `{ expr }` with `${ expr }`.
+*
+* @param text - Raw text (may contain `{...}` interpolation).
+* @returns String safe for embedding in a template literal (backticks escaped).
+*/
+function compileInterpolation(text) {
+	if (!text) return "";
+	return compileInterpolationFromSegments(tokenizeCurlyInterpolation(text, { attributeMode: false }));
+}
+/**
+* Compile an attribute value: `{ expr }` → interpolation; `{{` / `}}` → literal `{` / `}`.
+*
+* @param text - Attribute value string.
+* @returns String safe for template literal (backticks escaped, double-braces as literals).
+*/
+function compileAttributeInterpolation(text) {
+	if (!text) return "";
+	return compileInterpolationFromSegments(tokenizeCurlyInterpolation(text, { attributeMode: true }));
+}
+/** True if `name` equals `attr` or `prefix + attr` (e.g. `each` or `data-each`). */
+function isAttr(name, attr, prefix) {
+	return name === attr || name === prefix + attr;
+}
+/** Remove outer braces: `"{ expr }"` → `expr`. */
+function stripBraces(s) {
+	const trimmed = s.trim();
+	if (trimmed.startsWith("{") && trimmed.endsWith("}")) return trimmed.slice(1, -1).trim();
+	return trimmed;
+}
+/** Convert kebab-case to camelCase (e.g. `my-component` → `myComponent`). */
+function kebabToCamelCase(s) {
+	return s.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+/** Build a props object code string from key-value entries and optional spread (e.g. `{ ...base, title }`). */
+function buildPropsString(entries, spreadExpr) {
+	if (spreadExpr) return entries.length > 0 ? `{ ${spreadExpr}, ${entries.join(", ")} }` : `{ ${spreadExpr} }`;
+	return `{ ${entries.join(", ")} }`;
+}
+/** Escape backticks for safe embedding in generated template literals. */
+function escapeBackticks(s) {
+	return s.replace(/`/g, "\\`");
+}
+/** Emit code for a slots object whose values are variable names (e.g. `{ "default": __slot0 }`). */
+function emitSlotsObjectVars(slotsMap) {
+	return "{ " + Object.entries(slotsMap).map(([k, varName]) => `"${k}": ${varName}`).join(", ") + " }";
+}
+/**
+* Emit the default async render function: destructured context, script block, optional style/script/head blocks, then body that appends to `__out`.
+* Single source of truth for the shape of the compiled render function; codegen calls this with all sections.
+*
+* @param script - Build script content (imports + user code).
+* @param body - Generated statements that build the HTML string.
+* @param options - Optional getStaticPathsFn, rootStyles, rootScripts, styleCode, rootScriptsLines, headScriptsLines.
+* @returns Full module source (getStaticPaths + default render function).
+*/
+function emitRenderFunction(script, body, options = {}) {
+	const { getStaticPathsFn, rootStyles, rootScripts, styleCode = "", rootScriptsLines = [], headScriptsLines = [] } = options;
+	const stylesCode = rootStyles && rootStyles.length > 0 ? rootStyles.map((s) => `styles?.add(${JSON.stringify(s)});`).join("\n		") : "";
+	const scriptsCode = rootScripts && rootScripts.length > 0 ? rootScripts.map((s) => `scripts?.add(${JSON.stringify(s)});`).join("\n		") : "";
+	const rootScriptsBlock = rootScriptsLines.length > 0 ? rootScriptsLines.join("\n		") : "";
+	const headScriptsBlock = headScriptsLines.length > 0 ? headScriptsLines.map((s) => `injectedHeadScripts?.add(${s});`).join("\n		") : "";
+	const renderFn = `export default async function(Aero) {
+		const { ${getRenderContextDestructurePattern()} } = Aero;
+		${script}
+		${styleCode}
+		${stylesCode}
+		${scriptsCode}
+		${rootScriptsBlock}
+		${headScriptsBlock}
+		let __out = '';
+		${body}return __out;
+	}`;
+	if (getStaticPathsFn) return `${getStaticPathsFn}\n\n${renderFn}`.trim();
+	return renderFn.trim();
+}
+/**
+* Pairs of [inputKey, destructuredVarName] for the 4th argument to Aero.renderComponent(..., input).
+* Must stay in sync with runtime createContext / AeroRenderInput fields used by renderComponent.
+*/
+const RENDER_COMPONENT_CONTEXT_PAIRS = [
+	["request", "request"],
+	["url", "url"],
+	["params", "params"],
+	["site", "__aero_site"],
+	["styles", "styles"],
+	["scripts", "scripts"],
+	["headScripts", "injectedHeadScripts"]
+];
+/** Emit the 4th (context) argument to Aero.renderComponent(component, props, slots, CONTEXT). Used by emit.ts and codegen.ts. */
+function getRenderComponentContextArg() {
+	return `{ ${RENDER_COMPONENT_CONTEXT_PAIRS.map(([key, varName]) => key === varName ? key : `${key}: ${varName}`).join(", ")} }`;
+}
+/** Build destructuring pattern for the render function: request, url, params, site: __aero_site, ... */
+function getRenderContextDestructurePattern() {
+	return `slots = {}, renderComponent, ${RENDER_COMPONENT_CONTEXT_PAIRS.map(([key, varName]) => key === varName ? key : `${key}: ${varName}`).join(", ")}`;
+}
+/** Emit `let varName = '';` for a slot accumulator. */
+function emitSlotVar(varName) {
+	return `let ${varName} = '';\n`;
+}
+/** Emit `outVar += \`content\`;` (default `outVar` is `__out`). */
+function emitAppend(content, outVar = "__out") {
+	return `${outVar} += \`${content}\`;\n`;
+}
+/** Emit `if (condition) {`. */
+function emitIf(condition) {
+	return `if (${condition}) {\n`;
+}
+/** Emit `} else if (condition) {`. */
+function emitElseIf(condition) {
+	return `} else if (${condition}) {\n`;
+}
+/** Emit `} else {`. */
+function emitElse() {
+	return `} else {\n`;
+}
+/** Emit `}`. */
+function emitEnd() {
+	return `}\n`;
+}
+/** Emit `for (const item of items) {`. */
+function emitForOf(item, items) {
+	return `for (const ${item} of ${items}) {\n`;
+}
+/** Emit `outVar += slots['name'] ?? \`defaultContent\`;` (default `outVar` is `__out`). */
+function emitSlotOutput(name, defaultContent, outVar = "__out") {
+	return `${outVar} += slots['${name}'] ?? \`${defaultContent}\`;\n`;
+}
+
+//#endregion
+//#region src/compiler/emit.ts
+const DEFAULT_OUT = "__out";
+function outVarFor(node, defaultVar) {
+	switch (node.kind) {
+		case "Append":
+		case "Slot":
+		case "Component": return node.outVar ?? defaultVar;
+		case "ScriptPassData":
+		case "StylePassData": return node.outVar;
+		default: return defaultVar;
+	}
+}
+/**
+* Emit a list of IR nodes to JS statements appending to `outVar`.
+*
+* @param ir - List of IR nodes (body or style fragment).
+* @param outVar - Accumulator variable (default `__out`).
+* @returns Generated JS string.
+*/
+function emitToJS(ir, outVar = DEFAULT_OUT) {
+	let out = "";
+	for (const node of ir) out += emitNode(node, outVar);
+	return out;
+}
+function emitNode(node, outVar) {
+	switch (node.kind) {
+		case "Append": return emitAppend(node.content, outVarFor(node, outVar));
+		case "For": return emitForOf(node.item, node.items) + emitToJS(node.body, outVar) + emitEnd();
+		case "If": {
+			let code = emitIf(node.condition) + emitToJS(node.body, outVar);
+			if (node.elseIf?.length) for (const branch of node.elseIf) {
+				code = code.slice(0, -2) + emitElseIf(branch.condition);
+				code += emitToJS(branch.body, outVar);
+			}
+			if (node.else?.length) {
+				code = code.slice(0, -2) + emitElse();
+				code += emitToJS(node.else, outVar);
+			}
+			return code + emitEnd();
+		}
+		case "Slot": return emitSlotOutput(node.name, node.defaultContent, outVarFor(node, outVar));
+		case "SlotVar": return emitSlotVar(node.varName);
+		case "Component": {
+			let code = "";
+			for (const [slotName, slotIR] of Object.entries(node.slots)) {
+				const slotVar = node.slotVarMap[slotName];
+				if (slotVar === void 0) continue;
+				code += emitSlotVar(slotVar);
+				code += emitToJS(slotIR, slotVar);
+			}
+			const slotsString = emitSlotsObjectVars(node.slotVarMap);
+			const targetVar = outVarFor(node, outVar);
+			code += `${targetVar} += await Aero.renderComponent(${node.baseName}, ${node.propsString}, ${slotsString}, ${getRenderComponentContextArg()});\n`;
+			return code;
+		}
+		case "ScriptPassData": {
+			let code = "";
+			if (!node.isModule) code += emitAppend("\\n{\\n", node.outVar);
+			const jsMapExpr = `Object.entries(${node.passDataExpr}).map(([k, v]) => "\\nconst " + k + " = " + JSON.stringify(v) + ";").join("")`;
+			code += emitAppend(`\${${jsMapExpr}}\\n`, node.outVar);
+			return code;
+		}
+		case "StylePassData": {
+			const cssMapExpr = `Object.entries(${node.passDataExpr}).map(([k, v]) => "\\n  --" + k + ": " + String(v) + ";").join("")`;
+			return emitAppend(`\n:root {\${${cssMapExpr}}\n}\n`, node.outVar);
+		}
+		default: return "";
+	}
+}
+/**
+* Emit body and style IR to JS, and wrap style in a style var + styles?.add().
+* Matches current codegen behavior: bodyCode from body IR, styleCode from style IR.
+*/
+function emitBodyAndStyle(ir) {
+	const bodyCode = emitToJS(ir.body, DEFAULT_OUT);
+	let styleCode = "";
+	if (ir.style.length > 0) {
+		const styleVar = `__out_style_${Math.random().toString(36).slice(2)}`;
+		styleCode += `let ${styleVar} = '';\n`;
+		styleCode += emitToJS(ir.style, styleVar);
+		styleCode += `styles?.add(${styleVar});\n`;
+	}
+	return {
+		bodyCode,
+		styleCode
+	};
+}
+
+//#endregion
+//#region src/compiler/resolver.ts
+var Resolver = class {
+	root;
+	rootAbs;
+	resolvePathFn;
+	importer;
+	constructor(options) {
+		this.root = options.root;
+		this.rootAbs = path.resolve(this.root);
+		this.importer = options.importer ?? options.root;
+		this.resolvePathFn = options.resolvePath || ((v, _importer) => v);
+	}
+	/** Normalize resolved path: root-relative with `/` if under root, else posix-normalized; always forward slashes. */
+	normalizeResolved(next) {
+		if (path.isAbsolute(next)) {
+			const absolute = path.resolve(next);
+			if (absolute === this.rootAbs || absolute.startsWith(this.rootAbs + path.sep)) next = "/" + path.relative(this.rootAbs, absolute);
+			else next = path.posix.normalize(toPosix(next));
+		}
+		return toPosix(next);
+	}
+	/**
+	* Resolve an import specifier (e.g. `@components/header`) to a path.
+	* Returns the original specifier if the resolved value does not look like a path.
+	*
+	* @param specifier - Import specifier from the source file.
+	* @returns Resolved path or unchanged specifier.
+	*/
+	resolveImport(specifier) {
+		let next = this.resolvePathFn(specifier, this.importer);
+		if (!/^(\.{1,2}\/|\/|@|~)/.test(next)) return specifier;
+		next = this.normalizeResolved(next);
+		return next;
+	}
+	/**
+	* Resolve an attribute value that may be a path (e.g. `src` on script).
+	* Same rules as `resolveImport`; returns unchanged value if not path-like.
+	*
+	* @param value - Raw attribute value.
+	* @returns Resolved path or unchanged value.
+	*/
+	resolveAttrValue(value) {
+		let next = this.resolvePathFn(value, this.importer);
+		if (!/^(\.{1,2}\/|\/|@|~)/.test(next)) return value;
+		next = this.normalizeResolved(next);
+		return next;
+	}
+};
+
+//#endregion
+//#region src/compiler/codegen.ts
+/** Internal lowerer: walks DOM nodes and builds IR; used by compile(). */
+var Lowerer = class {
+	resolver;
+	slotCounter = 0;
+	constructor(resolver) {
+		this.resolver = resolver;
+	}
+	/** Checks if node has if/data-if attribute */
+	hasIfAttr(node) {
+		return node.nodeType === 1 && (node.hasAttribute(ATTR_IF) || node.hasAttribute(ATTR_PREFIX + ATTR_IF));
+	}
+	/** Checks if node has else-if/data-else-if attribute */
+	hasElseIfAttr(node) {
+		return node.nodeType === 1 && (node.hasAttribute(ATTR_ELSE_IF) || node.hasAttribute(ATTR_PREFIX + ATTR_ELSE_IF));
+	}
+	/** Checks if node has else/data-else attribute */
+	hasElseAttr(node) {
+		return node.nodeType === 1 && (node.hasAttribute(ATTR_ELSE) || node.hasAttribute(ATTR_PREFIX + ATTR_ELSE));
+	}
+	/** Gets the condition value from if/else-if attribute */
+	getCondition(node, attr) {
+		const plainValue = node.getAttribute(attr);
+		if (plainValue !== null) return this.requireBracedExpression(plainValue, attr, node);
+		const dataAttr = ATTR_PREFIX + attr;
+		const dataValue = node.getAttribute(dataAttr);
+		if (dataValue !== null) return this.requireBracedExpression(dataValue, dataAttr, node);
+		return null;
+	}
+	/**
+	* Require directive value to be a braced expression; optionally strip outer braces.
+	*
+	* @param value - Raw attribute value.
+	* @param directive - Attribute name for error message (e.g. `each`, `pass:data`).
+	* @param node - DOM node for error message (tag name).
+	* @param options - `strip: true` (default) returns inner expression; `strip: false` returns trimmed value including braces (e.g. for pass:data).
+	* @returns Trimmed value, with or without outer braces per options.
+	*/
+	requireBracedExpression(value, directive, node, options) {
+		const strip = options?.strip !== false;
+		const trimmed = value.trim();
+		if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+			const tagName = node?.tagName?.toLowerCase?.() || "element";
+			throw new Error(`Directive \`${directive}\` on <${tagName}> must use a braced expression, e.g. ${directive}="{ expression }".`);
+		}
+		return strip ? stripBraces(trimmed) : trimmed;
+	}
+	isSingleWrappedExpression(value) {
+		const trimmed = value.trim();
+		if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return false;
+		if (trimmed.startsWith("{{") || trimmed.endsWith("}}")) return false;
+		let depth = 0;
+		for (let i = 0; i < trimmed.length; i++) {
+			const char = trimmed[i];
+			if (char === "{") depth++;
+			if (char === "}") {
+				depth--;
+				if (depth < 0) return false;
+				if (depth === 0 && i !== trimmed.length - 1) return false;
+			}
+		}
+		return depth === 0;
+	}
+	/** Parses component attributes, extracting props and data-props */
+	parseComponentAttributes(node) {
+		const propsEntries = [];
+		let dataPropsExpression = null;
+		if (node.attributes) for (let i = 0; i < node.attributes.length; i++) {
+			const attr = node.attributes[i];
+			if (isAttr(attr.name, ATTR_EACH, ATTR_PREFIX)) continue;
+			if (isAttr(attr.name, ATTR_IF, ATTR_PREFIX)) continue;
+			if (isAttr(attr.name, ATTR_ELSE_IF, ATTR_PREFIX)) continue;
+			if (isAttr(attr.name, ATTR_ELSE, ATTR_PREFIX)) continue;
+			if (isAttr(attr.name, ATTR_PROPS, ATTR_PREFIX)) {
+				const value = attr.value?.trim() || "";
+				if (!value) dataPropsExpression = "...props";
+				else dataPropsExpression = this.requireBracedExpression(value, attr.name, node);
+				continue;
+			}
+			const rawValue = attr.value ?? "";
+			const escapedLiteral = escapeBackticks(rawValue);
+			let propVal;
+			if (this.isSingleWrappedExpression(rawValue)) propVal = stripBraces(escapedLiteral);
+			else {
+				const compiled = compileAttributeInterpolation(rawValue);
+				propVal = compiled.includes("${") || rawValue.includes("{{") || rawValue.includes("}}") ? `\`${compiled}\`` : `"${escapedLiteral}"`;
+			}
+			propsEntries.push(`${attr.name}: ${propVal}`);
+		}
+		return { propsString: buildPropsString(propsEntries, dataPropsExpression) };
+	}
+	/** Parses element attributes, extracting data-each and building the attribute string */
+	parseElementAttributes(node) {
+		const attributes = [];
+		let loopData = null;
+		let passDataExpr = null;
+		if (node.attributes) for (let i = 0; i < node.attributes.length; i++) {
+			const attr = node.attributes[i];
+			if (isAttr(attr.name, ATTR_EACH, ATTR_PREFIX)) {
+				const match = this.requireBracedExpression(attr.value || "", attr.name, node).match(EACH_REGEX);
+				if (!match) {
+					const tagName = node?.tagName?.toLowerCase?.() || "element";
+					throw new Error(`Directive \`${attr.name}\` on <${tagName}> must match "{ item in items }".`);
+				}
+				loopData = {
+					item: match[1],
+					items: match[2]
+				};
+				continue;
+			}
+			if (isAttr(attr.name, ATTR_IF, ATTR_PREFIX)) continue;
+			if (isAttr(attr.name, ATTR_ELSE_IF, ATTR_PREFIX)) continue;
+			if (isAttr(attr.name, ATTR_ELSE, ATTR_PREFIX)) continue;
+			if (isAttr(attr.name, ATTR_PASS_DATA, ATTR_PREFIX)) {
+				passDataExpr = validateSingleBracedExpression(attr.value || "", {
+					directive: attr.name,
+					tagName: node?.tagName?.toLowerCase?.() || "element"
+				});
+				continue;
+			}
+			if (attr.name === ATTR_IS_INLINE) continue;
+			let val = this.resolver.resolveAttrValue(attr.value ?? "");
+			if (!isDirectiveAttr(attr.name)) val = compileAttributeInterpolation(val);
+			attributes.push(`${attr.name}="${val}"`);
+		}
+		return {
+			attrString: attributes.length ? " " + attributes.join(" ") : "",
+			loopData,
+			passDataExpr
+		};
+	}
+	/** Dispatch by node type: text (3) → compileText, element (1) → compileElement; other types return []. */
+	compileNode(node, skipInterpolation = false, outVar = "__out") {
+		switch (node.nodeType) {
+			case 3: return this.compileText(node, skipInterpolation, outVar);
+			case 1: return this.compileElement(node, skipInterpolation, outVar);
+			default: return [];
+		}
+	}
+	/** Lower a list of nodes (e.g. body children) to IR. */
+	compileFragment(nodes) {
+		return this.compileChildNodes(nodes, false, "__out");
+	}
+	compileChildNodes(nodes, skipInterpolation, outVar) {
+		if (!nodes) return [];
+		const out = [];
+		let i = 0;
+		while (i < nodes.length) {
+			const node = nodes[i];
+			if (this.hasIfAttr(node)) {
+				const { nodes: chainNodes, consumed } = this.compileConditionalChain(nodes, i, skipInterpolation, outVar);
+				out.push(...chainNodes);
+				i += consumed;
+				continue;
+			}
+			out.push(...this.compileNode(node, skipInterpolation, outVar));
+			i++;
+		}
+		return out;
+	}
+	/**
+	* Lowers a conditional chain (if/else-if/else siblings) into one IR If node.
+	* Returns the IR and how many DOM nodes were consumed.
+	*/
+	compileConditionalChain(nodes, startIndex, skipInterpolation, outVar) {
+		let i = startIndex;
+		let condition = null;
+		let body = [];
+		const elseIf = [];
+		let elseBody;
+		while (i < nodes.length) {
+			const node = nodes[i];
+			if (!node || node.nodeType !== 1) {
+				if (node?.nodeType === 3 && node.textContent?.trim() === "") {
+					i++;
+					continue;
+				}
+				break;
+			}
+			if (condition === null) {
+				if (!this.hasIfAttr(node)) break;
+				condition = this.getCondition(node, ATTR_IF);
+				body = this.compileElement(node, skipInterpolation, outVar);
+				i++;
+			} else if (this.hasElseIfAttr(node)) {
+				const elseIfCondition = this.getCondition(node, ATTR_ELSE_IF);
+				elseIf.push({
+					condition: elseIfCondition,
+					body: this.compileElement(node, skipInterpolation, outVar)
+				});
+				i++;
+			} else if (this.hasElseAttr(node)) {
+				elseBody = this.compileElement(node, skipInterpolation, outVar);
+				i++;
+				break;
+			} else break;
+		}
+		return {
+			nodes: [{
+				kind: "If",
+				condition,
+				body,
+				...elseIf.length > 0 && { elseIf },
+				...elseBody && elseBody.length > 0 && { else: elseBody }
+			}],
+			consumed: i - startIndex
+		};
+	}
+	compileText(node, skipInterpolation, outVar) {
+		const text = node.textContent || "";
+		if (!text) return [];
+		return [{
+			kind: "Append",
+			content: skipInterpolation ? escapeBackticks(text) : compileInterpolation(text),
+			outVar
+		}];
+	}
+	/** Lower one element: slot, component (-component/-layout), or regular HTML (with optional data-each, pass:data). */
+	compileElement(node, skipInterpolation, outVar) {
+		const tagName = node.tagName.toLowerCase();
+		if (tagName === TAG_SLOT) return this.compileSlot(node, skipInterpolation, outVar);
+		if (COMPONENT_SUFFIX_REGEX.test(tagName)) return this.compileComponent(node, tagName, skipInterpolation, outVar);
+		const { attrString, loopData, passDataExpr } = this.parseElementAttributes(node);
+		const childSkip = skipInterpolation || tagName === "style" || tagName === "script" && !passDataExpr;
+		const inner = [];
+		if (VOID_TAGS.has(tagName)) inner.push({
+			kind: "Append",
+			content: `<${tagName}${attrString}>`,
+			outVar
+		});
+		else {
+			inner.push({
+				kind: "Append",
+				content: `<${tagName}${attrString}>`,
+				outVar
+			});
+			const isScript = tagName === "script";
+			const isStyle = tagName === "style";
+			let closeBlock = false;
+			if (isScript && passDataExpr) {
+				const result = this.emitScriptPassDataIR(passDataExpr, node, outVar);
+				inner.push(...result.nodes);
+				closeBlock = result.closeBlock;
+			} else if (isStyle && passDataExpr) inner.push({
+				kind: "StylePassData",
+				passDataExpr,
+				outVar
+			});
+			inner.push(...this.compileChildNodes(node.childNodes, childSkip, outVar));
+			if (closeBlock) inner.push({
+				kind: "Append",
+				content: "\\n}\\n",
+				outVar
+			});
+			inner.push({
+				kind: "Append",
+				content: `</${tagName}>`,
+				outVar
+			});
+		}
+		if (loopData) return [{
+			kind: "For",
+			item: loopData.item,
+			items: loopData.items,
+			body: inner
+		}];
+		return inner;
+	}
+	/**
+	* Builds IR for injecting `pass:data` into a `<script>` tag.
+	* For non-module scripts, the emitter emits the opening `{\n`; caller must append closing `}\n` (Append IR).
+	*/
+	emitScriptPassDataIR(passDataExpr, node, outVar) {
+		const isModule = node.getAttribute("type") === "module";
+		return {
+			nodes: [{
+				kind: "ScriptPassData",
+				passDataExpr,
+				isModule,
+				outVar
+			}],
+			closeBlock: !isModule
+		};
+	}
+	compileSlot(node, skipInterpolation, outVar) {
+		return [{
+			kind: "Slot",
+			name: node.getAttribute(ATTR_NAME) || SLOT_NAME_DEFAULT,
+			defaultContent: this.compileSlotDefaultContent(node.childNodes, skipInterpolation),
+			outVar
+		}];
+	}
+	/** Compiles slot default content into template literal content (for simple fallbacks). */
+	compileSlotDefaultContent(nodes, skipInterpolation) {
+		if (!nodes) return "";
+		let out = "";
+		for (let i = 0; i < nodes.length; i++) {
+			const node = nodes[i];
+			if (!node) continue;
+			if (node.nodeType === 3) {
+				const text = node.textContent || "";
+				if (text) out += skipInterpolation ? escapeBackticks(text) : compileInterpolation(text);
+			} else if (node.nodeType === 1) out += this.compileElementDefaultContent(node, skipInterpolation);
+		}
+		return out;
+	}
+	/** Compiles an element for slot default content (template literal format). */
+	compileElementDefaultContent(node, skipInterpolation) {
+		const tagName = node.tagName.toLowerCase();
+		if (tagName === TAG_SLOT) return `\${ slots['${node.getAttribute(ATTR_NAME) || SLOT_NAME_DEFAULT}'] ?? ${this.compileSlotDefaultContent(node.childNodes, skipInterpolation)} }`;
+		if (COMPONENT_SUFFIX_REGEX.test(tagName)) {
+			const kebabBase = tagName.replace(COMPONENT_SUFFIX_REGEX, "");
+			const baseName = kebabToCamelCase(kebabBase);
+			const { propsString } = this.parseComponentAttributes(node);
+			return `\${ await Aero.renderComponent(${baseName}, ${propsString}, {}, ${getRenderComponentContextArg()}) }`;
+		}
+		const { attrString } = this.parseElementAttributes(node);
+		if (VOID_TAGS.has(tagName)) return `<${tagName}${attrString}>`;
+		const childSkip = skipInterpolation || tagName === "style" || tagName === "script";
+		return `<${tagName}${attrString}>${this.compileSlotDefaultContent(node.childNodes, childSkip)}</${tagName}>`;
+	}
+	compileComponent(node, tagName, skipInterpolation, outVar) {
+		const kebabBase = tagName.replace(COMPONENT_SUFFIX_REGEX, "");
+		const baseName = kebabToCamelCase(kebabBase);
+		const { propsString } = this.parseComponentAttributes(node);
+		const slotVarMap = {};
+		const slotContentMap = { [SLOT_NAME_DEFAULT]: [] };
+		if (node.childNodes) for (let i = 0; i < node.childNodes.length; i++) {
+			const child = node.childNodes[i];
+			let slotName = SLOT_NAME_DEFAULT;
+			if (child.nodeType === 1) {
+				const slotAttr = child.getAttribute(ATTR_SLOT);
+				if (slotAttr) slotName = slotAttr;
+			}
+			slotContentMap[slotName] = slotContentMap[slotName] || [];
+			slotContentMap[slotName].push(child);
+		}
+		const slots = {};
+		for (const [slotName, children] of Object.entries(slotContentMap)) {
+			const slotVar = `__slot_${this.slotCounter++}`;
+			slotVarMap[slotName] = slotVar;
+			const slotIR = [];
+			for (const child of children) {
+				if (child.nodeType === 1) {
+					if (child.tagName?.toLowerCase() === TAG_SLOT && child.hasAttribute(ATTR_NAME) && child.hasAttribute(ATTR_SLOT)) {
+						const passthroughName = child.getAttribute(ATTR_NAME);
+						const defaultContent = this.compileSlotDefaultContent(child.childNodes, skipInterpolation);
+						slotIR.push({
+							kind: "Slot",
+							name: passthroughName,
+							defaultContent,
+							outVar: slotVar
+						});
+						continue;
+					}
+				}
+				slotIR.push(...this.compileNode(child, skipInterpolation, slotVar));
+			}
+			slots[slotName] = slotIR;
+		}
+		return [{
+			kind: "Component",
+			baseName,
+			propsString,
+			slots,
+			slotVarMap,
+			outVar
+		}];
+	}
+};
+/**
+* Compile a parsed template and options into a JavaScript module string (default async render function + optional getStaticPaths).
+*
+* @param parsed - Result from parser (buildScript, clientScripts, inlineScripts, blockingScripts, template).
+* @param options - Root, resolvePath, and optional overrides for client/inline/blocking script arrays.
+* @returns Module source: optional getStaticPaths export and default async function(Aero) that returns HTML string.
+*/
+function compile(parsed, options) {
+	options.inlineScripts ?? parsed.inlineScripts;
+	const resolver = new Resolver({
+		root: options.root,
+		resolvePath: options.resolvePath,
+		importer: options.importer
+	});
+	const lowerer = new Lowerer(resolver);
+	let script = parsed.buildScript ? parsed.buildScript.content : "";
+	const analysis = analyzeBuildScript(script);
+	script = analysis.scriptWithoutImportsAndGetStaticPaths;
+	const getStaticPathsFn = analysis.getStaticPathsFn;
+	const importsLines = [];
+	const quote = "\"";
+	for (const imp of analysis.imports) {
+		const modExpr = `await import(${quote}${resolver.resolveImport(imp.specifier)}${quote})`;
+		if (imp.defaultBinding) importsLines.push(`const ${imp.defaultBinding} = (${modExpr}).default`);
+		else if (imp.namedBindings.length > 0) {
+			const names = imp.namedBindings.map((b) => b.imported === b.local ? b.local : `${b.imported} as ${b.local}`).join(", ");
+			importsLines.push(`const {${names}} = ${modExpr}`);
+		} else if (imp.namespaceBinding) importsLines.push(`const ${imp.namespaceBinding} = ${modExpr}`);
+	}
+	const importsCode = importsLines.join("\n");
+	const { document } = parseHTML(`
+		<html lang="en">
+			<body>${parsed.template.replace(SELF_CLOSING_TAG_REGEX, (match, tagName, attrs) => {
+		const tag = String(tagName).toLowerCase();
+		if (VOID_TAGS.has(tag)) return match.replace(SELF_CLOSING_TAIL_REGEX, ">");
+		return `<${tagName}${attrs}></${tagName}>`;
+	})}</body>
+		</html>
+	`);
+	let styleCode = "";
+	if (document.body) {
+		const children = Array.from(document.body.childNodes);
+		for (const node of children) if (node.nodeType === 1 && node.tagName === "STYLE") {
+			const styleVar = `__out_style_${Math.random().toString(36).slice(2)}`;
+			const styleIR = lowerer.compileNode(node, false, styleVar);
+			styleCode += `let ${styleVar} = '';\n`;
+			styleCode += emitToJS(styleIR, styleVar);
+			styleCode += `styles?.add(${styleVar});\n`;
+			node.remove();
+		}
+	}
+	const { bodyCode } = emitBodyAndStyle({
+		body: document.body ? lowerer.compileFragment(document.body.childNodes) : [],
+		style: []
+	});
+	const rootScripts = [];
+	const headScripts = [];
+	const virtualPrefix = "/@aero/client/";
+	if (options.clientScripts?.some((c) => c.content.startsWith(virtualPrefix)) ?? false) script = `function __aeroScriptUrl(p){return '/'+'@aero/client/'+p}\n` + script;
+	if (options.clientScripts && options.clientScripts.length > 0) for (const clientScript of options.clientScripts) {
+		const attrs = clientScript.attrs ?? "";
+		const baseAttrs = attrs.includes("type=") ? attrs : `type="module"${attrs ? " " + attrs : ""}`;
+		const urlExpr = clientScript.content.startsWith(virtualPrefix) ? `__aeroScriptUrl(${JSON.stringify(clientScript.content.slice(14))})` : JSON.stringify(clientScript.content);
+		const tagExpr = `'<script ${baseAttrs.replace(/'/g, "\\'")} src="'+${urlExpr}+'"><\/script>'`;
+		const isHead = clientScript.injectInHead;
+		if (clientScript.passDataExpr) {
+			const jsonExpr = `JSON.stringify(${clientScript.passDataExpr})`;
+			if (isHead) headScripts.push(`(function(){const __pid=Aero.nextPassDataId();\`<\`+'script type="application/json" id="'+__pid+'" class="__aero_data">'+${jsonExpr}+'</'+'script>';window.__aero_data_next=JSON.parse(document.getElementById("'+__pid+'").textContent);})();${tagExpr}`);
+			else rootScripts.push(`(function(){const __pid=Aero.nextPassDataId();scripts?.add(\`<script type="application/json" id="\${__pid}" class="__aero_data">\${${jsonExpr}}<\/script>\`);scripts?.add(\`<script>window.__aero_data_next=JSON.parse(document.getElementById("\${__pid}").textContent);<\/script>\`);scripts?.add(${tagExpr});})();`);
+		} else if (isHead) headScripts.push(tagExpr);
+		else rootScripts.push(`scripts?.add(${tagExpr});`);
+	}
+	if (options.blockingScripts) for (const blockingScript of options.blockingScripts) if (blockingScript.passDataExpr) {
+		const jsMapExpr = `Object.entries(${validateSingleBracedExpression(blockingScript.passDataExpr, {
+			directive: "pass:data",
+			tagName: "script"
+		})}).map(([k, v]) => "\\nconst " + k + " = " + JSON.stringify(v) + ";").join("")`;
+		headScripts.push(`\`<script${blockingScript.attrs ? " " + blockingScript.attrs : ""}>\${${jsMapExpr}}${blockingScript.content.replace(/`/g, "\\`")}<\/script>\``);
+	} else {
+		const escapedContent = blockingScript.content.replace(/'/g, "\\'");
+		headScripts.push(`'<script${blockingScript.attrs ? " " + blockingScript.attrs : ""}>${escapedContent}<\/script>'`);
+	}
+	const renderFn = emitRenderFunction(script, bodyCode, {
+		getStaticPathsFn: getStaticPathsFn || void 0,
+		styleCode,
+		rootScriptsLines: rootScripts,
+		headScriptsLines: headScripts
+	});
+	return importsCode + "\n" + renderFn;
+}
+
+//#endregion
+//#region src/vite/build.ts
+/**
+* Register client scripts from parsed template into a Map.
+* Converts client script content to virtual URLs for Vite bundling.
+*/
+function registerClientScriptsToMap(parsed, baseName, target) {
+	const total = parsed.clientScripts.length;
+	for (let i = 0; i < total; i++) {
+		const clientScript = parsed.clientScripts[i];
+		const clientScriptUrl = getClientScriptVirtualUrl(baseName, i, total);
+		target.set(clientScriptUrl, {
+			content: clientScript.content,
+			passDataExpr: clientScript.passDataExpr,
+			injectInHead: clientScript.injectInHead
+		});
+	}
+}
+/** True if page has dynamic segments (e.g. `posts/[id]`). */
+function isDynamicPage(page) {
+	return isDynamicRoutePattern(page.pageName);
+}
+/** Replace `[key]` in pattern with params[key]; throws if a key is missing. */
+function expandPattern(pattern, params) {
+	return expandRoutePattern(pattern, params);
+}
+/** Recursively collect all .html file paths under dir. */
+function walkHtmlFiles(dir) {
+	if (!fs.existsSync(dir)) return [];
+	const files = [];
+	for (const item of fs.readdirSync(dir, { withFileTypes: true })) {
+		const fullPath = path$1.join(dir, item.name);
+		if (item.isDirectory()) {
+			files.push(...walkHtmlFiles(fullPath));
+			continue;
+		}
+		if (item.isFile() && item.name.endsWith(".html")) files.push(fullPath);
+	}
+	return files;
+}
+/** Page name to route path (e.g. index → '', about → about, blog/index → blog). */
+function toRouteFromPageName(pageName) {
+	if (pageName === "index") return "";
+	if (pageName.endsWith("/index")) return pageName.slice(0, -6);
+	return pageName;
+}
+/** Route path to output file path (e.g. '' → index.html, about → about/index.html). */
+function toOutputFile(routePath) {
+	if (routePath === "") return "index.html";
+	if (routePath === "404") return "404.html";
+	return toPosix(path$1.join(routePath, "index.html"));
+}
+/**
+* Generate sitemap.xml from route paths. Only called when site URL is set.
+* Excludes 404. Writes to distDir/sitemap.xml.
+*/
+function writeSitemap(routePaths, site, distDir) {
+	const base = site.replace(/\/$/, "");
+	const xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\n" + routePaths.filter((r) => r !== "404").map((routePath) => {
+		return `  <url>\n    <loc>${escapeXml(`${base}${(routePath === "" ? "" : `/${routePath}/`) || "/"}`)}</loc>\n  </url>`;
+	}).join("\n") + "\n</urlset>\n";
+	fs.writeFileSync(path$1.join(distDir, "sitemap.xml"), xml, "utf-8");
+}
+function escapeXml(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+/** Relative path from fromDir to targetPath, always starting with ./ when non-empty. */
+function normalizeRelativeLink(fromDir, targetPath) {
+	const rel = path$1.posix.relative(fromDir, targetPath);
+	if (!rel) return "./";
+	if (rel.startsWith(".")) return rel;
+	return `./${rel}`;
+}
+/** Relative path to a route (directory index); appends trailing slash for non-root routes. */
+function normalizeRelativeRouteLink(fromDir, routePath) {
+	const targetDir = routePath === "" ? "" : routePath;
+	const rel = path$1.posix.relative(fromDir, targetDir);
+	let res = !rel ? "./" : rel.startsWith(".") ? rel : `./${rel}`;
+	if (routePath !== "" && routePath !== "404" && !res.endsWith("/")) res += "/";
+	return res;
+}
+function normalizeRoutePathFromHref(value) {
+	if (value === "/") return "";
+	return value.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+/** True if URL is empty or matches SKIP_PROTOCOL_REGEX (external, hash, etc.). */
+function isSkippableUrl(value) {
+	if (!value) return true;
+	return SKIP_PROTOCOL_REGEX.test(value);
+}
+/** Root-relative path for manifest key (posix). */
+function toManifestKey(root, filePath) {
+	return toPosixRelative(filePath, root);
+}
+/** Resolve script/link src or href to absolute path; returns null for external/skippable or unresolvable. */
+function resolveTemplateAssetPath(rawValue, templateFile, root, resolvePath) {
+	if (!rawValue || isSkippableUrl(rawValue)) return null;
+	if (rawValue.startsWith("/")) return path$1.resolve(root, rawValue.slice(1));
+	if (rawValue.startsWith("@") || rawValue.startsWith("~")) {
+		const resolved = resolvePath ? resolvePath(rawValue, templateFile) : rawValue;
+		return path$1.isAbsolute(resolved) ? resolved : path$1.resolve(root, resolved);
+	}
+	if (rawValue.startsWith("./") || rawValue.startsWith("../")) return path$1.resolve(path$1.dirname(templateFile), rawValue);
+	return null;
+}
+/** All .html files under root/templateRoot (recursive). */
+function discoverTemplates(root, templateRoot) {
+	return walkHtmlFiles(path$1.resolve(root, templateRoot));
+}
+/** Static pages from pagesRoot: file paths, page names (via pagePathToKey), route paths, output files; home → index when no sibling index. */
+function discoverPages(root, pagesRoot) {
+	const pageFiles = walkHtmlFiles(path$1.resolve(root, pagesRoot));
+	const allPageNames = new Set(pageFiles.map((f) => pagePathToKey(toPosixRelative(f, root))));
+	return pageFiles.map((file) => {
+		let pageName = pagePathToKey(toPosixRelative(file, root));
+		if (pageName === "home" && !allPageNames.has("index")) pageName = "index";
+		else if (pageName.endsWith("/home")) {
+			const siblingIndex = pageName.slice(0, -5) + "/index";
+			if (!allPageNames.has(siblingIndex)) pageName = siblingIndex;
+		}
+		const routePath = toRouteFromPageName(pageName);
+		return {
+			pageName,
+			routePath,
+			sourceFile: file,
+			outputFile: toOutputFile(routePath)
+		};
+	});
+}
+/**
+* Discover all extracted client scripts from templates under root/templateRoot.
+*
+* @param root - Project root.
+* @param templateRoot - Directory under root containing .html templates (e.g. client).
+* @returns Map from virtual URL (e.g. `/@aero/client/client/pages/home.js`) to ScriptEntry.
+*/
+function discoverClientScriptContentMap(root, templateRoot) {
+	const map = /* @__PURE__ */ new Map();
+	for (const file of discoverTemplates(root, templateRoot)) {
+		const parsed = parse(fs.readFileSync(file, "utf-8"));
+		if (parsed.clientScripts.length === 0) continue;
+		registerClientScriptsToMap(parsed, toPosixRelative(file, root).replace(/\.html$/i, ""), map);
+	}
+	return map;
+}
+/** Rollup input entries for virtual client scripts (manifest key → virtual path); used by createBuildConfig. */
+function discoverClientScriptVirtualInputs(root, templateRoot) {
+	const entries = {};
+	for (const file of discoverTemplates(root, templateRoot)) {
+		const parsed = parse(fs.readFileSync(file, "utf-8"));
+		if (parsed.clientScripts.length === 0) continue;
+		const baseName = toPosixRelative(file, root).replace(/\.html$/i, "");
+		const { clientScripts } = parsed;
+		const total = clientScripts.length;
+		for (let i = 0; i < total; i++) {
+			const virtualPath = getClientScriptVirtualUrl(baseName, i, total);
+			const manifestKey = virtualPath.replace(/^\//, "");
+			entries[manifestKey] = virtualPath;
+		}
+	}
+	return entries;
+}
+/** Rollup input entries: script/link refs from templates, default client index, and assets/images. */
+function discoverAssetInputs(root, resolvePath, templateRoot = "client") {
+	const entries = /* @__PURE__ */ new Map();
+	for (const templateFile of discoverTemplates(root, templateRoot)) {
+		const { document } = parseHTML(fs.readFileSync(templateFile, "utf-8"));
+		const scripts = Array.from(document.querySelectorAll("script[src]"));
+		const styles = Array.from(document.querySelectorAll("link[rel=\"stylesheet\"][href]"));
+		const refs = [...scripts, ...styles];
+		for (const el of refs) {
+			const attr = el.hasAttribute("src") ? "src" : "href";
+			const resolved = resolveTemplateAssetPath(el.getAttribute(attr) || "", templateFile, root, resolvePath);
+			if (!resolved || !fs.existsSync(resolved)) continue;
+			const ext = path$1.extname(resolved).toLowerCase();
+			if (![
+				".js",
+				".mjs",
+				".ts",
+				".tsx",
+				".css"
+			].includes(ext)) continue;
+			entries.set(toManifestKey(root, resolved), resolved);
+		}
+	}
+	const defaultClientEntry = path$1.resolve(root, `${templateRoot}/index.ts`);
+	if (fs.existsSync(defaultClientEntry)) entries.set(toManifestKey(root, defaultClientEntry), defaultClientEntry);
+	const imagesDir = path$1.resolve(root, templateRoot, "assets/images");
+	if (fs.existsSync(imagesDir)) {
+		const imageFiles = walkFiles(imagesDir);
+		for (const file of imageFiles) {
+			const key = toManifestKey(root, file);
+			if (entries.has(key)) continue;
+			if (path$1.basename(file).startsWith(".")) continue;
+			entries.set(key, file);
+		}
+	}
+	return Object.fromEntries(entries);
+}
+/** Recursively collect all file paths under dir (no extension filter). */
+function walkFiles(dir) {
+	if (!fs.existsSync(dir)) return [];
+	const files = [];
+	for (const item of fs.readdirSync(dir, { withFileTypes: true })) {
+		const fullPath = path$1.join(dir, item.name);
+		if (item.isDirectory()) {
+			files.push(...walkFiles(fullPath));
+			continue;
+		}
+		if (item.isFile()) files.push(fullPath);
+	}
+	return files;
+}
+/** Prepend `<!doctype html>` if missing. */
+function addDoctype(html) {
+	return /^\s*<!doctype\s+html/i.test(html) ? html : `<!doctype html>\n${html}`;
+}
+/** Image extensions: when a manifest entry's .file is a .js chunk but .assets lists the real image, use it. */
+const ASSET_IMAGE_EXT = /\.(jpg|jpeg|png|gif|webp|svg|ico)(\?|$)/i;
+/** Rewrite one absolute URL to dist-relative using manifest and route set; leaves API and external URLs unchanged. */
+function rewriteAbsoluteUrl(value, fromDir, manifest, routeSet, apiPrefix = DEFAULT_API_PREFIX) {
+	if (value.startsWith(apiPrefix)) return value;
+	const noQuery = value.split(/[?#]/)[0] || value;
+	const suffix = value.slice(noQuery.length);
+	const manifestKey = noQuery.replace(/^\//, "");
+	let manifestEntry = manifest[noQuery] ?? manifest[manifestKey];
+	if (!manifestEntry && noQuery.startsWith("assets/")) {
+		const entry = Object.values(manifest).find((e) => e?.file === noQuery || e?.file === manifestKey);
+		if (entry) manifestEntry = entry;
+	}
+	if (manifestEntry?.file) return normalizeRelativeLink(fromDir, manifestEntry.assets?.find((a) => ASSET_IMAGE_EXT.test(a)) ?? manifestEntry.file) + suffix;
+	if (noQuery.startsWith("/assets/")) return normalizeRelativeLink(fromDir, noQuery.replace(/^\//, "")) + suffix;
+	const route = normalizeRoutePathFromHref(noQuery);
+	if (routeSet.has(route) || route === "") return (route === "404" ? normalizeRelativeLink(fromDir, toOutputFile(route)) : normalizeRelativeRouteLink(fromDir, route)) + suffix;
+	return normalizeRelativeLink(fromDir, noQuery.replace(/^\//, "")) + suffix;
+}
+/** Rewrite script src (virtual client → hashed asset) and LINK_ATTRS in rendered HTML; add doctype. */
+function rewriteRenderedHtml(html, outputFile, manifest, routeSet, apiPrefix = DEFAULT_API_PREFIX) {
+	const fromDir = path$1.posix.dirname(outputFile);
+	const { document } = parseHTML(html);
+	for (const script of Array.from(document.querySelectorAll("script[src]"))) {
+		const src = script.getAttribute("src") || "";
+		if (src.startsWith(CLIENT_SCRIPT_PREFIX)) {
+			const newSrc = rewriteAbsoluteUrl(src, fromDir, manifest, routeSet, apiPrefix);
+			script.setAttribute("src", newSrc);
+			script.setAttribute("type", "module");
+			script.removeAttribute("defer");
+			continue;
+		}
+		if (script.getAttribute("type") === "module") script.removeAttribute("defer");
+	}
+	for (const el of Array.from(document.querySelectorAll("*"))) for (const attrName of LINK_ATTRS) {
+		if (!el.hasAttribute(attrName)) continue;
+		const current = (el.getAttribute(attrName) || "").trim();
+		if (!current || isSkippableUrl(current)) continue;
+		if (!current.startsWith("/")) continue;
+		el.setAttribute(attrName, rewriteAbsoluteUrl(current, fromDir, manifest, routeSet, apiPrefix));
+	}
+	const htmlTag = document.documentElement;
+	if (htmlTag) return addDoctype(htmlTag.outerHTML);
+	return addDoctype(document.toString());
+}
+function readManifest(distDir) {
+	const manifestPath = path$1.join(distDir, ".vite", "manifest.json");
+	if (!fs.existsSync(manifestPath)) return {};
+	return JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+}
+/**
+* Render all static pages into outDir: discover pages, expand dynamic routes via getStaticPaths, run Vite in middleware mode, rewrite URLs, optionally minify.
+*
+* @param options - StaticBuildOptions (root, dirs, resolvePath, vitePlugins, minify).
+* @param outDir - Output directory (e.g. dist).
+*/
+async function renderStaticPages(options, outDir) {
+	const root = options.root;
+	const dirs = resolveDirs(options.dirs);
+	const apiPrefix = options.apiPrefix || DEFAULT_API_PREFIX;
+	const discoveredPages = discoverPages(root, path$1.join(dirs.client, "pages"));
+	const distDir = path$1.resolve(root, outDir);
+	const manifest = readManifest(distDir);
+	const previousAeroServer = process.env.AERO_SERVER;
+	process.env.AERO_SERVER = "false";
+	const server = await createServer({
+		configFile: false,
+		root,
+		cacheDir: path$1.join(root, ".aero", "vite-ssr"),
+		appType: "custom",
+		logLevel: "error",
+		plugins: options.vitePlugins ?? [],
+		server: {
+			middlewareMode: true,
+			hmr: false,
+			watch: { ignored: ["**/*"] }
+		}
+	});
+	try {
+		const runtime = await server.ssrLoadModule(RUNTIME_INSTANCE_MODULE_ID);
+		const pages = [];
+		for (const page of discoveredPages) {
+			if (!isDynamicPage(page)) {
+				pages.push(page);
+				continue;
+			}
+			const mod = await server.ssrLoadModule(page.sourceFile);
+			if (typeof mod.getStaticPaths !== "function") {
+				console.warn(`[aero] ⚠ Skipping dynamic page "${path$1.relative(root, page.sourceFile)}" — no getStaticPaths() exported. Page will not be pre-rendered.`);
+				continue;
+			}
+			const staticPaths = await mod.getStaticPaths();
+			if (!Array.isArray(staticPaths) || staticPaths.length === 0) {
+				console.warn(`[aero] ⚠ getStaticPaths() for "${path$1.relative(root, page.sourceFile)}" returned no paths. Page will not be pre-rendered.`);
+				continue;
+			}
+			for (const entry of staticPaths) {
+				const expandedPageName = expandPattern(page.pageName, entry.params);
+				const expandedRoute = toRouteFromPageName(expandedPageName);
+				pages.push({
+					pageName: expandedPageName,
+					routePath: expandedRoute,
+					sourceFile: page.sourceFile,
+					outputFile: toOutputFile(expandedRoute),
+					params: entry.params,
+					props: entry.props
+				});
+			}
+		}
+		const redirectFromSet = new Set((options.redirects ?? []).map((r) => r.from.replace(/^\/+|\/+$/g, "").trim() || ""));
+		const pathMatchesRedirect = (page) => {
+			const pathSegment = page.routePath === "" ? "" : page.routePath;
+			return redirectFromSet.has(pathSegment);
+		};
+		const pagesToRender = options.redirects?.length ? pages.filter((p) => !pathMatchesRedirect(p)) : pages;
+		const routeSet = new Set(pagesToRender.map((p) => p.routePath));
+		for (const page of pagesToRender) {
+			const routePath = page.routePath ? `/${page.routePath}` : "/";
+			const pageUrl = new URL(routePath, "http://localhost");
+			const renderTarget = isDynamicPage(page) ? toPosixRelative(page.sourceFile, path$1.resolve(root, dirs.client, "pages")).replace(/\.html$/i, "") : page.pageName;
+			let rendered = await runtime.aero.render(renderTarget, {
+				url: pageUrl,
+				request: new Request(pageUrl.toString(), { method: "GET" }),
+				routePath,
+				params: page.params || {},
+				props: page.props || {},
+				site: options.site
+			});
+			rendered = rewriteRenderedHtml(addDoctype(rendered), page.outputFile, manifest, routeSet, apiPrefix);
+			const isProd = typeof import.meta !== "undefined" && import.meta.env?.PROD;
+			if (options.minify && isProd) rendered = await minify(rendered, {
+				collapseWhitespace: true,
+				removeComments: true,
+				minifyCSS: true,
+				minifyJS: true
+			});
+			const outPath = path$1.join(distDir, page.outputFile);
+			fs.mkdirSync(path$1.dirname(outPath), { recursive: true });
+			fs.writeFileSync(outPath, rendered, "utf-8");
+		}
+		if (options.site && options.site.trim() !== "") writeSitemap([...new Set(pagesToRender.map((p) => p.routePath))], options.site.trim(), distDir);
+	} finally {
+		await server.close();
+		if (previousAeroServer === void 0) delete process.env.AERO_SERVER;
+		else process.env.AERO_SERVER = previousAeroServer;
+	}
+}
+/**
+* Vite build config: outDir, manifest, emptyOutDir, rollupOptions.input from discovered assets and virtual client scripts.
+*
+* @param options - Optional dirs and resolvePath for asset discovery.
+* @param root - Project root (default process.cwd()).
+* @returns Vite UserConfig.build fragment.
+*/
+function createBuildConfig(options = {}, root = process.cwd()) {
+	const dirs = resolveDirs(options.dirs);
+	const assetInputs = discoverAssetInputs(root, options.resolvePath, dirs.client);
+	const virtualClientInputs = discoverClientScriptVirtualInputs(root, dirs.client);
+	const inputs = {
+		...assetInputs,
+		...virtualClientInputs
+	};
+	return {
+		outDir: dirs.dist,
+		manifest: true,
+		emptyOutDir: true,
+		rollupOptions: {
+			input: inputs,
+			output: {
+				entryFileNames(chunkInfo) {
+					return `assets/${path$1.basename(chunkInfo.name)}-[hash].js`;
+				},
+				chunkFileNames(chunkInfo) {
+					if ((chunkInfo.facadeModuleId ?? "").includes("aero-html")) return `assets/aero-[hash].js`;
+					return `assets/${path$1.basename(chunkInfo.name)}-[hash].js`;
+				},
+				assetFileNames(assetInfo) {
+					return `assets/${path$1.basename(assetInfo.name || "")}-[hash][extname]`;
+				}
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/vite/index.ts
+const require = createRequire(import.meta.url);
+const AERO_DIR = ".aero";
+const NITRO_CONFIG_FILENAME = "nitro.config.mjs";
+/**
+* Generate Nitro config from Aero options and write to <projectRoot>/.aero/nitro.config.mjs.
+* root is the app/site directory (Vite config.root), e.g. examples/kitchen-sink or a create-aerobuilt project folder.
+* Returns the absolute path to .aero (Nitro cwd so it loads this file).
+*/
+function writeGeneratedNitroConfig(root, serverDir, redirects) {
+	const aeroDir = path.join(root, AERO_DIR);
+	mkdirSync(aeroDir, { recursive: true });
+	const routeRules = redirectsToRouteRules(redirects ?? []);
+	const nitroConfig = {
+		rootDir: "..",
+		output: { dir: path.join(root, ".output") },
+		scanDirs: [path.join(root, serverDir)],
+		routeRules,
+		noPublicDir: true
+	};
+	const content = `// Generated by Aero — do not edit
+export default ${JSON.stringify(nitroConfig, null, 2)}
+`;
+	writeFileSync(path.join(aeroDir, NITRO_CONFIG_FILENAME), content);
+	return aeroDir;
+}
+/** Run `nitro build` with generated config; used after static pages are written when options.server is true. */
+async function runNitroBuild(_root, configCwd) {
+	const nitroBin = process.platform === "win32" ? "nitro.cmd" : "nitro";
+	await new Promise((resolve, reject) => {
+		const child = spawn(nitroBin, ["build"], {
+			cwd: configCwd,
+			stdio: "inherit",
+			env: process.env
+		});
+		child.on("error", reject);
+		child.on("exit", (code) => {
+			if (code === 0) {
+				resolve();
+				return;
+			}
+			reject(/* @__PURE__ */ new Error(`[aero] nitro build failed with exit code ${code ?? "null"}`));
+		});
+	});
+}
+function createAeroConfigPlugin(state) {
+	return {
+		name: "vite-plugin-aero-config",
+		enforce: "pre",
+		config(userConfig, env) {
+			const root = userConfig.root || process.cwd();
+			const rawAliases = loadTsconfigAliases(root);
+			state.aliasResult = mergeWithDefaultAliases(rawAliases, root, state.dirs);
+			if (state.dirs.client !== DEFAULT_DIRS.client && rawAliases.projectRoot != null) console.warn("[aero] Custom dirs.client is set; ensure tsconfig paths for @pages, @layouts, @components match (e.g. @pages → \"" + state.dirs.client + "/pages\").");
+			const site = state.options.site ?? "";
+			return {
+				base: "./",
+				resolve: { alias: env?.command === "build" ? [...state.aliasResult.aliases, {
+					find: "@aerobuilt/core",
+					replacement: require.resolve("@aerobuilt/core/entry-prod")
+				}] : state.aliasResult.aliases },
+				define: { "import.meta.env.SITE": JSON.stringify(site) },
+				build: createBuildConfig({
+					resolvePath: state.aliasResult.resolve,
+					dirs: state.options.dirs
+				}, root)
+			};
+		},
+		configResolved(resolvedConfig) {
+			state.config = resolvedConfig;
+		}
+	};
+}
+/** True if filePath is an Aero template under client/pages, client/components, or client/layouts. */
+function isAeroTemplateHtml(filePath, root, dirs) {
+	const clientBase = path.join(root, dirs.client);
+	const rel = path.relative(clientBase, filePath);
+	if (rel.startsWith("..") || path.isAbsolute(rel)) return false;
+	const sep = path.sep;
+	return rel.startsWith("pages" + sep) || rel.startsWith("components" + sep) || rel.startsWith("layouts" + sep);
+}
+function createAeroVirtualsPlugin(state) {
+	return {
+		name: "vite-plugin-aero-virtuals",
+		enforce: "pre",
+		buildStart() {
+			if (!state.config) return;
+			discoverClientScriptContentMap(state.config.root, state.dirs.client).forEach((entry, url) => state.clientScripts.set(url, entry));
+		},
+		async resolveId(id, importer) {
+			if (id === RUNTIME_INSTANCE_MODULE_ID) return RESOLVED_RUNTIME_INSTANCE_MODULE_ID;
+			if (id.startsWith(CLIENT_SCRIPT_PREFIX)) return "\0" + id;
+			if (id.startsWith("\0" + CLIENT_SCRIPT_PREFIX)) return id;
+			if (id.startsWith(AERO_HTML_VIRTUAL_PREFIX)) return id;
+			if (id.includes("html-proxy") && id.includes("inline-css")) return AERO_EMPTY_INLINE_CSS_PREFIX + id;
+			if (id.startsWith("aero:content")) return null;
+			const resolved = await this.resolve(id, importer, { skipSelf: true });
+			if (resolved && resolved.id.endsWith(".html")) {
+				if (state.config?.command === "build" && state.aliasResult && isAeroTemplateHtml(resolved.id, state.config.root, state.dirs)) return AERO_HTML_VIRTUAL_PREFIX + resolved.id.replace(/\.html$/i, ".aero");
+				return resolved;
+			}
+			if ((id.startsWith("./") || id.startsWith("../") || id.startsWith("/") || id.startsWith("@") && !id.slice(1).split("/")[0].includes("-") && id.split("/").length < 3) && !id.includes(".") && !id.startsWith("\0") && !resolved?.id.includes("node_modules")) {
+				const resolvedHtml = await this.resolve(id + ".html", importer, { skipSelf: true });
+				if (resolvedHtml) {
+					if (state.config?.command === "build" && state.aliasResult && isAeroTemplateHtml(resolvedHtml.id, state.config.root, state.dirs)) return AERO_HTML_VIRTUAL_PREFIX + resolvedHtml.id.replace(/\.html$/i, ".aero");
+					return resolvedHtml;
+				}
+			}
+			return null;
+		},
+		load(id) {
+			if (id === RESOLVED_RUNTIME_INSTANCE_MODULE_ID) return `export { aero, onUpdate } from ${JSON.stringify(state.runtimeInstancePath)}`;
+			if (id.startsWith(AERO_EMPTY_INLINE_CSS_PREFIX)) return "/* aero: no inline styles */";
+			if (id.startsWith(AERO_HTML_VIRTUAL_PREFIX)) {
+				const filePath = id.slice(AERO_HTML_VIRTUAL_PREFIX.length).replace(/\.aero$/i, ".html");
+				if (!state.config || !state.aliasResult) return null;
+				this.addWatchFile(filePath);
+				try {
+					const parsed = parse(readFileSync(filePath, "utf-8"));
+					const baseName = toPosixRelative(filePath, state.config.root).replace(/\.html$/i, "");
+					registerClientScriptsToMap(parsed, baseName, state.clientScripts);
+					for (let i = 0; i < parsed.clientScripts.length; i++) parsed.clientScripts[i].content = getClientScriptVirtualUrl(baseName, i, parsed.clientScripts.length);
+					return {
+						code: compile(parsed, {
+							root: state.config.root,
+							clientScripts: parsed.clientScripts,
+							blockingScripts: parsed.blockingScripts,
+							inlineScripts: parsed.inlineScripts,
+							resolvePath: state.aliasResult.resolve,
+							importer: filePath
+						}),
+						map: null
+					};
+				} catch {
+					return null;
+				}
+			}
+			if (id.startsWith("\0" + CLIENT_SCRIPT_PREFIX)) {
+				const virtualId = id.slice(1);
+				const entry = state.clientScripts.get(virtualId);
+				if (!entry) return "";
+				if (entry.passDataExpr) {
+					const keys = extractObjectKeys(entry.passDataExpr);
+					if (keys.length > 0) return `var __aero_data=(typeof window!=='undefined'&&window.__aero_data_next!==undefined)?window.__aero_data_next:{};if(typeof window!=='undefined')delete window.__aero_data_next;const { ${keys.join(", ")} } = __aero_data;\n` + entry.content;
+				}
+				return entry.content;
+			}
+			return null;
+		}
+	};
+}
+function createAeroTransformPlugin(state) {
+	return {
+		name: "vite-plugin-aero-transform",
+		enforce: "pre",
+		transform(code, id) {
+			if (id.startsWith(AERO_HTML_VIRTUAL_PREFIX)) return null;
+			if (!id.endsWith(".html")) return null;
+			if (!state.config || !state.aliasResult) return null;
+			try {
+				const parsed = parse(code);
+				if (parsed.clientScripts.length > 0) {
+					const baseName = toPosixRelative(id, state.config.root).replace(/\.html$/i, "");
+					registerClientScriptsToMap(parsed, baseName, state.clientScripts);
+					for (let i = 0; i < parsed.clientScripts.length; i++) parsed.clientScripts[i].content = getClientScriptVirtualUrl(baseName, i, parsed.clientScripts.length);
+				}
+				return {
+					code: compile(parsed, {
+						root: state.config.root,
+						clientScripts: parsed.clientScripts,
+						blockingScripts: parsed.blockingScripts,
+						inlineScripts: parsed.inlineScripts,
+						resolvePath: state.aliasResult.resolve,
+						importer: id
+					}),
+					map: null
+				};
+			} catch (err) {
+				const relativePath = path.relative(state.config.root, id);
+				this.error(`[aero] Error compiling ${relativePath}: ${err.message}`);
+			}
+		}
+	};
+}
+function createAeroSsrPlugin(state) {
+	return {
+		name: "vite-plugin-aero-ssr",
+		configureServer(server) {
+			server.middlewares.use(async (req, res, next) => {
+				if (!req.url) return next();
+				if (req.method && req.method.toUpperCase() !== "GET") return next();
+				if (!req.headers.accept?.includes("text/html")) return next();
+				const pathname = req.url.split("?")[0] || "/";
+				if (pathname.startsWith(state.apiPrefix) || pathname.startsWith("/@fs") || pathname.startsWith("/@id")) return next();
+				const ext = path.extname(pathname);
+				if (ext && ext !== ".html") return next();
+				const redirects = state.options.redirects;
+				if (redirects?.length) {
+					for (const rule of redirects) if (pathname === rule.from) {
+						res.statusCode = rule.status ?? 302;
+						res.setHeader("Location", rule.to);
+						res.end();
+						return;
+					}
+				}
+				try {
+					const pageName = resolvePageName(req.url);
+					const mod = await server.ssrLoadModule(RUNTIME_INSTANCE_MODULE_ID);
+					const requestUrl = new URL(req.url, "http://localhost");
+					const requestHeaders = new Headers();
+					for (const [name, value] of Object.entries(req.headers)) {
+						if (value === void 0) continue;
+						if (Array.isArray(value)) {
+							for (const item of value) requestHeaders.append(name, item);
+							continue;
+						}
+						requestHeaders.set(name, value);
+					}
+					const request = new Request(requestUrl.toString(), {
+						method: req.method || "GET",
+						headers: requestHeaders
+					});
+					let renderPageName = pageName;
+					let renderInput = {
+						url: requestUrl,
+						request,
+						routePath: pathname,
+						site: state.options.site
+					};
+					const middleware = state.options.middleware;
+					if (middleware?.length) {
+						const ctx = {
+							url: requestUrl,
+							request,
+							routePath: pathname,
+							pageName,
+							site: state.options.site
+						};
+						for (const handler of middleware) {
+							const result = await Promise.resolve(handler(ctx));
+							if (result && "redirect" in result) {
+								res.statusCode = result.redirect.status ?? 302;
+								res.setHeader("Location", result.redirect.url);
+								res.end();
+								return;
+							}
+							if (result && "response" in result) {
+								res.statusCode = result.response.status;
+								result.response.headers.forEach((v, k) => res.setHeader(k, v));
+								const body = await result.response.arrayBuffer();
+								res.end(Buffer.from(body));
+								return;
+							}
+							if (result && "rewrite" in result) {
+								if (result.rewrite.pageName !== void 0) renderPageName = result.rewrite.pageName;
+								const { pageName: _pn, ...rest } = result.rewrite;
+								renderInput = {
+									...renderInput,
+									...rest
+								};
+							}
+						}
+					}
+					let rendered = await mod.aero.render(renderPageName, renderInput);
+					if (rendered === null) {
+						res.statusCode = 404;
+						rendered = await mod.aero.render("404", renderInput);
+					}
+					if (rendered === null) {
+						res.statusCode = 404;
+						res.setHeader("Content-Type", "text/html; charset=utf-8");
+						res.end("<h1>404 — Not Found</h1>");
+						return;
+					}
+					rendered = addDoctype(rendered);
+					const transformed = await server.transformIndexHtml(req.url, rendered);
+					res.setHeader("Content-Type", "text/html; charset=utf-8");
+					res.end(transformed);
+				} catch (err) {
+					next(err);
+				}
+			});
+		}
+	};
+}
+/**
+* Aero Vite plugin factory. Returns an array of plugins: config, virtuals, transform, SSR,
+* static-build, image optimizer, and optionally Nitro (serve only).
+* HMR for templates and content is handled by Vite's dependency graph when the app uses a single
+* client entry that imports @aerobuilt/core and calls aero.mount().
+*
+* @param options - AeroOptions (server, apiPrefix, dirs). Server can be disabled at runtime via AERO_SERVER=false.
+* @returns PluginOption[] to pass to Vite's plugins array.
+*/
+function aero(options = {}) {
+	const dirs = resolveDirs(options.dirs);
+	const apiPrefix = options.apiPrefix || DEFAULT_API_PREFIX;
+	const enableNitro = options.server === true && process.env.AERO_SERVER !== "false";
+	const runtimeInstanceMjsPath = fileURLToPath(new URL("../runtime/instance.mjs", import.meta.url));
+	const runtimeInstanceJsPath = fileURLToPath(new URL("../runtime/instance.js", import.meta.url));
+	const runtimeInstanceTsPath = fileURLToPath(new URL("../runtime/instance.ts", import.meta.url));
+	const runtimeInstancePath = existsSync(runtimeInstanceMjsPath) ? runtimeInstanceMjsPath : existsSync(runtimeInstanceJsPath) ? runtimeInstanceJsPath : runtimeInstanceTsPath;
+	const state = {
+		config: null,
+		aliasResult: null,
+		clientScripts: /* @__PURE__ */ new Map(),
+		runtimeInstancePath,
+		dirs,
+		apiPrefix,
+		options
+	};
+	const aeroConfigPlugin = createAeroConfigPlugin(state);
+	const aeroVirtualsPlugin = createAeroVirtualsPlugin(state);
+	const aeroTransformPlugin = createAeroTransformPlugin(state);
+	const aeroSsrPlugin = createAeroSsrPlugin(state);
+	/** Plugins needed for static build (resolve, load, transform); no SSR/HMR. */
+	const aeroCorePlugins = [
+		aeroConfigPlugin,
+		aeroVirtualsPlugin,
+		aeroTransformPlugin
+	];
+	const plugins = [
+		aeroConfigPlugin,
+		aeroVirtualsPlugin,
+		aeroTransformPlugin,
+		aeroSsrPlugin,
+		{
+			name: "vite-plugin-aero-static",
+			apply: "build",
+			async closeBundle() {
+				const root = state.config.root;
+				const outDir = state.config.build.outDir;
+				const shouldMinifyHtml = state.config.build.minify !== false && typeof import.meta !== "undefined" && import.meta.env?.PROD;
+				const staticPlugins = options.staticServerPlugins?.length ? [...aeroCorePlugins, ...options.staticServerPlugins] : aeroCorePlugins;
+				await renderStaticPages({
+					root,
+					resolvePath: state.aliasResult.resolve,
+					dirs: options.dirs,
+					apiPrefix,
+					vitePlugins: staticPlugins,
+					minify: shouldMinifyHtml,
+					site: options.site,
+					redirects: options.redirects
+				}, outDir);
+				if (enableNitro) await runNitroBuild(root, writeGeneratedNitroConfig(root, dirs.server, options.redirects));
+			}
+		},
+		ViteImageOptimizer({
+			exclude: void 0,
+			include: void 0,
+			includePublic: true,
+			logStats: true,
+			ansiColors: true,
+			svg: {
+				multipass: true,
+				plugins: [{
+					name: "preset-default",
+					params: {
+						overrides: { cleanupNumericValues: false },
+						cleanupIDs: {
+							minify: false,
+							remove: false
+						},
+						convertPathData: false
+					}
+				}]
+			},
+			png: { quality: 80 },
+			jpeg: { quality: 80 },
+			jpg: { quality: 80 },
+			tiff: { quality: 80 },
+			gif: {},
+			webp: { lossless: true },
+			avif: { lossless: true }
+		})
+	];
+	if (enableNitro) {
+		const rawNitroPlugins = nitro({ serverDir: dirs.server });
+		const nitroPlugins = Array.isArray(rawNitroPlugins) ? rawNitroPlugins : [rawNitroPlugins];
+		for (const nitroPlugin of nitroPlugins) {
+			if (!nitroPlugin || typeof nitroPlugin !== "object") continue;
+			const originalApply = nitroPlugin.apply;
+			plugins.push({
+				...nitroPlugin,
+				apply(pluginConfig, env) {
+					if (env.command !== "serve") return false;
+					if (env.isPreview) return false;
+					if (typeof originalApply === "function") return originalApply(pluginConfig, env);
+					if (originalApply) return originalApply === "serve";
+					return true;
+				}
+			});
+		}
+	}
+	return plugins;
+}
+
+//#endregion
+export { aero };