@absolutejs/absolute 0.19.0-beta.999 → 0.20.0-beta.1

package/dist/vue/server.js

@@ -3,7 +3,6 @@ var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 function __accessProp(key) {
   return this[key];
@@ -30,23 +29,6 @@ var __toESM = (mod, isNodeMode, target) => {
     cache.set(mod, to);
   return to;
 };
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -78,23 +60,465 @@ var __legacyMetadataTS = (k, v) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
-// src/constants.ts
-var ANGULAR_INIT_TIMEOUT_MS = 500, ANSI_ESCAPE_CODE = 27, ANSI_ESCAPE_LENGTH = 3, ASCII_SPACE = 32, BASE_36_RADIX = 36, BUN_BUILD_WARNING_SUPPRESSION = "wildcard sideEffects are not supported yet", BODY_SLICE_LENGTH = 2000, BYTES_PER_KILOBYTE = 1024, CLI_ARGS_OFFSET = 3, CSS_ERROR_RESOLVE_DELAY_MS = 50, CSS_MAX_CHECK_ATTEMPTS = 10, CSS_MAX_PARSE_TIMEOUT_MS = 500, CSS_SHEET_READY_TIMEOUT_MS = 100, DEFAULT_CHUNK_SIZE = 16384, DEFAULT_DEBOUNCE_MS = 15, DEFAULT_PORT = 3000, DEV_SERVER_RESTART_DEBOUNCE_MS = 100, DOM_UPDATE_DELAY_MS = 50, FILE_PROTOCOL_PREFIX_LENGTH = 7, FOCUS_ID_PREFIX_LENGTH = 3, FOCUS_IDX_PREFIX_LENGTH = 4, FOCUS_NAME_PREFIX_LENGTH = 5, HMR_UPDATE_TIMEOUT_MS = 2000, HOOK_SIGNATURE_LENGTH = 12, EXCLUDE_LAST_OFFSET = -1, HTTP_STATUS_OK = 200, HTTP_STATUS_BAD_REQUEST = 400, HTTP_STATUS_NOT_FOUND = 404, HOURS_IN_DAY = 24, HOURS_IN_HALF_DAY = 12, IMAGE_DEFAULT_DEVICE_SIZES, IMAGE_DEFAULT_IMAGE_SIZES, IMAGE_DEFAULT_QUALITY = 75, IMAGE_GLOB_SUFFIX_LENGTH = 2, MAX_ERROR_LENGTH = 200, MAX_RECONNECT_ATTEMPTS = 60, MILLISECONDS_IN_A_SECOND = 1000, MINUTES_IN_AN_HOUR = 60, SECONDS_IN_A_MINUTE = 60, MILLISECONDS_IN_A_MINUTE, MILLISECONDS_IN_A_DAY, OVERLAY_FADE_DURATION_MS = 150, PING_INTERVAL_MS = 30000, RAF_BATCH_COUNT = 3, RANDOM_ID_END_INDEX = 11, REBUILD_BATCH_DELAY_MS = 10, REBUILD_RELOAD_DELAY_MS = 200, RECONNECT_INITIAL_DELAY_MS = 500, RECONNECT_POLL_INTERVAL_MS = 300, REACT_STREAM_SLOT_FAST_DELAY_MS = 5, REACT_STREAM_SLOT_SLOW_DELAY_MS = 20, SIGINT_EXIT_CODE = 130, SIGTERM_EXIT_CODE = 143, SVELTE_CSS_LOAD_TIMEOUT_MS = 500, TIME_PRECISION = 2, TWO_THIRDS, UNFOUND_INDEX = -1, WEBSOCKET_NORMAL_CLOSURE = 1000, WORKSPACE_COMMAND_ARGS_OFFSET = 3, WORKSPACE_FAILURE_LOG_PRINT_LIMIT = 30, WORKSPACE_FAILURE_RECENT_LOG_LIMIT = 60, WORKSPACE_READY_ATTEMPT_TIMEOUT_MS = 5000, WORKSPACE_READY_PROBE_INTERVAL_MS = 250, WORKSPACE_READY_TIMEOUT_MS = 30000, WORKSPACE_SHUTDOWN_TIMEOUT_MS = 1e4, WORKSPACE_TUI_DEFAULT_HEIGHT = 28, WORKSPACE_TUI_DEFAULT_WIDTH = 100, WORKSPACE_TUI_ESCAPE_SEQUENCE_TIMEOUT_MS = 30, WORKSPACE_TUI_FOOTER_LINE_COUNT = 3, WORKSPACE_TUI_MIN_LOG_HEIGHT = 3, WORKSPACE_TUI_MIN_SERVICE_NAME_WIDTH = 7, WORKSPACE_TUI_MIN_TARGET_WIDTH = 8, WORKSPACE_TUI_MIN_WRAP_WIDTH = 12, WORKSPACE_TUI_PROMPT_CURSOR_OFFSET = 3, WORKSPACE_TUI_RECENT_LOG_LIMIT = 40, WORKSPACE_TUI_RENDER_DEBOUNCE_MS = 16, WORKSPACE_TUI_STATUS_WIDTH = 10, WORKSPACE_TUI_TARGET_PADDING_WIDTH = 6, WORKSPACE_TUI_VISIBILITY_WIDTH = 8;
-var init_constants = __esm(() => {
-  IMAGE_DEFAULT_DEVICE_SIZES = [
-    640,
-    750,
-    828,
-    1080,
-    1200,
-    1920,
-    2048,
-    3840
+// src/utils/inlinePageCss.ts
+var siblingCssCache, clearSiblingCssCache = () => {
+  siblingCssCache.clear();
+}, injectInlineCss = (headTag, css) => {
+  if (!css)
+    return headTag;
+  const styleBlock = `<style data-absolute-page-css>${css}</style>`;
+  return headTag.replace("</head>", `${styleBlock}</head>`);
+}, readSiblingCss = async (siblingJsPath) => {
+  if (!siblingJsPath)
+    return "";
+  const cssPath = siblingJsPath.replace(/\.js$/, ".css");
+  if (cssPath === siblingJsPath)
+    return "";
+  const cached = siblingCssCache.get(cssPath);
+  if (cached !== undefined)
+    return cached;
+  const { readFile } = await import("fs/promises");
+  try {
+    const css = await readFile(cssPath, "utf-8");
+    siblingCssCache.set(cssPath, css);
+    return css;
+  } catch {
+    siblingCssCache.set(cssPath, "");
+    return "";
+  }
+};
+var init_inlinePageCss = __esm(() => {
+  siblingCssCache = new Map;
+});
+
+// src/utils/spaRouteCss.ts
+import { readFile } from "fs/promises";
+import { dirname, isAbsolute, resolve } from "path";
+var sideManifestCache, readSideManifest = async (sideManifestPath) => {
+  const cached = sideManifestCache.get(sideManifestPath);
+  if (cached !== undefined)
+    return cached;
+  try {
+    const raw = await readFile(sideManifestPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const routes = Array.isArray(parsed) ? parsed : [];
+    sideManifestCache.set(sideManifestPath, routes);
+    return routes;
+  } catch {
+    sideManifestCache.set(sideManifestPath, []);
+    return [];
+  }
+}, compilePathToRegExp = (pattern) => {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const withParams = escaped.replace(/:([a-zA-Z_$][a-zA-Z0-9_$]*)/g, "[^/]+").replace(/\\\*/g, ".*");
+  return new RegExp(`^${withParams}$`);
+}, routeMatchers, matcherFor = (pattern) => {
+  const cached = routeMatchers.get(pattern);
+  if (cached !== undefined)
+    return cached;
+  const compiled = compilePathToRegExp(pattern);
+  routeMatchers.set(pattern, compiled);
+  return compiled;
+}, findMatchingRoute = (routes, pathname) => {
+  for (const route of routes) {
+    if (matcherFor(route.path).test(pathname))
+      return route;
+  }
+  return null;
+}, childCssCache, clearSpaRouteCssCaches = () => {
+  sideManifestCache.clear();
+  childCssCache.clear();
+}, readChildCss = async (cssPath, sideManifestPath) => {
+  if (!cssPath)
+    return "";
+  const resolvedCssPath = isAbsolute(cssPath) ? cssPath : resolve(dirname(sideManifestPath), cssPath);
+  const cached = childCssCache.get(resolvedCssPath);
+  if (cached !== undefined)
+    return cached;
+  try {
+    const css = await readFile(resolvedCssPath, "utf-8");
+    childCssCache.set(resolvedCssPath, css);
+    return css;
+  } catch {
+    childCssCache.set(resolvedCssPath, "");
+    return "";
+  }
+}, resolveSpaChildCss = async (siblingJsPath, requestUrl) => {
+  if (!siblingJsPath || !requestUrl)
+    return "";
+  const sideManifestPath = siblingJsPath.replace(/\.js$/, ".spa.json");
+  if (sideManifestPath === siblingJsPath)
+    return "";
+  const routes = await readSideManifest(sideManifestPath);
+  if (routes.length === 0)
+    return "";
+  let pathname;
+  try {
+    ({ pathname } = new URL(requestUrl));
+  } catch {
+    pathname = requestUrl.split("?")[0] ?? requestUrl;
+  }
+  const matched = findMatchingRoute(routes, pathname);
+  if (!matched)
+    return "";
+  const { cssPath: routeCssPath } = matched;
+  const cssPaths = [
+    routeCssPath,
+    ...routes.map((route) => route.cssPath)
+  ].filter((childCssPath, index, all) => childCssPath && all.indexOf(childCssPath) === index);
+  const chunks = await Promise.all(cssPaths.map((childCssPath) => readChildCss(childCssPath, sideManifestPath)));
+  return chunks.filter(Boolean).join(`
+`);
+};
+var init_spaRouteCss = __esm(() => {
+  sideManifestCache = new Map;
+  routeMatchers = new Map;
+  childCssCache = new Map;
+});
+
+// src/utils/stringModifiers.ts
+var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9\-_]+/g, "").replace(/[-_]{2,}/g, "-"), toKebab = (str) => normalizeSlug(str).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), toPascal = (str) => {
+  if (!str.includes("-") && !str.includes("_")) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  return normalizeSlug(str).split(/[-_]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join("");
+};
+
+// src/utils/resolveConvention.ts
+import { basename } from "path";
+var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boolean(value) && typeof value === "object", getMap = () => {
+  const value = Reflect.get(globalThis, CONVENTIONS_KEY);
+  if (isConventionsMap(value))
+    return value;
+  const empty = {};
+  return empty;
+}, derivePageName = (pagePath) => {
+  const base = basename(pagePath);
+  const dotIndex = base.indexOf(".");
+  const name = dotIndex > 0 ? base.slice(0, dotIndex) : base;
+  return toPascal(name);
+}, normalizeConventionPageName = (name) => toPascal(name).replace(/\d+$/, ""), hasErrorConvention = (framework) => {
+  const conventions = getMap()[framework];
+  if (!conventions)
+    return false;
+  if (conventions.defaults?.error)
+    return true;
+  return Object.values(conventions.pages ?? {}).some((page) => Boolean(page.error));
+}, resolveErrorConventionPath = (framework, pageName) => {
+  const conventions = getMap()[framework];
+  if (!conventions)
+    return;
+  const exact = conventions.pages?.[pageName]?.error;
+  if (exact)
+    return exact;
+  const normalizedPageName = normalizeConventionPageName(pageName);
+  for (const [candidate, page] of Object.entries(conventions.pages ?? {})) {
+    if (normalizeConventionPageName(candidate) === normalizedPageName) {
+      return page.error ?? conventions.defaults?.error;
+    }
+  }
+  return conventions.defaults?.error;
+}, resolveNotFoundConventionPath = (framework) => getMap()[framework]?.defaults?.notFound, setConventions = (map) => {
+  Reflect.set(globalThis, CONVENTIONS_KEY, map);
+}, isDev = () => true, buildErrorProps = (error) => {
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      name: error.name,
+      ...isDev() && error.stack ? { stack: error.stack } : {}
+    };
+  }
+  return { message: String(error), name: "Error" };
+}, renderReactError = async (conventionPath, errorProps) => {
+  const { createElement } = await import("react");
+  const { renderToReadableStream } = await import("react-dom/server");
+  const mod = await import(conventionPath);
+  const ErrorComponent = mod.default;
+  if (typeof ErrorComponent !== "function")
+    return null;
+  const element = createElement(ErrorComponent, errorProps);
+  const stream = await renderToReadableStream(element);
+  return new Response(stream, {
+    headers: { "Content-Type": "text/html" },
+    status: 500
+  });
+}, renderSvelteError = async (conventionPath, errorProps) => {
+  const { render } = await import("svelte/server");
+  const mod = await import(conventionPath);
+  const ErrorComponent = mod.default;
+  if (!ErrorComponent)
+    return null;
+  const { head, body } = render(ErrorComponent, {
+    props: errorProps
+  });
+  const html = `<!DOCTYPE html><html><head>${head}</head><body>${body}</body></html>`;
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" },
+    status: 500
+  });
+}, unescapeVueStyles = (ssrBody) => {
+  let styles = "";
+  const body = ssrBody.replace(/<style>([\s\S]*?)<\/style>/g, (_, css) => {
+    styles += `<style>${css.replace(/&quot;/g, '"').replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">")}</style>`;
+    return "";
+  });
+  return { body, styles };
+}, renderVueError = async (conventionPath, errorProps) => {
+  const { createSSRApp, h } = await import("vue");
+  const { renderToString } = await import("vue/server-renderer");
+  const mod = await import(conventionPath);
+  const ErrorComponent = mod.default;
+  if (!ErrorComponent)
+    return null;
+  const app = createSSRApp({
+    render: () => h(ErrorComponent, errorProps)
+  });
+  const rawBody = await renderToString(app);
+  const { styles, body } = unescapeVueStyles(rawBody);
+  const html = `<!DOCTYPE html><html><head>${styles}</head><body><div id="root">${body}</div></body></html>`;
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" },
+    status: 500
+  });
+}, renderAngularError = async (conventionPath, errorProps) => {
+  const mod = await import(conventionPath);
+  const renderFn = mod.default;
+  if (typeof renderFn !== "function")
+    return null;
+  const html = renderFn(errorProps);
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" },
+    status: 500
+  });
+}, escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;"), replaceErrorTokens = (template, errorProps) => template.replace(/\{\{\s*name\s*\}\}/g, escapeHtml(errorProps.name)).replace(/\{\{\s*message\s*\}\}/g, escapeHtml(errorProps.message)).replace(/\{\{\s*stack\s*\}\}/g, errorProps.stack ? escapeHtml(errorProps.stack) : ""), renderHtmlError = async (conventionPath, errorProps) => {
+  const template = await Bun.file(conventionPath).text();
+  const html = replaceErrorTokens(template, errorProps);
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" },
+    status: 500
+  });
+}, logConventionRenderError = (framework, label, renderError) => {
+  const message = renderError instanceof Error ? renderError.message : "";
+  if (message.includes("Cannot find module") || message.includes("Cannot find package") || message.includes("not found in module")) {
+    console.error(`[SSR] Convention ${label} page for ${framework} failed: missing framework package. Ensure the ${framework} runtime is installed (e.g. bun add ${framework === "react" ? "react react-dom" : framework}).`);
+    return;
+  }
+  console.error(`[SSR] Failed to render ${framework} convention ${label} page:`, renderError);
+}, renderEmberError = async () => null, renderEmberNotFound = async () => null, ERROR_RENDERERS, tryFrameworkErrorConvention = async (framework, pageName, errorProps, error) => {
+  let conventionPath = resolveErrorConventionPath(framework, pageName);
+  if (!conventionPath && error instanceof Error && error.stack) {
+    for (const match of error.stack.matchAll(/^\s*at\s+([A-Za-z_$][\w$]*)/gm)) {
+      const [, candidate] = match;
+      if (!candidate)
+        continue;
+      conventionPath = resolveErrorConventionPath(framework, candidate);
+      if (conventionPath)
+        break;
+    }
+  }
+  if (!conventionPath)
+    return null;
+  const renderer = ERROR_RENDERERS[framework];
+  if (!renderer)
+    return null;
+  try {
+    return await renderer(conventionPath, errorProps);
+  } catch (renderError) {
+    logConventionRenderError(framework, "error", renderError);
+  }
+  return null;
+}, renderConventionError = async (framework, pageName, error) => {
+  const errorProps = buildErrorProps(error);
+  const frameworkResponse = await tryFrameworkErrorConvention(framework, pageName, errorProps, error);
+  if (frameworkResponse)
+    return frameworkResponse;
+  if (framework !== "html") {
+    const htmlResponse = await tryFrameworkErrorConvention("html", pageName, errorProps, error);
+    if (htmlResponse)
+      return htmlResponse;
+  }
+  return null;
+}, renderReactNotFound = async (conventionPath) => {
+  const { createElement } = await import("react");
+  const { renderToReadableStream } = await import("react-dom/server");
+  const mod = await import(conventionPath);
+  const NotFoundComponent = mod.default;
+  if (typeof NotFoundComponent !== "function")
+    return null;
+  const element = createElement(NotFoundComponent);
+  const stream = await renderToReadableStream(element);
+  return new Response(stream, {
+    headers: { "Content-Type": "text/html" },
+    status: 404
+  });
+}, renderSvelteNotFound = async (conventionPath) => {
+  const { render } = await import("svelte/server");
+  const mod = await import(conventionPath);
+  const NotFoundComponent = mod.default;
+  if (!NotFoundComponent)
+    return null;
+  const { head, body } = render(NotFoundComponent);
+  const html = `<!DOCTYPE html><html><head>${head}</head><body>${body}</body></html>`;
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" },
+    status: 404
+  });
+}, renderVueNotFound = async (conventionPath) => {
+  const { createSSRApp, h } = await import("vue");
+  const { renderToString } = await import("vue/server-renderer");
+  const mod = await import(conventionPath);
+  const NotFoundComponent = mod.default;
+  if (!NotFoundComponent)
+    return null;
+  const app = createSSRApp({
+    render: () => h(NotFoundComponent)
+  });
+  const rawBody = await renderToString(app);
+  const { styles, body } = unescapeVueStyles(rawBody);
+  const html = `<!DOCTYPE html><html><head>${styles}</head><body><div id="root">${body}</div></body></html>`;
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" },
+    status: 404
+  });
+}, renderAngularNotFound = async (conventionPath) => {
+  const mod = await import(conventionPath);
+  const renderFn = mod.default;
+  if (typeof renderFn !== "function")
+    return null;
+  const html = renderFn();
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" },
+    status: 404
+  });
+}, renderHtmlNotFound = async (conventionPath) => {
+  const html = await Bun.file(conventionPath).text();
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" },
+    status: 404
+  });
+}, NOT_FOUND_RENDERERS, renderConventionNotFound = async (framework) => {
+  const conventionPath = resolveNotFoundConventionPath(framework);
+  if (!conventionPath)
+    return null;
+  const renderer = NOT_FOUND_RENDERERS[framework];
+  if (!renderer)
+    return null;
+  try {
+    return await renderer(conventionPath);
+  } catch (renderError) {
+    logConventionRenderError(framework, "not-found", renderError);
+  }
+  return null;
+}, NOT_FOUND_PRIORITY, renderFirstNotFound = async () => {
+  const renderNext = async (frameworks) => {
+    const [framework, ...remaining] = frameworks;
+    if (!framework) {
+      return null;
+    }
+    if (!getMap()[framework]?.defaults?.notFound) {
+      return renderNext(remaining);
+    }
+    const response = await renderConventionNotFound(framework);
+    if (response) {
+      return response;
+    }
+    return renderNext(remaining);
+  };
+  return renderNext(NOT_FOUND_PRIORITY);
+};
+var init_resolveConvention = __esm(() => {
+  ERROR_RENDERERS = {
+    angular: renderAngularError,
+    ember: renderEmberError,
+    html: renderHtmlError,
+    react: renderReactError,
+    svelte: renderSvelteError,
+    vue: renderVueError
+  };
+  NOT_FOUND_RENDERERS = {
+    angular: renderAngularNotFound,
+    ember: renderEmberNotFound,
+    html: renderHtmlNotFound,
+    react: renderReactNotFound,
+    svelte: renderSvelteNotFound,
+    vue: renderVueNotFound
+  };
+  NOT_FOUND_PRIORITY = [
+    "react",
+    "svelte",
+    "vue",
+    "angular",
+    "html"
   ];
-  IMAGE_DEFAULT_IMAGE_SIZES = [16, 32, 48, 64, 96, 128, 256, 384];
-  MILLISECONDS_IN_A_MINUTE = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE;
-  MILLISECONDS_IN_A_DAY = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE * MINUTES_IN_AN_HOUR * HOURS_IN_DAY;
-  TWO_THIRDS = 2 / 3;
+});
+
+// src/utils/spaRouteManifest.ts
+import { basename as basename2 } from "path";
+var SPA_ROUTES_KEY = "__absoluteSpaRoutes", setSpaRouteManifest = (hosts) => {
+  Reflect.set(globalThis, SPA_ROUTES_KEY, hosts);
+}, isRuntimeSpaHost = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "framework") === "string", getSpaRouteManifest = () => {
+  const value = Reflect.get(globalThis, SPA_ROUTES_KEY);
+  return Array.isArray(value) ? value.filter(isRuntimeSpaHost) : [];
+}, normalizePath = (path) => {
+  const withLeadingSlash = path.startsWith("/") ? path : `/${path}`;
+  const trimmed = withLeadingSlash.replace(/\/+$/, "");
+  return trimmed || "/";
+}, fullRoutePath = (baseHref, routePath) => {
+  const base = normalizePath(baseHref);
+  const route = normalizePath(routePath);
+  if (base !== "/" && (route === base || route.startsWith(`${base}/`))) {
+    return route;
+  }
+  if (base === "/")
+    return route;
+  return normalizePath(`${base}/${route.replace(/^\/+/, "")}`);
+}, routePattern = (path) => {
+  const segments = normalizePath(path).split("/").filter(Boolean);
+  let expression = "^";
+  for (const segment of segments) {
+    if (segment === "*" || segment === "**") {
+      expression += "(?:/.*)?";
+      continue;
+    }
+    const parameter = /^:[A-Za-z_$][A-Za-z0-9_$]*(?:\((.*)\))?(\?)?$/.exec(segment);
+    if (parameter) {
+      const valuePattern = parameter[1] || "[^/]+";
+      expression += parameter[2] ? `(?:/${valuePattern})?` : `/${valuePattern}`;
+      continue;
+    }
+    expression += `/${segment.replace(/[.+?^${}()|[\]\\]/g, "\\$&")}`;
+  }
+  return new RegExp(`${expression || "^/"}/?$`);
+}, sourcePageName = (sourceFile) => basename2(sourceFile).replace(/\.[^.]+$/, "").toLowerCase(), isKnownSpaRoute = (framework, pageName, request) => {
+  if (!request)
+    return true;
+  let pathname;
+  try {
+    pathname = normalizePath(new URL(request.url).pathname);
+  } catch {
+    return true;
+  }
+  const hosts = getSpaRouteManifest().filter((host) => {
+    if (host.framework !== framework)
+      return false;
+    if (sourcePageName(host.sourceFile) !== pageName.toLowerCase())
+      return false;
+    const base = normalizePath(host.baseHref);
+    return base === "/" || pathname === base || pathname.startsWith(`${base}/`);
+  });
+  if (hosts.length === 0)
+    return true;
+  return hosts.some((host) => host.routes.some((route) => routePattern(fullRoutePath(host.baseHref, route.path)).test(pathname)));
+}, renderSpaNotFound = async (framework, pageName, request) => {
+  if (isKnownSpaRoute(framework, pageName, request))
+    return null;
+  return await renderFirstNotFound() ?? new Response("Not found", {
+    headers: { "Content-Type": "text/plain" },
+    status: 404
+  });
+};
+var init_spaRouteManifest = __esm(() => {
+  init_resolveConvention();
 });
 
 // src/core/devRouteRegistrationCallsite.ts
@@ -107,22 +531,20 @@ __export(exports_devRouteRegistrationCallsite, {
 });
 import { AsyncLocalStorage } from "async_hooks";
 import { Elysia } from "elysia";
-var ROUTE_CALLSITE_STORAGE_KEY, ROUTE_CALLSITE_PATCHED_KEY, ROUTE_METHOD_NAMES, PAGE_HANDLER_NAMES, pageHandlerWrappers, handlerSourceMentionsPageHelper = (handler) => {
+var ROUTE_CALLSITE_STORAGE_KEY, ROUTE_CALLSITE_PATCHED_KEY, NODE_ENV_KEY = "NODE_ENV", ROUTE_METHOD_NAMES, PAGE_HANDLER_NAMES, pageHandlerWrappers, isPageHandlerFunction = (value) => typeof value === "function", handlerSourceMentionsPageHelper = (handler) => {
   const source = handler.toString();
   return PAGE_HANDLER_NAMES.some((name) => source.includes(name));
+}, getOriginalPageHandlerSource = (handler) => {
+  if (!isPageHandlerFunction(handler))
+    return;
+  const info = pageHandlerWrappers.get(handler);
+  return (info?.originalHandler ?? handler).toString();
 }, isPageHandler = (handler) => {
-  if (typeof handler !== "function")
+  if (!isPageHandlerFunction(handler))
     return false;
-  const fn = handler;
-  if (pageHandlerWrappers.has(fn))
+  if (pageHandlerWrappers.has(handler))
     return true;
-  return handlerSourceMentionsPageHelper(fn);
-}, getOriginalPageHandlerSource = (handler) => {
-  if (typeof handler !== "function")
-    return;
-  const fn = handler;
-  const info = pageHandlerWrappers.get(fn);
-  return (info?.originalHandler ?? fn).toString();
+  return handlerSourceMentionsPageHelper(handler);
 }, isObjectRecord3 = (value) => Boolean(value) && typeof value === "object", isAsyncLocalStorage2 = (value) => isObjectRecord3(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function", isRouteMethod = (value) => typeof value === "function", getRouteCallsiteStorage = () => {
   const value = Reflect.get(globalThis, ROUTE_CALLSITE_STORAGE_KEY);
   if (value === null || typeof value === "undefined") {
@@ -156,17 +578,22 @@ var ROUTE_CALLSITE_STORAGE_KEY, ROUTE_CALLSITE_PATCHED_KEY, ROUTE_METHOD_NAMES,
   return function wrappedRouteHandler(...args) {
     return storage.run({ callsite }, () => Reflect.apply(routeHandler, this, args));
   };
-}, createPatchedRouteMethod = (originalMethod, methodName) => function patchedRouteMethod(path, handler, ...rest) {
+}, createPatchedRouteMethod = (originalMethod, methodName) => function patchedRouteMethod(path, ...routeArguments) {
+  const handlerIndex = routeArguments.length >= 2 ? 1 : 0;
+  const handler = routeArguments[handlerIndex];
   const callsite = captureRouteRegistrationCallsite();
   const wrapped = wrapRouteHandlerWithCallsite(handler, callsite);
-  if (methodName === "get" && typeof handler === "function" && typeof wrapped === "function" && handlerSourceMentionsPageHelper(handler)) {
+  if (methodName === "get" && isPageHandlerFunction(handler) && isPageHandlerFunction(wrapped) && handlerSourceMentionsPageHelper(handler)) {
     pageHandlerWrappers.set(wrapped, {
       originalHandler: handler
     });
   }
-  return Reflect.apply(originalMethod, this, [path, wrapped, ...rest]);
+  routeArguments[handlerIndex] = wrapped;
+  return Reflect.apply(originalMethod, this, [path, ...routeArguments]);
 }, getCurrentRouteRegistrationCallsite = () => getRouteCallsiteStorage()?.getStore()?.callsite, patchElysiaRouteRegistrationCallsites = () => {
-  if (false) {}
+  if (process.env[NODE_ENV_KEY] === "production") {
+    return;
+  }
   if (Reflect.get(globalThis, ROUTE_CALLSITE_PATCHED_KEY) === true) {
     return;
   }
@@ -203,6 +630,43 @@ var init_devRouteRegistrationCallsite = __esm(() => {
   pageHandlerWrappers = new WeakMap;
 });
 
+// src/core/pageResponseCache.ts
+import { createHash } from "crypto";
+var STREAMING_PAGE_HEADER = "x-absolute-stream", HTML_CONTENT_TYPE = "text/html", streamingPageHeaders = (extra) => {
+  const headers = new Headers(extra);
+  headers.set("content-type", HTML_CONTENT_TYPE);
+  headers.set(STREAMING_PAGE_HEADER, "1");
+  return headers;
+}, computeEtag = (html) => `W/"${createHash("sha1").update(html).digest("base64url")}"`, withPageCacheHeaders = async (response, request, options) => {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.includes(HTML_CONTENT_TYPE))
+    return response;
+  const isStreaming = response.headers.get(STREAMING_PAGE_HEADER) === "1";
+  if (isStreaming && !options?.bufferStreamForEtag || !response.body) {
+    response.headers.delete(STREAMING_PAGE_HEADER);
+    response.headers.set("cache-control", "no-cache");
+    return response;
+  }
+  const html = await response.text();
+  const etag = computeEtag(html);
+  if (request?.headers.get("if-none-match") === etag) {
+    return new Response(null, {
+      headers: { "cache-control": "no-cache", etag },
+      status: 304
+    });
+  }
+  const headers = new Headers(response.headers);
+  headers.delete(STREAMING_PAGE_HEADER);
+  headers.set("cache-control", "no-cache");
+  headers.set("etag", etag);
+  return new Response(html, {
+    headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+};
+var init_pageResponseCache = () => {};
+
 // src/client/streamSwap.ts
 var streamSwapRuntime = () => {
   const absoluteWindow = window;
@@ -312,6 +776,26 @@ var streamSwapRuntime = () => {
   return value.slice(start + 1, end);
 }, getStreamSwapRuntimeScript = () => `(function(){${stripFunctionWrapper(streamSwapRuntime.toString())}})();`;
 
+// src/constants.ts
+var ANGULAR_INIT_TIMEOUT_MS = 500, ANSI_ESCAPE_CODE = 27, ANSI_ESCAPE_LENGTH = 3, ASCII_SPACE = 32, BASE_36_RADIX = 36, BUN_BUILD_WARNING_SUPPRESSION = "wildcard sideEffects are not supported yet", TAILWIND_BUN_CSS_WARNING_PATTERN, BODY_SLICE_LENGTH = 2000, BYTES_PER_KILOBYTE = 1024, CLI_ARGS_OFFSET = 3, CSS_ERROR_RESOLVE_DELAY_MS = 50, CSS_MAX_CHECK_ATTEMPTS = 10, CSS_MAX_PARSE_TIMEOUT_MS = 500, CSS_SHEET_READY_TIMEOUT_MS = 100, DEFAULT_CHUNK_SIZE = 16384, DEFAULT_DEBOUNCE_MS = 15, DEFAULT_PORT = 3000, DEV_SERVER_RESTART_DEBOUNCE_MS = 100, DOM_UPDATE_DELAY_MS = 50, FILE_PROTOCOL_PREFIX_LENGTH = 7, FOCUS_ID_PREFIX_LENGTH = 3, FOCUS_IDX_PREFIX_LENGTH = 4, FOCUS_NAME_PREFIX_LENGTH = 5, ESLINT_STUDIO_DEFAULT_HOST = "eslint.absolute.localhost", ESLINT_STUDIO_DEFAULT_PORT = 4099, CONFIG_DEFAULT_HOST = "config.absolute.localhost", CONFIG_DEFAULT_PORT = 4099, HMR_UPDATE_TIMEOUT_MS = 2000, HOOK_SIGNATURE_LENGTH = 12, EXCLUDE_LAST_OFFSET = -1, HTTP_STATUS_OK = 200, HTTP_STATUS_BAD_REQUEST = 400, HTTP_STATUS_NOT_FOUND = 404, HOURS_IN_DAY = 24, HOURS_IN_HALF_DAY = 12, IMAGE_DEFAULT_DEVICE_SIZES, IMAGE_DEFAULT_IMAGE_SIZES, IMAGE_DEFAULT_QUALITY = 75, IMAGE_GLOB_SUFFIX_LENGTH = 2, INSTANCE_PROBE_TIMEOUT_MS = 250, MAX_ERROR_LENGTH = 200, MAX_RECONNECT_ATTEMPTS = 60, MILLISECONDS_IN_A_SECOND = 1000, MINUTES_IN_AN_HOUR = 60, SECONDS_IN_A_MINUTE = 60, MILLISECONDS_IN_A_MINUTE, MILLISECONDS_IN_A_DAY, OVERLAY_FADE_DURATION_MS = 150, PING_INTERVAL_MS = 30000, LIST_LOG_TAIL_MAX_BYTES = 65536, LIST_TUI_COLUMN_GAP = 2, LIST_TUI_DEFAULT_HEIGHT = 28, LIST_TUI_DEFAULT_WIDTH = 100, LIST_TUI_ESCAPE_SEQUENCE_TIMEOUT_MS = 30, LIST_TUI_FOOTER_LINE_COUNT = 2, LIST_TUI_MARKER_WIDTH = 2, LIST_TUI_MIN_LOG_HEIGHT = 3, LIST_TUI_MIN_URL_WIDTH = 16, LIST_TUI_RENDER_DEBOUNCE_MS = 16, LIST_TUI_STATUS_MESSAGE_TIMEOUT_MS = 4000, LIST_WATCH_REFRESH_MS = 1000, RAF_BATCH_COUNT = 3, RANDOM_ID_END_INDEX = 11, REBUILD_BATCH_DELAY_MS = 10, REBUILD_RELOAD_DELAY_MS = 200, RECONNECT_INITIAL_DELAY_MS = 500, RECONNECT_POLL_INTERVAL_MS = 300, REACT_STREAM_SLOT_FAST_DELAY_MS = 5, REACT_STREAM_SLOT_SLOW_DELAY_MS = 20, SIGINT_EXIT_CODE = 130, SIGTERM_EXIT_CODE = 143, SVELTE_CSS_LOAD_TIMEOUT_MS = 500, TIME_PRECISION = 2, TWO_THIRDS, UNFOUND_INDEX = -1, WEBSOCKET_NORMAL_CLOSURE = 1000, DEFAULT_WEBSOCKET_IDLE_TIMEOUT_SECONDS = 240, DEFAULT_HTTP_IDLE_TIMEOUT_SECONDS = 240, MAX_HTTP_IDLE_TIMEOUT_SECONDS = 255, WORKSPACE_COMMAND_ARGS_OFFSET = 3, WORKSPACE_FAILURE_LOG_PRINT_LIMIT = 30, WORKSPACE_FAILURE_RECENT_LOG_LIMIT = 60, WORKSPACE_READY_ATTEMPT_TIMEOUT_MS = 5000, WORKSPACE_READY_PROBE_INTERVAL_MS = 250, WORKSPACE_READY_TIMEOUT_MS = 30000, WORKSPACE_SHUTDOWN_TIMEOUT_MS = 1e4, WORKSPACE_TUI_DEFAULT_HEIGHT = 28, WORKSPACE_TUI_DEFAULT_WIDTH = 100, WORKSPACE_TUI_ESCAPE_SEQUENCE_TIMEOUT_MS = 30, WORKSPACE_TUI_FOOTER_LINE_COUNT = 3, WORKSPACE_TUI_MIN_LOG_HEIGHT = 3, WORKSPACE_TUI_MIN_SERVICE_NAME_WIDTH = 7, WORKSPACE_TUI_MIN_TARGET_WIDTH = 8, WORKSPACE_TUI_MIN_WRAP_WIDTH = 12, WORKSPACE_TUI_PROMPT_CURSOR_OFFSET = 3, WORKSPACE_TUI_RECENT_LOG_LIMIT = 40, WORKSPACE_TUI_RENDER_DEBOUNCE_MS = 16, WORKSPACE_TUI_STATUS_WIDTH = 10, WORKSPACE_TUI_TARGET_PADDING_WIDTH = 6, WORKSPACE_TUI_VISIBILITY_WIDTH = 8;
+var init_constants = __esm(() => {
+  TAILWIND_BUN_CSS_WARNING_PATTERN = /invalid @ rule encountered: '@(theme|tailwind|source|utility|variant|custom-variant|apply|reference|plugin|config)'/;
+  IMAGE_DEFAULT_DEVICE_SIZES = [
+    640,
+    750,
+    828,
+    1080,
+    1200,
+    1920,
+    2048,
+    3840
+  ];
+  IMAGE_DEFAULT_IMAGE_SIZES = [16, 32, 48, 64, 96, 128, 256, 384];
+  MILLISECONDS_IN_A_MINUTE = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE;
+  MILLISECONDS_IN_A_DAY = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE * MINUTES_IN_AN_HOUR * HOURS_IN_DAY;
+  TWO_THIRDS = 2 / 3;
+});
+
 // src/utils/escapeScriptContent.ts
 var ESCAPE_LOOKUP, ESCAPE_REGEX, escapeScriptContent = (content) => content.replace(ESCAPE_REGEX, (char) => {
   const escaped = ESCAPE_LOOKUP[char];
@@ -988,6 +1472,19 @@ var colors2, frameworkColors, formatPath = (filePath) => {
   const errorMsg = error instanceof Error ? error.message : error;
   const fullMessage = `${colors2.red}error${colors2.reset} ${message}${errorMsg ? `: ${errorMsg}` : ""}`;
   console.error(`${timestamp} ${tag} ${fullMessage}`);
+}, logHmrClientUpdate = (path, framework, duration, target, serverMs, clientMs, outcome = "applied", kind) => {
+  const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
+  const targetLabel = target.startsWith("capacitor-") ? target.slice("capacitor-".length) : target;
+  const tag = `${colors2.cyan}[hmr:${targetLabel}]${colors2.reset}`;
+  const pathColor = framework ? getFrameworkColor(framework) : colors2.white;
+  const breakdown = serverMs === undefined || clientMs === undefined ? "" : `; server ${serverMs}ms, client ${clientMs}ms`;
+  let action = "failed after";
+  if (outcome === "applied")
+    action = "applied in";
+  else if (outcome === "reloaded")
+    action = "falling back to reload after";
+  const kindLabel = kind ? `${kind} ` : "";
+  console.log(`${timestamp} ${tag} ${framework ?? "update"} ${kindLabel}${pathColor}${formatPath(path)}${colors2.reset} ${colors2.dim}${action} ${duration}ms${breakdown}${colors2.reset}`);
 }, logHmrUpdate = (path, framework, duration) => {
   log("hmr update", { duration, framework, path });
 }, logInfo = (message) => {
@@ -1083,14 +1580,6 @@ body{min-height:100vh;background:linear-gradient(135deg,rgba(15,23,42,0.98) 0%,r
 </html>`;
 };
 
-// src/utils/stringModifiers.ts
-var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9\-_]+/g, "").replace(/[-_]{2,}/g, "-"), toKebab = (str) => normalizeSlug(str).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), toPascal = (str) => {
-  if (!str.includes("-") && !str.includes("_")) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  }
-  return normalizeSlug(str).split(/[-_]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join("");
-};
-
 // src/cli/scripts/telemetry.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
@@ -1114,7 +1603,7 @@ var init_telemetry = __esm(() => {
 // src/cli/telemetryEvent.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { arch, platform } from "os";
-import { dirname, join as join2, parse } from "path";
+import { dirname as dirname3, join as join2, parse } from "path";
 var checkCandidate = (candidate) => {
   if (!existsSync2(candidate)) {
     return null;
@@ -1139,7 +1628,7 @@ var checkCandidate = (candidate) => {
     if (version) {
       return version;
     }
-    dir = dirname(dir);
+    dir = dirname3(dir);
   }
   return "unknown";
 }, sendTelemetryEvent = (event, payload) => {
@@ -1178,18 +1667,18 @@ __export(exports_buildHMRClient, {
   buildHMRClient: () => buildHMRClient
 });
 import { existsSync as existsSync3 } from "fs";
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 var {build: bunBuild } = globalThis.Bun;
 var resolveHmrClientPath = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve(import.meta.dir, "client/hmrClient.ts");
+  const fromSource = resolve2(import.meta.dir, "client/hmrClient.ts");
   if (existsSync3(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client/hmrClient.ts");
+  const fromNodeModules = resolve2(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client/hmrClient.ts");
   if (existsSync3(fromNodeModules))
     return fromNodeModules;
-  return resolve(import.meta.dir, "dev/client/hmrClient.ts");
+  return resolve2(import.meta.dir, "dev/client/hmrClient.ts");
 }, hmrClientPath, buildHMRClient = async () => {
   const entryPoint = hmrClientPath;
   const result = await bunBuild({
@@ -1325,12 +1814,11 @@ var runWithStreamingSlotRegistry = async (task) => {
 };
 
 // src/vue/pageHandler.ts
-init_constants();
-import { readdir } from "fs/promises";
-import { basename as basename2, dirname as dirname2 } from "path";
+init_inlinePageCss();
+init_spaRouteCss();
+init_spaRouteManifest();
 
 // src/core/islandPageContext.ts
-init_constants();
 var BOOTSTRAP_MANIFEST_KEY = "BootstrapClient";
 var ISLAND_MARKER = 'data-island="true"';
 var MANIFEST_MARKER = "__ABSOLUTE_MANIFEST__";
@@ -1451,61 +1939,69 @@ var pipeStreamWithHeadInjection = (stream, markup) => {
 var pipeStreamWithIslandMarkerDetection = (stream, markup) => {
   const encoder = new TextEncoder;
   const decoder = new TextDecoder;
-  const lookbehind = Math.max(ISLAND_MARKER.length, BYTES_PER_KILOBYTE);
-  const processPending = (controller, pending, injected) => {
-    if (injected) {
-      controller.enqueue(encoder.encode(pending));
-      return { injected, pending: "" };
+  const headLookbehind = CLOSING_HEAD_TAG.length - 1;
+  const enqueue = (controller, text) => {
+    if (text.length > 0) {
+      controller.enqueue(encoder.encode(text));
     }
-    const markerIndex = pending.indexOf(ISLAND_MARKER);
-    if (markerIndex >= 0) {
-      const tagStart = pending.lastIndexOf("<", markerIndex);
-      const injectAt = tagStart >= 0 ? tagStart : markerIndex;
-      const next = `${pending.slice(0, injectAt)}${markup}${pending.slice(injectAt)}`;
-      controller.enqueue(encoder.encode(next));
-      return { injected: true, pending: "" };
+  };
+  const processHolding = (controller, held) => {
+    if (!held.includes(ISLAND_MARKER)) {
+      return { held, injected: false, pending: "", sawHead: true };
     }
-    return {
-      injected,
-      pending: flushSafePendingText(controller, encoder, pending, lookbehind)
-    };
+    enqueue(controller, `${markup}${held}`);
+    return { held: "", injected: true, pending: "", sawHead: true };
   };
-  const finishIslandMarkerStream = (controller, pending) => {
-    const finalPending = pending + decoder.decode();
-    if (finalPending.length > 0) {
-      controller.enqueue(encoder.encode(finalPending));
+  const processHead = (controller, pending) => {
+    const headIndex = pending.indexOf(CLOSING_HEAD_TAG);
+    if (headIndex < 0) {
+      return {
+        held: "",
+        injected: false,
+        pending: flushSafePendingText(controller, encoder, pending, headLookbehind),
+        sawHead: false
+      };
     }
-    controller.close();
+    enqueue(controller, pending.slice(0, headIndex));
+    return processHolding(controller, pending.slice(headIndex));
   };
-  const consumeIslandChunk = async (controller, reader, pending, injected) => {
-    const { done, value } = await readStreamChunk(reader);
-    if (done || !value) {
-      return { done, injected, pending };
+  const processChunk = (controller, state, chunk) => {
+    if (state.injected) {
+      enqueue(controller, chunk);
+      return state;
     }
-    const processed = processPending(controller, pending + streamChunkToString(value, decoder), injected);
-    return {
-      done,
-      injected: processed.injected,
-      pending: processed.pending
-    };
+    if (!state.sawHead) {
+      return processHead(controller, state.pending + chunk);
+    }
+    return processHolding(controller, state.held + chunk);
   };
-  const runIslandMarkerLoop = async (controller, reader) => {
-    const consumeNextIslandChunk = async (injected, pending) => {
-      const consumed = await consumeIslandChunk(controller, reader, pending, injected);
-      const nextState = updateInjectedState(consumed, injected, pending);
-      if (nextState.done) {
-        return { injected, pending };
+  const finishMarkerStream = (controller, state) => {
+    const tail = decoder.decode();
+    const remainder = state.injected ? tail : (state.sawHead ? state.held : state.pending) + tail;
+    enqueue(controller, remainder);
+    controller.close();
+  };
+  const runMarkerLoop = (controller, reader) => {
+    const consumeNext = async (state) => {
+      const { done, value } = await readStreamChunk(reader);
+      if (done || !value) {
+        return state;
       }
-      return consumeNextIslandChunk(nextState.injected, nextState.pending);
+      return consumeNext(processChunk(controller, state, streamChunkToString(value, decoder)));
     };
-    return consumeNextIslandChunk(false, "");
+    return consumeNext({
+      held: "",
+      injected: false,
+      pending: "",
+      sawHead: false
+    });
   };
   return new ReadableStream({
     async start(controller) {
       const reader = stream.getReader();
       try {
-        const { pending } = await runIslandMarkerLoop(controller, reader);
-        finishIslandMarkerStream(controller, pending);
+        const finalState = await runMarkerLoop(controller, reader);
+        finishMarkerStream(controller, finalState);
       } catch (error) {
         controller.error(error);
       }
@@ -1543,9 +2039,11 @@ var setCurrentIslandManifest = (manifest) => {
 
 // src/vue/pageHandler.ts
 init_devRouteRegistrationCallsite();
+init_pageResponseCache();
 
 // src/core/responseEnhancers.ts
 init_streamingSlots();
+init_pageResponseCache();
 var toResponse = async (responseLike) => responseLike;
 var cloneHeaders = (response) => {
   const headers = new Headers(response.headers);
@@ -1560,392 +2058,140 @@ var enhanceHtmlResponseWithStreamingSlots = (response, {
   policy
 } = {}) => {
   if (!response.body || streamingSlots.length === 0) {
-    return response;
-  }
-  const body = appendStreamingSlotPatchesToStream(response.body, streamingSlots, {
-    nonce,
-    onError,
-    policy,
-    runtimePlacement,
-    runtimePreludeScript
-  });
-  return new Response(body, {
-    headers: cloneHeaders(response),
-    status: response.status,
-    statusText: response.statusText
-  });
-};
-var withStreamingSlots = async (responseLike, options = {}) => enhanceHtmlResponseWithStreamingSlots(await toResponse(responseLike), options);
-var mergeStreamingSlots = (registered, explicit) => {
-  const merged = new Map;
-  for (const slot of registered)
-    merged.set(slot.id, slot);
-  for (const slot of explicit)
-    merged.set(slot.id, slot);
-  return [...merged.values()];
-};
-var withRegisteredStreamingSlots = async (renderResponse, options = {}) => {
-  const { result, slots } = await runWithStreamingSlotRegistry(renderResponse);
-  const explicit = options.streamingSlots ?? [];
-  return withStreamingSlots(result, {
-    ...options,
-    streamingSlots: mergeStreamingSlots(slots, explicit)
-  });
-};
-
-// src/core/streamingSlotWarningScope.ts
-init_logger();
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-var STREAMING_SLOT_WARNING_STORAGE_KEY2 = Symbol.for("absolutejs.streamingSlotWarningAsyncLocalStorage");
-var isObjectRecord4 = (value) => Boolean(value) && typeof value === "object";
-var isAsyncLocalStorage3 = (value) => isObjectRecord4(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function";
-var getWarningStorage = () => {
-  const value = Reflect.get(globalThis, STREAMING_SLOT_WARNING_STORAGE_KEY2);
-  if (value === null || typeof value === "undefined") {
-    return;
-  }
-  return isAsyncLocalStorage3(value) ? value : undefined;
-};
-var ensureWarningStorage = () => {
-  const existing = getWarningStorage();
-  if (existing) {
-    return existing;
-  }
-  const storage = new AsyncLocalStorage2;
-  Reflect.set(globalThis, STREAMING_SLOT_WARNING_STORAGE_KEY2, storage);
-  return storage;
-};
-var normalizeCallsitePath2 = (value) => value.replace(`${process.cwd()}/`, "").replace(process.cwd(), "").replace(/^\.\/+/, "");
-var formatWarningCallsite = (callsite) => {
-  const match = callsite.match(/^(.*?)(:\d+:\d+)$/);
-  if (!match) {
-    return `\x1B[36m${callsite}\x1B[0m`;
-  }
-  return `\x1B[36m${match[1]}\x1B[33m${match[2]}\x1B[0m`;
-};
-var shouldIgnoreWarningFrame = (frame) => frame.includes("/node_modules/") || frame.includes("/dist/") || frame.includes("/src/react/pageHandler.") || frame.includes("/src/vue/pageHandler.") || frame.includes("/src/svelte/pageHandler.") || frame.includes("/src/angular/pageHandler.") || frame.includes("/src/core/streamingSlotWarningScope.");
-var getWarningLocation = (frame) => frame.match(/\((\/[^)]+:\d+:\d+)\)$/)?.[1] ?? frame.match(/at (\/[^ ]+:\d+:\d+)$/)?.[1];
-var extractCallsiteFromStack = (stack) => {
-  const location = stack.split(`
-`).slice(1).map((line) => line.trim()).filter((frame) => !shouldIgnoreWarningFrame(frame)).map((frame) => getWarningLocation(frame)).find((frameLocation) => frameLocation !== undefined);
-  return location ? normalizeCallsitePath2(location) : undefined;
-};
-var buildMissingCollectorWarning = (primitiveName, handlerCallsite) => `${primitiveName} rendered during SSR without streaming slot collection enabled. Add { collectStreamingSlots: true } to this page handler to enable out-of-order streaming for this route.${handlerCallsite ? ` Update ${formatWarningCallsite(handlerCallsite)}.` : ""}`;
-setStreamingSlotWarningController({
-  maybeWarn: (primitiveName) => {
-    const store = getWarningStorage()?.getStore();
-    if (!store || store.hasWarned) {
-      return;
-    }
-    store.hasWarned = true;
-    logWarn(buildMissingCollectorWarning(primitiveName, store.handlerCallsite));
-  }
-});
-var captureStreamingSlotWarningCallsite = () => {
-  if (false) {}
-  const { stack } = new Error;
-  if (!stack) {
-    return;
-  }
-  return extractCallsiteFromStack(stack);
-};
-var runWithStreamingSlotWarningScope = (task, metadata) => ensureWarningStorage().run({ handlerCallsite: metadata?.handlerCallsite, hasWarned: false }, task);
-// src/utils/resolveConvention.ts
-import { basename } from "path";
-var CONVENTIONS_KEY = "__absoluteConventions";
-var isConventionsMap = (value) => Boolean(value) && typeof value === "object";
-var getMap = () => {
-  const value = Reflect.get(globalThis, CONVENTIONS_KEY);
-  if (isConventionsMap(value))
-    return value;
-  const empty = {};
-  return empty;
-};
-var derivePageName = (pagePath) => {
-  const base = basename(pagePath);
-  const dotIndex = base.indexOf(".");
-  const name = dotIndex > 0 ? base.slice(0, dotIndex) : base;
-  return toPascal(name);
-};
-var normalizeConventionPageName = (name) => toPascal(name).replace(/\d+$/, "");
-var resolveErrorConventionPath = (framework, pageName) => {
-  const conventions = getMap()[framework];
-  if (!conventions)
-    return;
-  const exact = conventions.pages?.[pageName]?.error;
-  if (exact)
-    return exact;
-  const normalizedPageName = normalizeConventionPageName(pageName);
-  for (const [candidate, page] of Object.entries(conventions.pages ?? {})) {
-    if (normalizeConventionPageName(candidate) === normalizedPageName) {
-      return page.error ?? conventions.defaults?.error;
-    }
-  }
-  return conventions.defaults?.error;
-};
-var resolveNotFoundConventionPath = (framework) => getMap()[framework]?.defaults?.notFound;
-var hasErrorConvention = (framework) => {
-  const conventions = getMap()[framework];
-  if (!conventions)
-    return false;
-  if (conventions.defaults?.error)
-    return true;
-  return Object.values(conventions.pages ?? {}).some((page) => Boolean(page.error));
-};
-var setConventions = (map) => {
-  Reflect.set(globalThis, CONVENTIONS_KEY, map);
-};
-var isDev = () => true;
-var buildErrorProps = (error) => {
-  if (error instanceof Error) {
-    return {
-      name: error.name,
-      message: error.message,
-      ...isDev() && error.stack ? { stack: error.stack } : {}
-    };
-  }
-  return { name: "Error", message: String(error) };
-};
-var renderReactError = async (conventionPath, errorProps) => {
-  const { createElement } = await import("react");
-  const { renderToReadableStream } = await import("react-dom/server");
-  const mod = await import(conventionPath);
-  const ErrorComponent = mod.default;
-  if (typeof ErrorComponent !== "function")
-    return null;
-  const element = createElement(ErrorComponent, errorProps);
-  const stream = await renderToReadableStream(element);
-  return new Response(stream, {
-    headers: { "Content-Type": "text/html" },
-    status: 500
-  });
-};
-var renderSvelteError = async (conventionPath, errorProps) => {
-  const { render } = await import("svelte/server");
-  const mod = await import(conventionPath);
-  const ErrorComponent = mod.default;
-  if (!ErrorComponent)
-    return null;
-  const { head, body } = render(ErrorComponent, {
-    props: errorProps
-  });
-  const html = `<!DOCTYPE html><html><head>${head}</head><body>${body}</body></html>`;
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 500
-  });
-};
-var unescapeVueStyles = (ssrBody) => {
-  let styles = "";
-  const body = ssrBody.replace(/<style>([\s\S]*?)<\/style>/g, (_, css) => {
-    styles += `<style>${css.replace(/&quot;/g, '"').replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">")}</style>`;
-    return "";
-  });
-  return { body, styles };
-};
-var renderVueError = async (conventionPath, errorProps) => {
-  const { createSSRApp, h } = await import("vue");
-  const { renderToString } = await import("vue/server-renderer");
-  const mod = await import(conventionPath);
-  const ErrorComponent = mod.default;
-  if (!ErrorComponent)
-    return null;
-  const app = createSSRApp({
-    render: () => h(ErrorComponent, errorProps)
+    return response;
+  }
+  const body = appendStreamingSlotPatchesToStream(response.body, streamingSlots, {
+    nonce,
+    onError,
+    policy,
+    runtimePlacement,
+    runtimePreludeScript
   });
-  const rawBody = await renderToString(app);
-  const { styles, body } = unescapeVueStyles(rawBody);
-  const html = `<!DOCTYPE html><html><head>${styles}</head><body><div id="root">${body}</div></body></html>`;
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 500
+  const headers = cloneHeaders(response);
+  headers.set(STREAMING_PAGE_HEADER, "1");
+  return new Response(body, {
+    headers,
+    status: response.status,
+    statusText: response.statusText
   });
 };
-var renderAngularError = async (conventionPath, errorProps) => {
-  const mod = await import(conventionPath);
-  const renderFn = mod.default;
-  if (typeof renderFn !== "function")
-    return null;
-  const html = renderFn(errorProps);
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 500
-  });
+var withStreamingSlots = async (responseLike, options = {}) => enhanceHtmlResponseWithStreamingSlots(await toResponse(responseLike), options);
+var mergeStreamingSlots = (registered, explicit) => {
+  const merged = new Map;
+  for (const slot of registered)
+    merged.set(slot.id, slot);
+  for (const slot of explicit)
+    merged.set(slot.id, slot);
+  return [...merged.values()];
 };
-var escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-var replaceErrorTokens = (template, errorProps) => template.replace(/\{\{\s*name\s*\}\}/g, escapeHtml(errorProps.name)).replace(/\{\{\s*message\s*\}\}/g, escapeHtml(errorProps.message)).replace(/\{\{\s*stack\s*\}\}/g, errorProps.stack ? escapeHtml(errorProps.stack) : "");
-var renderHtmlError = async (conventionPath, errorProps) => {
-  const template = await Bun.file(conventionPath).text();
-  const html = replaceErrorTokens(template, errorProps);
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 500
+var withRegisteredStreamingSlots = async (renderResponse, options = {}) => {
+  const { result, slots } = await runWithStreamingSlotRegistry(renderResponse);
+  const explicit = options.streamingSlots ?? [];
+  return withStreamingSlots(result, {
+    ...options,
+    streamingSlots: mergeStreamingSlots(slots, explicit)
   });
 };
-var logConventionRenderError = (framework, label, renderError) => {
-  const message = renderError instanceof Error ? renderError.message : "";
-  if (message.includes("Cannot find module") || message.includes("Cannot find package") || message.includes("not found in module")) {
-    console.error(`[SSR] Convention ${label} page for ${framework} failed: missing framework package. Ensure the ${framework} runtime is installed (e.g. bun add ${framework === "react" ? "react react-dom" : framework}).`);
+
+// src/core/streamingSlotWarningScope.ts
+init_logger();
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var STREAMING_SLOT_WARNING_STORAGE_KEY2 = Symbol.for("absolutejs.streamingSlotWarningAsyncLocalStorage");
+var isObjectRecord4 = (value) => Boolean(value) && typeof value === "object";
+var isAsyncLocalStorage3 = (value) => isObjectRecord4(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function";
+var getWarningStorage = () => {
+  const value = Reflect.get(globalThis, STREAMING_SLOT_WARNING_STORAGE_KEY2);
+  if (value === null || typeof value === "undefined") {
     return;
   }
-  console.error(`[SSR] Failed to render ${framework} convention ${label} page:`, renderError);
-};
-var renderEmberError = async () => null;
-var renderEmberNotFound = async () => null;
-var ERROR_RENDERERS = {
-  angular: renderAngularError,
-  ember: renderEmberError,
-  html: renderHtmlError,
-  react: renderReactError,
-  svelte: renderSvelteError,
-  vue: renderVueError
+  return isAsyncLocalStorage3(value) ? value : undefined;
 };
-var tryFrameworkErrorConvention = async (framework, pageName, errorProps, error) => {
-  let conventionPath = resolveErrorConventionPath(framework, pageName);
-  if (!conventionPath && error instanceof Error && error.stack) {
-    for (const match of error.stack.matchAll(/^\s*at\s+([A-Za-z_$][\w$]*)/gm)) {
-      const candidate = match[1];
-      if (!candidate)
-        continue;
-      conventionPath = resolveErrorConventionPath(framework, candidate);
-      if (conventionPath)
-        break;
-    }
-  }
-  if (!conventionPath)
-    return null;
-  const renderer = ERROR_RENDERERS[framework];
-  if (!renderer)
-    return null;
-  try {
-    return await renderer(conventionPath, errorProps);
-  } catch (renderError) {
-    logConventionRenderError(framework, "error", renderError);
+var ensureWarningStorage = () => {
+  const existing = getWarningStorage();
+  if (existing) {
+    return existing;
   }
-  return null;
+  const storage = new AsyncLocalStorage2;
+  Reflect.set(globalThis, STREAMING_SLOT_WARNING_STORAGE_KEY2, storage);
+  return storage;
 };
-var renderConventionError = async (framework, pageName, error) => {
-  const errorProps = buildErrorProps(error);
-  const frameworkResponse = await tryFrameworkErrorConvention(framework, pageName, errorProps, error);
-  if (frameworkResponse)
-    return frameworkResponse;
-  if (framework !== "html") {
-    const htmlResponse = await tryFrameworkErrorConvention("html", pageName, errorProps, error);
-    if (htmlResponse)
-      return htmlResponse;
+var normalizeCallsitePath2 = (value) => value.replace(`${process.cwd()}/`, "").replace(process.cwd(), "").replace(/^\.\/+/, "");
+var formatWarningCallsite = (callsite) => {
+  const match = callsite.match(/^(.*?)(:\d+:\d+)$/);
+  if (!match) {
+    return `\x1B[36m${callsite}\x1B[0m`;
   }
-  return null;
-};
-var renderReactNotFound = async (conventionPath) => {
-  const { createElement } = await import("react");
-  const { renderToReadableStream } = await import("react-dom/server");
-  const mod = await import(conventionPath);
-  const NotFoundComponent = mod.default;
-  if (typeof NotFoundComponent !== "function")
-    return null;
-  const element = createElement(NotFoundComponent);
-  const stream = await renderToReadableStream(element);
-  return new Response(stream, {
-    headers: { "Content-Type": "text/html" },
-    status: 404
-  });
-};
-var renderSvelteNotFound = async (conventionPath) => {
-  const { render } = await import("svelte/server");
-  const mod = await import(conventionPath);
-  const NotFoundComponent = mod.default;
-  if (!NotFoundComponent)
-    return null;
-  const { head, body } = render(NotFoundComponent);
-  const html = `<!DOCTYPE html><html><head>${head}</head><body>${body}</body></html>`;
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 404
-  });
-};
-var renderVueNotFound = async (conventionPath) => {
-  const { createSSRApp, h } = await import("vue");
-  const { renderToString } = await import("vue/server-renderer");
-  const mod = await import(conventionPath);
-  const NotFoundComponent = mod.default;
-  if (!NotFoundComponent)
-    return null;
-  const app = createSSRApp({
-    render: () => h(NotFoundComponent)
-  });
-  const rawBody = await renderToString(app);
-  const { styles, body } = unescapeVueStyles(rawBody);
-  const html = `<!DOCTYPE html><html><head>${styles}</head><body><div id="root">${body}</div></body></html>`;
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 404
-  });
-};
-var renderAngularNotFound = async (conventionPath) => {
-  const mod = await import(conventionPath);
-  const renderFn = mod.default;
-  if (typeof renderFn !== "function")
-    return null;
-  const html = renderFn();
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 404
-  });
+  return `\x1B[36m${match[1]}\x1B[33m${match[2]}\x1B[0m`;
 };
-var renderHtmlNotFound = async (conventionPath) => {
-  const html = await Bun.file(conventionPath).text();
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 404
-  });
+var shouldIgnoreWarningFrame = (frame) => frame.includes("/node_modules/") || frame.includes("/dist/") || frame.includes("/src/react/pageHandler.") || frame.includes("/src/vue/pageHandler.") || frame.includes("/src/svelte/pageHandler.") || frame.includes("/src/angular/pageHandler.") || frame.includes("/src/core/streamingSlotWarningScope.");
+var getWarningLocation = (frame) => frame.match(/\((\/[^)]+:\d+:\d+)\)$/)?.[1] ?? frame.match(/at (\/[^ ]+:\d+:\d+)$/)?.[1];
+var extractCallsiteFromStack = (stack) => {
+  const location = stack.split(`
+`).slice(1).map((line) => line.trim()).filter((frame) => !shouldIgnoreWarningFrame(frame)).map((frame) => getWarningLocation(frame)).find((frameLocation) => frameLocation !== undefined);
+  return location ? normalizeCallsitePath2(location) : undefined;
 };
-var NOT_FOUND_RENDERERS = {
-  angular: renderAngularNotFound,
-  ember: renderEmberNotFound,
-  html: renderHtmlNotFound,
-  react: renderReactNotFound,
-  svelte: renderSvelteNotFound,
-  vue: renderVueNotFound
+var buildMissingCollectorWarning = (primitiveName, handlerCallsite) => `${primitiveName} rendered during SSR without streaming slot collection enabled. Add { collectStreamingSlots: true } to this page handler to enable out-of-order streaming for this route.${handlerCallsite ? ` Update ${formatWarningCallsite(handlerCallsite)}.` : ""}`;
+setStreamingSlotWarningController({
+  maybeWarn: (primitiveName) => {
+    const store = getWarningStorage()?.getStore();
+    if (!store || store.hasWarned) {
+      return;
+    }
+    store.hasWarned = true;
+    logWarn(buildMissingCollectorWarning(primitiveName, store.handlerCallsite));
+  }
+});
+var captureStreamingSlotWarningCallsite = () => {
+  if (false) {}
+  const { stack } = new Error;
+  if (!stack) {
+    return;
+  }
+  return extractCallsiteFromStack(stack);
 };
-var renderConventionNotFound = async (framework) => {
-  const conventionPath = resolveNotFoundConventionPath(framework);
-  if (!conventionPath)
-    return null;
-  const renderer = NOT_FOUND_RENDERERS[framework];
-  if (!renderer)
-    return null;
+var runWithStreamingSlotWarningScope = (task, metadata) => ensureWarningStorage().run({ handlerCallsite: metadata?.handlerCallsite, hasWarned: false }, task);
+
+// src/vue/pageHandler.ts
+init_resolveConvention();
+
+// src/vue/resolveGeneratedVueModulePath.ts
+init_constants();
+import { access, readdir, stat } from "fs/promises";
+import { basename as basename3, dirname as dirname2 } from "path";
+var canAccess = async (path) => {
   try {
-    return await renderer(conventionPath);
-  } catch (renderError) {
-    logConventionRenderError(framework, "not-found", renderError);
+    await access(path);
+    return true;
+  } catch {
+    return false;
   }
-  return null;
 };
-var NOT_FOUND_PRIORITY = [
-  "react",
-  "svelte",
-  "vue",
-  "angular",
-  "html"
-];
-var renderFirstNotFound = async () => {
-  const renderNext = async (frameworks) => {
-    const [framework, ...remaining] = frameworks;
-    if (!framework) {
-      return null;
-    }
-    if (!getMap()[framework]?.defaults?.notFound) {
-      return renderNext(remaining);
-    }
-    const response = await renderConventionNotFound(framework);
-    if (response) {
-      return response;
-    }
-    return renderNext(remaining);
-  };
-  return renderNext(NOT_FOUND_PRIORITY);
+var resolveGeneratedVueModulePath = async (pagePath) => {
+  if (await canAccess(pagePath))
+    return pagePath;
+  const pageDirectory = dirname2(pagePath);
+  const expectedPrefix = `${basename3(pagePath, ".js").split(".")[0]}.`;
+  try {
+    const pageEntries = await readdir(pageDirectory, {
+      withFileTypes: true
+    });
+    const matchingEntries = pageEntries.filter((entry) => entry.isFile() && entry.name.endsWith(".js") && (entry.name === `${expectedPrefix.slice(0, EXCLUDE_LAST_OFFSET)}.js` || entry.name.startsWith(expectedPrefix)));
+    const candidates = await Promise.all(matchingEntries.map(async (entry) => {
+      const path = `${pageDirectory}/${entry.name}`;
+      const metadata = await stat(path);
+      return { modifiedAt: metadata.mtimeMs, path };
+    }));
+    candidates.sort((left, right) => right.modifiedAt - left.modifiedAt || left.path.localeCompare(right.path));
+    return candidates[0]?.path ?? pagePath;
+  } catch {
+    return pagePath;
+  }
 };
 
+// src/vue/teleports.ts
+var ABSOLUTE_TELEPORT_TARGET_ID = "absolute-teleports";
+var ABSOLUTE_TELEPORT_TARGET = `#${ABSOLUTE_TELEPORT_TARGET_ID}`;
+
 // src/vue/pageHandler.ts
 var isRecord2 = (value) => typeof value === "object" && value !== null;
 var isGenericVueComponent = (value) => typeof value === "function" || isRecord2(value);
@@ -1955,29 +2201,15 @@ var readHasIslands = (value) => {
   const hasIslands = value["__ABSOLUTE_PAGE_HAS_ISLANDS__"];
   return typeof hasIslands === "boolean" ? hasIslands : false;
 };
+var isVueSetupApp = (value) => typeof value === "function";
 var readSetupAppHook = (value) => {
   if (!isRecord2(value))
     return null;
-  const setupApp = value["setupApp"];
-  return typeof setupApp === "function" ? setupApp : null;
+  const { setupApp } = value;
+  return isVueSetupApp(setupApp) ? setupApp : null;
 };
+var readHasSpaRoutes = (value) => isRecord2(value) && Array.isArray(value["routes"]);
 var readDefaultExport = (value) => isRecord2(value) ? value.default : undefined;
-var resolveCurrentGeneratedVueModulePath = async (pagePath) => {
-  const pageDirectory = dirname2(pagePath);
-  const expectedPrefix = `${basename2(pagePath, ".js").split(".")[0]}.`;
-  try {
-    const pageEntries = await readdir(pageDirectory, {
-      withFileTypes: true
-    });
-    const matchingEntry = pageEntries.find((entry) => entry.isFile() && entry.name.endsWith(".js") && (entry.name === `${expectedPrefix.slice(0, EXCLUDE_LAST_OFFSET)}.js` || entry.name.startsWith(expectedPrefix)));
-    if (!matchingEntry) {
-      return pagePath;
-    }
-    return `${pageDirectory}/${matchingEntry.name}`;
-  } catch {
-    return pagePath;
-  }
-};
 var resolveRequestRenderUrl = (request) => {
   if (!request)
     return "/";
@@ -1994,40 +2226,53 @@ var primeVueStream = async (stream) => {
   return { firstChunk, reader };
 };
 var cachedSsrOnlyHmrShim = null;
+var buildSsrOnlyHmrShim = async () => {
+  const { buildHMRClient: buildHMRClient2 } = await Promise.resolve().then(() => (init_buildHMRClient(), exports_buildHMRClient));
+  const bundle = await buildHMRClient2();
+  return `<script>window.__HMR_FRAMEWORK__="vue";</script><script data-hmr-client>${bundle}</script>`;
+};
 var getSsrOnlyHmrShim = () => {
   if (cachedSsrOnlyHmrShim)
     return cachedSsrOnlyHmrShim;
-  cachedSsrOnlyHmrShim = (async () => {
-    const { buildHMRClient: buildHMRClient2 } = await Promise.resolve().then(() => (init_buildHMRClient(), exports_buildHMRClient));
-    const bundle = await buildHMRClient2();
-    return `<script>window.__HMR_FRAMEWORK__="vue";</script><script data-hmr-client>${bundle}</script>`;
-  })();
+  cachedSsrOnlyHmrShim = buildSsrOnlyHmrShim();
   return cachedSsrOnlyHmrShim;
 };
 var handleVuePageRequest = async (input) => {
   const passedPageComponent = input.Page;
-  const resolvedHeadTag = input.headTag ?? "<head></head>";
+  const userHeadTag = input.headTag ?? "<head></head>";
   const resolvedOptions = input;
   const resolvedPagePath = input.pagePath;
+  const [siblingCss, spaChildCss] = await Promise.all([
+    readSiblingCss(resolvedPagePath),
+    resolveSpaChildCss(resolvedPagePath, input.request?.url)
+  ]);
+  const resolvedHeadTag = injectInlineCss(injectInlineCss(userHeadTag, siblingCss), spaChildCss);
   const maybeProps = input.props;
   const clientMode = input.client ?? "auto";
   const resolvedIndexPath = input.indexPath;
+  if (clientMode === "auto" && resolvedIndexPath === "") {
+    throw new Error(`Asset "${derivePageName(resolvedPagePath)}Index" not found in manifest.`);
+  }
   if (clientMode === "auto" && !resolvedIndexPath) {
     throw new Error('handleVuePageRequest: `indexPath` is required when `client` is `"auto"` (the default). Pass `client: "none"` to ship a SSR-only page with no client bundle.');
   }
   try {
+    const spaNotFound = await renderSpaNotFound("vue", derivePageName(resolvedPagePath), input.request);
+    if (spaNotFound)
+      return withPageCacheHeaders(spaNotFound, input.request);
     const handlerCallsite = resolvedOptions?.collectStreamingSlots === true ? undefined : getCurrentRouteRegistrationCallsite() ?? captureStreamingSlotWarningCallsite();
     const renderPageResponse = async () => {
       const resolvePageComponent = async () => {
         if (isGenericVueComponent(passedPageComponent)) {
+          const setupApp = null;
           return {
             component: passedPageComponent,
             hasIslands: readHasIslands(passedPageComponent),
-            routes: null,
-            setupApp: null
+            hasSpaRoutes: false,
+            setupApp
           };
         }
-        const generatedPagePath = await resolveCurrentGeneratedVueModulePath(resolvedPagePath);
+        const generatedPagePath = await resolveGeneratedVueModulePath(resolvedPagePath);
         const importedPageModule = await import(generatedPagePath);
         const importedPageComponent = readDefaultExport(importedPageModule) ?? importedPageModule;
         if (!isGenericVueComponent(importedPageComponent)) {
@@ -2036,28 +2281,31 @@ var handleVuePageRequest = async (input) => {
         return {
           component: importedPageComponent,
           hasIslands: readHasIslands(importedPageModule),
+          hasSpaRoutes: readHasSpaRoutes(importedPageModule),
           setupApp: readSetupAppHook(importedPageModule)
         };
       };
       const resolvedPage = await resolvePageComponent();
-      const { createSSRApp, h } = await import("vue");
-      const { renderToWebStream } = await import("vue/server-renderer");
-      const app = createSSRApp({
-        render: () => h(resolvedPage.component, maybeProps ?? null)
-      });
+      const { createSSRApp } = await import("vue");
+      const { renderToString, renderToWebStream } = await import("vue/server-renderer");
+      const app = createSSRApp(resolvedPage.component, maybeProps ?? null);
       let pendingRedirect = null;
+      let pendingNotFound = false;
       if (resolvedPage.setupApp) {
         const url = resolveRequestRenderUrl(input.request);
         await resolvedPage.setupApp(app, {
           isServer: true,
           router: null,
+          url,
+          setNotFound: () => {
+            pendingNotFound = true;
+          },
           setRedirect: (location, status) => {
             pendingRedirect = {
               location,
               status: status ?? 302
             };
-          },
-          url
+          }
         });
       }
       if (pendingRedirect !== null) {
@@ -2067,11 +2315,33 @@ var handleVuePageRequest = async (input) => {
           status: redirect.status
         });
       }
-      const bodyStream = renderToWebStream(app);
-      const { firstChunk, reader } = await primeVueStream(bodyStream);
+      if (pendingNotFound) {
+        return await renderFirstNotFound() ?? new Response("Not found", {
+          headers: { "Content-Type": "text/plain" },
+          status: 404
+        });
+      }
+      const ssrContext = {};
       const head = `<!DOCTYPE html><html>${resolvedHeadTag}<body><div id="root">`;
       const ssrOnlyHmrShim = clientMode === "none" ? await getSsrOnlyHmrShim() : "";
-      const tail = clientMode === "none" ? `</div>${ssrOnlyHmrShim}</body></html>` : `</div><script>window.__INITIAL_PROPS__=${JSON.stringify(maybeProps ?? {})}</script><script type="module" src="${resolvedIndexPath}"></script></body></html>`;
+      const buildTail = () => {
+        const teleports = ssrContext.teleports?.[ABSOLUTE_TELEPORT_TARGET] ?? "";
+        const teleportHost = `<div id="${ABSOLUTE_TELEPORT_TARGET_ID}">${teleports}</div>`;
+        return clientMode === "none" ? `</div>${teleportHost}${ssrOnlyHmrShim}</body></html>` : `</div>${teleportHost}<script>window.__INITIAL_PROPS__=${JSON.stringify(maybeProps ?? {})}</script><script type="module" src="${resolvedIndexPath}"></script></body></html>`;
+      };
+      if (resolvedPage.hasSpaRoutes && clientMode === "auto") {
+        return new Response(`${head}${buildTail()}`, {
+          headers: { "Content-Type": "text/html" }
+        });
+      }
+      if (resolvedOptions?.collectStreamingSlots !== true) {
+        const body = await renderToString(app, ssrContext);
+        return new Response(`${head}${body}${buildTail()}`, {
+          headers: streamingPageHeaders()
+        });
+      }
+      const bodyStream = renderToWebStream(app, ssrContext);
+      const { firstChunk, reader } = await primeVueStream(bodyStream);
       const stream = new ReadableStream({
         start(controller) {
           controller.enqueue(head);
@@ -2079,12 +2349,18 @@ var handleVuePageRequest = async (input) => {
             controller.enqueue(firstChunk.value);
           }
           if (firstChunk.done) {
-            controller.enqueue(tail);
+            controller.enqueue(buildTail());
             controller.close();
             return;
           }
           const pumpLoop = () => {
-            reader.read().then(({ done, value }) => done ? (controller.enqueue(tail), controller.close()) : (controller.enqueue(value), pumpLoop())).catch((err) => controller.error(err));
+            reader.read().then(({ done, value }) => done ? (controller.enqueue(buildTail()), controller.close()) : (controller.enqueue(value), pumpLoop())).catch((err) => {
+              console.error("[SSR] Vue streaming render error:", err);
+              reader.cancel(err).catch(() => {
+                return;
+              });
+              controller.error(err);
+            });
           };
           pumpLoop();
         }
@@ -2093,20 +2369,24 @@ var handleVuePageRequest = async (input) => {
         hasIslands: resolvedPage.hasIslands
       });
       return new Response(htmlStream, {
-        headers: { "Content-Type": "text/html" }
+        headers: streamingPageHeaders()
       });
     };
-    return await runWithStreamingSlotWarningScope(() => resolvedOptions?.collectStreamingSlots === true ? withRegisteredStreamingSlots(renderPageResponse, resolvedOptions) : renderPageResponse(), { handlerCallsite });
+    const pageResponse = await runWithStreamingSlotWarningScope(() => resolvedOptions?.collectStreamingSlots === true ? withRegisteredStreamingSlots(renderPageResponse, resolvedOptions) : renderPageResponse(), { handlerCallsite });
+    return withPageCacheHeaders(pageResponse, input.request, {
+      bufferStreamForEtag: input.bufferStreamForEtag
+    });
   } catch (error) {
     console.error("[SSR] Vue render error:", error);
     const pageName = derivePageName(resolvedPagePath);
     const conventionResponse = await renderConventionError("vue", pageName, error);
-    if (conventionResponse)
-      return conventionResponse;
-    return new Response(ssrErrorPage("vue", error), {
+    if (conventionResponse) {
+      return withPageCacheHeaders(conventionResponse, input.request);
+    }
+    return withPageCacheHeaders(new Response(ssrErrorPage("vue", error), {
       headers: { "Content-Type": "text/html" },
       status: 500
-    });
+    }), input.request);
   }
 };
 // src/vue/routerRedirectProviders.ts
@@ -2131,5 +2411,5 @@ export {
   applyVueRouterRedirect
 };
 
-//# debugId=F925C9676FC0E5B064756E2164756E21
+//# debugId=89D724EF33B3354364756E2164756E21
 //# sourceMappingURL=server.js.map