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

package/dist/angular/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) {
@@ -94,8 +76,9 @@ var ABSOLUTE_HTTP_TRANSFER_CACHE_SKIP_HEADER = "x-skip-transfer-cache", buildAbs
 };
 
 // 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 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,
@@ -112,6 +95,37 @@ var init_constants = __esm(() => {
   TWO_THIRDS = 2 / 3;
 });
 
+// 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/ssrErrorPage.ts
 var exports_ssrErrorPage = {};
 __export(exports_ssrErrorPage, {
@@ -176,6 +190,274 @@ var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-
   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"
+  ];
+});
+
 // src/utils/registerClientScript.ts
 var scriptRegistry, requestCounter = 0, getRequestId = () => `req_${Date.now()}_${++requestCounter}`, ssrContextGetter = null, getSsrContextId = () => ssrContextGetter?.() || Object.getOwnPropertyDescriptor(globalThis, "__absolutejs_requestId")?.value, registerClientScript = (script, requestId) => {
   const id = requestId || getSsrContextId() || getRequestId();
@@ -297,7 +579,7 @@ var resolveAngularPackageDir = (specifier) => {
 var init_resolveAngularPackage = () => {};
 
 // src/utils/runtimeMode.ts
-var ENV_VAR = "NODE_ENV", isProductionRuntime = () => process.env[ENV_VAR] === "production", isDevelopmentRuntime = () => process.env[ENV_VAR] === "development";
+var ENV_VAR = "NODE_ENV", isDevelopmentRuntime = () => process.env[ENV_VAR] === "development", isProductionRuntime = () => process.env[ENV_VAR] === "production";
 
 // src/angular/angularPatch.ts
 var exports_angularPatch = {};
@@ -389,7 +671,14 @@ var ensureHead = (doc) => {
   }
   try {
     const adapter = new \u{275}DominoAdapter;
-    const seedDoc = typeof adapter.createHtmlDocument === "function" ? adapter.createHtmlDocument() : typeof adapter.getDefaultDocument === "function" ? adapter.getDefaultDocument() : null;
+    const resolveSeedDoc = () => {
+      if (typeof adapter.createHtmlDocument === "function")
+        return adapter.createHtmlDocument();
+      if (typeof adapter.getDefaultDocument === "function")
+        return adapter.getDefaultDocument();
+      return null;
+    };
+    const seedDoc = resolveSeedDoc();
     if (seedDoc) {
       patchElementLayout(seedDoc);
       const probe = seedDoc.createElement("div");
@@ -468,9 +757,12 @@ var initDominoAdapter = (platformServer) => {
   return {
     APP_BASE_HREF: common.APP_BASE_HREF,
     bootstrapApplication: platformBrowser.bootstrapApplication,
+    Component: core.Component,
     DomSanitizer: platformBrowser.DomSanitizer,
     ENVIRONMENT_INITIALIZER: core.ENVIRONMENT_INITIALIZER,
     inject: core.inject,
+    InjectionToken: core.InjectionToken,
+    NgComponentOutlet: common.NgComponentOutlet,
     provideClientHydration: platformBrowser.provideClientHydration,
     provideServerRendering: platformServer.provideServerRendering,
     provideZonelessChangeDetection: core.provideZonelessChangeDetection,
@@ -493,16 +785,85 @@ var init_angularDeps = __esm(() => {
   init_resolveAngularPackage();
 });
 
-// src/core/currentIslandRegistry.ts
-var requireCurrentIslandRegistry = () => {
-  const registry = globalThis.__absoluteIslandRegistry;
-  if (!registry) {
-    throw new Error("No island registry is active. Configure `islands.registry` in absolute.config.ts before rendering <Island />.");
+// 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 registry;
-}, setCurrentIslandRegistry = (registry) => {
-  globalThis.__absoluteIslandRegistry = registry;
-};
+  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/currentIslandRegistry.ts
+var requireCurrentIslandRegistry = () => {
+  const registry = globalThis.__absoluteIslandRegistry;
+  if (!registry) {
+    throw new Error("No island registry is active. Configure `islands.registry` in absolute.config.ts before rendering <Island />.");
+  }
+  return registry;
+}, setCurrentIslandRegistry = (registry) => {
+  globalThis.__absoluteIslandRegistry = registry;
+};
 
 // src/angular/requestProviders.ts
 var buildRequestProviders = (deps, request, requestContext, responseInit) => [
@@ -589,7 +950,7 @@ __export(exports_islands, {
   isAngularComponent: () => isAngularComponent,
   getAngularIslandSelector: () => getAngularIslandSelector
 });
-var angularIslandSelector = "abs-angular-island", isAngularComponent = (value) => typeof value === "function", getAngularIslandSelector = (_islandId) => angularIslandSelector, getSelectorFromRenderedIsland = (rootElement) => {
+var angularIslandSelector = "abs-angular-island", getAngularIslandSelector = (_islandId) => angularIslandSelector, isAngularComponent = (value) => typeof value === "function", getSelectorFromRenderedIsland = (rootElement) => {
   const firstChild = rootElement.firstElementChild;
   if (!(firstChild instanceof HTMLElement)) {
     return null;
@@ -643,9 +1004,8 @@ var angularIslandSelector = "abs-angular-island", isAngularComponent = (value) =
   const componentName = typeof component.name === "string" && component.name.length > 0 ? component.name : "AngularIsland";
   return `${componentName}:${JSON.stringify(props)}`;
 }, buildAngularIslandWrapperMetadata = async (component, islandId, wrapperKey) => {
-  const { Component, InjectionToken: InjectionToken2, inject } = await import("@angular/core");
-  const { NgComponentOutlet } = await import("@angular/common");
   const deps = await getAngularDeps();
+  const { Component, InjectionToken: InjectionToken2, NgComponentOutlet, inject } = deps;
   const selector = getAngularIslandSelector(islandId);
   const propsToken = new InjectionToken2(`${wrapperKey}:props`);
 
@@ -751,7 +1111,15 @@ var init_islands = __esm(() => {
 var renderAngularIslandToHtmlInternal = async (component, props, islandId) => {
   const { renderAngularIslandToHtml: renderAngularIslandToHtml2 } = await Promise.resolve().then(() => (init_islands(), exports_islands));
   return renderAngularIslandToHtml2(component, props, islandId);
-}, renderAngularIslandToHtml2, renderReactIslandToHtml = (component, props) => import("react").then(({ createElement }) => import("react-dom/server").then(({ renderToStaticMarkup }) => renderToStaticMarkup(createElement(component, props)))), renderSvelteIslandToHtml = (component, props) => import("svelte/server").then(({ render }) => {
+}, renderAngularIslandToHtml2, LEADING_HOISTED_RESOURCE_RE, stripLeadingHoistedResources = (html) => {
+  let result = html;
+  let match = LEADING_HOISTED_RESOURCE_RE.exec(result);
+  while (match) {
+    result = result.slice(match[0].length);
+    match = LEADING_HOISTED_RESOURCE_RE.exec(result);
+  }
+  return result.trimStart();
+}, renderReactIslandToHtml = (component, props) => import("react").then(({ createElement }) => import("react-dom/server").then(({ renderToString }) => stripLeadingHoistedResources(renderToString(createElement(component, props))))), renderSvelteIslandToHtml = (component, props) => import("svelte/server").then(({ render }) => {
   const { body } = render(component, { props });
   return body;
 }), renderVueIslandToHtml = (component, props) => import("vue").then(({ createSSRApp, h: createVueVNode }) => {
@@ -762,10 +1130,576 @@ var renderAngularIslandToHtmlInternal = async (component, props, islandId) => {
 });
 var init_islandSsr = __esm(() => {
   renderAngularIslandToHtml2 = renderAngularIslandToHtmlInternal;
+  LEADING_HOISTED_RESOURCE_RE = /^\s*(?:<link\b[^>]*\/?>|<meta\b[^>]*\/?>|<title\b[^>]*>[\s\S]*?<\/title>|<style\b[^>]*>[\s\S]*?<\/style>|<script\b[^>]*>[\s\S]*?<\/script>)/i;
+});
+
+// src/build/maskLiterals.ts
+var SENTINEL, RISKY_STRING_CONTENT, isIdentChar = (c) => /[A-Za-z0-9_$]/.test(c), REGEX_OK_AFTER_CHAR, REGEX_OK_AFTER_WORD, maskLiterals = (src) => {
+  const n = src.length;
+  const pieces = [];
+  let out = "";
+  let i = 0;
+  let prevChar = "";
+  let prevWord = "";
+  let prevWasSpace = false;
+  const mask = (text) => {
+    out += SENTINEL + pieces.length + SENTINEL;
+    pieces.push(text);
+    prevChar = ")";
+    prevWord = "";
+    prevWasSpace = false;
+  };
+  const endOfString = (start) => {
+    const q = src[start];
+    let j = start + 1;
+    while (j < n) {
+      const c = src[j];
+      if (c === "\\") {
+        j += 2;
+        continue;
+      }
+      if (c === q)
+        return j + 1;
+      if (c === `
+`)
+        return j;
+      j++;
+    }
+    return j;
+  };
+  const endOfInterp = (start) => {
+    let j = start;
+    let depth = 1;
+    let ipChar = "";
+    let ipWord = "";
+    let ipSpace = false;
+    while (j < n && depth > 0) {
+      const c = src[j];
+      if (c === "\\") {
+        j += 2;
+        continue;
+      }
+      if (c === "`") {
+        j = endOfTemplate(j);
+        ipChar = ")";
+        ipWord = "";
+        ipSpace = false;
+        continue;
+      }
+      if (c === '"' || c === "'") {
+        j = endOfString(j);
+        ipChar = '"';
+        ipWord = "";
+        ipSpace = false;
+        continue;
+      }
+      if (c === "/" && src[j + 1] === "/") {
+        const nl = src.indexOf(`
+`, j);
+        j = nl < 0 ? n : nl;
+        continue;
+      }
+      if (c === "/" && src[j + 1] === "*") {
+        const e = src.indexOf("*/", j + 2);
+        j = e < 0 ? n : e + 2;
+        continue;
+      }
+      if (c === "/" && (ipChar === "" || REGEX_OK_AFTER_CHAR.has(ipChar) || REGEX_OK_AFTER_WORD.has(ipWord))) {
+        const e = endOfRegex(j);
+        if (e > 0) {
+          j = e;
+          ipChar = ")";
+          ipWord = "";
+          ipSpace = false;
+          continue;
+        }
+      }
+      if (c === "{")
+        depth++;
+      else if (c === "}")
+        depth--;
+      j++;
+      if (c === " " || c === "\t" || c === "\r" || c === `
+`) {
+        ipSpace = true;
+        continue;
+      }
+      if (isIdentChar(c)) {
+        ipWord = isIdentChar(ipChar) && !ipSpace ? ipWord + c : c;
+      } else {
+        ipWord = "";
+      }
+      ipChar = c;
+      ipSpace = false;
+    }
+    return j;
+  };
+  function endOfTemplate(start) {
+    let j = start + 1;
+    while (j < n) {
+      const c = src[j];
+      if (c === "\\") {
+        j += 2;
+        continue;
+      }
+      if (c === "`")
+        return j + 1;
+      if (c === "$" && src[j + 1] === "{") {
+        j = endOfInterp(j + 2);
+        continue;
+      }
+      j++;
+    }
+    return j;
+  }
+  const endOfRegex = (start) => {
+    let j = start + 1;
+    let inClass = false;
+    while (j < n) {
+      const c = src[j];
+      if (c === "\\") {
+        j += 2;
+        continue;
+      }
+      if (c === `
+`)
+        return -1;
+      if (c === "[")
+        inClass = true;
+      else if (c === "]")
+        inClass = false;
+      else if (c === "/" && !inClass) {
+        j++;
+        break;
+      }
+      j++;
+    }
+    while (j < n && /[a-z]/i.test(src[j] ?? ""))
+      j++;
+    return j;
+  };
+  while (i < n) {
+    const c = src[i];
+    const c2 = src[i + 1];
+    if (c === "/" && c2 === "/") {
+      out += "//";
+      i += 2;
+      const s = i;
+      while (i < n && src[i] !== `
+`)
+        i++;
+      mask(src.slice(s, i));
+      continue;
+    }
+    if (c === "/" && c2 === "*") {
+      out += "/*";
+      i += 2;
+      const e = src.indexOf("*/", i);
+      const end = e < 0 ? n : e;
+      mask(src.slice(i, end));
+      i = end < n ? end + 2 : n;
+      if (end < n)
+        out += "*/";
+      continue;
+    }
+    if (c === "`") {
+      const end = endOfTemplate(i);
+      mask(src.slice(i, end));
+      i = end;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      const end = endOfString(i);
+      const text = src.slice(i, end);
+      if (RISKY_STRING_CONTENT.test(text)) {
+        mask(text);
+      } else {
+        out += text;
+        prevChar = '"';
+        prevWord = "";
+        prevWasSpace = false;
+      }
+      i = end;
+      continue;
+    }
+    if (c === "/" && (prevChar === "" || REGEX_OK_AFTER_CHAR.has(prevChar) || REGEX_OK_AFTER_WORD.has(prevWord))) {
+      const end = endOfRegex(i);
+      if (end > 0) {
+        out += src.slice(i, end);
+        i = end;
+        prevChar = ")";
+        prevWord = "";
+        prevWasSpace = false;
+        continue;
+      }
+    }
+    out += c;
+    i++;
+    if (c === " " || c === "\t" || c === "\r" || c === `
+`) {
+      prevWasSpace = true;
+      continue;
+    }
+    if (isIdentChar(c)) {
+      const contiguous = isIdentChar(prevChar) && !prevWasSpace;
+      prevWord = contiguous ? prevWord + c : c;
+    } else {
+      prevWord = "";
+    }
+    prevChar = c;
+    prevWasSpace = false;
+  }
+  const restoreRegex = new RegExp(`${SENTINEL}(\\d+)${SENTINEL}`, "g");
+  const restore = (rewritten) => rewritten.replace(restoreRegex, (_m, d) => pieces[Number(d)] ?? "");
+  return { masked: out, restore };
+};
+var init_maskLiterals = __esm(() => {
+  SENTINEL = String.fromCharCode(57344);
+  RISKY_STRING_CONTENT = /\b(?:from|import|require)\s*\(?\s*["'`]/;
+  REGEX_OK_AFTER_CHAR = new Set([
+    "(",
+    ",",
+    "=",
+    ":",
+    "[",
+    "!",
+    "&",
+    "|",
+    "?",
+    "{",
+    "}",
+    ";",
+    "+",
+    "-",
+    "*",
+    "/",
+    "%",
+    "^",
+    "~",
+    "<",
+    ">"
+  ]);
+  REGEX_OK_AFTER_WORD = new Set([
+    "return",
+    "typeof",
+    "instanceof",
+    "in",
+    "of",
+    "new",
+    "delete",
+    "void",
+    "do",
+    "else",
+    "yield",
+    "await",
+    "case"
+  ]);
+});
+
+// src/build/nativeRewrite.ts
+import { dlopen, FFIType, ptr } from "bun:ffi";
+import { platform, arch } from "os";
+import { resolve as resolve2 } from "path";
+var ffiDefinition, nativeLib = null, loadNative = () => {
+  if (nativeLib !== null)
+    return nativeLib;
+  const osPlatform = platform();
+  const cpu = arch();
+  const platformMap = {
+    "darwin-arm64": "darwin-arm64/fast_ops.dylib",
+    "darwin-x64": "darwin-x64/fast_ops.dylib",
+    "linux-arm64": "linux-arm64/fast_ops.so",
+    "linux-x64": "linux-x64/fast_ops.so",
+    "win32-arm64": "windows-arm64/fast_ops.dll",
+    "win32-x64": "windows-x64/fast_ops.dll"
+  };
+  const libPath = platformMap[`${osPlatform}-${cpu}`];
+  if (!libPath)
+    return null;
+  try {
+    const fullPath = resolve2(import.meta.dir, "../../native/packages", libPath);
+    const lib = dlopen(fullPath, ffiDefinition);
+    nativeLib = lib.symbols;
+    return nativeLib;
+  } catch {
+    return null;
+  }
+}, nativeRewriteImports = (content, replacements) => {
+  const lib = loadNative();
+  if (!lib)
+    return null;
+  const jsonStr = JSON.stringify(replacements);
+  const contentBuf = Buffer.from(content);
+  const jsonBuf = Buffer.from(jsonStr);
+  const outBuf = Buffer.alloc(content.length * 2);
+  const outLenBuf = new BigUint64Array([BigInt(outBuf.length)]);
+  const result = lib.rewrite_imports(ptr(contentBuf), contentBuf.length, ptr(jsonBuf), jsonBuf.length, ptr(outBuf), ptr(new Uint8Array(outLenBuf.buffer)));
+  if (result < 0)
+    return null;
+  if (result === 0)
+    return content;
+  const outLen = Number(outLenBuf[0]);
+  return outBuf.subarray(0, outLen).toString("utf-8");
+};
+var init_nativeRewrite = __esm(() => {
+  ffiDefinition = {
+    rewrite_imports: {
+      args: [
+        FFIType.ptr,
+        FFIType.u64,
+        FFIType.ptr,
+        FFIType.u64,
+        FFIType.ptr,
+        FFIType.ptr
+      ],
+      returns: FFIType.i32
+    }
+  };
+});
+
+// src/build/rewriteImportsPlugin.ts
+var exports_rewriteImportsPlugin = {};
+__export(exports_rewriteImportsPlugin, {
+  rewriteVendorDirectories: () => rewriteVendorDirectories,
+  rewriteImportsInContent: () => rewriteImportsInContent,
+  rewriteBuildOutputsWith: () => rewriteBuildOutputsWith,
+  rewriteBuildOutputs: () => rewriteBuildOutputs,
+  jsRewriteImports: () => jsRewriteImports,
+  fixMissingReExportNamespacesInContent: () => fixMissingReExportNamespacesInContent,
+  buildWithImportRewrite: () => buildWithImportRewrite
+});
+import { readdir } from "fs/promises";
+import { join as join2 } from "path";
+var escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewriteImports = (content, replacements) => {
+  let result = content;
+  for (const [specifier, webPath] of replacements) {
+    const escaped = escapeRegex(specifier);
+    const fromRegex = new RegExp(`(from\\s*["'])${escaped}(["'])`, "g");
+    const sideEffectRegex = new RegExp(`(import\\s*["'])${escaped}(["'])`, "g");
+    const dynamicRegex = new RegExp(`(import\\s*\\(\\s*["'])${escaped}(["']\\s*\\))`, "g");
+    result = result.replace(fromRegex, `$1${webPath}$2`);
+    result = result.replace(sideEffectRegex, `$1${webPath}$2`);
+    result = result.replace(dynamicRegex, `$1${webPath}$2`);
+  }
+  return result;
+}, rewriteImportsInContent = (content, vendorPaths) => {
+  if (Object.keys(vendorPaths).length === 0)
+    return content;
+  const replacements = Object.entries(vendorPaths).sort(([keyA], [keyB]) => keyB.length - keyA.length);
+  const { masked, restore } = maskLiterals(content);
+  const native = nativeRewriteImports(masked, replacements);
+  return restore(native ?? jsRewriteImports(masked, replacements));
+}, fixMissingReExportNamespacesInContent = (content) => {
+  const REEXPORT_PATTERN = /__reExport\(\s*[A-Za-z_$][\w$]*\s*,\s*([A-Za-z_$][\w$]*)\s*\)/g;
+  REEXPORT_PATTERN.lastIndex = 0;
+  const missing = [];
+  let match;
+  while ((match = REEXPORT_PATTERN.exec(content)) !== null) {
+    const ident = match[1];
+    if (!ident)
+      continue;
+    const nsImportRe = new RegExp(`\\bimport\\s*\\*\\s*as\\s+${ident}\\s+from\\b`);
+    if (nsImportRe.test(content))
+      continue;
+    const declRe = new RegExp(`\\b(?:const|let|var|function|class)\\s+${ident}\\b`);
+    if (declRe.test(content))
+      continue;
+    const namedImportRe = new RegExp(`\\bimport\\s*\\{[^}]*\\b${ident}\\b[^}]*\\}\\s*from\\b`);
+    if (namedImportRe.test(content))
+      continue;
+    const importPathRe = /(?:from\s+|import\s*)["']([^"']+)["']/g;
+    let pathMatch;
+    let sourcePath;
+    while ((pathMatch = importPathRe.exec(content)) !== null) {
+      const p = pathMatch[1];
+      if (!p)
+        continue;
+      const base = p.split("/").pop()?.replace(/\.[mc]?js$/, "");
+      if (!base)
+        continue;
+      const normalized = base.startsWith("_") ? base.slice(1) : base;
+      if (normalized === ident || normalized.endsWith(`_${ident}`)) {
+        sourcePath = p;
+        break;
+      }
+    }
+    if (sourcePath)
+      missing.push({ ident, path: sourcePath });
+  }
+  if (missing.length === 0)
+    return content;
+  const seen = new Set;
+  const unique = missing.filter((entry) => {
+    if (seen.has(entry.ident))
+      return false;
+    seen.add(entry.ident);
+    return true;
+  });
+  const inserts = unique.map((entry) => `import * as ${entry.ident} from "${entry.path}";`).join(`
+`);
+  return `${inserts}
+${content}`;
+}, isReadableArtifact = (artifact) => artifact.path.endsWith(".js"), rewriteBuildOutputs = async (outputs, vendorPaths) => {
+  if (Object.keys(vendorPaths).length === 0)
+    return;
+  await Promise.all(outputs.filter(isReadableArtifact).map(async (artifact) => {
+    let original;
+    try {
+      original = await artifact.text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+    const rewritten = rewriteImportsInContent(original, vendorPaths);
+    if (rewritten === original)
+      return;
+    try {
+      await Bun.write(artifact.path, rewritten);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+  }));
+}, rewriteBuildOutputsWith = async (outputs, resolveVendorPaths) => {
+  await Promise.all(outputs.filter(isReadableArtifact).map(async (artifact) => {
+    const vendorPaths = resolveVendorPaths(artifact);
+    if (Object.keys(vendorPaths).length === 0)
+      return;
+    let original;
+    try {
+      original = await artifact.text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+    const rewritten = rewriteImportsInContent(original, vendorPaths);
+    if (rewritten === original)
+      return;
+    try {
+      await Bun.write(artifact.path, rewritten);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+  }));
+}, rewriteVendorDirectories = async (vendorDirs, vendorPaths) => {
+  if (Object.keys(vendorPaths).length === 0)
+    return;
+  const allFiles = [];
+  for (const dir of vendorDirs) {
+    try {
+      const entries = await readdir(dir);
+      for (const entry of entries) {
+        if (entry.endsWith(".js"))
+          allFiles.push(join2(dir, entry));
+      }
+    } catch {}
+  }
+  await Promise.all(allFiles.map(async (filePath) => {
+    let original;
+    try {
+      original = await Bun.file(filePath).text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+    let next = rewriteImportsInContent(original, vendorPaths);
+    next = fixMissingReExportNamespacesInContent(next);
+    if (next === original)
+      return;
+    try {
+      await Bun.write(filePath, next);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+  }));
+}, buildWithImportRewrite = async (pendingBuild, vendorPaths) => {
+  const result = await pendingBuild;
+  if (result.outputs.length > 0) {
+    await rewriteBuildOutputs(result.outputs, vendorPaths);
+  }
+  return result;
+};
+var init_rewriteImportsPlugin = __esm(() => {
+  init_maskLiterals();
+  init_nativeRewrite();
+});
+
+// src/core/angularServerModule.ts
+import { mkdir } from "fs/promises";
+import { dirname, join as join3, relative } from "path";
+var serverCacheRoot, compiledModuleCache, ANGULAR_SPECIFIER_RE, getCachedModulePath = (sourcePath) => {
+  const relativeSourcePath = relative(process.cwd(), sourcePath).replace(/\\/g, "/");
+  const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
+  return join3(serverCacheRoot, `${normalizedSourcePath}.server.js`);
+}, collectVendorPaths = (code) => {
+  const vendorPaths = {};
+  if (!isProductionRuntime()) {
+    return vendorPaths;
+  }
+  const specifiers = new Set([...code.matchAll(ANGULAR_SPECIFIER_RE)].map((match) => match[1]));
+  specifiers.forEach((specifier) => {
+    if (!specifier)
+      return;
+    const resolved = resolveAngularRuntimePath(specifier);
+    if (resolved === specifier)
+      return;
+    vendorPaths[specifier] = resolved;
+  });
+  return vendorPaths;
+}, buildAngularServerModule = async (sourcePath) => {
+  const result = await Bun.build({
+    entrypoints: [sourcePath],
+    format: "esm",
+    packages: "external",
+    target: "bun",
+    throw: false
+  });
+  const entry = result.outputs.find((output) => output.kind === "entry-point");
+  if (!result.success || !entry) {
+    const message = result.logs.map((log) => String(log)).join(`
+`);
+    throw new Error(`Failed to compile Angular island server module for "${sourcePath}":
+${message}`);
+  }
+  const code = await entry.text();
+  const rewritten = rewriteImportsInContent(code, collectVendorPaths(code));
+  const modulePath = getCachedModulePath(sourcePath);
+  await mkdir(dirname(modulePath), { recursive: true });
+  await Bun.write(modulePath, rewritten);
+  return modulePath;
+}, compileAngularServerModule = (sourcePath) => {
+  const cached = compiledModuleCache.get(sourcePath);
+  if (cached) {
+    return cached;
+  }
+  const compiledModulePromise = buildAngularServerModule(sourcePath);
+  compiledModuleCache.set(sourcePath, compiledModulePromise);
+  return compiledModulePromise;
+};
+var init_angularServerModule = __esm(() => {
+  init_resolveAngularPackage();
+  init_rewriteImportsPlugin();
+  serverCacheRoot = join3(process.cwd(), ".absolutejs", "islands", "angular");
+  compiledModuleCache = new Map;
+  ANGULAR_SPECIFIER_RE = /["'](@angular\/[^"']+)["']/g;
 });
 
 // src/build/resolvePackageImport.ts
-import { resolve as resolve2, join as join2 } from "path";
+import { resolve as resolve3, join as join4 } from "path";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 var resolveExportPath = (entry, conditions) => {
   if (typeof entry === "string")
@@ -787,11 +1721,11 @@ var resolveExportPath = (entry, conditions) => {
   const packageName = isScoped ? `${parts[0]}/${parts[1]}` : parts[0];
   const subpath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
   const exportKey = subpath ? `./${subpath}` : ".";
-  const currentPackageJsonPath = resolve2(process.cwd(), "package.json");
+  const currentPackageJsonPath = resolve3(process.cwd(), "package.json");
   const currentPackageJson = existsSync2(currentPackageJsonPath) ? JSON.parse(readFileSync2(currentPackageJsonPath, "utf-8")) : null;
   const currentPackageDir = currentPackageJson?.name === packageName ? process.cwd() : null;
-  const packageDir = currentPackageDir ?? resolve2(process.cwd(), "node_modules", packageName ?? "");
-  const packageJsonPath = join2(packageDir, "package.json");
+  const packageDir = currentPackageDir ?? resolve3(process.cwd(), "node_modules", packageName ?? "");
+  const packageJsonPath = join4(packageDir, "package.json");
   if (!existsSync2(packageJsonPath))
     return null;
   try {
@@ -806,12 +1740,12 @@ var resolveExportPath = (entry, conditions) => {
     if (!importPath)
       return null;
     if (currentPackageDir && importPath.startsWith("./dist/")) {
-      const sourceCandidate = resolve2(packageDir, importPath.replace(/^\.\/dist\//, "./src/"));
+      const sourceCandidate = resolve3(packageDir, importPath.replace(/^\.\/dist\//, "./src/"));
       if (existsSync2(sourceCandidate)) {
         return sourceCandidate;
       }
     }
-    const resolved = resolve2(packageDir, importPath);
+    const resolved = resolve3(packageDir, importPath);
     return existsSync2(resolved) ? resolved : null;
   } catch {
     return null;
@@ -968,12 +1902,12 @@ import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
 import {
-  dirname,
+  dirname as dirname2,
   extname,
   isAbsolute,
-  join as join3,
-  relative,
-  resolve as resolve3
+  join as join5,
+  relative as relative2,
+  resolve as resolve4
 } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 var CSS_EXTENSION_PATTERN, STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATTERN, importOptionalPeer, requireOptionalPeer, requireFromCwd, isPreprocessableStylePath = (filePath) => STYLE_EXTENSION_PATTERN.test(filePath), isStyleModulePath = (filePath) => STYLE_MODULE_EXTENSION_PATTERN.test(filePath), isStylePath = (filePath) => /\.(css|s[ac]ss|less|styl(?:us)?)$/i.test(filePath), getStyleBaseName = (filePath) => filePath.replace(/\.(css|s[ac]ss|less|styl(?:us)?)$/i, ""), getStyleLanguage = (filePathOrLanguage) => {
@@ -1009,9 +1943,9 @@ ${message}`);
     return requireOptionalPeer(specifier);
   }
 }, normalizeLoadPaths = (filePath, paths = []) => [
-  dirname(filePath),
+  dirname2(filePath),
   process.cwd(),
-  ...paths.map((path) => resolve3(process.cwd(), path))
+  ...paths.map((path) => resolve4(process.cwd(), path))
 ], tsconfigAliasCache, stripJsonComments = (source) => source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1"), normalizeAliasEntries = (aliases) => Object.entries(aliases ?? {}).map(([pattern, value]) => ({
   pattern,
   replacements: Array.isArray(value) ? value : [value]
@@ -1019,7 +1953,7 @@ ${message}`);
   const cwd = process.cwd();
   if (tsconfigAliasCache?.cwd === cwd)
     return tsconfigAliasCache;
-  const tsconfigPath = resolve3(cwd, "tsconfig.json");
+  const tsconfigPath = resolve4(cwd, "tsconfig.json");
   const empty = { aliases: [], baseUrl: cwd, cwd };
   if (!existsSync3(tsconfigPath)) {
     tsconfigAliasCache = empty;
@@ -1028,7 +1962,7 @@ ${message}`);
   try {
     const parsed = JSON.parse(stripJsonComments(readFileSync3(tsconfigPath, "utf-8")));
     const compilerOptions = parsed.compilerOptions ?? {};
-    const baseUrl = resolve3(cwd, compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve4(cwd, compilerOptions.baseUrl ?? ".");
     tsconfigAliasCache = {
       aliases: normalizeAliasEntries(compilerOptions.paths),
       baseUrl,
@@ -1056,7 +1990,7 @@ ${message}`);
       continue;
     const wildcard = match[1] ?? "";
     for (const replacement of alias.replacements) {
-      targets.push(resolve3(baseUrl, replacement.replace("*", wildcard)));
+      targets.push(resolve4(baseUrl, replacement.replace("*", wildcard)));
     }
   }
   return targets;
@@ -1070,21 +2004,21 @@ ${message}`);
   const ext = extname(basePath);
   const paths = ext ? [basePath] : getLanguageExtensions(language).flatMap((extension) => [
     `${basePath}${extension}`,
-    join3(basePath, `index${extension}`)
+    join5(basePath, `index${extension}`)
   ]);
   if (language === "scss" || language === "sass") {
     return paths.flatMap((path) => {
-      const dir = dirname(path);
+      const dir = dirname2(path);
       const base = path.slice(dir.length + 1);
-      return [path, join3(dir, `_${base}`)];
+      return [path, join5(dir, `_${base}`)];
     });
   }
   return paths;
 }, resolveImportPath = (specifier, fromDirectory, loadPaths, language, config) => {
   const rawCandidates = [
     ...resolveAliasTargets(specifier, config),
-    isAbsolute(specifier) ? specifier : resolve3(fromDirectory, specifier),
-    ...loadPaths.map((path) => resolve3(path, specifier))
+    isAbsolute(specifier) ? specifier : resolve4(fromDirectory, specifier),
+    ...loadPaths.map((path) => resolve4(path, specifier))
   ];
   for (const candidate of rawCandidates.flatMap((path) => getCandidatePaths(path, language))) {
     if (existsSync3(candidate))
@@ -1100,8 +2034,8 @@ ${message}`);
     path: url.slice(0, markerIndex)
   };
 }, rebaseCssUrls = (contents, sourceFile, entryFile) => {
-  const sourceDir = dirname(sourceFile);
-  const entryDir = dirname(entryFile);
+  const sourceDir = dirname2(sourceFile);
+  const entryDir = dirname2(entryFile);
   if (sourceDir === entryDir)
     return contents;
   return contents.replace(/url\(\s*(['"]?)([^'")]+)\1\s*\)/gi, (match, quote, rawUrl) => {
@@ -1109,7 +2043,7 @@ ${message}`);
     if (!trimmedUrl || isExternalCssUrl(trimmedUrl))
       return match;
     const { marker, path } = splitCssUrl(trimmedUrl);
-    const rebased = relative(entryDir, resolve3(sourceDir, path)).replace(/\\/g, "/");
+    const rebased = relative2(entryDir, resolve4(sourceDir, path)).replace(/\\/g, "/");
     const normalized = rebased.startsWith(".") ? rebased : `./${rebased}`;
     const nextQuote = quote || '"';
     return `url(${nextQuote}${normalized}${marker}${nextQuote})`;
@@ -1117,7 +2051,7 @@ ${message}`);
 }, rewriteAliasedStyleImports = (contents, sourceFile, loadPaths, language, config) => contents.replace(/(@(?:use|forward|import|require)\s+)(["'])([^"']+)\2/g, (match, prefix, quote, specifier) => {
   if (specifier.startsWith(".") || isAbsolute(specifier) || isExternalCssUrl(specifier))
     return match;
-  const resolved = resolveImportPath(specifier, dirname(sourceFile), loadPaths, language, config);
+  const resolved = resolveImportPath(specifier, dirname2(sourceFile), loadPaths, language, config);
   return resolved ? `${prefix}${quote}${resolved}${quote}` : match;
 }), preprocessLoadedStyle = (contents, sourceFile, entryFile, loadPaths = [], language, config) => {
   const rebased = rebaseCssUrls(contents, sourceFile, entryFile);
@@ -1147,7 +2081,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   }
   return mod;
 }, loadPostcssConfigFile = async (configPath) => {
-  const resolved = resolve3(process.cwd(), configPath);
+  const resolved = resolve4(process.cwd(), configPath);
   const loaded = resolved.endsWith(".cjs") || resolved.endsWith(".cts") ? requireOptionalPeerSync(resolved) : await importOptionalPeer(`${new URL(`file://${resolved}`).href}?t=${Date.now()}`);
   const config = normalizePostcssModule(loaded);
   const value = typeof config === "function" ? await config({
@@ -1207,9 +2141,9 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   return result.css;
 }, createSassImporter = (entryFile, loadPaths, language, config, deps) => ({
   canonicalize(specifier, options) {
-    const fromDirectory = options.containingUrl ? dirname(fileURLToPath(options.containingUrl)) : dirname(entryFile);
+    const fromDirectory = options.containingUrl ? dirname2(fileURLToPath(options.containingUrl)) : dirname2(entryFile);
     const resolved = resolveImportPath(specifier, fromDirectory, loadPaths, language, config);
-    return resolved ? new URL(pathToFileURL(resolve3(resolved)).href) : null;
+    return resolved ? new URL(pathToFileURL(resolve4(resolved)).href) : null;
   },
   load(canonicalUrl) {
     const filePath = fileURLToPath(canonicalUrl);
@@ -1226,9 +2160,9 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   install(less, pluginManager) {
     const baseManager = new less.FileManager;
     const manager = Object.create(baseManager);
-    manager.supports = (filename, currentDirectory) => Boolean(resolveImportPath(filename, resolve3(currentDirectory), loadPaths, "less", config));
+    manager.supports = (filename, currentDirectory) => Boolean(resolveImportPath(filename, resolve4(currentDirectory), loadPaths, "less", config));
     manager.loadFile = async (filename, currentDirectory) => {
-      const resolved = resolveImportPath(filename, resolve3(currentDirectory), loadPaths, "less", config);
+      const resolved = resolveImportPath(filename, resolve4(currentDirectory), loadPaths, "less", config);
       if (!resolved) {
         throw new Error(`Unable to resolve Less import "${filename}"`);
       }
@@ -1265,29 +2199,29 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
         const stylusDeps = renderer.deps?.();
         if (Array.isArray(stylusDeps)) {
           for (const dep of stylusDeps)
-            deps.add(resolve3(dep));
+            deps.add(resolve4(dep));
         }
       }
       resolveCss(css ?? "");
     });
   });
 }, styleDependencyGraph, styleOutputHashes, recordStyleDeps = (entry, deps) => {
-  const key = resolve3(entry);
+  const key = resolve4(entry);
   const stripped = new Set;
   for (const dep of deps) {
-    const resolved = resolve3(dep);
+    const resolved = resolve4(dep);
     if (resolved !== key)
       stripped.add(resolved);
   }
   styleDependencyGraph.set(key, stripped);
 }, addStyleImporter = (importerPath, stylePath) => {
-  const key = resolve3(importerPath);
-  const target = resolve3(stylePath);
+  const key = resolve4(importerPath);
+  const target = resolve4(stylePath);
   const deps = styleDependencyGraph.get(key) ?? new Set;
   deps.add(target);
   styleDependencyGraph.set(key, deps);
 }, findStyleEntriesImporting = (changedPath) => {
-  const target = resolve3(changedPath);
+  const target = resolve4(changedPath);
   const importers = [];
   for (const [entry, deps] of styleDependencyGraph) {
     if (deps.has(target))
@@ -1295,13 +2229,13 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   }
   return importers;
 }, recordStyleOutput = (entry, css) => {
-  const key = resolve3(entry);
+  const key = resolve4(entry);
   const hash = createHash("sha1").update(css).digest("hex");
   const previous = styleOutputHashes.get(key);
   styleOutputHashes.set(key, hash);
   return previous !== hash;
 }, forgetStyleEntry = (entry) => {
-  const key = resolve3(entry);
+  const key = resolve4(entry);
   styleDependencyGraph.delete(key);
   styleOutputHashes.delete(key);
 }, compileStyleSource = async (filePath, source, languageHint, config) => {
@@ -1327,7 +2261,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
         loadPaths,
         style: "expanded",
         syntax: language === "sass" ? "indented" : "scss",
-        url: new URL(pathToFileURL(resolve3(filePath)).href)
+        url: new URL(pathToFileURL(resolve4(filePath)).href)
       });
       const css = await runPostcss(result.css, filePath, config);
       const loadedUrls = result.loadedUrls ?? [];
@@ -1335,7 +2269,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
         if (url.protocol !== "file:")
           continue;
         const dep = fileURLToPath(url);
-        if (resolve3(dep) === resolve3(filePath))
+        if (resolve4(dep) === resolve4(filePath))
           continue;
         deps.add(dep);
       }
@@ -1456,7 +2390,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
     const start = match.index ?? 0;
     const end = start + match[0].length;
     parts.push(content.slice(cursor, start));
-    const fullPath = isAbsolute(importPath) ? importPath : resolve3(baseDir, importPath);
+    const fullPath = isAbsolute(importPath) ? importPath : resolve4(baseDir, importPath);
     if (visited.has(fullPath) || !existsSync3(fullPath)) {
       parts.push(visited.has(fullPath) ? "" : match[0]);
       cursor = end;
@@ -1465,7 +2399,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
     const nextVisited = new Set(visited);
     nextVisited.add(fullPath);
     const imported = await readFile(fullPath, "utf-8");
-    parts.push(await resolveCssImportsAsync(imported, dirname(fullPath), nextVisited));
+    parts.push(await resolveCssImportsAsync(imported, dirname2(fullPath), nextVisited));
     cursor = end;
   }
   parts.push(content.slice(cursor));
@@ -1474,13 +2408,13 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   if (!isPreprocessableStylePath(filePath)) {
     const raw = await readFile(filePath, "utf-8");
     const processed = await runPostcss(raw, filePath, config);
-    return resolveCssImportsAsync(processed, dirname(filePath), new Set([filePath]));
+    return resolveCssImportsAsync(processed, dirname2(filePath), new Set([filePath]));
   }
   const compiled = await compileStyleSource(filePath, undefined, undefined, config);
-  return resolveCssImportsAsync(compiled, dirname(filePath), new Set([filePath]));
+  return resolveCssImportsAsync(compiled, dirname2(filePath), new Set([filePath]));
 }, resolveCssImportsSync = (content, baseDir, visited) => {
   return content.replace(CSS_IMPORT_PATTERN, (match, importPath) => {
-    const fullPath = isAbsolute(importPath) ? importPath : resolve3(baseDir, importPath);
+    const fullPath = isAbsolute(importPath) ? importPath : resolve4(baseDir, importPath);
     if (visited.has(fullPath))
       return "";
     if (!existsSync3(fullPath))
@@ -1488,7 +2422,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
     const nextVisited = new Set(visited);
     nextVisited.add(fullPath);
     const imported = readFileSync3(fullPath, "utf-8");
-    return resolveCssImportsSync(imported, dirname(fullPath), nextVisited);
+    return resolveCssImportsSync(imported, dirname2(fullPath), nextVisited);
   });
 }, compileStyleFileIfNeededSync = (filePath, config) => {
   const rawContents = readFileSync3(filePath, "utf-8");
@@ -1514,18 +2448,18 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
       loadPaths,
       style: "expanded",
       syntax: language === "sass" ? "indented" : "scss",
-      url: new URL(pathToFileURL(resolve3(filePath)).href)
+      url: new URL(pathToFileURL(resolve4(filePath)).href)
     });
     const loadedUrls = result.loadedUrls ?? [];
     for (const url of loadedUrls) {
       if (url.protocol !== "file:")
         continue;
       const dep = fileURLToPath(url);
-      if (resolve3(dep) === resolve3(filePath))
+      if (resolve4(dep) === resolve4(filePath))
         continue;
       addStyleImporter(filePath, dep);
     }
-    return resolveCssImportsSync(result.css, dirname(filePath), new Set([filePath]));
+    return resolveCssImportsSync(result.css, dirname2(filePath), new Set([filePath]));
   }
   if (language === "less") {
     throw new Error(`Unable to compile ${filePath}: Less styleUrl preprocessing is async-only. Import the Less file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
@@ -1533,7 +2467,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   if (language === "stylus") {
     throw new Error(`Unable to compile ${filePath}: Stylus styleUrl preprocessing is async-only. Import the Stylus file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
   }
-  return resolveCssImportsSync(rawContents, dirname(filePath), new Set([filePath]));
+  return resolveCssImportsSync(rawContents, dirname2(filePath), new Set([filePath]));
 }, getCssOutputExtension = (filePath) => isPreprocessableStylePath(filePath) ? ".css" : extname(filePath);
 var init_stylePreprocessor = __esm(() => {
   CSS_EXTENSION_PATTERN = /\.css$/i;
@@ -1542,7 +2476,7 @@ var init_stylePreprocessor = __esm(() => {
   STYLE_LANGUAGE_PATTERN = /^(s[ac]ss|less|styl(?:us)?)$/i;
   importOptionalPeer = new Function("specifier", "return import(specifier)");
   requireOptionalPeer = new Function("specifier", "return require(specifier)");
-  requireFromCwd = createRequire(join3(process.cwd(), "package.json"));
+  requireFromCwd = createRequire(join5(process.cwd(), "package.json"));
   styleDependencyGraph = new Map;
   styleOutputHashes = new Map;
   stylePreprocessorPlugin = createStylePreprocessorPlugin();
@@ -1550,14 +2484,14 @@ var init_stylePreprocessor = __esm(() => {
 });
 
 // src/core/svelteServerModule.ts
-import { mkdir, readdir } from "fs/promises";
-import { basename as basename2, dirname as dirname2, extname as extname2, join as join4, relative as relative2, resolve as resolve4 } from "path";
-var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
-  const importPath = relative2(dirname2(from), target).replace(/\\/g, "/");
+import { mkdir as mkdir2, readdir as readdir2 } from "fs/promises";
+import { basename as basename3, dirname as dirname3, extname as extname2, join as join6, relative as relative3, resolve as resolve5 } from "path";
+var serverCacheRoot2, compiledModuleCache2, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
+  const importPath = relative3(dirname3(from), target).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
 }, processDirectoryEntries = (entries, dir, targetFileName, stack) => {
   for (const entry of entries) {
-    const entryPath = join4(dir, entry.name);
+    const entryPath = join6(dir, entry.name);
     if (entry.isDirectory())
       stack.push(entryPath);
     if (entry.isFile() && entry.name === targetFileName) {
@@ -1571,7 +2505,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   const nextStack = [];
   const dirEntries = await Promise.all(dirs.map(async (dir) => ({
     dir,
-    entries: await readdir(dir, {
+    entries: await readdir2(dir, {
       encoding: "utf-8",
       withFileTypes: true
     })
@@ -1582,16 +2516,16 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
       return found;
   }
   return searchDirectoryLevel(nextStack, targetFileName);
-}, findSourceFileByBasename = async (searchRoot, targetFileName) => searchDirectoryLevel([searchRoot], targetFileName), normalizeBuiltSvelteFileName = (sourcePath) => basename2(sourcePath).replace(/-[a-z0-9]{6,}(?=\.svelte$)/i, ""), resolveOriginalSourcePath = async (sourcePath) => {
+}, findSourceFileByBasename = async (searchRoot, targetFileName) => searchDirectoryLevel([searchRoot], targetFileName), normalizeBuiltSvelteFileName = (sourcePath) => basename3(sourcePath).replace(/-[a-z0-9]{6,}(?=\.svelte$)/i, ""), resolveOriginalSourcePath = async (sourcePath) => {
   const cachedPath = originalSourcePathCache.get(sourcePath);
   if (cachedPath !== undefined) {
     return cachedPath;
   }
-  if (!sourcePath.includes(`${join4(process.cwd(), "build")}${process.platform === "win32" ? "" : "/"}`) && !sourcePath.includes("/build/")) {
+  if (!sourcePath.includes(`${join6(process.cwd(), "build")}${process.platform === "win32" ? "" : "/"}`) && !sourcePath.includes("/build/")) {
     originalSourcePathCache.set(sourcePath, sourcePath);
     return sourcePath;
   }
-  const resolvedSourcePath = await findSourceFileByBasename(join4(process.cwd(), "src"), normalizeBuiltSvelteFileName(sourcePath));
+  const resolvedSourcePath = await findSourceFileByBasename(join6(process.cwd(), "src"), normalizeBuiltSvelteFileName(sourcePath));
   const nextPath = resolvedSourcePath ?? sourcePath;
   originalSourcePathCache.set(sourcePath, nextPath);
   return nextPath;
@@ -1599,7 +2533,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (!spec.startsWith(".")) {
     return null;
   }
-  const basePath = resolve4(dirname2(from), spec);
+  const basePath = resolve5(dirname3(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -1607,19 +2541,19 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
     `${basePath}.mjs`,
     `${basePath}.cjs`,
     `${basePath}.json`,
-    join4(basePath, "index.ts"),
-    join4(basePath, "index.js"),
-    join4(basePath, "index.mjs"),
-    join4(basePath, "index.cjs"),
-    join4(basePath, "index.json")
+    join6(basePath, "index.ts"),
+    join6(basePath, "index.js"),
+    join6(basePath, "index.mjs"),
+    join6(basePath, "index.cjs"),
+    join6(basePath, "index.json")
   ];
   const existResults = await Promise.all(candidates.map((candidate) => Bun.file(candidate).exists()));
   const foundIndex = existResults.indexOf(true);
   return foundIndex >= 0 ? candidates[foundIndex] ?? null : null;
-}, getCachedModulePath = (sourcePath) => {
-  const relativeSourcePath = relative2(process.cwd(), sourcePath).replace(/\\/g, "/");
+}, getCachedModulePath2 = (sourcePath) => {
+  const relativeSourcePath = relative3(process.cwd(), sourcePath).replace(/\\/g, "/");
   const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
-  return join4(serverCacheRoot, `${normalizedSourcePath}.server.js`);
+  return join6(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
 }, resolveSvelteImport = async (spec, from) => {
   if (!spec.startsWith(".") && !spec.startsWith("/")) {
     const resolved = resolvePackageImport(spec);
@@ -1631,7 +2565,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (!spec.startsWith(".")) {
     return null;
   }
-  const explicitPath = resolve4(dirname2(from), spec);
+  const explicitPath = resolve5(dirname3(from), spec);
   if (extname2(explicitPath) === ".svelte") {
     return explicitPath;
   }
@@ -1651,7 +2585,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   }
   await Bun.write(path, content);
 }, compileSvelteServerModule = async (sourcePath) => {
-  const cachedModulePath = compiledModuleCache.get(sourcePath);
+  const cachedModulePath = compiledModuleCache2.get(sourcePath);
   if (cachedModulePath) {
     return cachedModulePath;
   }
@@ -1690,7 +2624,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
       continue;
     if (resolvedChildModules[index])
       continue;
-    rewrittenModulePaths.set(spec, ensureRelativeImportPath(getCachedModulePath(sourcePath), resolvedModuleImport));
+    rewrittenModulePaths.set(spec, ensureRelativeImportPath(getCachedModulePath2(sourcePath), resolvedModuleImport));
   }
   for (const [spec, resolvedModuleImport] of rewrittenModulePaths) {
     transpiled = transpiled.replaceAll(spec, resolvedModuleImport);
@@ -1704,15 +2638,15 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
     generate: "server"
   }).js.code;
   for (const [spec, compiledChildPath] of childModulePaths) {
-    compiledCode = compiledCode.replaceAll(spec, ensureRelativeImportPath(getCachedModulePath(sourcePath), compiledChildPath));
+    compiledCode = compiledCode.replaceAll(spec, ensureRelativeImportPath(getCachedModulePath2(sourcePath), compiledChildPath));
   }
   for (const [spec, resolvedModuleImport] of rewrittenModulePaths) {
     compiledCode = compiledCode.replaceAll(spec, resolvedModuleImport);
   }
-  const compiledModulePath = getCachedModulePath(sourcePath);
-  await mkdir(dirname2(compiledModulePath), { recursive: true });
+  const compiledModulePath = getCachedModulePath2(sourcePath);
+  await mkdir2(dirname3(compiledModulePath), { recursive: true });
   await writeIfChanged(compiledModulePath, compiledCode);
-  compiledModuleCache.set(sourcePath, compiledModulePath);
+  compiledModuleCache2.set(sourcePath, compiledModulePath);
   return compiledModulePath;
 };
 var init_svelteServerModule = __esm(() => {
@@ -1720,8 +2654,8 @@ var init_svelteServerModule = __esm(() => {
   init_lowerIslandSyntax();
   init_lowerAwaitSlotSyntax();
   init_stylePreprocessor();
-  serverCacheRoot = join4(process.cwd(), ".absolutejs", "islands", "svelte");
-  compiledModuleCache = new Map;
+  serverCacheRoot2 = join6(process.cwd(), ".absolutejs", "islands", "svelte");
+  compiledModuleCache2 = new Map;
   originalSourcePathCache = new Map;
   transpiler = new Bun.Transpiler({
     loader: "ts",
@@ -1729,18 +2663,31 @@ var init_svelteServerModule = __esm(() => {
   });
 });
 
+// src/utils/vueCompiler.ts
+var createVueCompiler = async () => {
+  const [compiler, typescript] = await Promise.all([
+    import("@vue/compiler-sfc"),
+    import("typescript")
+  ]);
+  compiler.registerTS?.(() => typescript);
+  return compiler;
+}, compilerPromise, loadVueCompiler = () => {
+  compilerPromise ??= createVueCompiler();
+  return compilerPromise;
+};
+
 // src/core/vueServerModule.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4, realpathSync } from "fs";
-import { mkdir as mkdir2 } from "fs/promises";
-import { dirname as dirname3, join as join5, relative as relative3, resolve as resolve5 } from "path";
+import { mkdir as mkdir3 } from "fs/promises";
+import { dirname as dirname4, join as join7, relative as relative4, resolve as resolve6 } from "path";
 var {Transpiler } = globalThis.Bun;
-var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, transpiler2, ensureRelativeImportPath2 = (from, target) => {
-  const importPath = relative3(dirname3(from), target).replace(/\\/g, "/");
+var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot3, compiledModuleCache3, transpiler2, ensureRelativeImportPath2 = (from, target) => {
+  const importPath = relative4(dirname4(from), target).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
-}, getCachedModulePath2 = (sourcePath) => {
-  const relativeSourcePath = relative3(process.cwd(), sourcePath).replace(/\\/g, "/");
+}, getCachedModulePath3 = (sourcePath) => {
+  const relativeSourcePath = relative4(process.cwd(), sourcePath).replace(/\\/g, "/");
   const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
-  return join5(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
+  return join7(serverCacheRoot3, `${normalizedSourcePath}.server.js`);
 }, writeIfChanged2 = async (path, content) => {
   const targetFile = Bun.file(path);
   if (await targetFile.exists()) {
@@ -1767,10 +2714,10 @@ var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, tran
 `) : nonVueLines.join(`
 `);
 }, extractRelativeVueImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => typeof importPath === "string" && importPath.startsWith(".") && importPath.endsWith(".vue")), compileVueServerModule = async (sourcePath) => {
-  const cachedModulePath = compiledModuleCache2.get(sourcePath);
+  const cachedModulePath = compiledModuleCache3.get(sourcePath);
   if (cachedModulePath)
     return cachedModulePath;
-  const compiler = await import("@vue/compiler-sfc");
+  const compiler = await loadVueCompiler();
   const source = await Bun.file(sourcePath).text();
   const { descriptor } = compiler.parse(source, { filename: sourcePath });
   const componentId = Bun.hash(sourcePath).toString(BASE_36_RADIX).slice(0, ISLAND_COMPONENT_ID_LENGTH);
@@ -1778,8 +2725,8 @@ var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, tran
   const compiledScript = hasScript ? compiler.compileScript(descriptor, {
     fs: {
       fileExists: existsSync4,
-      readFile: (file) => existsSync4(file) ? readFileSync4(file, "utf-8") : undefined,
-      realpath: realpathSync
+      realpath: realpathSync,
+      readFile: (file) => existsSync4(file) ? readFileSync4(file, "utf-8") : undefined
     },
     id: componentId,
     inlineTemplate: false
@@ -1800,7 +2747,7 @@ var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, tran
   }).code : "const ssrRender = () => {};";
   const childImportPaths = extractRelativeVueImports(compiledScript.content);
   const compiledChildren = await Promise.all(childImportPaths.map(async (relativeImport) => ({
-    compiledPath: await compileVueServerModule(resolve5(dirname3(sourcePath), relativeImport)),
+    compiledPath: await compileVueServerModule(resolve6(dirname4(sourcePath), relativeImport)),
     spec: relativeImport
   })));
   const strippedScript = stripExports(compiledScript.content);
@@ -1812,20 +2759,20 @@ var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, tran
     "export default script;"
   ].join(`
 `));
-  const compiledModulePath = getCachedModulePath2(sourcePath);
+  const compiledModulePath = getCachedModulePath3(sourcePath);
   let rewritten = assembled;
   for (const child of compiledChildren) {
     rewritten = rewritten.replaceAll(child.spec, ensureRelativeImportPath2(compiledModulePath, child.compiledPath));
   }
-  await mkdir2(dirname3(compiledModulePath), { recursive: true });
+  await mkdir3(dirname4(compiledModulePath), { recursive: true });
   await writeIfChanged2(compiledModulePath, rewritten);
-  compiledModuleCache2.set(sourcePath, compiledModulePath);
+  compiledModuleCache3.set(sourcePath, compiledModulePath);
   return compiledModulePath;
 };
 var init_vueServerModule = __esm(() => {
   init_constants();
-  serverCacheRoot2 = join5(process.cwd(), ".absolutejs", "islands", "vue");
-  compiledModuleCache2 = new Map;
+  serverCacheRoot3 = join7(process.cwd(), ".absolutejs", "islands", "vue");
+  compiledModuleCache3 = new Map;
   transpiler2 = new Transpiler({ loader: "ts", target: "browser" });
 });
 
@@ -1971,8 +2918,17 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
     throw new Error("Resolved Vue island is not a valid Vue component.");
   }
   return resolvedComponent;
+}, loadAngularServerBuildComponent = async (buildReferencePath, exportName) => {
+  const serverModulePath = await compileAngularServerModule(buildReferencePath);
+  const loadedModule = await import(serverModulePath);
+  if (exportName && exportName !== "default" && exportName in loadedModule) {
+    return loadedModule[exportName];
+  }
+  return "default" in loadedModule ? loadedModule.default : loadedModule;
 }, resolveAngularServerIslandComponent = async (component) => {
-  const resolvedComponent = await resolveServerIslandComponent(component);
+  const buildReference = getIslandBuildReference(component);
+  const buildReferencePath = buildReference?.source ? resolveBuildReferencePath(buildReference.source, import.meta.url) : null;
+  const resolvedComponent = buildReferencePath ? await loadAngularServerBuildComponent(buildReferencePath, buildReference?.export) : await resolveServerIslandComponent(component);
   if (!isAngularServerIslandComponent(resolvedComponent)) {
     throw new Error("Resolved Angular island is not a valid Angular component.");
   }
@@ -2028,6 +2984,7 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
 };
 var init_renderIslandMarkup = __esm(() => {
   init_islandSsr();
+  init_angularServerModule();
   init_svelteServerModule();
   init_vueServerModule();
   init_islandMarkupAttributes();
@@ -2046,22 +3003,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") {
@@ -2095,17 +3050,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;
   }
@@ -2142,6 +3102,43 @@ var init_devRouteRegistrationCallsite = __esm(() => {
   pageHandlerWrappers = new WeakMap;
 });
 
+// src/core/pageResponseCache.ts
+import { createHash as createHash2 } 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/"${createHash2("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;
@@ -2901,12 +3898,12 @@ var init_startupBanner = __esm(() => {
 // src/utils/logger.ts
 var colors2, frameworkColors, formatPath = (filePath) => {
   const cwd = process.cwd();
-  let relative4 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
-  relative4 = relative4.replace(/\\/g, "/");
-  if (!relative4.startsWith("/")) {
-    relative4 = `/${relative4}`;
+  let relative5 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+  relative5 = relative5.replace(/\\/g, "/");
+  if (!relative5.startsWith("/")) {
+    relative5 = `/${relative5}`;
   }
-  return relative4;
+  return relative5;
 }, getFrameworkColor = (framework) => frameworkColors[framework] || colors2.white, log = (action, options) => {
   const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
   const tag = `${colors2.cyan}[hmr]${colors2.reset}`;
@@ -2927,6 +3924,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) => {
@@ -3510,8 +4520,8 @@ __export(exports_generatedDir, {
   getGeneratedRoot: () => getGeneratedRoot,
   getFrameworkGeneratedDir: () => getFrameworkGeneratedDir
 });
-import { join as join6 } from "path";
-var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getGeneratedRoot = (projectRoot = process.cwd()) => join6(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME), getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join6(getGeneratedRoot(projectRoot), framework);
+import { join as join8 } from "path";
+var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join8(getGeneratedRoot(projectRoot), framework), getGeneratedRoot = (projectRoot = process.cwd()) => join8(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME);
 var init_generatedDir = () => {};
 
 // src/build/compileAngular.ts
@@ -3524,7 +4534,7 @@ __export(exports_compileAngular, {
   compileAngular: () => compileAngular
 });
 import { existsSync as existsSync5, readFileSync as readFileSync5, promises as fs } from "fs";
-import { join as join7, basename as basename3, sep, dirname as dirname4, resolve as resolve6, relative as relative4 } from "path";
+import { join as join9, basename as basename4, sep, dirname as dirname5, resolve as resolve7, relative as relative5 } from "path";
 var {Glob } = globalThis.Bun;
 import ts from "typescript";
 var traceAngularPhase = async (name, fn, metadata) => {
@@ -3532,10 +4542,10 @@ var traceAngularPhase = async (name, fn, metadata) => {
   return tracePhase ? tracePhase(`compile/angular/${name}`, fn, metadata) : await fn();
 }, readTsconfigPathAliases = () => {
   try {
-    const configPath = resolve6(process.cwd(), "tsconfig.json");
+    const configPath = resolve7(process.cwd(), "tsconfig.json");
     const config = ts.readConfigFile(configPath, ts.sys.readFile).config;
     const compilerOptions = config?.compilerOptions ?? {};
-    const baseUrl = resolve6(process.cwd(), compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve7(process.cwd(), compilerOptions.baseUrl ?? ".");
     const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
     return { aliases, baseUrl };
   } catch {
@@ -3555,7 +4565,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     const wildcardValue = exactMatch ? "" : specifier.slice(prefix.length, specifier.length - suffix.length);
     for (const replacement of alias.replacements) {
       const candidate = replacement.replace("*", wildcardValue);
-      const resolved = resolveSourceFile(resolve6(baseUrl, candidate));
+      const resolved = resolveSourceFile(resolve7(baseUrl, candidate));
       if (resolved)
         return resolved;
     }
@@ -3567,20 +4577,20 @@ var traceAngularPhase = async (name, fn, metadata) => {
     `${candidate}.tsx`,
     `${candidate}.js`,
     `${candidate}.jsx`,
-    join7(candidate, "index.ts"),
-    join7(candidate, "index.tsx"),
-    join7(candidate, "index.js"),
-    join7(candidate, "index.jsx")
+    join9(candidate, "index.ts"),
+    join9(candidate, "index.tsx"),
+    join9(candidate, "index.js"),
+    join9(candidate, "index.jsx")
   ];
   return candidates.find((file) => existsSync5(file));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
-  const baseDir = resolve6(rootDir);
+  const baseDir = resolve7(rootDir);
   const tsconfigAliases = readTsconfigPathAliases();
   const transpiler3 = new Bun.Transpiler({ loader: "tsx" });
   const scanCache = new Map;
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile(resolve6(fromDir, specifier));
+      return resolveSourceFile(resolve7(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile);
     if (aliased)
@@ -3589,7 +4599,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve6(resolved);
+      const absolute = resolve7(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile(absolute);
@@ -3605,7 +4615,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
         usesLegacyAnimations: false
       });
     }
-    const resolved = resolve6(actualPath);
+    const resolved = resolve7(actualPath);
     const cached = scanCache.get(resolved);
     if (cached)
       return cached;
@@ -3634,7 +4644,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     const actualPath = resolveSourceFile(filePath);
     if (!actualPath)
       return false;
-    const resolved = resolve6(actualPath);
+    const resolved = resolve7(actualPath);
     if (visited.has(resolved))
       return false;
     visited.add(resolved);
@@ -3642,7 +4652,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     if (scan.usesLegacyAnimations)
       return true;
     for (const specifier of scan.imports) {
-      const importedPath = resolveLocalImport(specifier, dirname4(resolved));
+      const importedPath = resolveLocalImport(specifier, dirname5(resolved));
       if (importedPath && await visit(importedPath, visited)) {
         return true;
       }
@@ -3652,14 +4662,14 @@ var traceAngularPhase = async (name, fn, metadata) => {
   return (entryPath) => visit(entryPath);
 }, resolveDevClientDir = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve6(import.meta.dir, "../dev/client");
+  const fromSource = resolve7(import.meta.dir, "../dev/client");
   if (existsSync5(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve6(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve7(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync5(fromNodeModules))
     return fromNodeModules;
-  return resolve6(import.meta.dir, "./dev/client");
+  return resolve7(import.meta.dir, "./dev/client");
 }, devClientDir, hmrClientPath, formatDiagnosticMessage = (diagnostic) => {
   try {
     return ts.flattenDiagnosticMessageText(diagnostic.messageText, `
@@ -3701,12 +4711,12 @@ var traceAngularPhase = async (name, fn, metadata) => {
     return `${path.replace(/\.ts$/, ".js")}${query}`;
   if (hasJsLikeExtension(path))
     return `${path}${query}`;
-  const importerDir = dirname4(importerOutputPath);
-  const fileCandidate = resolve6(importerDir, `${path}.js`);
+  const importerDir = dirname5(importerOutputPath);
+  const fileCandidate = resolve7(importerDir, `${path}.js`);
   if (outputFiles?.has(fileCandidate) || existsSync5(fileCandidate)) {
     return `${path}.js${query}`;
   }
-  const indexCandidate = resolve6(importerDir, path, "index.js");
+  const indexCandidate = resolve7(importerDir, path, "index.js");
   if (outputFiles?.has(indexCandidate) || existsSync5(indexCandidate)) {
     return `${path}/index.js${query}`;
   }
@@ -3734,18 +4744,18 @@ var traceAngularPhase = async (name, fn, metadata) => {
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve6(dirname4(fromFile), specifier);
+  const basePath = resolve7(dirname5(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join7(basePath, "index.ts"),
-    join7(basePath, "index.tsx"),
-    join7(basePath, "index.mts"),
-    join7(basePath, "index.cts")
+    join9(basePath, "index.ts"),
+    join9(basePath, "index.tsx"),
+    join9(basePath, "index.mts"),
+    join9(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve6(candidate)).find((candidate) => existsSync5(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+  return candidates.map((candidate) => resolve7(candidate)).find((candidate) => existsSync5(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile2) => {
   const hostSource = readFile2?.(fileName);
   if (typeof hostSource === "string")
@@ -3769,18 +4779,18 @@ var traceAngularPhase = async (name, fn, metadata) => {
   const paths = [];
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1])
-    paths.push(join7(fileDir, templateUrlMatch[1]));
+    paths.push(join9(fileDir, templateUrlMatch[1]));
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (styleUrlMatch?.[1])
-    paths.push(join7(fileDir, styleUrlMatch[1]));
+    paths.push(join9(fileDir, styleUrlMatch[1]));
   const styleUrlsMatch = findUncommentedMatch(source, /styleUrls\s*:\s*\[([^\]]+)\]/);
   const urlMatches = styleUrlsMatch?.[1]?.match(/['"]([^'"]+)['"]/g);
   if (urlMatches) {
     for (const urlMatch of urlMatches) {
-      paths.push(join7(fileDir, urlMatch.replace(/['"]/g, "")));
+      paths.push(join9(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
-  return paths.map((path) => resolve6(path));
+  return paths.map((path) => resolve7(path));
 }, readResourceCacheFile = async (cachePath) => {
   try {
     const entry = JSON.parse(await fs.readFile(cachePath, "utf-8"));
@@ -3792,13 +4802,13 @@ var traceAngularPhase = async (name, fn, metadata) => {
     return null;
   }
 }, writeResourceCacheFile = async (cachePath, source) => {
-  await fs.mkdir(dirname4(cachePath), { recursive: true });
+  await fs.mkdir(dirname5(cachePath), { recursive: true });
   await fs.writeFile(cachePath, JSON.stringify({
     source,
     version: 1
   }), "utf-8");
 }, resolveResourceTransformCachePath = async (filePath, source, stylePreprocessors) => {
-  const resourcePaths = collectAngularResourcePaths(source, dirname4(filePath));
+  const resourcePaths = collectAngularResourcePaths(source, dirname5(filePath));
   const resourceContents = await Promise.all(resourcePaths.map(async (resourcePath) => {
     const content = await fs.readFile(resourcePath, "utf-8");
     return `${resourcePath}\x00${content}`;
@@ -3811,7 +4821,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     safeStableStringify(stylePreprocessors ?? null)
   ].join("\x00");
   const cacheKey = Bun.hash(cacheInput).toString(BASE_36_RADIX);
-  return join7(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey}.json`);
+  return join9(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey}.json`);
 }, precomputeAotResourceTransforms = async (inputPaths, readFile2, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
@@ -3822,7 +4832,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     transformedFiles: 0
   };
   const transformFile = async (filePath) => {
-    const resolvedPath = resolve6(filePath);
+    const resolvedPath = resolve7(filePath);
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
@@ -3838,7 +4848,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
       transformedSource = cached.source;
     } else {
       stats.cacheMisses += 1;
-      const transformed = await inlineResources(source, dirname4(resolvedPath), stylePreprocessors);
+      const transformed = await inlineResources(source, dirname5(resolvedPath), stylePreprocessors);
       transformedSource = transformed.source;
       await writeResourceCacheFile(cachePath, transformedSource);
     }
@@ -3857,7 +4867,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
   return { stats, transformedSources };
 }, compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
   const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
-    const outputPath = resolve6(join7(outDir, relative4(process.cwd(), resolve6(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve7(join9(outDir, relative5(process.cwd(), resolve7(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
       buildIslandMetadataExports(readFileSync5(inputPath, "utf-8"))
@@ -3867,8 +4877,8 @@ var traceAngularPhase = async (name, fn, metadata) => {
   const { readConfiguration, performCompilation, EmitFlags } = await traceAngularPhase("aot/import-compiler-cli", () => import("@angular/compiler-cli"));
   const tsLibDir = await traceAngularPhase("aot/resolve-typescript-lib", () => {
     const tsPath = __require.resolve("typescript");
-    const tsRootDir = dirname4(tsPath);
-    return tsRootDir.endsWith("lib") ? tsRootDir : resolve6(tsRootDir, "lib");
+    const tsRootDir = dirname5(tsPath);
+    return tsRootDir.endsWith("lib") ? tsRootDir : resolve7(tsRootDir, "lib");
   });
   const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
   const options = {
@@ -3899,18 +4909,18 @@ var traceAngularPhase = async (name, fn, metadata) => {
   const originalGetDefaultLibFileName = host.getDefaultLibFileName;
   host.getDefaultLibFileName = (opts) => {
     const fileName = originalGetDefaultLibFileName ? originalGetDefaultLibFileName(opts) : "lib.d.ts";
-    return basename3(fileName);
+    return basename4(fileName);
   };
   const originalGetSourceFile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
     if (fileName.startsWith("lib.") && fileName.endsWith(".d.ts") && tsLibDir) {
-      const resolvedPath = join7(tsLibDir, fileName);
+      const resolvedPath = join9(tsLibDir, fileName);
       return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
     }
     return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
   };
   const emitted = {};
-  const resolvedOutDir = resolve6(outDir);
+  const resolvedOutDir = resolve7(outDir);
   host.writeFile = (fileName, text) => {
     const relativePath = resolveRelativePath(fileName, resolvedOutDir, outDir);
     emitted[relativePath] = text;
@@ -3932,12 +4942,12 @@ var traceAngularPhase = async (name, fn, metadata) => {
     if (!fileName.endsWith(".ts") || fileName.endsWith(".d.ts")) {
       return source;
     }
-    const resolvedPath = resolve6(fileName);
+    const resolvedPath = resolve7(fileName);
     return transformedSources.get(resolvedPath) ?? source;
   };
   const originalGetSourceFileForCompile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
-    const source = transformedSources.get(resolve6(fileName));
+    const source = transformedSources.get(resolve7(fileName));
     if (source) {
       return ts.createSourceFile(fileName, source, languageVersion, true);
     }
@@ -3959,9 +4969,9 @@ var traceAngularPhase = async (name, fn, metadata) => {
   const entries = await traceAngularPhase("aot/postprocess-emitted-js", () => {
     const rawEntries = Object.entries(emitted).filter(([fileName]) => fileName.endsWith(".js")).map(([fileName, content]) => ({
       content,
-      target: join7(outDir, fileName)
+      target: join9(outDir, fileName)
     }));
-    const outputFiles = new Set(rawEntries.map(({ target }) => resolve6(target)));
+    const outputFiles = new Set(rawEntries.map(({ target }) => resolve7(target)));
     return rawEntries.map(({ content, target }) => {
       let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
         const rewritten = rewriteRelativeJsSpecifier(target, path, outputFiles);
@@ -3976,17 +4986,17 @@ var traceAngularPhase = async (name, fn, metadata) => {
         return cleaned ? `import { ${cleaned}, InternalInjectFlags } from '@angular/core'` : `import { InternalInjectFlags } from '@angular/core'`;
       });
       processedContent = processedContent.replace(/\b(?<!Internal)InjectFlags\b/g, "InternalInjectFlags");
-      processedContent += islandMetadataByOutputPath.get(resolve6(target)) ?? "";
+      processedContent += islandMetadataByOutputPath.get(resolve7(target)) ?? "";
       return { content: processedContent, target };
     });
   });
   await traceAngularPhase("aot/write-output", () => Promise.all(entries.map(async ({ target, content }) => {
-    await fs.mkdir(dirname4(target), { recursive: true });
+    await fs.mkdir(dirname5(target), { recursive: true });
     await fs.writeFile(target, content, "utf-8");
   })), { outputs: entries.length });
   return await traceAngularPhase("aot/collect-output-paths", () => entries.map(({ target }) => target), { outputs: entries.length });
 }, compileAngularFile = async (inputPath, outDir, stylePreprocessors) => compileAngularFiles([inputPath], outDir, stylePreprocessors), jitContentCache, invalidateAngularJitCache = (filePath) => {
-  jitContentCache.delete(resolve6(filePath));
+  jitContentCache.delete(resolve7(filePath));
 }, wrapperOutputCache, escapeTemplateContent = (content) => content.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${"), findUncommentedMatch = (source, pattern) => {
   const re = new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g");
   let match;
@@ -3999,7 +5009,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
   }
   return null;
 }, resolveAngularDeferImportSpecifier = () => {
-  const sourceEntry = resolve6(import.meta.dir, "../angular/components/index.ts");
+  const sourceEntry = resolve7(import.meta.dir, "../angular/components/index.ts");
   if (existsSync5(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
@@ -4136,7 +5146,7 @@ ${fields}
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join7(fileDir, templateUrlMatch[1]);
+    const templatePath = join9(fileDir, templateUrlMatch[1]);
     if (!existsSync5(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -4167,7 +5177,7 @@ ${fields}
 }, inlineTemplateAndLowerDeferSync = (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join7(fileDir, templateUrlMatch[1]);
+    const templatePath = join9(fileDir, templateUrlMatch[1]);
     if (!existsSync5(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -4204,7 +5214,7 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join7(fileDir, styleUrl), stylePreprocessors);
+    return readAndEscapeFile(join9(fileDir, styleUrl), stylePreprocessors);
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -4215,7 +5225,7 @@ ${fields}
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join7(fileDir, styleUrlMatch[1]), stylePreprocessors);
+  const escaped = await readAndEscapeFile(join9(fileDir, styleUrlMatch[1]), stylePreprocessors);
   if (!escaped)
     return source;
   return source.slice(0, styleUrlMatch.index) + `styles: [\`${escaped}\`]` + source.slice(styleUrlMatch.index + styleUrlMatch[0].length);
@@ -4228,11 +5238,71 @@ ${fields}
     deferSlots: inlinedTemplate.deferSlots,
     source: result
   };
+}, CLASS_KEYWORD = "class", isIdentifierChar = (char) => char !== undefined && /[A-Za-z0-9_$]/.test(char), skipStringLiteral = (source, start) => {
+  const quote = source[start];
+  let index = start + 1;
+  while (index < source.length) {
+    if (source[index] === "\\") {
+      index += 2;
+      continue;
+    }
+    if (source[index] === quote)
+      return index + 1;
+    index += 1;
+  }
+  return index;
+}, findDecoratedClassKeyword = (source, start) => {
+  let index = start;
+  let depth = 0;
+  while (index < source.length) {
+    const char = source[index];
+    if (char === '"' || char === "'" || char === "`") {
+      index = skipStringLiteral(source, index);
+      continue;
+    }
+    const isOpen = char === "(" || char === "[" || char === "{";
+    const isClose = char === ")" || char === "]" || char === "}";
+    const atClass = depth === 0 && source.startsWith(CLASS_KEYWORD, index) && !isIdentifierChar(source[index - 1]) && !isIdentifierChar(source[index + CLASS_KEYWORD.length]);
+    if (atClass)
+      return index;
+    if (isOpen)
+      depth += 1;
+    else if (isClose)
+      depth -= 1;
+    index += 1;
+  }
+  return -1;
+}, hoistExportPastDecorators = (source) => {
+  const exportBeforeDecorator = /\bexport\s+(?=@)/g;
+  let result = "";
+  let lastIndex = 0;
+  let match = exportBeforeDecorator.exec(source);
+  while (match !== null) {
+    const decoratorStart = match.index + match[0].length;
+    const classIndex = findDecoratedClassKeyword(source, decoratorStart);
+    if (classIndex !== -1) {
+      result += source.slice(lastIndex, match.index);
+      result += source.slice(decoratorStart, classIndex);
+      result += `export ${CLASS_KEYWORD}`;
+      lastIndex = classIndex + CLASS_KEYWORD.length;
+      exportBeforeDecorator.lastIndex = lastIndex;
+    }
+    match = exportBeforeDecorator.exec(source);
+  }
+  result += source.slice(lastIndex);
+  return result;
+}, PROVIDERS_INJECTION_BLOCK_RE, readPreservedInjection = async (targetPath) => {
+  try {
+    const existing = await fs.readFile(targetPath, "utf-8");
+    return PROVIDERS_INJECTION_BLOCK_RE.exec(existing)?.[0] ?? "";
+  } catch {
+    return "";
+  }
 }, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors, cacheBuster) => {
-  const entryPath = resolve6(inputPath);
+  const entryPath = resolve7(inputPath);
   const allOutputs = [];
   const visited = new Set;
-  const baseDir = resolve6(rootDir ?? process.cwd());
+  const baseDir = resolve7(rootDir ?? process.cwd());
   let usesLegacyAnimations = false;
   const angularTranspiler = new Bun.Transpiler({
     loader: "ts",
@@ -4251,16 +5321,16 @@ ${fields}
       `${candidate}.js`,
       `${candidate}.jsx`,
       `${candidate}.json`,
-      join7(candidate, "index.ts"),
-      join7(candidate, "index.tsx"),
-      join7(candidate, "index.js"),
-      join7(candidate, "index.jsx")
+      join9(candidate, "index.ts"),
+      join9(candidate, "index.tsx"),
+      join9(candidate, "index.js"),
+      join9(candidate, "index.jsx")
     ];
     return candidates.find((file) => existsSync5(file));
   };
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile2(resolve6(fromDir, specifier));
+      return resolveSourceFile2(resolve7(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile2);
     if (aliased)
@@ -4269,7 +5339,7 @@ ${fields}
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve6(resolved);
+      const absolute = resolve7(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile2(absolute);
@@ -4278,13 +5348,13 @@ ${fields}
     }
   };
   const toOutputPath = (sourcePath) => {
-    const inputDir = dirname4(sourcePath);
-    const fileBase = basename3(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
+    const inputDir = dirname5(sourcePath);
+    const fileBase = basename4(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
     if (inputDir === outDir || inputDir.startsWith(`${outDir}${sep}`)) {
-      return join7(inputDir, fileBase);
+      return join9(inputDir, fileBase);
     }
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
-    return join7(outDir, relativeDir, fileBase);
+    return join9(outDir, relativeDir, fileBase);
   };
   const withCacheBuster = (specifier) => {
     if (!cacheBuster)
@@ -4292,7 +5362,7 @@ ${fields}
     return specifier.includes("?") ? `${specifier}&t=${cacheBuster}` : `${specifier}?t=${cacheBuster}`;
   };
   const transpileAndRewrite = (sourceCode, relativeDir, actualPath, importRewrites) => {
-    let processedContent = angularTranspiler.transformSync(sourceCode);
+    let processedContent = angularTranspiler.transformSync(hoistExportPastDecorators(sourceCode));
     const outputPath = toOutputPath(actualPath);
     const rewriteBareImport = (prefix, specifier, suffix) => {
       const rewritten = importRewrites.get(specifier);
@@ -4321,21 +5391,21 @@ ${fields}
         return `${prefix}${dots}`;
       return `${prefix}../${dots}`;
     });
-    if (resolve6(actualPath) === entryPath) {
+    if (resolve7(actualPath) === entryPath) {
       processedContent += buildIslandMetadataExports(sourceCode);
     }
     return processedContent;
   };
   const transpileFile = async (filePath) => {
-    const resolved = resolve6(filePath);
+    const resolved = resolve7(filePath);
     if (visited.has(resolved))
       return;
     visited.add(resolved);
     if (resolved.endsWith(".json") && existsSync5(resolved)) {
-      const inputDir2 = dirname4(resolved);
+      const inputDir2 = dirname5(resolved);
       const relativeDir2 = inputDir2.startsWith(baseDir) ? inputDir2.substring(baseDir.length + 1) : inputDir2;
-      const targetDir2 = join7(outDir, relativeDir2);
-      const targetPath2 = join7(targetDir2, basename3(resolved));
+      const targetDir2 = join9(outDir, relativeDir2);
+      const targetPath2 = join9(targetDir2, basename4(resolved));
       await fs.mkdir(targetDir2, { recursive: true });
       await fs.copyFile(resolved, targetPath2);
       allOutputs.push(targetPath2);
@@ -4347,13 +5417,13 @@ ${fields}
     if (!existsSync5(actualPath))
       return;
     let sourceCode = await fs.readFile(actualPath, "utf-8");
-    const inlined = await inlineResources(sourceCode, dirname4(actualPath), stylePreprocessors);
-    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname4(actualPath)).source;
-    const inputDir = dirname4(actualPath);
-    const fileBase = basename3(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
+    const inlined = await inlineResources(sourceCode, dirname5(actualPath), stylePreprocessors);
+    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname5(actualPath)).source;
+    const inputDir = dirname5(actualPath);
+    const fileBase = basename4(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
     const targetPath = toOutputPath(actualPath);
-    const targetDir = dirname4(targetPath);
-    const relativeDir = relative4(outDir, targetDir).replace(/\\/g, "/");
+    const targetDir = dirname5(targetPath);
+    const relativeDir = relative5(outDir, targetDir).replace(/\\/g, "/");
     const localImports = [];
     const importRewrites = new Map;
     const fromRegex = /(?:from|import)\s+['"]([^'".][^'"]*|\.\.?\/[^'"]+)['"]/g;
@@ -4374,19 +5444,20 @@ ${fields}
       const resolved2 = resolveLocalImport(specifier, inputDir);
       if (!resolved2)
         return null;
-      const relativeImport = relative4(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
+      const relativeImport = relative5(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
       const relativeRewrite = relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`;
       importRewrites.set(specifier, relativeRewrite);
       return resolved2;
     }).filter((path) => Boolean(path));
-    const isEntry = resolve6(actualPath) === resolve6(entryPath);
+    const isEntry = resolve7(actualPath) === resolve7(entryPath);
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey = actualPath;
     const shouldWriteFile = cacheBuster && isEntry ? true : jitContentCache.get(cacheKey) !== contentHash || !existsSync5(targetPath);
     if (shouldWriteFile) {
       const processedContent = transpileAndRewrite(sourceCode, relativeDir, actualPath, importRewrites);
+      const preservedInjection = await readPreservedInjection(targetPath);
       await fs.mkdir(targetDir, { recursive: true });
-      await fs.writeFile(targetPath, processedContent, "utf-8");
+      await fs.writeFile(targetPath, processedContent + preservedInjection, "utf-8");
       jitContentCache.set(cacheKey, contentHash);
     }
     allOutputs.push(targetPath);
@@ -4413,13 +5484,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join7(compiledParent, "indexes");
+  const indexesDir = join9(compiledParent, "indexes");
   await traceAngularPhase("setup/create-indexes-dir", () => fs.mkdir(indexesDir, { recursive: true }));
-  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve6(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
+  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve7(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   if (!hmr) {
     await traceAngularPhase("aot/copy-json-resources", async () => {
       const cwd = process.cwd();
-      const angularSrcDir = resolve6(outRoot);
+      const angularSrcDir = resolve7(outRoot);
       if (!existsSync5(angularSrcDir))
         return;
       const jsonGlob = new Glob("**/*.json");
@@ -4427,32 +5498,32 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
         absolute: false,
         cwd: angularSrcDir
       })) {
-        const sourcePath = join7(angularSrcDir, rel);
-        const cwdRel = relative4(cwd, sourcePath);
-        const targetPath = join7(compiledRoot, cwdRel);
-        await fs.mkdir(dirname4(targetPath), { recursive: true });
+        const sourcePath = join9(angularSrcDir, rel);
+        const cwdRel = relative5(cwd, sourcePath);
+        const targetPath = join9(compiledRoot, cwdRel);
+        await fs.mkdir(dirname5(targetPath), { recursive: true });
         await fs.copyFile(sourcePath, targetPath);
       }
     });
   }
   const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
   const compileTasks = entryPoints.map(async (entry) => {
-    const resolvedEntry = resolve6(entry);
-    const relativeEntry = relative4(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
+    const resolvedEntry = resolve7(entry);
+    const relativeEntry = relative5(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
     const compileEntry = () => compileAngularFileJIT(resolvedEntry, compiledRoot, outRoot, stylePreprocessors);
     let outputs = hmr ? await traceAngularPhase("jit/compile-entry", compileEntry, {
       entry: resolvedEntry
     }) : aotOutputs;
-    const fileBase = basename3(resolvedEntry).replace(/\.[tj]s$/, "");
+    const fileBase = basename4(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
     const compiledFallbackPaths = [
-      join7(compiledRoot, relativeEntry),
-      join7(compiledRoot, "pages", jsName),
-      join7(compiledRoot, jsName)
-    ].map((file) => resolve6(file));
+      join9(compiledRoot, relativeEntry),
+      join9(compiledRoot, "pages", jsName),
+      join9(compiledRoot, jsName)
+    ].map((file) => resolve7(file));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
-        ...candidatePaths.map((file) => resolve6(file)),
+        ...candidatePaths.map((file) => resolve7(file)),
         ...compiledFallbackPaths
       ];
       let candidate = normalizedCandidates.find((file) => existsSync5(file) && file.endsWith(`${sep}${relativeEntry}`));
@@ -4497,9 +5568,11 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const pageInjectionForHash = providersInjection?.pagesByFile.get(resolvedEntry);
     const providersHashInput = providersInjection ? (() => {
       let providersSourceContent = "";
-      try {
-        providersSourceContent = readFileSync5(providersInjection.appProvidersSource, "utf-8");
-      } catch {}
+      if (providersInjection.appProvidersSource) {
+        try {
+          providersSourceContent = readFileSync5(providersInjection.appProvidersSource, "utf-8");
+        } catch {}
+      }
       return JSON.stringify({
         basePath: pageInjectionForHash?.basePath ?? null,
         hasRoutes: pageInjectionForHash?.hasRoutes ?? false,
@@ -4508,7 +5581,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     })() : "no-providers";
     const serverContentHash = `${Bun.hash(original).toString(BASE_36_RADIX)}.${Bun.hash(providersHashInput).toString(BASE_36_RADIX)}`;
     const cachedWrapper = wrapperOutputCache.get(resolvedEntry);
-    const clientFile = join7(indexesDir, jsName);
+    const clientFile = join9(indexesDir, jsName);
     if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync5(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
       return {
         clientPath: clientFile,
@@ -4536,20 +5609,22 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const pageInjection = providersInjection?.pagesByFile.get(resolvedEntry);
     rewritten = rewritten.replace(/\n\/\* __ABS_PROVIDERS_INJECTION_START \*\/[\s\S]*?\/\* __ABS_PROVIDERS_INJECTION_END \*\/\n?/g, "");
     if (providersInjection && pageInjection) {
-      const compiledAppProvidersPath = (() => {
-        const angularDirAbs = resolve6(outRoot);
-        const appSourceAbs = resolve6(providersInjection.appProvidersSource);
-        const rel = relative4(angularDirAbs, appSourceAbs).replace(/\\/g, "/");
-        return join7(compiledParent, rel).replace(/\.[cm]?[tj]sx?$/, ".js");
-      })();
-      const appProvidersSpec = (() => {
-        const rel = relative4(dirname4(rawServerFile), compiledAppProvidersPath).replace(/\\/g, "/");
-        return rel.startsWith(".") ? rel : `./${rel}`;
-      })();
-      const importLines = [
-        `import { appProviders as __abs_globalProviders } from "${appProvidersSpec}";`
-      ];
-      const fragments = ["...__abs_globalProviders"];
+      const importLines = [];
+      const fragments = [];
+      if (providersInjection.appProvidersSource) {
+        const compiledAppProvidersPath = (() => {
+          const angularDirAbs = resolve7(outRoot);
+          const appSourceAbs = resolve7(providersInjection.appProvidersSource);
+          const rel = relative5(angularDirAbs, appSourceAbs).replace(/\\/g, "/");
+          return join9(compiledParent, rel).replace(/\.[cm]?[tj]sx?$/, ".js");
+        })();
+        const appProvidersSpec = (() => {
+          const rel = relative5(dirname5(rawServerFile), compiledAppProvidersPath).replace(/\\/g, "/");
+          return rel.startsWith(".") ? rel : `./${rel}`;
+        })();
+        importLines.push(`import { appProviders as __abs_globalProviders } from "${appProvidersSpec}";`);
+        fragments.push("...__abs_globalProviders");
+      }
       if (pageInjection.hasRoutes) {
         importLines.push(`import { provideRouter as __abs_provideRouter, withComponentInputBinding as __abs_withComponentInputBinding, withViewTransitions as __abs_withViewTransitions } from "@angular/router";`);
         fragments.push("__abs_provideRouter(routes, __abs_withComponentInputBinding(), __abs_withViewTransitions())");
@@ -4558,16 +5633,18 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
         importLines.push(`import { APP_BASE_HREF as __abs_APP_BASE_HREF } from "@angular/common";`);
         fragments.push(`{ provide: __abs_APP_BASE_HREF, useValue: ${JSON.stringify(pageInjection.basePath)} }`);
       }
-      rewritten += `
+      if (fragments.length > 0) {
+        rewritten += `
 /* __ABS_PROVIDERS_INJECTION_START */
 ${importLines.join(`
 `)}
 export const providers = [${fragments.join(", ")}];
 /* __ABS_PROVIDERS_INJECTION_END */
 `;
+      }
     }
     await traceAngularPhase("wrapper/write-server-output", () => fs.writeFile(rawServerFile, rewritten, "utf-8"), { entry: resolvedEntry });
-    const relativePath = relative4(indexesDir, rawServerFile).replace(/\\/g, "/");
+    const relativePath = relative5(indexesDir, rawServerFile).replace(/\\/g, "/");
     const normalizedImportPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
     const hmrPreamble = hmr ? `window.__HMR_FRAMEWORK__ = "angular";
 import "${hmrClientPath}";
@@ -4763,9 +5840,10 @@ var init_compileAngular = __esm(() => {
   init_stylePreprocessor();
   init_generatedDir();
   devClientDir = resolveDevClientDir();
-  hmrClientPath = join7(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath = join9(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
+  PROVIDERS_INJECTION_BLOCK_RE = /\n\/\* __ABS_PROVIDERS_INJECTION_START \*\/[\s\S]*?\/\* __ABS_PROVIDERS_INJECTION_END \*\/\n?/;
 });
 
 // src/core/streamingSlotRegistrar.ts
@@ -4931,13 +6009,11 @@ var provideDeterministicEnv = (options = {}) => {
 // src/angular/pageHandler.ts
 init_constants();
 import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
-import { mkdir as mkdir3, symlink } from "fs/promises";
-import { tmpdir } from "os";
-import { basename as basename4, dirname as dirname5, join as join8, resolve as resolve7 } from "path";
+import { lstat, mkdir as mkdir4, readlink, symlink } from "fs/promises";
+import { basename as basename5, dirname as dirname6, join as join10, resolve as resolve8 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/core/islandPageContext.ts
-init_constants();
 var BOOTSTRAP_MANIFEST_KEY = "BootstrapClient";
 var ISLAND_MARKER = 'data-island="true"';
 var MANIFEST_MARKER = "__ABSOLUTE_MANIFEST__";
@@ -4962,488 +6038,203 @@ var injectHeadMarkup = (html, markup) => {
       return `${html.slice(0, openingBodyIndex)}<head>${markup}</head>${html.slice(openingBodyIndex)}`;
     }
   }
-  return `<!DOCTYPE html><html><head>${markup}</head><body>${html}</body></html>`;
-};
-var streamChunkToString = (value, decoder) => typeof value === "string" ? value : decoder.decode(value, { stream: true });
-var flushSafePendingText = (controller, encoder, pending, lookbehind) => {
-  if (pending.length <= lookbehind) {
-    return pending;
-  }
-  const safeText = pending.slice(0, pending.length - lookbehind);
-  controller.enqueue(encoder.encode(safeText));
-  return pending.slice(-lookbehind);
-};
-var updateInjectedState = (consumed, injected, pending) => {
-  if (consumed.done) {
-    return { done: true, injected, pending };
-  }
-  return {
-    done: false,
-    injected: consumed.injected,
-    pending: consumed.pending
-  };
-};
-var readStreamChunk = async (reader) => {
-  const { done, value } = await reader.read();
-  if (done || !value) {
-    return { done, value: undefined };
-  }
-  return { done, value };
-};
-var pipeStreamWithHeadInjection = (stream, markup) => {
-  const encoder = new TextEncoder;
-  const decoder = new TextDecoder;
-  const lookbehind = CLOSING_HEAD_TAG.length - 1;
-  const processPending = (controller, pending, injected) => {
-    if (injected) {
-      controller.enqueue(encoder.encode(pending));
-      return { injected, pending: "" };
-    }
-    const headIndex = pending.indexOf(CLOSING_HEAD_TAG);
-    if (headIndex >= 0) {
-      const next = `${pending.slice(0, headIndex)}${markup}${pending.slice(headIndex)}`;
-      controller.enqueue(encoder.encode(next));
-      return { injected: true, pending: "" };
-    }
-    return {
-      injected,
-      pending: flushSafePendingText(controller, encoder, pending, lookbehind)
-    };
-  };
-  const finishHeadInjectionStream = (controller, pending, injected) => {
-    let finalPending = pending + decoder.decode();
-    if (!injected) {
-      finalPending = injectHeadMarkup(finalPending, markup);
-    }
-    if (finalPending.length > 0) {
-      controller.enqueue(encoder.encode(finalPending));
-    }
-    controller.close();
-  };
-  const consumeHeadChunk = async (controller, reader, pending, injected) => {
-    const { done, value } = await readStreamChunk(reader);
-    if (done || !value) {
-      return { done, injected, pending };
-    }
-    const processed = processPending(controller, pending + streamChunkToString(value, decoder), injected);
-    return {
-      done,
-      injected: processed.injected,
-      pending: processed.pending
-    };
-  };
-  const runHeadInjectionLoop = async (controller, reader) => {
-    const consumeNextHeadChunk = async (injected, pending) => {
-      const consumed = await consumeHeadChunk(controller, reader, pending, injected);
-      const nextState = updateInjectedState(consumed, injected, pending);
-      if (nextState.done) {
-        return { injected, pending };
-      }
-      return consumeNextHeadChunk(nextState.injected, nextState.pending);
-    };
-    return consumeNextHeadChunk(false, "");
-  };
-  return new ReadableStream({
-    async start(controller) {
-      const reader = stream.getReader();
-      try {
-        const { injected, pending } = await runHeadInjectionLoop(controller, reader);
-        finishHeadInjectionStream(controller, pending, injected);
-      } catch (error) {
-        controller.error(error);
-      }
-    }
-  });
-};
-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 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: "" };
-    }
-    return {
-      injected,
-      pending: flushSafePendingText(controller, encoder, pending, lookbehind)
-    };
-  };
-  const finishIslandMarkerStream = (controller, pending) => {
-    const finalPending = pending + decoder.decode();
-    if (finalPending.length > 0) {
-      controller.enqueue(encoder.encode(finalPending));
-    }
-    controller.close();
-  };
-  const consumeIslandChunk = async (controller, reader, pending, injected) => {
-    const { done, value } = await readStreamChunk(reader);
-    if (done || !value) {
-      return { done, injected, pending };
-    }
-    const processed = processPending(controller, pending + streamChunkToString(value, decoder), injected);
-    return {
-      done,
-      injected: processed.injected,
-      pending: processed.pending
-    };
-  };
-  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 };
-      }
-      return consumeNextIslandChunk(nextState.injected, nextState.pending);
-    };
-    return consumeNextIslandChunk(false, "");
-  };
-  return new ReadableStream({
-    async start(controller) {
-      const reader = stream.getReader();
-      try {
-        const { pending } = await runIslandMarkerLoop(controller, reader);
-        finishIslandMarkerStream(controller, pending);
-      } catch (error) {
-        controller.error(error);
-      }
-    }
-  });
-};
-var htmlContainsIslands = (html) => html.includes(ISLAND_MARKER);
-var injectIslandPageContext = (html, options) => {
-  const manifest = globalThis.__absoluteManifest;
-  const hasIslands = options?.hasIslands ?? htmlContainsIslands(html);
-  if (!manifest || !hasIslands) {
-    return html;
-  }
-  if (html.includes(MANIFEST_MARKER) || html.includes(ISLAND_STATE_MARKER)) {
-    return html;
-  }
-  return injectHeadMarkup(html, buildIslandsHeadMarkup(manifest));
-};
-var injectIslandPageContextStream = (stream, options) => {
-  const manifest = globalThis.__absoluteManifest;
-  if (!manifest)
-    return stream;
-  const markup = buildIslandsHeadMarkup(manifest);
-  if (options?.hasIslands === true) {
-    return pipeStreamWithHeadInjection(stream, markup);
-  }
-  if (options?.hasIslands === false) {
-    return stream;
-  }
-  return pipeStreamWithIslandMarkerDetection(stream, markup);
-};
-var setCurrentIslandManifest = (manifest) => {
-  globalThis.__absoluteManifest = manifest;
-};
-// 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)
-  });
-  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
-  });
-};
-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 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 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);
-};
-var renderEmberError = async () => null;
-var renderEmberNotFound = async () => null;
-var ERROR_RENDERERS = {
-  angular: renderAngularError,
-  ember: renderEmberError,
-  html: renderHtmlError,
-  react: renderReactError,
-  svelte: renderSvelteError,
-  vue: renderVueError
-};
-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);
-  }
-  return null;
+  return `<!DOCTYPE html><html><head>${markup}</head><body>${html}</body></html>`;
 };
-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 streamChunkToString = (value, decoder) => typeof value === "string" ? value : decoder.decode(value, { stream: true });
+var flushSafePendingText = (controller, encoder, pending, lookbehind) => {
+  if (pending.length <= lookbehind) {
+    return pending;
   }
-  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
-  });
+  const safeText = pending.slice(0, pending.length - lookbehind);
+  controller.enqueue(encoder.encode(safeText));
+  return pending.slice(-lookbehind);
 };
-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 updateInjectedState = (consumed, injected, pending) => {
+  if (consumed.done) {
+    return { done: true, injected, pending };
+  }
+  return {
+    done: false,
+    injected: consumed.injected,
+    pending: consumed.pending
+  };
 };
-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 readStreamChunk = async (reader) => {
+  const { done, value } = await reader.read();
+  if (done || !value) {
+    return { done, value: undefined };
+  }
+  return { done, value };
 };
-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
+var pipeStreamWithHeadInjection = (stream, markup) => {
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  const lookbehind = CLOSING_HEAD_TAG.length - 1;
+  const processPending = (controller, pending, injected) => {
+    if (injected) {
+      controller.enqueue(encoder.encode(pending));
+      return { injected, pending: "" };
+    }
+    const headIndex = pending.indexOf(CLOSING_HEAD_TAG);
+    if (headIndex >= 0) {
+      const next = `${pending.slice(0, headIndex)}${markup}${pending.slice(headIndex)}`;
+      controller.enqueue(encoder.encode(next));
+      return { injected: true, pending: "" };
+    }
+    return {
+      injected,
+      pending: flushSafePendingText(controller, encoder, pending, lookbehind)
+    };
+  };
+  const finishHeadInjectionStream = (controller, pending, injected) => {
+    let finalPending = pending + decoder.decode();
+    if (!injected) {
+      finalPending = injectHeadMarkup(finalPending, markup);
+    }
+    if (finalPending.length > 0) {
+      controller.enqueue(encoder.encode(finalPending));
+    }
+    controller.close();
+  };
+  const consumeHeadChunk = async (controller, reader, pending, injected) => {
+    const { done, value } = await readStreamChunk(reader);
+    if (done || !value) {
+      return { done, injected, pending };
+    }
+    const processed = processPending(controller, pending + streamChunkToString(value, decoder), injected);
+    return {
+      done,
+      injected: processed.injected,
+      pending: processed.pending
+    };
+  };
+  const runHeadInjectionLoop = async (controller, reader) => {
+    const consumeNextHeadChunk = async (injected, pending) => {
+      const consumed = await consumeHeadChunk(controller, reader, pending, injected);
+      const nextState = updateInjectedState(consumed, injected, pending);
+      if (nextState.done) {
+        return { injected, pending };
+      }
+      return consumeNextHeadChunk(nextState.injected, nextState.pending);
+    };
+    return consumeNextHeadChunk(false, "");
+  };
+  return new ReadableStream({
+    async start(controller) {
+      const reader = stream.getReader();
+      try {
+        const { injected, pending } = await runHeadInjectionLoop(controller, reader);
+        finishHeadInjectionStream(controller, pending, injected);
+      } catch (error) {
+        controller.error(error);
+      }
+    }
   });
 };
-var renderHtmlNotFound = async (conventionPath) => {
-  const html = await Bun.file(conventionPath).text();
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" },
-    status: 404
+var pipeStreamWithIslandMarkerDetection = (stream, markup) => {
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  const headLookbehind = CLOSING_HEAD_TAG.length - 1;
+  const enqueue = (controller, text) => {
+    if (text.length > 0) {
+      controller.enqueue(encoder.encode(text));
+    }
+  };
+  const processHolding = (controller, held) => {
+    if (!held.includes(ISLAND_MARKER)) {
+      return { held, injected: false, pending: "", sawHead: true };
+    }
+    enqueue(controller, `${markup}${held}`);
+    return { held: "", injected: true, pending: "", sawHead: true };
+  };
+  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
+      };
+    }
+    enqueue(controller, pending.slice(0, headIndex));
+    return processHolding(controller, pending.slice(headIndex));
+  };
+  const processChunk = (controller, state, chunk) => {
+    if (state.injected) {
+      enqueue(controller, chunk);
+      return state;
+    }
+    if (!state.sawHead) {
+      return processHead(controller, state.pending + chunk);
+    }
+    return processHolding(controller, state.held + chunk);
+  };
+  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 consumeNext(processChunk(controller, state, streamChunkToString(value, decoder)));
+    };
+    return consumeNext({
+      held: "",
+      injected: false,
+      pending: "",
+      sawHead: false
+    });
+  };
+  return new ReadableStream({
+    async start(controller) {
+      const reader = stream.getReader();
+      try {
+        const finalState = await runMarkerLoop(controller, reader);
+        finishMarkerStream(controller, finalState);
+      } catch (error) {
+        controller.error(error);
+      }
+    }
   });
 };
-var NOT_FOUND_RENDERERS = {
-  angular: renderAngularNotFound,
-  ember: renderEmberNotFound,
-  html: renderHtmlNotFound,
-  react: renderReactNotFound,
-  svelte: renderSvelteNotFound,
-  vue: renderVueNotFound
+var htmlContainsIslands = (html) => html.includes(ISLAND_MARKER);
+var injectIslandPageContext = (html, options) => {
+  const manifest = globalThis.__absoluteManifest;
+  const hasIslands = options?.hasIslands ?? htmlContainsIslands(html);
+  if (!manifest || !hasIslands) {
+    return html;
+  }
+  if (html.includes(MANIFEST_MARKER) || html.includes(ISLAND_STATE_MARKER)) {
+    return html;
+  }
+  return injectHeadMarkup(html, buildIslandsHeadMarkup(manifest));
 };
-var 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);
+var injectIslandPageContextStream = (stream, options) => {
+  const manifest = globalThis.__absoluteManifest;
+  if (!manifest)
+    return stream;
+  const markup = buildIslandsHeadMarkup(manifest);
+  if (options?.hasIslands === true) {
+    return pipeStreamWithHeadInjection(stream, markup);
   }
-  return null;
+  if (options?.hasIslands === false) {
+    return stream;
+  }
+  return pipeStreamWithIslandMarkerDetection(stream, markup);
 };
-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 setCurrentIslandManifest = (manifest) => {
+  globalThis.__absoluteManifest = manifest;
 };
 
 // src/angular/pageHandler.ts
+init_inlinePageCss();
+init_resolveConvention();
 init_registerClientScript();
 init_angularDeps();
 
@@ -5522,6 +6313,9 @@ var buildRouterRedirectProviders = async (deps, responseInit) => {
   ];
 };
 
+// src/angular/pageHandler.ts
+init_spaRouteManifest();
+
 // src/angular/lowerServerIslands.ts
 init_renderIslandMarkup();
 var ANGULAR_ISLAND_TAG_RE = /<absolute-island\b([^>]*)>[\s\S]*?<\/absolute-island>/gi;
@@ -5661,8 +6455,12 @@ var resetSsrSanitizer = () => {
   ssrSanitizer = null;
 };
 
+// src/angular/pageHandler.ts
+init_pageResponseCache();
+
 // src/core/responseEnhancers.ts
 init_streamingSlots();
+init_pageResponseCache();
 var toResponse = async (responseLike) => responseLike;
 var cloneHeaders = (response) => {
   const headers = new Headers(response.headers);
@@ -5686,8 +6484,10 @@ var enhanceHtmlResponseWithStreamingSlots = (response, {
     runtimePlacement,
     runtimePreludeScript
   });
+  const headers = cloneHeaders(response);
+  headers.set(STREAMING_PAGE_HEADER, "1");
   return new Response(body, {
-    headers: cloneHeaders(response),
+    headers,
     status: response.status,
     statusText: response.statusText
   });
@@ -5770,15 +6570,40 @@ var runWithStreamingSlotWarningScope = (task, metadata) => ensureWarningStorage(
 
 // src/angular/pageHandler.ts
 init_ssrRender();
-var lastSelector = "angular-page";
 var isRecord5 = (value) => typeof value === "object" && value !== null;
 var isAngularComponent2 = (value) => typeof value === "function";
+var componentHostsRouterOutlet = (component) => {
+  const componentDef = Reflect.get(component, "\u0275cmp");
+  if (!isRecord5(componentDef))
+    return false;
+  const rawDependencies = componentDef.dependencies;
+  const dependencies = typeof rawDependencies === "function" ? Reflect.apply(rawDependencies, undefined, []) : rawDependencies;
+  if (!Array.isArray(dependencies))
+    return false;
+  return dependencies.some((dependency) => {
+    if (dependency === null || typeof dependency !== "object" && typeof dependency !== "function")
+      return false;
+    const directiveDef = Reflect.get(dependency, "\u0275dir") ?? dependency;
+    if (!isRecord5(directiveDef))
+      return false;
+    const { selectors } = directiveDef;
+    return Array.isArray(selectors) && JSON.stringify(selectors).includes("router-outlet");
+  });
+};
 var resolvePageComponent = (pageModule) => {
   const defaultExport = pageModule.default;
   if (isAngularComponent2(defaultExport)) {
     return defaultExport;
   }
-  return Object.values(pageModule).findLast((value) => isAngularComponent2(value));
+  const components = Object.values(pageModule).filter(isAngularComponent2);
+  if (components.length <= 1) {
+    return components[0];
+  }
+  const outletHosts = components.filter(componentHostsRouterOutlet);
+  if (outletHosts.length === 1) {
+    return outletHosts[0];
+  }
+  return components.at(-1);
 };
 var compilerImportPromise = null;
 var ensureAngularCompiler = () => {
@@ -5790,27 +6615,48 @@ var ensureAngularCompiler = () => {
   return compilerImportPromise;
 };
 var readAngularPageModule = (value) => isRecord5(value) ? value : null;
-var resolveAngularSsrOutDir = () => process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR ?? join8(tmpdir(), "absolutejs", "generated", "angular-ssr");
+var resolveAngularSsrOutDir = (projectRoot = process.cwd(), configuredOutDir = process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR) => configuredOutDir ?? join10(projectRoot, ".absolutejs", "runtime", "angular-ssr");
 var createAngularRuntimeCacheBuster = () => `${Date.now().toString(BASE_36_RADIX)}.${Math.random().toString(BASE_36_RADIX).substring(2, RANDOM_ID_END_INDEX)}`;
-var ensureAngularSsrNodeModules = async (outDir) => {
-  const outRoot = resolve7(dirname5(dirname5(outDir)));
-  const nodeModulesLink = join8(outRoot, "node_modules");
-  if (process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR) {
+var existingNodeModulesLinkMatches = async (nodeModulesLink, expectedTarget) => {
+  try {
+    const stats = await lstat(nodeModulesLink);
+    if (!stats.isSymbolicLink()) {
+      throw new Error(`Refusing non-symlink Angular SSR dependency path: ${nodeModulesLink}`);
+    }
+    const target = resolve8(dirname6(nodeModulesLink), await readlink(nodeModulesLink));
+    if (target !== expectedTarget) {
+      throw new Error(`Refusing Angular SSR dependency link outside this project: ${target}`);
+    }
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+};
+var ensureAngularSsrNodeModules = async (outDir, projectRoot = process.cwd(), hasConfiguredOutDir = Boolean(process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR)) => {
+  const outRoot = resolve8(dirname6(dirname6(outDir)));
+  const nodeModulesLink = join10(outRoot, "node_modules");
+  if (hasConfiguredOutDir) {
     return;
   }
-  if (nodeModulesLink === resolve7(process.cwd(), "node_modules")) {
+  const expectedTarget = resolve8(projectRoot, "node_modules");
+  if (nodeModulesLink === expectedTarget) {
     return;
   }
-  if (await Bun.file(nodeModulesLink).exists()) {
+  if (await existingNodeModulesLinkMatches(nodeModulesLink, expectedTarget)) {
     return;
   }
-  await mkdir3(outRoot, { recursive: true });
+  await mkdir4(outRoot, { recursive: true });
   try {
-    await symlink(resolve7(process.cwd(), "node_modules"), nodeModulesLink, "dir");
+    await symlink(expectedTarget, nodeModulesLink, "dir");
   } catch (error) {
-    if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") {
+    if (!(error instanceof Error) || !("code" in error))
       throw error;
-    }
+    if (error.code !== "EEXIST")
+      throw error;
+    await existingNodeModulesLinkMatches(nodeModulesLink, expectedTarget);
   }
 };
 var resolveRuntimeAngularModulePath = async (pagePath) => {
@@ -5820,16 +6666,16 @@ var resolveRuntimeAngularModulePath = async (pagePath) => {
         const { stat } = await import("fs/promises");
         const stats = await stat(pagePath);
         return {
-          path: pagePath,
-          cacheBuster: stats.mtimeMs.toString(BASE_36_RADIX)
+          cacheBuster: stats.mtimeMs.toString(BASE_36_RADIX),
+          path: pagePath
         };
       } catch {
-        return { path: pagePath, cacheBuster: undefined };
+        return { cacheBuster: undefined, path: pagePath };
       }
     }
     return {
-      path: pagePath,
-      cacheBuster: undefined
+      cacheBuster: undefined,
+      path: pagePath
     };
   }
   const outDir = resolveAngularSsrOutDir();
@@ -5837,11 +6683,11 @@ var resolveRuntimeAngularModulePath = async (pagePath) => {
   const { compileAngularFileJIT: compileAngularFileJIT2 } = await Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular));
   const cacheBuster = createAngularRuntimeCacheBuster();
   const outputs = await compileAngularFileJIT2(pagePath, outDir, process.cwd(), undefined, cacheBuster);
-  const expectedFileName = basename4(pagePath).replace(/\.ts$/, ".js");
+  const expectedFileName = basename5(pagePath).replace(/\.ts$/, ".js");
   const runtimePagePath = outputs.find((output) => output.endsWith(`/${expectedFileName}`)) ?? outputs.find((output) => output.endsWith(`\\${expectedFileName}`)) ?? outputs[0] ?? pagePath;
   return {
-    path: runtimePagePath,
-    cacheBuster
+    cacheBuster,
+    path: runtimePagePath
   };
 };
 var buildRuntimeModuleSpecifier = (modulePath, cacheBuster) => {
@@ -5874,14 +6720,19 @@ setSsrContextGetter(() => angularSsrContext.getStore());
 var handleAngularPageRequest = async (input) => {
   const requestId = `angular_${Date.now()}_${Math.random().toString(BASE_36_RADIX).substring(2, RANDOM_ID_END_INDEX)}`;
   return angularSsrContext.run(requestId, async () => {
+    const spaNotFound = await renderSpaNotFound("angular", derivePageName(input.pagePath), input.request);
+    if (spaNotFound)
+      return withPageCacheHeaders(spaNotFound, input.request);
     await ensureAngularCompiler();
-    const resolvedHeadTag = input.headTag ?? "<head></head>";
+    const userHeadTag = input.headTag ?? "<head></head>";
     const resolvedIndexPath = input.indexPath;
     const options = input;
     const resolvedPagePath = input.pagePath;
     const maybeRequestContext = input.requestContext;
     const responseInit = input.responseInit ?? {};
     const resolvedUrl = resolveRequestRenderUrl(input.request);
+    const siblingCss = await readSiblingCss(resolvedPagePath);
+    const resolvedHeadTag = injectInlineCss(userHeadTag, siblingCss);
     cacheRouteData(resolvedPagePath, {
       headTag: resolvedHeadTag,
       requestContext: maybeRequestContext
@@ -5904,7 +6755,6 @@ var handleAngularPageRequest = async (input) => {
         const usesLegacyAnimations = pageModule.__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ === true;
         const deps = baseDeps;
         const selector = resolveSelector(deps, resolvedPagePath, PageComponent);
-        lastSelector = selector;
         const htmlString = `<!DOCTYPE html><html>${resolvedHeadTag}<body><${selector}></${selector}></body></html>`;
         resetSsrSanitizer();
         const sanitizer = getSsrSanitizer(deps);
@@ -5924,17 +6774,19 @@ var handleAngularPageRequest = async (input) => {
         const html = injectIslandPageContext(injectSsrScripts(htmlWithLoweredIslands, requestId, resolvedIndexPath, maybeRequestContext), { hasIslands: shouldProcessIslands });
         return new Response(html, withHtmlContentType(responseInit));
       };
-      return await runWithStreamingSlotWarningScope(() => options?.collectStreamingSlots === true ? withRegisteredStreamingSlots(renderPageResponse, options) : renderPageResponse(), { handlerCallsite });
+      const pageResponse = await runWithStreamingSlotWarningScope(() => options?.collectStreamingSlots === true ? withRegisteredStreamingSlots(renderPageResponse, options) : renderPageResponse(), { handlerCallsite });
+      return withPageCacheHeaders(pageResponse, input.request);
     } catch (error) {
       console.error("[SSR] Angular render error:", error);
       const pageName = derivePageName(resolvedPagePath);
       const conventionResponse = await renderConventionError("angular", pageName, error);
-      if (conventionResponse)
-        return conventionResponse;
-      return new Response(ssrErrorPage("angular", error), {
+      if (conventionResponse) {
+        return withPageCacheHeaders(conventionResponse, input.request);
+      }
+      return withPageCacheHeaders(new Response(ssrErrorPage("angular", error), {
         headers: { "Content-Type": "text/html" },
         status: 500
-      });
+      }), input.request);
     }
   });
 };
@@ -5960,5 +6812,5 @@ export {
   ABSOLUTE_HTTP_TRANSFER_CACHE_SKIP_HEADER
 };
 
-//# debugId=AEF6FBA51C59AAB664756E2164756E21
+//# debugId=61E1DD96B8611B8364756E2164756E21
 //# sourceMappingURL=server.js.map