@aerobuilt/core 0.1.0

package/dist/vite/index.js

@@ -0,0 +1,2049 @@
+import {
+  pagePathToKey,
+  resolvePageName,
+  toPosix,
+  toPosixRelative
+} from "../chunk-7A3WBPH4.js";
+import {
+  redirectsToRouteRules
+} from "../chunk-F7MXQXLM.js";
+
+// src/utils/parse.ts
+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;
+}
+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;
+}
+
+// src/vite/index.ts
+import { ViteImageOptimizer } from "vite-plugin-image-optimizer";
+import { nitro } from "nitro/vite";
+
+// src/vite/defaults.ts
+var CLIENT_SCRIPT_PREFIX = "/@aero/client/";
+function getClientScriptVirtualUrl(baseName, index, total) {
+  const suffix = total === 1 ? ".js" : `.${index}.js`;
+  return CLIENT_SCRIPT_PREFIX + baseName + suffix;
+}
+var RUNTIME_INSTANCE_MODULE_ID = "virtual:aero/runtime-instance";
+var RESOLVED_RUNTIME_INSTANCE_MODULE_ID = "\0virtual:aero/runtime-instance";
+var AERO_EMPTY_INLINE_CSS_PREFIX = "\0aero:empty-inline-css:";
+var AERO_HTML_VIRTUAL_PREFIX = "\0aero-html:";
+var DEFAULT_DIRS = {
+  client: "client",
+  server: "server",
+  dist: "dist"
+};
+var DEFAULT_API_PREFIX = "/api";
+var LINK_ATTRS = [
+  "href",
+  "src",
+  "action",
+  "hx-get",
+  "hx-post",
+  "hx-put",
+  "hx-patch",
+  "hx-delete"
+];
+var SKIP_PROTOCOL_REGEX = /^(?:https?:\/\/|\/\/|mailto:|tel:|data:|javascript:|#|blob:|file:\/\/)/i;
+function getServerDir(dirs) {
+  return dirs?.server ?? dirs?.serverDir ?? DEFAULT_DIRS.server;
+}
+function resolveDirs(dirs) {
+  return {
+    client: dirs?.client ?? DEFAULT_DIRS.client,
+    server: getServerDir(dirs),
+    dist: dirs?.dist ?? DEFAULT_DIRS.dist
+  };
+}
+
+// src/compiler/parser.ts
+import { parseHTML } from "linkedom";
+function getCommentRanges(html) {
+  const ranges = [];
+  const commentRegex = /<!--[\s\S]*?-->/g;
+  let match;
+  while ((match = commentRegex.exec(html)) !== null) {
+    ranges.push([match.index, match.index + match[0].length]);
+  }
+  return ranges;
+}
+function isInsideComment(pos, commentRanges) {
+  return commentRanges.some(([start, end]) => pos >= start && pos < end);
+}
+function isInsideForeignNamespace(html, pos) {
+  const before = html.slice(0, pos);
+  const svgOpens = (before.match(/<svg[\s>]/gi) || []).length;
+  const svgCloses = (before.match(/<\/svg\s*>/gi) || []).length;
+  if (svgOpens > svgCloses) return true;
+  const mathOpens = (before.match(/<math[\s>]/gi) || []).length;
+  const mathCloses = (before.match(/<\/math\s*>/gi) || []).length;
+  return mathOpens > mathCloses;
+}
+function parse(html) {
+  html = html.replace(/^\uFEFF/, "");
+  const commentRanges = getCommentRanges(html);
+  let buildContent = [];
+  let clientScripts = [];
+  let inlineScripts = [];
+  let blockingScripts = [];
+  const SCRIPT_REGEX = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+  const edits = [];
+  const scriptsToRemove = [];
+  const isInHead = (html2, scriptStart) => {
+    const beforeScript = html2.slice(0, scriptStart);
+    let headOpen = -1;
+    const headOpenRe = /<head(?=[\s>])/gi;
+    let m;
+    while ((m = headOpenRe.exec(beforeScript)) !== null) headOpen = m.index;
+    const headClose = beforeScript.lastIndexOf("</head>");
+    return headOpen > headClose;
+  };
+  let match = SCRIPT_REGEX.exec(html);
+  while (match !== null) {
+    const start = match.index;
+    const end = match.index + match[0].length;
+    const fullTag = match[0];
+    const attrsMatch = match[1] || "";
+    const content = match[2] || "";
+    if (isInsideComment(start, commentRanges)) {
+      match = SCRIPT_REGEX.exec(html);
+      continue;
+    }
+    if (isInsideForeignNamespace(html, start)) {
+      match = SCRIPT_REGEX.exec(html);
+      continue;
+    }
+    const { document } = parseHTML(fullTag);
+    const scriptEl = document.querySelector("script");
+    if (scriptEl) {
+      const passData = scriptEl.getAttribute("pass:data") || void 0;
+      let cleanedAttrs = attrsMatch.replace(/\bis:build\b/g, "").replace(/\bis:inline\b/g, "").replace(/\bis:blocking\b/g, "");
+      const inHead = isInHead(html, start);
+      if (!scriptEl.hasAttribute("is:inline") && !inHead) {
+        cleanedAttrs = cleanedAttrs.replace(/pass:data="[^"]*"/g, "").replace(/pass:data='[^']*'/g, "").replace(/pass:data=\{[^}]*\}/g, "");
+      }
+      cleanedAttrs = cleanedAttrs.replace(/\s+/g, " ").trim();
+      const openingTag = fullTag.slice(0, fullTag.indexOf(">") + 1);
+      const isPlainDefault = /^<script\s*>$/i.test(openingTag);
+      if (isPlainDefault) {
+        scriptsToRemove.push({
+          start,
+          end,
+          type: "client",
+          content: content.trim(),
+          attrs: cleanedAttrs,
+          passDataExpr: passData,
+          injectInHead: inHead
+        });
+        edits.push({ start, end });
+      } else if (scriptEl.hasAttribute("is:build")) {
+        scriptsToRemove.push({
+          start,
+          end,
+          type: "build",
+          content: content.trim(),
+          attrs: cleanedAttrs
+        });
+        edits.push({ start, end });
+      } else if (scriptEl.hasAttribute("is:inline")) {
+        inlineScripts.push({
+          attrs: cleanedAttrs,
+          content: content.trim(),
+          passDataExpr: passData
+        });
+        edits.push({
+          start,
+          end,
+          newContent: `<script${cleanedAttrs ? " " + cleanedAttrs : ""}>${content.trim()}</script>`
+        });
+      } else if (scriptEl.hasAttribute("is:blocking")) {
+        scriptsToRemove.push({
+          start,
+          end,
+          type: "blocking",
+          content: content.trim(),
+          attrs: cleanedAttrs,
+          passDataExpr: passData
+        });
+        edits.push({ start, end });
+      } else if (scriptEl.hasAttribute("src")) {
+        const src = scriptEl.getAttribute("src") || "";
+        const isLocalScript = !src.startsWith("http://") && !src.startsWith("https://");
+        const hasType = cleanedAttrs.includes("type=");
+        if (isLocalScript && !hasType) {
+          const attrsForModule = cleanedAttrs.replace(/\bdefer\s*=\s*["'][^"']*["']/gi, "").replace(/\bdefer\b/gi, "").replace(/\bsrc\s*=\s*["'][^"']*["']/gi, "").replace(/\s+/g, " ").trim();
+          const newAttrs = attrsForModule ? attrsForModule + ' type="module"' : 'type="module"';
+          edits.push({
+            start,
+            end,
+            newContent: `<script ${newAttrs} src="${src}"></script>`
+          });
+        }
+      } else if (!scriptEl.hasAttribute("is:inline") && inHead) {
+      } else {
+        scriptsToRemove.push({
+          start,
+          end,
+          type: "client",
+          content: content.trim(),
+          attrs: cleanedAttrs,
+          passDataExpr: passData
+        });
+        edits.push({ start, end });
+      }
+    }
+    match = SCRIPT_REGEX.exec(html);
+  }
+  edits.sort((a, b) => a.start - b.start);
+  let template = "";
+  let last = 0;
+  for (const e of edits) {
+    template += html.slice(last, e.start);
+    if (e.newContent !== void 0) template += e.newContent;
+    last = e.end;
+  }
+  template += html.slice(last);
+  for (const s of scriptsToRemove) {
+    if (s.type === "build") buildContent.push(s.content);
+    if (s.type === "client")
+      clientScripts.push({
+        attrs: s.attrs,
+        content: s.content,
+        passDataExpr: s.passDataExpr,
+        injectInHead: s.injectInHead
+      });
+    if (s.type === "blocking")
+      blockingScripts.push({
+        attrs: s.attrs,
+        content: s.content,
+        passDataExpr: s.passDataExpr
+      });
+  }
+  const buildScript = buildContent.length > 0 ? { content: buildContent.join("\n") } : null;
+  return {
+    buildScript,
+    clientScripts,
+    inlineScripts,
+    blockingScripts,
+    template: template.trim()
+  };
+}
+
+// src/compiler/constants.ts
+var ATTR_PREFIX = "data-";
+var ATTR_PROPS = "props";
+var ATTR_EACH = "each";
+var ATTR_IF = "if";
+var ATTR_ELSE_IF = "else-if";
+var ATTR_ELSE = "else";
+var ATTR_NAME = "name";
+var ATTR_SLOT = "slot";
+var ATTR_IS_INLINE = "is:inline";
+var ATTR_PASS_DATA = "pass:data";
+var TAG_SLOT = "slot";
+var SLOT_NAME_DEFAULT = "default";
+var EACH_REGEX = /^(\w+)\s+in\s+(.+)$/;
+var CURLY_INTERPOLATION_REGEX = /{([\s\S]+?)}/g;
+var COMPONENT_SUFFIX_REGEX = /-(component|layout)$/;
+var IMPORT_REGEX = /((?:^|[\r\n;])\s*)import\s+(?:(\w+)|\{([^}]+)\}|\*\s+as\s+(\w+))\s+from\s+(['"])(.+?)\5/g;
+var SELF_CLOSING_TAG_REGEX = /<([a-z0-9-]+)([^>]*?)\/>/gi;
+var SELF_CLOSING_TAIL_REGEX = /\/>$/;
+var ALPINE_ATTR_REGEX = /^(x-|[@:.]).*/;
+var VOID_TAGS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+
+// src/compiler/helpers.ts
+function compileInterpolation(text) {
+  if (!text) return "";
+  let compiled = text.replace(/`/g, "\\`");
+  compiled = compiled.replace(/{([\s\S]+?)}/g, "${$1}");
+  return compiled;
+}
+function compileAttributeInterpolation(text) {
+  if (!text) return "";
+  const openSentinel = "__AERO_ESC_OPEN__";
+  const closeSentinel = "__AERO_ESC_CLOSE__";
+  let compiled = text.replace(/`/g, "\\`");
+  compiled = compiled.replace(/{{/g, openSentinel).replace(/}}/g, closeSentinel);
+  compiled = compiled.replace(/{([\s\S]+?)}/g, "${$1}");
+  compiled = compiled.replace(new RegExp(openSentinel, "g"), "{").replace(new RegExp(closeSentinel, "g"), "}");
+  return compiled;
+}
+function isAttr(name, attr, prefix) {
+  return name === attr || name === prefix + attr;
+}
+function stripBraces(s) {
+  const trimmed = s.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+}
+function kebabToCamelCase(s) {
+  return s.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+function buildPropsString(entries, spreadExpr) {
+  if (spreadExpr) {
+    return entries.length > 0 ? `{ ${spreadExpr}, ${entries.join(", ")} }` : `{ ${spreadExpr} }`;
+  }
+  return `{ ${entries.join(", ")} }`;
+}
+function escapeBackticks(s) {
+  return s.replace(/`/g, "\\`");
+}
+function emitSlotsObjectVars(slotsMap) {
+  const entries = Object.entries(slotsMap).map(([k, varName]) => `"${k}": ${varName}`).join(", ");
+  return "{ " + entries + " }";
+}
+function extractGetStaticPaths(script) {
+  const regex = /export\s+(async\s+)?function\s+getStaticPaths\s*\([^)]*\)\s*\{/;
+  const match = regex.exec(script);
+  if (!match) return { fnText: null, remaining: script };
+  const start = match.index;
+  const braceStart = start + match[0].length - 1;
+  let depth = 1;
+  let i = braceStart + 1;
+  let inString = null;
+  let inComment = null;
+  while (i < script.length && depth > 0) {
+    const char = script[i];
+    const next = script[i + 1];
+    if (inComment) {
+      if (inComment === "//" && char === "\n") inComment = null;
+      else if (inComment === "/*" && char === "*" && next === "/") {
+        inComment = null;
+        i++;
+      }
+    } else if (inString) {
+      if (char === "\\") {
+        i++;
+      } else if (char === inString) {
+        inString = null;
+      }
+    } else {
+      if (char === "/" && next === "/") {
+        inComment = "//";
+        i++;
+      } else if (char === "/" && next === "*") {
+        inComment = "/*";
+        i++;
+      } else if (char === '"' || char === "'" || char === "`") {
+        inString = char;
+      } else if (char === "{") {
+        depth++;
+      } else if (char === "}") {
+        depth--;
+      }
+    }
+    i++;
+  }
+  if (depth !== 0) {
+    return { fnText: null, remaining: script };
+  }
+  const fnText = script.slice(start, i);
+  const remaining = (script.slice(0, start) + script.slice(i)).trim();
+  return { fnText, remaining };
+}
+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}
+
+${renderFn}`.trim();
+  }
+  return renderFn.trim();
+}
+var RENDER_COMPONENT_CONTEXT_PAIRS = [
+  ["request", "request"],
+  ["url", "url"],
+  ["params", "params"],
+  ["site", "__aero_site"],
+  ["styles", "styles"],
+  ["scripts", "scripts"],
+  ["headScripts", "injectedHeadScripts"]
+];
+function getRenderComponentContextArg() {
+  const entries = RENDER_COMPONENT_CONTEXT_PAIRS.map(
+    ([key, varName]) => key === varName ? key : `${key}: ${varName}`
+  );
+  return `{ ${entries.join(", ")} }`;
+}
+function getRenderContextDestructurePattern() {
+  const entries = RENDER_COMPONENT_CONTEXT_PAIRS.map(
+    ([key, varName]) => key === varName ? key : `${key}: ${varName}`
+  );
+  return `slots = {}, renderComponent, ${entries.join(", ")}`;
+}
+function emitSlotVar(varName) {
+  return `let ${varName} = '';
+`;
+}
+function emitAppend(content, outVar = "__out") {
+  return `${outVar} += \`${content}\`;
+`;
+}
+function emitIf(condition) {
+  return `if (${condition}) {
+`;
+}
+function emitElseIf(condition) {
+  return `} else if (${condition}) {
+`;
+}
+function emitElse() {
+  return `} else {
+`;
+}
+function emitEnd() {
+  return `}
+`;
+}
+function emitForOf(item, items) {
+  return `for (const ${item} of ${items}) {
+`;
+}
+function emitSlotOutput(name, defaultContent, outVar = "__out") {
+  return `${outVar} += slots['${name}'] ?? \`${defaultContent}\`;
+`;
+}
+
+// src/compiler/emit.ts
+var 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;
+  }
+}
+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()});
+`;
+      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(`
+:root {\${${cssMapExpr}}
+}
+`, node.outVar);
+    }
+    default: {
+      const _ = node;
+      return "";
+    }
+  }
+}
+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} = '';
+`;
+    styleCode += emitToJS(ir.style, styleVar);
+    styleCode += `styles?.add(${styleVar});
+`;
+  }
+  return { bodyCode, styleCode };
+}
+
+// src/compiler/codegen.ts
+import { parseHTML as parseHTML2 } from "linkedom";
+
+// src/compiler/resolver.ts
+import path from "path";
+var Resolver = class {
+  root;
+  rootAbs;
+  resolvePathFn;
+  constructor(options) {
+    this.root = options.root;
+    this.rootAbs = path.resolve(this.root);
+    this.resolvePathFn = options.resolvePath || ((v) => 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);
+      const isWithinRoot = absolute === this.rootAbs || absolute.startsWith(this.rootAbs + path.sep);
+      if (isWithinRoot) {
+        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);
+    const looksPath = /^(\.{1,2}\/|\/|@|~)/.test(next);
+    if (!looksPath) 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);
+    const looksPath = /^(\.{1,2}\/|\/|@|~)/.test(next);
+    if (!looksPath) return value;
+    next = this.normalizeResolved(next);
+    return next;
+  }
+};
+
+// src/compiler/codegen.ts
+var Lowerer = class {
+  resolver;
+  slotCounter = 0;
+  constructor(resolver) {
+    this.resolver = resolver;
+  }
+  // =========================================================================
+  // Conditional chain helpers
+  // =========================================================================
+  /** 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;
+  }
+  requireBracedExpression(value, directive, node) {
+    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 stripBraces(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);
+          const hasInterpolation = compiled.includes("${") || rawValue.includes("{{") || rawValue.includes("}}");
+          propVal = hasInterpolation ? `\`${compiled}\`` : `"${escapedLiteral}"`;
+        }
+        propsEntries.push(`${attr.name}: ${propVal}`);
+      }
+    }
+    const propsString = buildPropsString(propsEntries, dataPropsExpression);
+    return { propsString };
+  }
+  /** 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 content = this.requireBracedExpression(attr.value || "", attr.name, node);
+          const match = content.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 = this.requireBracedExpression(attr.value || "", attr.name, node);
+          continue;
+        }
+        if (attr.name === ATTR_IS_INLINE) {
+          continue;
+        }
+        let val = escapeBackticks(attr.value);
+        val = this.resolver.resolveAttrValue(val);
+        const isAlpine = ALPINE_ATTR_REGEX.test(attr.name);
+        if (!isAlpine) {
+          val = val.replace(CURLY_INTERPOLATION_REGEX, "${$1}");
+        }
+        attributes.push(`${attr.name}="${val}"`);
+      }
+    }
+    const attrString = attributes.length ? " " + attributes.join(" ") : "";
+    return { attrString, 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;
+      }
+    }
+    const ifNode = {
+      kind: "If",
+      condition,
+      body,
+      ...elseIf.length > 0 && { elseIf },
+      ...elseBody && elseBody.length > 0 && { else: elseBody }
+    };
+    return { nodes: [ifNode], consumed: i - startIndex };
+  }
+  compileText(node, skipInterpolation, outVar) {
+    const text = node.textContent || "";
+    if (!text) return [];
+    const content = skipInterpolation ? escapeBackticks(text) : compileInterpolation(text);
+    return [{ kind: "Append", content, 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";
+    const nodes = [{ kind: "ScriptPassData", passDataExpr, isModule, outVar }];
+    return { nodes, closeBlock: !isModule };
+  }
+  compileSlot(node, skipInterpolation, outVar) {
+    const slotName = node.getAttribute(ATTR_NAME) || SLOT_NAME_DEFAULT;
+    const defaultContent = this.compileSlotDefaultContent(node.childNodes, skipInterpolation);
+    return [{ kind: "Slot", name: slotName, defaultContent, 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) {
+      const slotName = node.getAttribute(ATTR_NAME) || SLOT_NAME_DEFAULT;
+      const defaultContent = this.compileSlotDefaultContent(node.childNodes, skipInterpolation);
+      return `\${ slots['${slotName}'] ?? ${defaultContent} }`;
+    }
+    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";
+    const children = this.compileSlotDefaultContent(node.childNodes, childSkip);
+    return `<${tagName}${attrString}>${children}</${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) {
+          const childTagName = child.tagName?.toLowerCase();
+          if (childTagName === 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
+      }
+    ];
+  }
+};
+function compile(parsed, options) {
+  const inlineScripts = options.inlineScripts ?? parsed.inlineScripts;
+  const resolver = new Resolver({
+    root: options.root,
+    resolvePath: options.resolvePath
+  });
+  const lowerer = new Lowerer(resolver);
+  let script = parsed.buildScript ? parsed.buildScript.content : "";
+  const imports = [];
+  script = script.replace(IMPORT_REGEX, (m, prefix, name, names, starName, q, p) => {
+    const resolved = resolver.resolveImport(p);
+    if (name) {
+      imports.push(`const ${name} = (await import(${q}${resolved}${q})).default`);
+    } else if (names) {
+      imports.push(`const {${names}} = await import(${q}${resolved}${q})`);
+    } else if (starName) {
+      imports.push(`const ${starName} = await import(${q}${resolved}${q})`);
+    }
+    return prefix;
+  });
+  const importsCode = imports.join("\n");
+  const { fnText: getStaticPathsFn, remaining: scriptWithoutPaths } = extractGetStaticPaths(script);
+  script = scriptWithoutPaths;
+  const expandedTemplate = 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}>`;
+    }
+  );
+  const { document } = parseHTML2(`
+		<html lang="en">
+			<body>${expandedTemplate}</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} = '';
+`;
+        styleCode += emitToJS(styleIR, styleVar);
+        styleCode += `styles?.add(${styleVar});
+`;
+        node.remove();
+      }
+    }
+  }
+  const bodyIR = document.body ? lowerer.compileFragment(document.body.childNodes) : [];
+  const { bodyCode } = emitBodyAndStyle({ body: bodyIR, style: [] });
+  const rootScripts = [];
+  const headScripts = [];
+  const virtualPrefix = "/@aero/client/";
+  const hasVirtualClientScripts = options.clientScripts?.some((c) => c.content.startsWith(virtualPrefix)) ?? false;
+  if (hasVirtualClientScripts) {
+    script = `function __aeroScriptUrl(p){return '/'+'@aero/client/'+p}
+` + script;
+  }
+  if (options.clientScripts && options.clientScripts.length > 0) {
+    for (const clientScript of options.clientScripts) {
+      const attrs = clientScript.attrs ?? "";
+      const hasType = attrs.includes("type=");
+      const baseAttrs = hasType ? attrs : `type="module"${attrs ? " " + attrs : ""}`;
+      const urlExpr = clientScript.content.startsWith(virtualPrefix) ? `__aeroScriptUrl(${JSON.stringify(clientScript.content.slice(virtualPrefix.length))})` : JSON.stringify(clientScript.content);
+      const baseAttrsEscaped = baseAttrs.replace(/'/g, "\\'");
+      const tagExpr = `'<script ${baseAttrsEscaped} src="'+${urlExpr}+'"></script>'`;
+      const isHead = clientScript.injectInHead;
+      if (clientScript.passDataExpr) {
+        const jsonExpr = `JSON.stringify(${stripBraces(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 trimmed = blockingScript.passDataExpr.trim();
+        if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+          throw new Error(
+            `Directive \`pass:data\` on <script> must use a braced expression, e.g. pass:data="{ { expression } }".`
+          );
+        }
+        const jsMapExpr = `Object.entries(${stripBraces(blockingScript.passDataExpr)}).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;
+}
+
+// src/utils/aliases.ts
+import path2 from "path";
+import { getTsconfig } from "get-tsconfig";
+function loadTsconfigAliases(root) {
+  const result = getTsconfig(root);
+  if (!result) return { aliases: [], resolvePath: void 0 };
+  const config = result.config;
+  const options = config.compilerOptions;
+  const paths = options?.paths || {};
+  const baseUrl = options?.baseUrl || ".";
+  const baseDir = path2.resolve(path2.dirname(result.path || root), baseUrl);
+  const aliases = [];
+  for (const [key, values] of Object.entries(paths)) {
+    const valueArr = Array.from(values);
+    const first = valueArr[0];
+    if (typeof first !== "string" || first.length === 0) continue;
+    const find = key.replace(/\/*$/, "").replace("/*", "");
+    const target = first.replace(/\/*$/, "").replace("/*", "");
+    const replacement = path2.resolve(baseDir, target);
+    aliases.push({ find, replacement });
+  }
+  const resolvePath = (id) => {
+    for (const entry of aliases) {
+      if (id === entry.find || id.startsWith(`${entry.find}/`)) {
+        const rest = id.slice(entry.find.length);
+        return path2.join(entry.replacement, rest);
+      }
+    }
+    return id;
+  };
+  return { aliases, resolvePath };
+}
+
+// src/vite/build.ts
+import { minify as minifyHTML } from "html-minifier-next";
+import fs from "fs";
+import path3 from "path";
+import { parseHTML as parseHTML3 } from "linkedom";
+import { createServer } from "vite";
+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
+    });
+  }
+}
+function isDynamicPage(page) {
+  return /\[.+?\]/.test(page.pageName);
+}
+function expandPattern(pattern, params) {
+  return pattern.replace(/\[(.+?)\]/g, (_, key) => {
+    if (!(key in params)) {
+      throw new Error(
+        `[aero] getStaticPaths: missing param "${key}" for pattern "${pattern}". Provided params: ${JSON.stringify(params)}`
+      );
+    }
+    return params[key];
+  });
+}
+function walkHtmlFiles(dir) {
+  if (!fs.existsSync(dir)) return [];
+  const files = [];
+  for (const item of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path3.join(dir, item.name);
+    if (item.isDirectory()) {
+      files.push(...walkHtmlFiles(fullPath));
+      continue;
+    }
+    if (item.isFile() && item.name.endsWith(".html")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function toRouteFromPageName(pageName) {
+  if (pageName === "index") return "";
+  if (pageName.endsWith("/index")) return pageName.slice(0, -"/index".length);
+  return pageName;
+}
+function toOutputFile(routePath) {
+  if (routePath === "") return "index.html";
+  if (routePath === "404") return "404.html";
+  return toPosix(path3.join(routePath, "index.html"));
+}
+function writeSitemap(routePaths, site, distDir) {
+  const base = site.replace(/\/$/, "");
+  const urls = routePaths.filter((r) => r !== "404").map((routePath) => {
+    const pathSegment = routePath === "" ? "" : `/${routePath}/`;
+    const loc = `${base}${pathSegment || "/"}`;
+    return `  <url>
+    <loc>${escapeXml(loc)}</loc>
+  </url>`;
+  });
+  const xml = '<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n' + urls.join("\n") + "\n</urlset>\n";
+  fs.writeFileSync(path3.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;");
+}
+function normalizeRelativeLink(fromDir, targetPath) {
+  const rel = path3.posix.relative(fromDir, targetPath);
+  if (!rel) return "./";
+  if (rel.startsWith(".")) return rel;
+  return `./${rel}`;
+}
+function normalizeRelativeRouteLink(fromDir, routePath) {
+  const targetDir = routePath === "" ? "" : routePath;
+  const rel = path3.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(/\/+$/, "");
+}
+function isSkippableUrl(value) {
+  if (!value) return true;
+  return SKIP_PROTOCOL_REGEX.test(value);
+}
+function toManifestKey(root, filePath) {
+  return toPosixRelative(filePath, root);
+}
+function resolveTemplateAssetPath(rawValue, templateFile, root, resolvePath) {
+  if (!rawValue || isSkippableUrl(rawValue)) return null;
+  if (rawValue.startsWith("/")) return path3.resolve(root, rawValue.slice(1));
+  if (rawValue.startsWith("@") || rawValue.startsWith("~")) {
+    const resolved = resolvePath ? resolvePath(rawValue) : rawValue;
+    return path3.isAbsolute(resolved) ? resolved : path3.resolve(root, resolved);
+  }
+  if (rawValue.startsWith("./") || rawValue.startsWith("../")) {
+    return path3.resolve(path3.dirname(templateFile), rawValue);
+  }
+  return null;
+}
+function discoverTemplates(root, templateRoot) {
+  return walkHtmlFiles(path3.resolve(root, templateRoot));
+}
+function discoverPages(root, pagesRoot) {
+  const pagesDir = path3.resolve(root, pagesRoot);
+  const pageFiles = walkHtmlFiles(pagesDir);
+  const allPageNames = new Set(
+    pageFiles.map((f) => pagePathToKey(toPosixRelative(f, root)))
+  );
+  return pageFiles.map((file) => {
+    const relFromRoot = toPosixRelative(file, root);
+    let pageName = pagePathToKey(relFromRoot);
+    if (pageName === "home" && !allPageNames.has("index")) {
+      pageName = "index";
+    } else if (pageName.endsWith("/home")) {
+      const siblingIndex = pageName.slice(0, -"/home".length) + "/index";
+      if (!allPageNames.has(siblingIndex)) {
+        pageName = siblingIndex;
+      }
+    }
+    const routePath = toRouteFromPageName(pageName);
+    return {
+      pageName,
+      routePath,
+      sourceFile: file,
+      outputFile: toOutputFile(routePath)
+    };
+  });
+}
+function discoverClientScriptContentMap(root, templateRoot) {
+  const map = /* @__PURE__ */ new Map();
+  for (const file of discoverTemplates(root, templateRoot)) {
+    const source = fs.readFileSync(file, "utf-8");
+    const parsed = parse(source);
+    if (parsed.clientScripts.length === 0) continue;
+    const rel = toPosixRelative(file, root);
+    const baseName = rel.replace(/\.html$/i, "");
+    registerClientScriptsToMap(parsed, baseName, map);
+  }
+  return map;
+}
+function discoverClientScriptVirtualInputs(root, templateRoot) {
+  const entries = {};
+  for (const file of discoverTemplates(root, templateRoot)) {
+    const source = fs.readFileSync(file, "utf-8");
+    const parsed = parse(source);
+    if (parsed.clientScripts.length === 0) continue;
+    const rel = toPosixRelative(file, root);
+    const baseName = rel.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;
+}
+function discoverAssetInputs(root, resolvePath, templateRoot = "client") {
+  const entries = /* @__PURE__ */ new Map();
+  for (const templateFile of discoverTemplates(root, templateRoot)) {
+    const source = fs.readFileSync(templateFile, "utf-8");
+    const { document } = parseHTML3(source);
+    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 raw = el.getAttribute(attr) || "";
+      const resolved = resolveTemplateAssetPath(raw, templateFile, root, resolvePath);
+      if (!resolved || !fs.existsSync(resolved)) continue;
+      const ext = path3.extname(resolved).toLowerCase();
+      if (![".js", ".mjs", ".ts", ".tsx", ".css"].includes(ext)) continue;
+      entries.set(toManifestKey(root, resolved), resolved);
+    }
+  }
+  const defaultClientEntry = path3.resolve(root, `${templateRoot}/index.ts`);
+  if (fs.existsSync(defaultClientEntry)) {
+    entries.set(toManifestKey(root, defaultClientEntry), defaultClientEntry);
+  }
+  const imagesDir = path3.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 (path3.basename(file).startsWith(".")) continue;
+      entries.set(key, file);
+    }
+  }
+  return Object.fromEntries(entries);
+}
+function walkFiles(dir) {
+  if (!fs.existsSync(dir)) return [];
+  const files = [];
+  for (const item of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path3.join(dir, item.name);
+    if (item.isDirectory()) {
+      files.push(...walkFiles(fullPath));
+      continue;
+    }
+    if (item.isFile()) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function addDoctype(html) {
+  return /^\s*<!doctype\s+html/i.test(html) ? html : `<!doctype html>
+${html}`;
+}
+var ASSET_IMAGE_EXT = /\.(jpg|jpeg|png|gif|webp|svg|ico)(\?|$)/i;
+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) {
+    const entryWithAssets = manifestEntry;
+    const imageAsset = entryWithAssets.assets?.find((a) => ASSET_IMAGE_EXT.test(a));
+    const fileToUse = imageAsset ?? manifestEntry.file;
+    const rel2 = normalizeRelativeLink(fromDir, fileToUse);
+    return rel2 + suffix;
+  }
+  if (noQuery.startsWith("/assets/")) {
+    const rel2 = normalizeRelativeLink(fromDir, noQuery.replace(/^\//, ""));
+    return rel2 + suffix;
+  }
+  const route = normalizeRoutePathFromHref(noQuery);
+  if (routeSet.has(route) || route === "") {
+    const rel2 = route === "404" ? normalizeRelativeLink(fromDir, toOutputFile(route)) : normalizeRelativeRouteLink(fromDir, route);
+    return rel2 + suffix;
+  }
+  const rel = normalizeRelativeLink(fromDir, noQuery.replace(/^\//, ""));
+  return rel + suffix;
+}
+function rewriteRenderedHtml(html, outputFile, manifest, routeSet, apiPrefix = DEFAULT_API_PREFIX) {
+  const fromDir = path3.posix.dirname(outputFile);
+  const { document } = parseHTML3(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 = path3.join(distDir, ".vite", "manifest.json");
+  if (!fs.existsSync(manifestPath)) return {};
+  return JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+}
+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, path3.join(dirs.client, "pages"));
+  const distDir = path3.resolve(root, outDir);
+  const manifest = readManifest(distDir);
+  const previousAeroNitro = process.env.AERO_NITRO;
+  process.env.AERO_NITRO = "false";
+  const staticCacheDir = path3.join(root, ".aero", "vite-ssr");
+  const server = await createServer({
+    configFile: false,
+    root,
+    cacheDir: staticCacheDir,
+    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] \u26A0 Skipping dynamic page "${path3.relative(root, page.sourceFile)}" \u2014 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] \u26A0 getStaticPaths() for "${path3.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, path3.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 minifyHTML(rendered, {
+          collapseWhitespace: true,
+          removeComments: true,
+          minifyCSS: true,
+          minifyJS: true
+        });
+      }
+      const outPath = path3.join(distDir, page.outputFile);
+      fs.mkdirSync(path3.dirname(outPath), { recursive: true });
+      fs.writeFileSync(outPath, rendered, "utf-8");
+    }
+    if (options.site && options.site.trim() !== "") {
+      const routePaths = [...new Set(pagesToRender.map((p) => p.routePath))];
+      writeSitemap(routePaths, options.site.trim(), distDir);
+    }
+  } finally {
+    await server.close();
+    if (previousAeroNitro === void 0) {
+      delete process.env.AERO_NITRO;
+    } else {
+      process.env.AERO_NITRO = previousAeroNitro;
+    }
+  }
+}
+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) {
+          const name = path3.basename(chunkInfo.name);
+          return `assets/${name}-[hash].js`;
+        },
+        chunkFileNames(chunkInfo) {
+          const facade = chunkInfo.facadeModuleId ?? "";
+          if (facade.includes("aero-html")) {
+            return `assets/aero-[hash].js`;
+          }
+          const name = path3.basename(chunkInfo.name);
+          return `assets/${name}-[hash].js`;
+        },
+        assetFileNames(assetInfo) {
+          const name = path3.basename(assetInfo.name || "");
+          return `assets/${name}-[hash][extname]`;
+        }
+      }
+    }
+  };
+}
+
+// src/vite/index.ts
+import { spawn } from "child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import path4 from "path";
+var require2 = createRequire(import.meta.url);
+var AERO_DIR = ".aero";
+var NITRO_CONFIG_FILENAME = "nitro.config.mjs";
+function writeGeneratedNitroConfig(root, serverDir, redirects) {
+  const aeroDir = path4.join(root, AERO_DIR);
+  mkdirSync(aeroDir, { recursive: true });
+  const routeRules = redirectsToRouteRules(redirects ?? []);
+  const nitroConfig = {
+    rootDir: "..",
+    output: { dir: path4.join(root, ".output") },
+    scanDirs: [path4.join(root, serverDir)],
+    routeRules,
+    noPublicDir: true
+  };
+  const content = `// Generated by Aero \u2014 do not edit
+export default ${JSON.stringify(nitroConfig, null, 2)}
+`;
+  writeFileSync(path4.join(aeroDir, NITRO_CONFIG_FILENAME), content);
+  return aeroDir;
+}
+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(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();
+      state.aliasResult = loadTsconfigAliases(root);
+      const site = state.options.site ?? "";
+      const alias = env?.command === "build" ? [
+        ...state.aliasResult.aliases,
+        {
+          find: "@aerobuilt/core",
+          replacement: require2.resolve("@aerobuilt/core/entry-prod")
+        }
+      ] : state.aliasResult.aliases;
+      return {
+        base: "./",
+        resolve: { alias },
+        define: {
+          "import.meta.env.SITE": JSON.stringify(site)
+        },
+        build: createBuildConfig(
+          { resolvePath: state.aliasResult.resolvePath, dirs: state.options.dirs },
+          root
+        )
+      };
+    },
+    configResolved(resolvedConfig) {
+      state.config = resolvedConfig;
+    }
+  };
+}
+function isAeroTemplateHtml(filePath, root, dirs) {
+  const clientBase = path4.join(root, dirs.client);
+  const rel = path4.relative(clientBase, filePath);
+  if (rel.startsWith("..") || path4.isAbsolute(rel)) return false;
+  const sep = path4.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;
+      const contentMap = discoverClientScriptContentMap(state.config.root, state.dirs.client);
+      contentMap.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;
+      }
+      const isPathLike = (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");
+      if (isPathLike) {
+        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 code = readFileSync(filePath, "utf-8");
+          const parsed = parse(code);
+          const relativePath = toPosixRelative(filePath, state.config.root);
+          const baseName = relativePath.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
+            );
+          }
+          const generated = compile(parsed, {
+            root: state.config.root,
+            clientScripts: parsed.clientScripts,
+            blockingScripts: parsed.blockingScripts,
+            inlineScripts: parsed.inlineScripts,
+            resolvePath: state.aliasResult.resolvePath
+          });
+          return { code: generated, 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) {
+            const preamble = `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;
+`;
+            return preamble + 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 relativePath = toPosixRelative(id, state.config.root);
+          const baseName = relativePath.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
+            );
+          }
+        }
+        const generated = compile(parsed, {
+          root: state.config.root,
+          clientScripts: parsed.clientScripts,
+          blockingScripts: parsed.blockingScripts,
+          inlineScripts: parsed.inlineScripts,
+          resolvePath: state.aliasResult.resolvePath
+        });
+        return {
+          code: generated,
+          map: null
+        };
+      } catch (err) {
+        const relativePath = path4.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();
+        const acceptsHtml = req.headers.accept?.includes("text/html");
+        if (!acceptsHtml) return next();
+        const pathname = req.url.split("?")[0] || "/";
+        if (pathname.startsWith(state.apiPrefix) || pathname.startsWith("/@fs") || pathname.startsWith("/@id")) {
+          return next();
+        }
+        const ext = path4.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 \u2014 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);
+        }
+      });
+    }
+  };
+}
+function aero(options = {}) {
+  const dirs = resolveDirs(options.dirs);
+  const apiPrefix = options.apiPrefix || DEFAULT_API_PREFIX;
+  const enableNitro = options.nitro === true && process.env.AERO_NITRO !== "false";
+  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(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);
+  const aeroCorePlugins = [aeroConfigPlugin, aeroVirtualsPlugin, aeroTransformPlugin];
+  const staticBuildPlugin = {
+    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.resolvePath,
+          dirs: options.dirs,
+          apiPrefix,
+          vitePlugins: staticPlugins,
+          minify: shouldMinifyHtml,
+          site: options.site,
+          redirects: options.redirects
+        },
+        outDir
+      );
+      if (enableNitro) {
+        const configCwd = writeGeneratedNitroConfig(root, dirs.server, options.redirects);
+        await runNitroBuild(root, configCwd);
+      }
+    }
+  };
+  const plugins = [
+    aeroConfigPlugin,
+    aeroVirtualsPlugin,
+    aeroTransformPlugin,
+    aeroSsrPlugin,
+    staticBuildPlugin,
+    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;
+}
+export {
+  aero
+};