@absolutejs/absolute 0.19.0-beta.852 → 0.19.0-beta.854

package/dist/index.js

@@ -8573,6 +8573,8 @@ var colors2, frameworkColors, formatPath = (filePath) => {
   console.error(`${timestamp} ${tag} ${fullMessage}`);
 }, logHmrUpdate = (path, framework, duration) => {
   log("hmr update", { duration, framework, path });
+}, logInfo = (message) => {
+  log(message);
 }, logScriptUpdate = (path, framework, duration) => {
   log("script update", { duration, framework, path });
 }, logServerReload = () => {
@@ -9823,19 +9825,87 @@ var init_angularLinkerPlugin = __esm(() => {
   angularLinkerPlugin = createAngularLinkerPlugin(false);
 });
 
+// src/dev/angular/hmrInjectionPlugin.ts
+var exports_hmrInjectionPlugin = {};
+__export(exports_hmrInjectionPlugin, {
+  createAngularHmrInjectionPlugin: () => createAngularHmrInjectionPlugin
+});
+import { readFile as readFile5 } from "fs/promises";
+import { relative as relative6, resolve as resolve15 } from "path";
+var COMPONENT_DECORATOR_RE, buildHmrTail = (className, encodedIdLiteral) => `
+
+// absolutejs HMR \u2014 auto-generated; mirrors compileHmrInitializer from
+// @angular/compiler with import.meta.hot adapted to globalThis.__angularHmr.
+{
+  const __ng_hmr_id = ${encodedIdLiteral};
+  const __ng_hmr_load = async (t) => {
+    const [u, core] = await Promise.all([
+      import('/@ng/component?c=' + encodeURIComponent(__ng_hmr_id) + '&t=' + t),
+      import('@angular/core')
+    ]);
+    if (u && typeof u.default === 'function') u.default(${className}, [core]);
+  };
+  if (typeof globalThis !== 'undefined' &&
+      globalThis.__angularHmr &&
+      typeof globalThis.__angularHmr.on === 'function') {
+    globalThis.__angularHmr.on('angular:component-update', (d) => {
+      if (d && d.id === __ng_hmr_id) __ng_hmr_load(d.timestamp);
+    });
+  }
+}
+`, createAngularHmrInjectionPlugin = (params) => {
+  const { generatedAngularRoot, userAngularRoot, projectRoot } = params;
+  const normalizedGenRoot = resolve15(generatedAngularRoot).replace(/\\/g, "/");
+  return {
+    name: "absolute-angular-hmr-injection",
+    setup(build2) {
+      build2.onLoad({ filter: /\.component\.js$/ }, async (args) => {
+        const normalizedPath = args.path.replace(/\\/g, "/");
+        if (!normalizedPath.startsWith(normalizedGenRoot + "/"))
+          return;
+        const text = await readFile5(args.path, "utf8");
+        const seen = new Set;
+        const classNames = [];
+        let match;
+        const re2 = new RegExp(COMPONENT_DECORATOR_RE.source, COMPONENT_DECORATOR_RE.flags);
+        while ((match = re2.exec(text)) !== null) {
+          const className = match[1];
+          if (className && !seen.has(className)) {
+            seen.add(className);
+            classNames.push(className);
+          }
+        }
+        if (classNames.length === 0)
+          return;
+        const relFromGenRoot = relative6(generatedAngularRoot, args.path).replace(/\\/g, "/");
+        const userTsPath = resolve15(userAngularRoot, relFromGenRoot.replace(/\.js$/, ".ts"));
+        const projectRel = relative6(projectRoot, userTsPath).replace(/\\/g, "/");
+        const tail = classNames.map((className) => {
+          const id = `${projectRel}@${className}`;
+          return buildHmrTail(className, JSON.stringify(id));
+        }).join("");
+        return { contents: text + tail, loader: "js" };
+      });
+    }
+  };
+};
+var init_hmrInjectionPlugin = __esm(() => {
+  COMPONENT_DECORATOR_RE = /([A-Z][A-Za-z0-9_$]*)\s*=\s*__legacyDecorateClassTS[A-Za-z0-9_$]*\s*\(\s*\[[\s\S]*?\bComponent[A-Za-z0-9_$]*\s*\(/g;
+});
+
 // src/utils/cleanStaleOutputs.ts
 import { rm as rm2 } from "fs/promises";
-import { resolve as resolve15 } from "path";
+import { resolve as resolve16 } from "path";
 var {Glob: Glob5 } = globalThis.Bun;
 var HASHED_FILE_PATTERN, cleanStaleOutputs = async (buildPath, currentOutputPaths) => {
-  const currentPaths = new Set(currentOutputPaths.map((path) => resolve15(path)));
+  const currentPaths = new Set(currentOutputPaths.map((path) => resolve16(path)));
   const glob = new Glob5("**/*");
   const removals = [];
-  for (const relative6 of glob.scanSync({ cwd: buildPath })) {
-    const absolute = resolve15(buildPath, relative6);
+  for (const relative7 of glob.scanSync({ cwd: buildPath })) {
+    const absolute = resolve16(buildPath, relative7);
     if (currentPaths.has(absolute))
       continue;
-    if (!HASHED_FILE_PATTERN.test(relative6))
+    if (!HASHED_FILE_PATTERN.test(relative7))
       continue;
     removals.push(rm2(absolute, { force: true }));
   }
@@ -10064,11 +10134,11 @@ var init_buildDirectoryLock = __esm(() => {
 });
 
 // src/utils/validateSafePath.ts
-import { resolve as resolve16, relative as relative6 } from "path";
+import { resolve as resolve17, relative as relative7 } from "path";
 var validateSafePath = (targetPath, baseDirectory) => {
-  const absoluteBase = resolve16(baseDirectory);
-  const absoluteTarget = resolve16(baseDirectory, targetPath);
-  const relativePath = normalizePath(relative6(absoluteBase, absoluteTarget));
+  const absoluteBase = resolve17(baseDirectory);
+  const absoluteTarget = resolve17(baseDirectory, targetPath);
+  const relativePath = normalizePath(relative7(absoluteBase, absoluteTarget));
   if (relativePath.startsWith("../") || relativePath === "..") {
     throw new Error(`Unsafe path: ${targetPath}`);
   }
@@ -10145,22 +10215,22 @@ import {
   join as join16,
   basename as basename5,
   extname as extname5,
-  resolve as resolve17,
-  relative as relative7,
+  resolve as resolve18,
+  relative as relative8,
   sep as sep2
 } from "path";
 import { env as env2 } from "process";
 var {write, file: file2, Transpiler } = globalThis.Bun;
 var resolveDevClientDir2 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve17(import.meta.dir, "../dev/client");
+  const fromSource = resolve18(import.meta.dir, "../dev/client");
   if (existsSync15(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve17(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve18(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync15(fromNodeModules))
     return fromNodeModules;
-  return resolve17(import.meta.dir, "./dev/client");
+  return resolve18(import.meta.dir, "./dev/client");
 }, devClientDir2, hmrClientPath3, persistentCache, sourceHashCache, clearSvelteCompilerCache = () => {
   persistentCache.clear();
   sourceHashCache.clear();
@@ -10190,7 +10260,7 @@ var resolveDevClientDir2 = () => {
 }, resolveRelativeModule2 = async (spec, from) => {
   if (!spec.startsWith("."))
     return null;
-  const basePath = resolve17(dirname11(from), spec);
+  const basePath = resolve18(dirname11(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -10217,7 +10287,7 @@ var resolveDevClientDir2 = () => {
     const resolved = resolvePackageImport(spec);
     return resolved && /\.svelte(\.(?:ts|js))?$/.test(resolved) ? resolved : null;
   }
-  const basePath = resolve17(dirname11(from), spec);
+  const basePath = resolve18(dirname11(from), spec);
   const explicit = /\.(svelte|svelte\.(?:ts|js))$/.test(basePath);
   if (!explicit) {
     const extensions = [".svelte", ".svelte.ts", ".svelte.js"];
@@ -10238,8 +10308,8 @@ var resolveDevClientDir2 = () => {
     return jsPath;
   return null;
 }, addModuleRewrite = (rewrites, rawSpec, resolvedModule, ssrOutputDir, clientOutputDir) => {
-  const toServer = relative7(ssrOutputDir, resolvedModule).replace(/\\/g, "/");
-  const toClient = relative7(clientOutputDir, resolvedModule).replace(/\\/g, "/");
+  const toServer = relative8(ssrOutputDir, resolvedModule).replace(/\\/g, "/");
+  const toClient = relative8(clientOutputDir, resolvedModule).replace(/\\/g, "/");
   rewrites.set(rawSpec, {
     client: toClient.startsWith(".") || toClient.startsWith("/") ? toClient : `./${toClient}`,
     server: toServer.startsWith(".") ? toServer : `./${toServer}`
@@ -10277,8 +10347,8 @@ var resolveDevClientDir2 = () => {
     const preprocessedClient = isModule ? loweredClientSource.code : (await preprocess(loweredClientSource.code, svelteStylePreprocessor)).code;
     const transpiledServer = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler2.transformSync(preprocessedServer) : preprocessedServer;
     const transpiledClient = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler2.transformSync(preprocessedClient) : preprocessedClient;
-    const rawRel = dirname11(relative7(svelteRoot, src)).replace(/\\/g, "/");
-    const relDir = rawRel.startsWith("..") ? `_ext/${relative7(process.cwd(), dirname11(src)).replace(/\\/g, "/")}` : rawRel;
+    const rawRel = dirname11(relative8(svelteRoot, src)).replace(/\\/g, "/");
+    const relDir = rawRel.startsWith("..") ? `_ext/${relative8(process.cwd(), dirname11(src)).replace(/\\/g, "/")}` : rawRel;
     const baseName = basename5(src).replace(/\.svelte(\.(ts|js))?$/, "");
     const importPaths = Array.from(transpiledServer.matchAll(/from\s+['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((path) => path !== undefined);
     const resolvedModuleImports = await Promise.all(importPaths.map((importPath) => resolveRelativeModule2(importPath, src)));
@@ -10299,15 +10369,15 @@ var resolveDevClientDir2 = () => {
         addModuleRewrite(externalRewrites, rawSpec, resolvedModule, ssrOutputDir, clientOutputDir);
       if (!resolved)
         continue;
-      const childRel = relative7(svelteRoot, resolved).replace(/\\/g, "/");
+      const childRel = relative8(svelteRoot, resolved).replace(/\\/g, "/");
       if (!childRel.startsWith(".."))
         continue;
       const childBuilt2 = cache.get(resolved);
       if (!childBuilt2)
         continue;
       const origSpec = rawSpec.replace(/\.svelte(?:\.(?:ts|js))?$/, ".js");
-      const toServer = relative7(ssrOutputDir, childBuilt2.ssr).replace(/\\/g, "/");
-      const toClient = relative7(clientOutputDir, childBuilt2.client).replace(/\\/g, "/");
+      const toServer = relative8(ssrOutputDir, childBuilt2.ssr).replace(/\\/g, "/");
+      const toClient = relative8(clientOutputDir, childBuilt2.client).replace(/\\/g, "/");
       externalRewrites.set(origSpec, {
         client: toClient.startsWith(".") ? toClient : `./${toClient}`,
         server: toServer.startsWith(".") ? toServer : `./${toServer}`
@@ -10341,7 +10411,7 @@ var resolveDevClientDir2 = () => {
       }).js.code;
       let code = compiled.replace(/\.svelte(?:\.(?:ts|js))?(['"])/g, ".js$1");
       if (mode === "client" && isDev2) {
-        const moduleKey = `/@src/${relative7(process.cwd(), src).replace(/\\/g, "/")}`;
+        const moduleKey = `/@src/${relative8(process.cwd(), src).replace(/\\/g, "/")}`;
         code = code.replace(/if\s*\(import\.meta\.hot\)\s*\{/, `if (typeof window !== "undefined") {
   if (!window.__SVELTE_HMR_ACCEPT__) window.__SVELTE_HMR_ACCEPT__ = {};
   var __hmr_accept = function(cb) { window.__SVELTE_HMR_ACCEPT__[${JSON.stringify(moduleKey)}] = cb; };`);
@@ -10384,10 +10454,10 @@ var resolveDevClientDir2 = () => {
   };
   const roots = await Promise.all(entryPoints.map(build2));
   await Promise.all(roots.map(async ({ client: client2, hasAwaitSlot }) => {
-    const relClientDir = dirname11(relative7(clientDir, client2));
+    const relClientDir = dirname11(relative8(clientDir, client2));
     const name = basename5(client2, extname5(client2));
     const indexPath = join16(indexDir, relClientDir, `${name}.js`);
-    const importRaw = relative7(dirname11(indexPath), client2).split(sep2).join("/");
+    const importRaw = relative8(dirname11(indexPath), client2).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev2 ? `window.__HMR_FRAMEWORK__ = "svelte";
 import "${hmrClientPath3}";
@@ -10464,7 +10534,7 @@ if (typeof window !== "undefined") {
   return {
     svelteClientPaths: roots.map(({ client: client2 }) => client2),
     svelteIndexPaths: roots.map(({ client: client2 }) => {
-      const rel = dirname11(relative7(clientDir, client2));
+      const rel = dirname11(relative8(clientDir, client2));
       return join16(indexDir, rel, basename5(client2));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
@@ -10553,20 +10623,20 @@ import {
   dirname as dirname12,
   isAbsolute as isAbsolute3,
   join as join17,
-  relative as relative8,
-  resolve as resolve18
+  relative as relative9,
+  resolve as resolve19
 } from "path";
 var {file: file3, write: write2, Transpiler: Transpiler2 } = globalThis.Bun;
 var resolveDevClientDir3 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve18(import.meta.dir, "../dev/client");
+  const fromSource = resolve19(import.meta.dir, "../dev/client");
   if (existsSync16(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve18(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve19(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync16(fromNodeModules))
     return fromNodeModules;
-  return resolve18(import.meta.dir, "./dev/client");
+  return resolve19(import.meta.dir, "./dev/client");
 }, devClientDir3, hmrClientPath4, transpiler3, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, clearVueHmrCaches = () => {
   scriptCache.clear();
   scriptSetupCache.clear();
@@ -10605,14 +10675,14 @@ var resolveDevClientDir3 = () => {
     return "template-only";
   }
   return "full";
-}, generateVueHmrId = (sourceFilePath, vueRootDir) => relative8(vueRootDir, sourceFilePath).replace(/\\/g, "/").replace(/\.vue$/, ""), extractImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => importPath !== undefined), toJs = (filePath, sourceDir) => {
+}, generateVueHmrId = (sourceFilePath, vueRootDir) => relative9(vueRootDir, sourceFilePath).replace(/\\/g, "/").replace(/\.vue$/, ""), extractImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => importPath !== undefined), toJs = (filePath, sourceDir) => {
   if (filePath.endsWith(".vue"))
     return filePath.replace(/\.vue$/, ".js");
   if (filePath.endsWith(".ts"))
     return filePath.replace(/\.ts$/, ".js");
   if (isStylePath(filePath)) {
     if (sourceDir && (filePath.startsWith("./") || filePath.startsWith("../"))) {
-      return resolve18(sourceDir, filePath);
+      return resolve19(sourceDir, filePath);
     }
     return filePath;
   }
@@ -10638,7 +10708,7 @@ var resolveDevClientDir3 = () => {
   const cachedResult = cacheMap.get(sourceFilePath);
   if (cachedResult)
     return cachedResult;
-  const relativeFilePath = relative8(vueRootDir, sourceFilePath).replace(/\\/g, "/");
+  const relativeFilePath = relative9(vueRootDir, sourceFilePath).replace(/\\/g, "/");
   const relativeWithoutExtension = relativeFilePath.replace(/\.vue$/, "");
   const fileBaseName = basename6(sourceFilePath, ".vue");
   const componentId = toKebab(fileBaseName);
@@ -10676,12 +10746,12 @@ var resolveDevClientDir3 = () => {
   const childComponentPaths = importPaths.filter((path) => path.startsWith(".") && path.endsWith(".vue"));
   const packageComponentPaths = Array.from(resolvedPackageVueImports.entries());
   const helperModulePaths = importPaths.filter((path) => path.startsWith(".") && !path.endsWith(".vue") && !isStylePath(path));
-  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute3(path)) && isStylePath(path)).map((path) => isAbsolute3(path) ? path : resolve18(dirname12(sourceFilePath), path));
+  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute3(path)) && isStylePath(path)).map((path) => isAbsolute3(path) ? path : resolve19(dirname12(sourceFilePath), path));
   for (const stylePath of stylePathsImported) {
     addStyleImporter(sourceFilePath, stylePath);
   }
   const childBuildResults = await Promise.all([
-    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve18(dirname12(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
+    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve19(dirname12(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
     ...packageComponentPaths.map(([, absolutePath]) => compileVueFile(absolutePath, outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors))
   ]);
   const hasScript = descriptor.script || descriptor.scriptSetup;
@@ -10772,7 +10842,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     let result2 = code;
     for (const [bareImport, paths] of packageImportRewrites) {
       const targetPath = mode === "server" ? paths.server : paths.client;
-      let rel = relative8(dirname12(outputPath), targetPath).replace(/\\/g, "/");
+      let rel = relative9(dirname12(outputPath), targetPath).replace(/\\/g, "/");
       if (!rel.startsWith("."))
         rel = `./${rel}`;
       result2 = result2.replaceAll(bareImport, rel);
@@ -10790,7 +10860,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     hmrId,
     serverPath: serverOutputPath,
     tsHelperPaths: [
-      ...helperModulePaths.map((helper) => resolve18(dirname12(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
+      ...helperModulePaths.map((helper) => resolve19(dirname12(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
       ...childBuildResults.flatMap((child) => child.tsHelperPaths)
     ]
   };
@@ -10813,7 +10883,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   const buildCache = new Map;
   const allTsHelperPaths = new Set;
   const compiledPages = await Promise.all(entryPoints.map(async (entryPath) => {
-    const result = await compileVueFile(resolve18(entryPath), {
+    const result = await compileVueFile(resolve19(entryPath), {
       client: clientOutputDir,
       css: cssOutputDir,
       server: serverOutputDir
@@ -10821,7 +10891,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     result.tsHelperPaths.forEach((path) => allTsHelperPaths.add(path));
     const entryBaseName = basename6(entryPath, ".vue");
     const indexOutputFile = join17(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join17(clientOutputDir, relative8(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    const clientOutputFile = join17(clientOutputDir, relative9(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
     await mkdir4(dirname12(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev2 ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
@@ -10829,7 +10899,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     ] : [];
     await write2(indexOutputFile, [
       ...vueHmrImports,
-      `import Comp, * as PageModule from "${relative8(dirname12(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
+      `import Comp, * as PageModule from "${relative9(dirname12(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
       'import { createSSRApp, createApp } from "vue";',
       "",
       "// HMR State Preservation: Check for preserved state from HMR",
@@ -10973,7 +11043,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   await Promise.all(Array.from(allTsHelperPaths).map(async (tsPath) => {
     const sourceCode = await file3(tsPath).text();
     const transpiledCode = transpiler3.transformSync(sourceCode);
-    const relativeJsPath = relative8(vueRootDir, tsPath).replace(/\.ts$/, ".js");
+    const relativeJsPath = relative9(vueRootDir, tsPath).replace(/\.ts$/, ".js");
     const outClientPath = join17(clientOutputDir, relativeJsPath);
     const outServerPath = join17(serverOutputDir, relativeJsPath);
     await mkdir4(dirname12(outClientPath), { recursive: true });
@@ -11478,17 +11548,17 @@ __export(exports_compileAngular, {
   compileAngular: () => compileAngular
 });
 import { existsSync as existsSync17, readFileSync as readFileSync13, promises as fs } from "fs";
-import { join as join18, basename as basename7, sep as sep3, dirname as dirname13, resolve as resolve19, relative as relative9 } from "path";
+import { join as join18, basename as basename7, sep as sep3, dirname as dirname13, resolve as resolve20, relative as relative10 } from "path";
 import ts2 from "typescript";
 var traceAngularPhase = async (name, fn2, metadata2) => {
   const tracePhase = globalThis.__absoluteBuildTracePhase;
   return tracePhase ? tracePhase(`compile/angular/${name}`, fn2, metadata2) : await fn2();
 }, readTsconfigPathAliases = () => {
   try {
-    const configPath2 = resolve19(process.cwd(), "tsconfig.json");
+    const configPath2 = resolve20(process.cwd(), "tsconfig.json");
     const config = ts2.readConfigFile(configPath2, ts2.sys.readFile).config;
     const compilerOptions = config?.compilerOptions ?? {};
-    const baseUrl = resolve19(process.cwd(), compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve20(process.cwd(), compilerOptions.baseUrl ?? ".");
     const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
     return { aliases, baseUrl };
   } catch {
@@ -11508,7 +11578,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     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(resolve19(baseUrl, candidate));
+      const resolved = resolveSourceFile(resolve20(baseUrl, candidate));
       if (resolved)
         return resolved;
     }
@@ -11527,13 +11597,13 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   ];
   return candidates.find((file4) => existsSync17(file4));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
-  const baseDir = resolve19(rootDir);
+  const baseDir = resolve20(rootDir);
   const tsconfigAliases = readTsconfigPathAliases();
   const transpiler4 = new Bun.Transpiler({ loader: "tsx" });
   const scanCache = new Map;
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile(resolve19(fromDir, specifier));
+      return resolveSourceFile(resolve20(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile);
     if (aliased)
@@ -11542,7 +11612,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve19(resolved);
+      const absolute = resolve20(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile(absolute);
@@ -11558,7 +11628,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
         usesLegacyAnimations: false
       });
     }
-    const resolved = resolve19(actualPath);
+    const resolved = resolve20(actualPath);
     const cached = scanCache.get(resolved);
     if (cached)
       return cached;
@@ -11587,7 +11657,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     const actualPath = resolveSourceFile(filePath);
     if (!actualPath)
       return false;
-    const resolved = resolve19(actualPath);
+    const resolved = resolve20(actualPath);
     if (visited.has(resolved))
       return false;
     visited.add(resolved);
@@ -11605,34 +11675,15 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   return (entryPath) => visit(entryPath);
 }, resolveDevClientDir4 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve19(import.meta.dir, "../dev/client");
+  const fromSource = resolve20(import.meta.dir, "../dev/client");
   if (existsSync17(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve19(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve20(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync17(fromNodeModules))
     return fromNodeModules;
-  return resolve19(import.meta.dir, "./dev/client");
-}, devClientDir4, hmrClientPath5, hmrRuntimePath, injectHMRRegistration = (content, sourceId) => {
-  const entityClassRegex = /(?:export\s+)?class\s+(\w+(?:Component|Service|Directive|Pipe))\s/g;
-  const entityNames = [];
-  let match;
-  while ((match = entityClassRegex.exec(content)) !== null) {
-    if (match[1])
-      entityNames.push(match[1]);
-  }
-  if (entityNames.length === 0)
-    return content;
-  const registrations = entityNames.map((name) => `  if (typeof ${name} === 'function') window.__ANGULAR_HMR__.register('${sourceId}#${name}', ${name});`).join(`
-`);
-  const hmrBlock = `
-// Angular HMR Runtime Layer (Level 3) \u2014 Auto-registration
-if (typeof window !== 'undefined' && window.__ANGULAR_HMR__) {
-${registrations}
-}
-`;
-  return content + hmrBlock;
-}, formatDiagnosticMessage = (diagnostic) => {
+  return resolve20(import.meta.dir, "./dev/client");
+}, devClientDir4, hmrClientPath5, formatDiagnosticMessage = (diagnostic) => {
   try {
     return ts2.flattenDiagnosticMessageText(diagnostic.messageText, `
 `);
@@ -11674,11 +11725,11 @@ ${registrations}
   if (hasJsLikeExtension(path))
     return `${path}${query}`;
   const importerDir = dirname13(importerOutputPath);
-  const fileCandidate = resolve19(importerDir, `${path}.js`);
+  const fileCandidate = resolve20(importerDir, `${path}.js`);
   if (outputFiles?.has(fileCandidate) || existsSync17(fileCandidate)) {
     return `${path}.js${query}`;
   }
-  const indexCandidate = resolve19(importerDir, path, "index.js");
+  const indexCandidate = resolve20(importerDir, path, "index.js");
   if (outputFiles?.has(indexCandidate) || existsSync17(indexCandidate)) {
     return `${path}/index.js${query}`;
   }
@@ -11706,7 +11757,7 @@ ${registrations}
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve19(dirname13(fromFile), specifier);
+  const basePath = resolve20(dirname13(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
@@ -11717,9 +11768,9 @@ ${registrations}
     join18(basePath, "index.mts"),
     join18(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve19(candidate)).find((candidate) => existsSync17(candidate) && !candidate.endsWith(".d.ts")) ?? null;
-}, readFileForAotTransform = async (fileName, readFile5) => {
-  const hostSource = readFile5?.(fileName);
+  return candidates.map((candidate) => resolve20(candidate)).find((candidate) => existsSync17(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+}, readFileForAotTransform = async (fileName, readFile6) => {
+  const hostSource = readFile6?.(fileName);
   if (typeof hostSource === "string")
     return hostSource;
   return fs.readFile(fileName, "utf-8");
@@ -11752,7 +11803,7 @@ ${registrations}
       paths.push(join18(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
-  return paths.map((path) => resolve19(path));
+  return paths.map((path) => resolve20(path));
 }, readResourceCacheFile = async (cachePath) => {
   try {
     const entry = JSON.parse(await fs.readFile(cachePath, "utf-8"));
@@ -11784,7 +11835,7 @@ ${registrations}
   ].join("\x00");
   const cacheKey2 = Bun.hash(cacheInput).toString(BASE_36_RADIX);
   return join18(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
-}, precomputeAotResourceTransforms = async (inputPaths, readFile5, stylePreprocessors) => {
+}, precomputeAotResourceTransforms = async (inputPaths, readFile6, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
   const stats = {
@@ -11794,14 +11845,14 @@ ${registrations}
     transformedFiles: 0
   };
   const transformFile = async (filePath) => {
-    const resolvedPath = resolve19(filePath);
+    const resolvedPath = resolve20(filePath);
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
     if (!existsSync17(resolvedPath) || resolvedPath.endsWith(".d.ts"))
       return;
     stats.filesVisited += 1;
-    const source = await readFileForAotTransform(resolvedPath, readFile5);
+    const source = await readFileForAotTransform(resolvedPath, readFile6);
     const cachePath = await resolveResourceTransformCachePath(resolvedPath, source, stylePreprocessors);
     const cached = await readResourceCacheFile(cachePath);
     let transformedSource;
@@ -11829,7 +11880,7 @@ ${registrations}
   return { stats, transformedSources };
 }, compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
   const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
-    const outputPath = resolve19(join18(outDir, relative9(process.cwd(), resolve19(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve20(join18(outDir, relative10(process.cwd(), resolve20(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
       buildIslandMetadataExports(readFileSync13(inputPath, "utf-8"))
@@ -11840,7 +11891,7 @@ ${registrations}
   const tsLibDir = await traceAngularPhase("aot/resolve-typescript-lib", () => {
     const tsPath = __require.resolve("typescript");
     const tsRootDir = dirname13(tsPath);
-    return tsRootDir.endsWith("lib") ? tsRootDir : resolve19(tsRootDir, "lib");
+    return tsRootDir.endsWith("lib") ? tsRootDir : resolve20(tsRootDir, "lib");
   });
   const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
   const options = {
@@ -11882,7 +11933,7 @@ ${registrations}
     return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
   };
   const emitted = {};
-  const resolvedOutDir = resolve19(outDir);
+  const resolvedOutDir = resolve20(outDir);
   host.writeFile = (fileName, text) => {
     const relativePath = resolveRelativePath(fileName, resolvedOutDir, outDir);
     emitted[relativePath] = text;
@@ -11904,12 +11955,12 @@ ${registrations}
     if (!fileName.endsWith(".ts") || fileName.endsWith(".d.ts")) {
       return source;
     }
-    const resolvedPath = resolve19(fileName);
+    const resolvedPath = resolve20(fileName);
     return transformedSources.get(resolvedPath) ?? source;
   };
   const originalGetSourceFileForCompile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
-    const source = transformedSources.get(resolve19(fileName));
+    const source = transformedSources.get(resolve20(fileName));
     if (source) {
       return ts2.createSourceFile(fileName, source, languageVersion, true);
     }
@@ -11933,7 +11984,7 @@ ${registrations}
       content,
       target: join18(outDir, fileName)
     }));
-    const outputFiles = new Set(rawEntries.map(({ target }) => resolve19(target)));
+    const outputFiles = new Set(rawEntries.map(({ target }) => resolve20(target)));
     return rawEntries.map(({ content, target }) => {
       let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
         const rewritten = rewriteRelativeJsSpecifier(target, path, outputFiles);
@@ -11948,7 +11999,7 @@ ${registrations}
         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(resolve19(target)) ?? "";
+      processedContent += islandMetadataByOutputPath.get(resolve20(target)) ?? "";
       return { content: processedContent, target };
     });
   });
@@ -11969,7 +12020,7 @@ ${registrations}
   }
   return null;
 }, resolveAngularDeferImportSpecifier = () => {
-  const sourceEntry = resolve19(import.meta.dir, "../angular/components/index.ts");
+  const sourceEntry = resolve20(import.meta.dir, "../angular/components/index.ts");
   if (existsSync17(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
@@ -12199,10 +12250,10 @@ ${fields}
     source: result
   };
 }, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors, cacheBuster) => {
-  const entryPath = resolve19(inputPath);
+  const entryPath = resolve20(inputPath);
   const allOutputs = [];
   const visited = new Set;
-  const baseDir = resolve19(rootDir ?? process.cwd());
+  const baseDir = resolve20(rootDir ?? process.cwd());
   let usesLegacyAnimations = false;
   const angularTranspiler = new Bun.Transpiler({
     loader: "ts",
@@ -12229,7 +12280,7 @@ ${fields}
   };
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile2(resolve19(fromDir, specifier));
+      return resolveSourceFile2(resolve20(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile2);
     if (aliased)
@@ -12238,7 +12289,7 @@ ${fields}
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve19(resolved);
+      const absolute = resolve20(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile2(absolute);
@@ -12287,13 +12338,13 @@ ${fields}
         return `${prefix}${dots}`;
       return `${prefix}../${dots}`;
     });
-    if (resolve19(actualPath) === entryPath) {
+    if (resolve20(actualPath) === entryPath) {
       processedContent += buildIslandMetadataExports(sourceCode);
     }
     return processedContent;
   };
   const transpileFile = async (filePath) => {
-    const resolved = resolve19(filePath);
+    const resolved = resolve20(filePath);
     if (visited.has(resolved))
       return;
     visited.add(resolved);
@@ -12330,7 +12381,7 @@ ${fields}
       const resolved2 = resolveLocalImport(specifier, inputDir);
       if (!resolved2)
         return null;
-      const relativeImport = relative9(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
+      const relativeImport = relative10(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
       const relativeRewrite = relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`;
       importRewrites.set(specifier, relativeRewrite);
       return resolved2;
@@ -12370,11 +12421,11 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
   const compiledRoot = compiledParent;
   const indexesDir = join18(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) => resolve19(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
+  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve20(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
   const compileTasks = entryPoints.map(async (entry) => {
-    const resolvedEntry = resolve19(entry);
-    const relativeEntry = relative9(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
+    const resolvedEntry = resolve20(entry);
+    const relativeEntry = relative10(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
     const compileEntry = () => compileAngularFileJIT(resolvedEntry, compiledRoot, outRoot, stylePreprocessors);
     let outputs = hmr ? await traceAngularPhase("jit/compile-entry", compileEntry, {
       entry: resolvedEntry
@@ -12385,10 +12436,10 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
       join18(compiledRoot, relativeEntry),
       join18(compiledRoot, "pages", jsName),
       join18(compiledRoot, jsName)
-    ].map((file4) => resolve19(file4));
+    ].map((file4) => resolve20(file4));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
-        ...candidatePaths.map((file4) => resolve19(file4)),
+        ...candidatePaths.map((file4) => resolve20(file4)),
         ...compiledFallbackPaths
       ];
       let candidate = normalizedCandidates.find((file4) => existsSync17(file4) && file4.endsWith(`${sep3}pages${sep3}${jsName}`));
@@ -12455,14 +12506,10 @@ export default ${componentClassName};
 export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
 `;
     }
-    if (hmr) {
-      rewritten = injectHMRRegistration(rewritten, resolvedEntry);
-    }
     await traceAngularPhase("wrapper/write-server-output", () => fs.writeFile(rawServerFile, rewritten, "utf-8"), { entry: resolvedEntry });
-    const relativePath = relative9(indexesDir, rawServerFile).replace(/\\/g, "/");
+    const relativePath = relative10(indexesDir, rawServerFile).replace(/\\/g, "/");
     const normalizedImportPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
     const hmrPreamble = hmr ? `window.__HMR_FRAMEWORK__ = "angular";
-import "${hmrRuntimePath}";
 import "${hmrClientPath5}";
 ` : "";
     const hydration = hmr ? `${hmrPreamble}
@@ -12504,68 +12551,66 @@ var absoluteHttpTransferCacheOptions = {
     }
 };
 
-// Re-export the page module so HMR fast-patch (in handlers/angular.ts) can
-// dynamically import this chunk and discover the freshly-built component
-// classes without needing a separate build artifact.
-export * from '${normalizedImportPath}';
-
-// Record this evaluation's \`routes\` and \`providers\` exports for the
-// HMR fast-patch to compare against on the next reload. If they change
-// (a new route was added, a provider was edited), fast-patch falls back
-// to a full re-bootstrap because those values are consumed once at
-// bootstrap and won't propagate to the running router/injector via an
-// in-place component patch.
-if (typeof window !== 'undefined' && window.__ANGULAR_HMR__ && typeof window.__ANGULAR_HMR__.recordPageExports === 'function') {
-    var __abs_hmr_routes = Reflect.get(pageModule, 'routes');
-    window.__ANGULAR_HMR__.recordPageExports('${resolvedEntry}', __abs_hmr_routes, maybePageProviders);
-}
-
-// Re-Bootstrap HMR with View Transitions API.
-// Skipped during fast-patch: the HMR client sets
-// window.__ANGULAR_HMR_FAST_PATCH__ = true before \`import()\`-ing this
-// chunk so it can read the new component classes via \`export *\` above
-// without destroying the running app.
-if (!window.__ANGULAR_HMR_FAST_PATCH__) {
-    if (window.__ANGULAR_APP__) {
-        try { window.__ANGULAR_APP__.destroy(); } catch (_err) { /* ignore */ }
-        window.__ANGULAR_APP__ = null;
-    }
-
-    // Ensure root element exists after destroy (Angular removes it)
-    var _sel = ${componentClassName}.\u0275cmp?.selectors?.[0]?.[0] || 'ng-app';
-    if (!document.querySelector(_sel)) {
-        (document.getElementById('root') || document.body).appendChild(document.createElement(_sel));
-    }
-
-    var providers = [provideZonelessChangeDetection()];
-    if (!window.__HMR_SKIP_HYDRATION__ && !pageHasIslands) {
-        providers.push(provideClientHydration(withHttpTransferCacheOptions(absoluteHttpTransferCacheOptions)));
-    }
-    delete window.__HMR_SKIP_HYDRATION__;
-    providers.push.apply(providers, pageProviders);
-    providers.push.apply(providers, propProviders);
-    window.__ABS_SLOT_HYDRATION_PENDING__ = pageHasRawStreamingSlots;
-
-    if (pageHasRawStreamingSlots) {
+// SURGICAL_HMR Tier 1 \u2014 Re-bootstrap hook. The dev client invokes
+// \`window.__ABS_ANGULAR_REBOOTSTRAP__()\` when it receives an
+// \`angular:rebootstrap\` WS message; the hook looks up this page's
+// freshly-built bundle URL (the rebuild already broadcast its
+// updated manifest, so window.__HMR_MANIFEST__ is current) and
+// dynamic-imports it. Re-importing the chunk re-runs the
+// destroy+bootstrap block below \u2014 no special path needed because
+// chunk eval is the bootstrap.
+window.__ABS_ANGULAR_PAGE_BUNDLE_ID__ = '${toPascal(fileBase)}Index';
+window.__ABS_ANGULAR_REBOOTSTRAP__ = async function() {
+    var id = window.__ABS_ANGULAR_PAGE_BUNDLE_ID__;
+    var manifest = window.__HMR_MANIFEST__ || {};
+    var newUrl = manifest[id];
+    if (!newUrl) {
+        console.warn('[absolutejs] no bundle URL in manifest for', id, '\u2014 full reload');
+        window.location.reload();
+        return;
+    }
+    await import(newUrl + '?t=' + Date.now());
+};
+
+if (window.__ANGULAR_APP__) {
+    try { window.__ANGULAR_APP__.destroy(); } catch (_err) { /* ignore */ }
+    window.__ANGULAR_APP__ = null;
+}
+
+// Ensure root element exists after destroy (Angular removes it)
+var _sel = ${componentClassName}.\u0275cmp?.selectors?.[0]?.[0] || 'ng-app';
+if (!document.querySelector(_sel)) {
+    (document.getElementById('root') || document.body).appendChild(document.createElement(_sel));
+}
+
+var providers = [provideZonelessChangeDetection()];
+if (!window.__HMR_SKIP_HYDRATION__ && !pageHasIslands) {
+    providers.push(provideClientHydration(withHttpTransferCacheOptions(absoluteHttpTransferCacheOptions)));
+}
+delete window.__HMR_SKIP_HYDRATION__;
+providers.push.apply(providers, pageProviders);
+providers.push.apply(providers, propProviders);
+window.__ABS_SLOT_HYDRATION_PENDING__ = pageHasRawStreamingSlots;
+
+if (pageHasRawStreamingSlots) {
+    window.__ABS_SLOT_HYDRATION_PENDING__ = false;
+    if (typeof window.__ABS_SLOT_FLUSH__ === 'function') {
+        requestAnimationFrame(function() {
+            window.__ABS_SLOT_FLUSH__();
+        });
+    }
+} else {
+    bootstrapApplication(${componentClassName}, {
+        providers: providers
+    }).then(function (appRef) {
+        window.__ANGULAR_APP__ = appRef;
         window.__ABS_SLOT_HYDRATION_PENDING__ = false;
         if (typeof window.__ABS_SLOT_FLUSH__ === 'function') {
             requestAnimationFrame(function() {
                 window.__ABS_SLOT_FLUSH__();
             });
         }
-    } else {
-        bootstrapApplication(${componentClassName}, {
-            providers: providers
-        }).then(function (appRef) {
-            window.__ANGULAR_APP__ = appRef;
-            window.__ABS_SLOT_HYDRATION_PENDING__ = false;
-            if (typeof window.__ABS_SLOT_FLUSH__ === 'function') {
-                requestAnimationFrame(function() {
-                    window.__ABS_SLOT_FLUSH__();
-                });
-            }
-        });
-    }
+    });
 }
 `.trim() : `
 import '@angular/compiler';
@@ -12667,7 +12712,6 @@ var init_compileAngular = __esm(() => {
   init_generatedDir();
   devClientDir4 = resolveDevClientDir4();
   hmrClientPath5 = join18(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
-  hmrRuntimePath = join18(devClientDir4, "handlers", "angularRuntime.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
 });
@@ -13121,7 +13165,7 @@ __export(exports_compileEmber, {
 });
 import { existsSync as existsSync18 } from "fs";
 import { mkdir as mkdir5, rm as rm4 } from "fs/promises";
-import { basename as basename8, dirname as dirname14, extname as extname6, join as join19, resolve as resolve20 } from "path";
+import { basename as basename8, dirname as dirname14, extname as extname6, join as join19, resolve as resolve21 } from "path";
 var {build: bunBuild2, Transpiler: Transpiler3, write: write3, file: file4 } = globalThis.Bun;
 var cachedPreprocessor = null, getPreprocessor = async () => {
   if (cachedPreprocessor)
@@ -13217,7 +13261,7 @@ export const importSync = (specifier) => {
         const originalImporter = stagedSourceMap.get(args.importer);
         if (!originalImporter)
           return;
-        const candidateBase = resolve20(dirname14(originalImporter), args.path);
+        const candidateBase = resolve21(dirname14(originalImporter), args.path);
         const extensionsToTry = ["", ".gts", ".gjs", ".ts", ".js"];
         for (const ext of extensionsToTry) {
           const candidate = candidateBase + ext;
@@ -13276,7 +13320,7 @@ export const renderToHTML = (props = {}) => {
 export { PageComponent };
 export default PageComponent;
 `, compileEmberFile = async (entry, compiledRoot, cwd = process.cwd()) => {
-  const resolvedEntry = resolve20(entry);
+  const resolvedEntry = resolve21(entry);
   const source = await file4(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -13296,8 +13340,8 @@ export default PageComponent;
     mkdir5(serverDir, { recursive: true }),
     mkdir5(clientDir, { recursive: true })
   ]);
-  const tmpPagePath = resolve20(join19(tmpDir, `${baseName}.module.js`));
-  const tmpHarnessPath = resolve20(join19(tmpDir, `${baseName}.harness.js`));
+  const tmpPagePath = resolve21(join19(tmpDir, `${baseName}.module.js`));
+  const tmpHarnessPath = resolve21(join19(tmpDir, `${baseName}.harness.js`));
   await Promise.all([
     write3(tmpPagePath, transpiled),
     write3(tmpHarnessPath, generateServerHarness(tmpPagePath))
@@ -13339,7 +13383,7 @@ export default PageComponent;
     serverPaths: outputs.map((o) => o.serverPath)
   };
 }, compileEmberFileSource = async (entry) => {
-  const resolvedEntry = resolve20(entry);
+  const resolvedEntry = resolve21(entry);
   const source = await file4(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -13372,24 +13416,24 @@ __export(exports_buildReactVendor, {
   buildReactVendor: () => buildReactVendor
 });
 import { existsSync as existsSync19, mkdirSync as mkdirSync7 } from "fs";
-import { join as join20, resolve as resolve21 } from "path";
+import { join as join20, resolve as resolve22 } from "path";
 import { rm as rm5 } from "fs/promises";
 var {build: bunBuild3 } = globalThis.Bun;
 var resolveJsxDevRuntimeCompatPath = () => {
   const candidates = [
-    resolve21(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
-    resolve21(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve21(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve21(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve21(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve21(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve22(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
+    resolve22(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve22(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve22(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve22(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve22(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
     if (existsSync19(candidate)) {
       return candidate.replace(/\\/g, "/");
     }
   }
-  return (candidates[0] ?? resolve21(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
+  return (candidates[0] ?? resolve22(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
 }, jsxDevRuntimeCompatPath, reactSpecifiers, isResolvable = (specifier) => {
   try {
     Bun.resolveSync(specifier, process.cwd());
@@ -14039,7 +14083,7 @@ import {
   statSync,
   writeFileSync as writeFileSync8
 } from "fs";
-import { basename as basename9, dirname as dirname15, extname as extname7, join as join25, relative as relative10, resolve as resolve22 } from "path";
+import { basename as basename9, dirname as dirname15, extname as extname7, join as join25, relative as relative11, resolve as resolve23 } from "path";
 import { cwd, env as env3, exit } from "process";
 var {build: bunBuild7, Glob: Glob7 } = globalThis.Bun;
 var isDev2, isBuildTraceEnabled = () => {
@@ -14130,8 +14174,8 @@ var isDev2, isBuildTraceEnabled = () => {
   }
 }, resolveAbsoluteVersion = async () => {
   const candidates = [
-    resolve22(import.meta.dir, "..", "..", "package.json"),
-    resolve22(import.meta.dir, "..", "package.json")
+    resolve23(import.meta.dir, "..", "..", "package.json"),
+    resolve23(import.meta.dir, "..", "package.json")
   ];
   const resolveCandidate = async (remaining) => {
     const [candidate, ...rest] = remaining;
@@ -14147,7 +14191,7 @@ var isDev2, isBuildTraceEnabled = () => {
   };
   await resolveCandidate(candidates);
 }, SKIP_DIRS, addWorkerPathIfExists = (file5, relPath, workerPaths) => {
-  const absPath = resolve22(file5, "..", relPath);
+  const absPath = resolve23(file5, "..", relPath);
   try {
     statSync(absPath);
     workerPaths.add(absPath);
@@ -14209,7 +14253,7 @@ var isDev2, isBuildTraceEnabled = () => {
     return;
   }
   const indexFiles = readDir(reactIndexesPath).filter((file5) => file5.endsWith(".tsx"));
-  const pagesRel = relative10(process.cwd(), resolve22(reactPagesPath)).replace(/\\/g, "/");
+  const pagesRel = relative11(process.cwd(), resolve23(reactPagesPath)).replace(/\\/g, "/");
   for (const file5 of indexFiles) {
     let content = readFileSync14(join25(reactIndexesPath, file5), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
@@ -14217,27 +14261,27 @@ var isDev2, isBuildTraceEnabled = () => {
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
   const svelteIndexDir = join25(getFrameworkGeneratedDir("svelte"), "indexes");
-  const sveltePageEntries = svelteEntries.filter((file5) => resolve22(file5).startsWith(resolve22(sveltePagesPath)));
+  const sveltePageEntries = svelteEntries.filter((file5) => resolve23(file5).startsWith(resolve23(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename9(entry).replace(/\.svelte(\.(ts|js))?$/, "");
     const indexFile = join25(svelteIndexDir, "pages", `${name}.js`);
     if (!existsSync20(indexFile))
       continue;
     let content = readFileSync14(indexFile, "utf-8");
-    const srcRel = relative10(process.cwd(), resolve22(entry)).replace(/\\/g, "/");
+    const srcRel = relative11(process.cwd(), resolve23(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
     writeFileSync8(join25(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
   const vueIndexDir = join25(getFrameworkGeneratedDir("vue"), "indexes");
-  const vuePageEntries = vueEntries.filter((file5) => resolve22(file5).startsWith(resolve22(vuePagesPath)));
+  const vuePageEntries = vueEntries.filter((file5) => resolve23(file5).startsWith(resolve23(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename9(entry, ".vue");
     const indexFile = join25(vueIndexDir, `${name}.js`);
     if (!existsSync20(indexFile))
       continue;
     let content = readFileSync14(indexFile, "utf-8");
-    const srcRel = relative10(process.cwd(), resolve22(entry)).replace(/\\/g, "/");
+    const srcRel = relative11(process.cwd(), resolve23(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Comp(?:\s*,\s*\*\s+as\s+\w+)?\s+from\s+['"]([^'"]+)['"]/, (match) => match.replace(/from\s+['"][^'"]+['"]/, `from "/@src/${srcRel}"`));
     writeFileSync8(join25(devIndexDir, `${name}.vue.js`), content);
   }
@@ -14250,7 +14294,7 @@ var isDev2, isBuildTraceEnabled = () => {
   const last = allComments[allComments.length - 1];
   if (!last?.[1])
     return JSON.stringify(outputPath);
-  const srcPath = resolve22(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
+  const srcPath = resolve23(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
   return JSON.stringify(srcPath);
 }, QUOTE_CHARS, OPEN_BRACES, CLOSE_BRACES, findFunctionExpressionEnd = (content, startPos) => {
   let depth = 0;
@@ -14312,7 +14356,7 @@ ${content.slice(firstUseIdx)}`;
 }, buildDevUrlFileMap = (urlReferencedFiles, projectRoot) => {
   const urlFileMap = new Map;
   for (const srcPath of urlReferencedFiles) {
-    const rel = relative10(projectRoot, srcPath).replace(/\\/g, "/");
+    const rel = relative11(projectRoot, srcPath).replace(/\\/g, "/");
     const name = basename9(srcPath);
     const mtime = Math.round(statSync(srcPath).mtimeMs);
     const url = `/@src/${rel}?v=${mtime}`;
@@ -14327,7 +14371,7 @@ ${content.slice(firstUseIdx)}`;
     const output = nonReactClientOutputs.find((artifact) => basename9(artifact.path).startsWith(`${srcBase}.`));
     if (!output)
       continue;
-    urlFileMap.set(basename9(srcPath), `/${relative10(buildPath, output.path).replace(/\\/g, "/")}`);
+    urlFileMap.set(basename9(srcPath), `/${relative11(buildPath, output.path).replace(/\\/g, "/")}`);
   }
   return urlFileMap;
 }, buildUrlFileMap = (urlReferencedFiles, hmr, projectRoot, buildPath, nonReactClientOutputs) => {
@@ -14575,13 +14619,13 @@ ${content.slice(firstUseIdx)}`;
   const filterToIncrementalEntries = (entryPoints, mapToSource) => {
     if (!isIncremental || !incrementalFiles)
       return entryPoints;
-    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve22(f2)));
+    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve23(f2)));
     const matchingEntries = [];
     for (const entry of entryPoints) {
       const sourceFile = mapToSource(entry);
       if (!sourceFile)
         continue;
-      if (!normalizedIncremental.has(resolve22(sourceFile)))
+      if (!normalizedIncremental.has(resolve23(sourceFile)))
         continue;
       matchingEntries.push(entry);
     }
@@ -14643,7 +14687,7 @@ ${content.slice(firstUseIdx)}`;
   }
   const shouldIncludeHtmlAssets = !isIncremental || normalizedIncrementalFiles?.some((f2) => f2.includes("/html/") && (f2.endsWith(".html") || isStylePath(f2)));
   const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
-    if (entry.startsWith(resolve22(reactIndexesPath))) {
+    if (entry.startsWith(resolve23(reactIndexesPath))) {
       const pageName = basename9(entry, ".tsx");
       return join25(reactPagesPath, `${pageName}.tsx`);
     }
@@ -14722,7 +14766,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandSvelteClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandSvelteClientPathMap.set(resolve22(sourcePath), clientPath);
+    islandSvelteClientPathMap.set(resolve23(sourcePath), clientPath);
   }
   const islandVueClientPathMap = new Map;
   for (let idx = 0;idx < islandVueSources.length; idx++) {
@@ -14730,7 +14774,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandVueClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandVueClientPathMap.set(resolve22(sourcePath), clientPath);
+    islandVueClientPathMap.set(resolve23(sourcePath), clientPath);
   }
   const islandAngularClientPathMap = new Map;
   for (let idx = 0;idx < islandAngularSources.length; idx++) {
@@ -14738,7 +14782,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandAngularClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandAngularClientPathMap.set(resolve22(sourcePath), clientPath);
+    islandAngularClientPathMap.set(resolve23(sourcePath), clientPath);
   }
   const reactConventionSources = collectConventionSourceFiles(conventionsMap.react);
   const svelteConventionSources = collectConventionSourceFiles(conventionsMap.svelte);
@@ -15051,6 +15095,13 @@ ${content.slice(firstUseIdx)}`;
       outdir: buildPath,
       plugins: [
         stylePreprocessorPlugin2,
+        ...angularDir && hmr ? [
+          createAngularHmrInjectionPlugin({
+            generatedAngularRoot: getFrameworkGeneratedDir("angular", projectRoot),
+            projectRoot,
+            userAngularRoot: angularDir
+          })
+        ] : [],
         ...angularDir ? [createAngularLinkerPlugin(hmr)] : [],
         ...htmlScriptPlugin ? [htmlScriptPlugin] : []
       ],
@@ -15071,6 +15122,13 @@ ${content.slice(firstUseIdx)}`;
       outdir: buildPath,
       plugins: [
         stylePreprocessorPlugin2,
+        ...angularDir && hmr ? [
+          createAngularHmrInjectionPlugin({
+            generatedAngularRoot: getFrameworkGeneratedDir("angular", projectRoot),
+            projectRoot,
+            userAngularRoot: angularDir
+          })
+        ] : [],
         ...angularDir ? [createAngularLinkerPlugin(hmr)] : []
       ],
       root: islandEntryResult.generatedRoot,
@@ -15161,7 +15219,7 @@ ${content.slice(firstUseIdx)}`;
       const fileDir = dirname15(artifact.path);
       const relativePaths = {};
       for (const [specifier, absolute] of Object.entries(angularServerVendorPaths2)) {
-        const rel = relative10(fileDir, absolute);
+        const rel = relative11(fileDir, absolute);
         relativePaths[specifier] = rel.startsWith(".") ? rel : `./${rel}`;
       }
       return relativePaths;
@@ -15366,6 +15424,7 @@ var init_build = __esm(() => {
   init_rewriteReactImports();
   init_telemetryEvent();
   init_angularLinkerPlugin();
+  init_hmrInjectionPlugin();
   init_cleanStaleOutputs();
   init_cleanup();
   init_commonAncestor();
@@ -15580,7 +15639,7 @@ var init_buildEmberVendor = __esm(() => {
 // src/dev/dependencyGraph.ts
 import { existsSync as existsSync22, readFileSync as readFileSync15 } from "fs";
 var {Glob: Glob8 } = globalThis.Bun;
-import { resolve as resolve23 } from "path";
+import { resolve as resolve24 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
   const lower = filePath.toLowerCase();
   if (lower.endsWith(".ts") || lower.endsWith(".tsx") || lower.endsWith(".jsx"))
@@ -15594,8 +15653,8 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
     return null;
   }
-  const fromDir = resolve23(fromFile, "..");
-  const normalized = resolve23(fromDir, importPath);
+  const fromDir = resolve24(fromFile, "..");
+  const normalized = resolve24(fromDir, importPath);
   const extensions = [
     ".ts",
     ".tsx",
@@ -15625,7 +15684,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     dependents.delete(normalizedPath);
   }
 }, addFileToGraph = (graph, filePath) => {
-  const normalizedPath = resolve23(filePath);
+  const normalizedPath = resolve24(filePath);
   if (!existsSync22(normalizedPath))
     return;
   const dependencies = extractDependencies(normalizedPath);
@@ -15642,10 +15701,10 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
 }, IGNORED_SEGMENTS, buildInitialDependencyGraph = (graph, directories) => {
   const processedFiles = new Set;
   const glob = new Glob8("**/*.{ts,tsx,js,jsx,vue,svelte,html,htm}");
-  const resolvedDirs = directories.map((dir) => resolve23(dir)).filter((dir) => existsSync22(dir));
+  const resolvedDirs = directories.map((dir) => resolve24(dir)).filter((dir) => existsSync22(dir));
   const allFiles = resolvedDirs.flatMap((dir) => Array.from(glob.scanSync({ absolute: true, cwd: dir })));
   for (const file5 of allFiles) {
-    const fullPath = resolve23(file5);
+    const fullPath = resolve24(file5);
     if (IGNORED_SEGMENTS.some((seg) => fullPath.includes(seg)))
       continue;
     if (processedFiles.has(fullPath))
@@ -15758,7 +15817,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     return [];
   }
 }, getAffectedFiles = (graph, changedFile) => {
-  const normalizedPath = resolve23(changedFile);
+  const normalizedPath = resolve24(changedFile);
   const affected = new Set;
   const toProcess = [normalizedPath];
   const processNode = (current) => {
@@ -15798,7 +15857,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   }
   graph.dependents.delete(normalizedPath);
 }, removeFileFromGraph = (graph, filePath) => {
-  const normalizedPath = resolve23(filePath);
+  const normalizedPath = resolve24(filePath);
   removeDepsForFile(graph, normalizedPath);
   removeDependentsForFile(graph, normalizedPath);
 };
@@ -15841,12 +15900,12 @@ var globalVersionCounter = 0, createModuleVersionTracker = () => new Map, getNex
 };
 
 // src/dev/configResolver.ts
-import { resolve as resolve24 } from "path";
+import { resolve as resolve25 } from "path";
 var resolveBuildPaths = (config) => {
   const cwd2 = process.cwd();
   const normalize = (path) => path.replace(/\\/g, "/");
-  const withDefault = (value, fallback) => normalize(resolve24(cwd2, value ?? fallback));
-  const optional = (value) => value ? normalize(resolve24(cwd2, value)) : undefined;
+  const withDefault = (value, fallback) => normalize(resolve25(cwd2, value ?? fallback));
+  const optional = (value) => value ? normalize(resolve25(cwd2, value)) : undefined;
   return {
     angularDir: optional(config.angularDirectory),
     assetsDir: optional(config.assetsDirectory),
@@ -15898,8 +15957,8 @@ var init_clientManager = __esm(() => {
 });
 
 // src/dev/pathUtils.ts
-import { existsSync as existsSync23 } from "fs";
-import { resolve as resolve25 } from "path";
+import { existsSync as existsSync23, readdirSync, readFileSync as readFileSync16 } from "fs";
+import { dirname as dirname16, resolve as resolve26 } from "path";
 var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   if (shouldIgnorePath(filePath, resolved)) {
     return "ignored";
@@ -15973,13 +16032,80 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
     return "assets";
   }
   return "unknown";
+}, collectAngularResourceDirs = (angularDir) => {
+  const out = new Set;
+  const angularRoot = resolve26(angularDir);
+  const angularRootNormalized = normalizePath(angularRoot);
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+      const full = resolve26(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".component.ts")) {
+        continue;
+      }
+      let source;
+      try {
+        source = readFileSync16(full, "utf8");
+      } catch {
+        continue;
+      }
+      const refs = [];
+      const tplRe = /templateUrl\s*:\s*['"]([^'"]+)['"]/g;
+      const styleRe = /styleUrl\s*:\s*['"]([^'"]+)['"]/g;
+      const stylesArrRe = /styleUrls\s*:\s*\[([^\]]*)\]/g;
+      const literalRe = /['"]([^'"]+)['"]/g;
+      let match;
+      while ((match = tplRe.exec(source)) !== null) {
+        if (match[1])
+          refs.push(match[1]);
+      }
+      while ((match = styleRe.exec(source)) !== null) {
+        if (match[1])
+          refs.push(match[1]);
+      }
+      while ((match = stylesArrRe.exec(source)) !== null) {
+        const inner = match[1];
+        if (!inner)
+          continue;
+        let strMatch;
+        const innerRe = new RegExp(literalRe.source, literalRe.flags);
+        while ((strMatch = innerRe.exec(inner)) !== null) {
+          if (strMatch[1])
+            refs.push(strMatch[1]);
+        }
+      }
+      const componentDir = dirname16(full);
+      for (const ref of refs) {
+        const refAbs = normalizePath(resolve26(componentDir, ref));
+        const refDir = normalizePath(dirname16(refAbs));
+        if (refDir === angularRootNormalized || refDir.startsWith(angularRootNormalized + "/")) {
+          continue;
+        }
+        out.add(refDir);
+      }
+    }
+  };
+  walk(angularRoot);
+  return Array.from(out);
 }, collectPositiveWatchRoots = (config, resolved) => {
   const cwd2 = process.cwd();
   const roots = [];
   const push = (path) => {
     if (!path)
       return;
-    const abs = normalizePath(resolve25(cwd2, path));
+    const abs = normalizePath(resolve26(cwd2, path));
     if (!roots.includes(abs))
       roots.push(abs);
   };
@@ -16004,13 +16130,20 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   push(cfg.assetsDir);
   push(cfg.stylesDir);
   for (const candidate of ["src", "db", "assets", "styles"]) {
-    const abs = normalizePath(resolve25(cwd2, candidate));
+    const abs = normalizePath(resolve26(cwd2, candidate));
     if (existsSync23(abs) && !roots.includes(abs))
       roots.push(abs);
   }
   const extraDirs = config.dev?.watchDirs ?? [];
   for (const dir of extraDirs)
     push(dir);
+  if (cfg.angularDir) {
+    const resourceDirs = collectAngularResourceDirs(cfg.angularDir);
+    for (const dir of resourceDirs) {
+      if (!roots.includes(dir))
+        roots.push(dir);
+    }
+  }
   return roots;
 }, getWatchPaths = (config, resolved) => {
   const roots = collectPositiveWatchRoots(config, resolved);
@@ -16068,7 +16201,7 @@ var init_pathUtils = __esm(() => {
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
 import { existsSync as existsSync24 } from "fs";
-import { join as join27, resolve as resolve26 } from "path";
+import { join as join27, resolve as resolve27 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -16113,7 +16246,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
 }, addFileWatchers = (state, paths, onFileChange) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
-    const absolutePath = resolve26(path).replace(/\\/g, "/");
+    const absolutePath = resolve27(path).replace(/\\/g, "/");
     if (!existsSync24(absolutePath)) {
       return;
     }
@@ -16124,7 +16257,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const watchPaths = getWatchPaths(config, state.resolvedPaths);
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
-    const absolutePath = resolve26(path).replace(/\\/g, "/");
+    const absolutePath = resolve27(path).replace(/\\/g, "/");
     if (!existsSync24(absolutePath)) {
       return;
     }
@@ -16139,13 +16272,13 @@ var init_fileWatcher = __esm(() => {
 });
 
 // src/dev/assetStore.ts
-import { resolve as resolve27 } from "path";
+import { resolve as resolve28 } from "path";
 import { readdir as readdir4, unlink } from "fs/promises";
 var mimeTypes, getMimeType = (filePath) => {
   const ext = filePath.slice(filePath.lastIndexOf("."));
   return mimeTypes[ext] ?? "application/octet-stream";
 }, HASHED_FILE_RE, stripHash = (webPath) => webPath.replace(/\.[a-z0-9]{8}(\.(js|css|mjs))$/, "$1"), processWalkEntry = (entry, dir, liveByIdentity, walkAndClean) => {
-  const fullPath = resolve27(dir, entry.name);
+  const fullPath = resolve28(dir, entry.name);
   if (entry.isDirectory()) {
     return walkAndClean(fullPath);
   }
@@ -16161,10 +16294,10 @@ var mimeTypes, getMimeType = (filePath) => {
 }, cleanStaleAssets = async (store, manifest, buildDir) => {
   const liveByIdentity = new Map;
   for (const webPath of store.keys()) {
-    const diskPath = resolve27(buildDir, webPath.slice(1));
+    const diskPath = resolve28(buildDir, webPath.slice(1));
     liveByIdentity.set(stripHash(diskPath), diskPath);
   }
-  const absBuildDir = resolve27(buildDir);
+  const absBuildDir = resolve28(buildDir);
   Object.values(manifest).forEach((val) => {
     if (!HASHED_FILE_RE.test(val))
       return;
@@ -16182,7 +16315,7 @@ var mimeTypes, getMimeType = (filePath) => {
   } catch {}
 }, lookupAsset = (store, path) => store.get(path), processScanEntry = (entry, dir, prefix, store, scanDir) => {
   if (entry.isDirectory()) {
-    return scanDir(resolve27(dir, entry.name), `${prefix}${entry.name}/`);
+    return scanDir(resolve28(dir, entry.name), `${prefix}${entry.name}/`);
   }
   if (!entry.name.startsWith("chunk-")) {
     return null;
@@ -16191,7 +16324,7 @@ var mimeTypes, getMimeType = (filePath) => {
   if (store.has(webPath)) {
     return null;
   }
-  return Bun.file(resolve27(dir, entry.name)).bytes().then((bytes) => {
+  return Bun.file(resolve28(dir, entry.name)).bytes().then((bytes) => {
     store.set(webPath, bytes);
     return;
   }).catch(() => {});
@@ -16213,7 +16346,7 @@ var mimeTypes, getMimeType = (filePath) => {
   for (const webPath of newIdentities.values()) {
     if (store.has(webPath))
       continue;
-    loadPromises.push(Bun.file(resolve27(buildDir, webPath.slice(1))).bytes().then((bytes) => {
+    loadPromises.push(Bun.file(resolve28(buildDir, webPath.slice(1))).bytes().then((bytes) => {
       store.set(webPath, bytes);
       return;
     }).catch(() => {}));
@@ -16243,10 +16376,10 @@ var init_assetStore = __esm(() => {
 });
 
 // src/dev/fileHashTracker.ts
-import { readFileSync as readFileSync16 } from "fs";
+import { readFileSync as readFileSync17 } from "fs";
 var computeFileHash = (filePath) => {
   try {
-    const fileContent = readFileSync16(filePath);
+    const fileContent = readFileSync17(filePath);
     return Number(Bun.hash(fileContent));
   } catch {
     return UNFOUND_INDEX;
@@ -16326,9 +16459,9 @@ var init_transformCache = __esm(() => {
 });
 
 // src/dev/reactComponentClassifier.ts
-import { resolve as resolve28 } from "path";
+import { resolve as resolve29 } from "path";
 var classifyComponent = (filePath) => {
-  const normalizedPath = resolve28(filePath);
+  const normalizedPath = resolve29(filePath);
   if (normalizedPath.includes("/react/pages/")) {
     return "server";
   }
@@ -16340,7 +16473,7 @@ var classifyComponent = (filePath) => {
 var init_reactComponentClassifier = () => {};
 
 // src/dev/moduleMapper.ts
-import { basename as basename10, resolve as resolve29 } from "path";
+import { basename as basename10, resolve as resolve30 } from "path";
 var buildModulePaths = (moduleKeys, manifest) => {
   const modulePaths = {};
   moduleKeys.forEach((key) => {
@@ -16350,7 +16483,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return modulePaths;
 }, processChangedFile = (sourceFile, framework, manifest, resolvedPaths, processedFiles) => {
-  const normalizedFile = resolve29(sourceFile);
+  const normalizedFile = resolve30(sourceFile);
   const normalizedPath = normalizedFile.replace(/\\/g, "/");
   if (processedFiles.has(normalizedFile)) {
     return null;
@@ -16386,7 +16519,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return grouped;
 }, mapSourceFileToManifestKeys = (sourceFile, framework, resolvedPaths) => {
-  const normalizedFile = resolve29(sourceFile);
+  const normalizedFile = resolve30(sourceFile);
   const fileName = basename10(normalizedFile);
   const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|css|html)$/, "");
   const pascalName = toPascal(baseName);
@@ -16545,247 +16678,6 @@ var init_ssrCache = __esm(() => {
   dirtyFrameworks = new Set;
 });
 
-// src/dev/angular/editTypeDetection.ts
-import { readFileSync as readFileSync17 } from "fs";
-import { basename as basename11 } from "path";
-import * as ts3 from "typescript";
-var TYPE_PRIORITY, STYLE_EXT_RE, COMPONENT_STYLE_RE, TEMPLATE_RE, COMPONENT_CLASS_RE, SERVICE_RE, ROUTES_RE, PAGE_TS_RE, SIDE_EFFECT_CALL_NAMES, SIDE_EFFECT_NEW_NAMES, getCalleeName = (node) => {
-  const callee = node.expression;
-  if (ts3.isIdentifier(callee))
-    return callee.text;
-  if (ts3.isPropertyAccessExpression(callee))
-    return callee.name.text;
-  return null;
-}, getNewExprName = (node) => {
-  const callee = node.expression;
-  if (ts3.isIdentifier(callee))
-    return callee.text;
-  if (ts3.isPropertyAccessExpression(callee))
-    return callee.name.text;
-  return null;
-}, collectMethodBodies = (cls) => {
-  const methods = new Map;
-  cls.members.forEach((member) => {
-    if (!member.name || !ts3.isIdentifier(member.name))
-      return;
-    if (ts3.isMethodDeclaration(member) && member.body) {
-      methods.set(member.name.text, member.body);
-      return;
-    }
-    if (ts3.isPropertyDeclaration(member) && member.initializer) {
-      const init = member.initializer;
-      if (ts3.isArrowFunction(init) || ts3.isFunctionExpression(init)) {
-        methods.set(member.name.text, init.body);
-      }
-    }
-  });
-  return methods;
-}, findSideEffectInBody = (body, methods, visited) => {
-  let hit = { found: false };
-  const walk = (node) => {
-    if (hit.found)
-      return;
-    if (ts3.isCallExpression(node)) {
-      const name = getCalleeName(node);
-      if (name && SIDE_EFFECT_CALL_NAMES.has(name)) {
-        hit = {
-          found: true,
-          reason: `constructor invokes ${name}(...)`
-        };
-        return;
-      }
-      if (name && methods.has(name) && !visited.has(name)) {
-        visited.add(name);
-        const target = methods.get(name);
-        if (target) {
-          const inner = findSideEffectInBody(target, methods, visited);
-          if (inner.found) {
-            hit = {
-              found: true,
-              reason: `${inner.reason} (via this.${name}())`
-            };
-            return;
-          }
-        }
-      }
-    }
-    if (ts3.isNewExpression(node)) {
-      const name = getNewExprName(node);
-      if (name && SIDE_EFFECT_NEW_NAMES.has(name)) {
-        hit = {
-          found: true,
-          reason: `constructor instantiates new ${name}(...)`
-        };
-        return;
-      }
-    }
-    ts3.forEachChild(node, walk);
-  };
-  walk(body);
-  return hit;
-}, analyzeServiceFile = (file5) => {
-  let source;
-  try {
-    source = readFileSync17(file5, "utf8");
-  } catch {
-    return {
-      hasSideEffectCtor: true,
-      reason: "service file unreadable \u2014 defaulting to reboot"
-    };
-  }
-  const sf = ts3.createSourceFile(file5, source, ts3.ScriptTarget.Latest, true);
-  let result = {
-    hasSideEffectCtor: false,
-    reason: "constructor has no side-effecting calls"
-  };
-  const visit = (node) => {
-    if (result.hasSideEffectCtor)
-      return;
-    if (!ts3.isClassDeclaration(node)) {
-      ts3.forEachChild(node, visit);
-      return;
-    }
-    const methods = collectMethodBodies(node);
-    const ctor = node.members.find(ts3.isConstructorDeclaration);
-    const targets = [];
-    if (ctor?.body)
-      targets.push(ctor.body);
-    node.members.forEach((member) => {
-      if (ts3.isPropertyDeclaration(member) && member.initializer) {
-        targets.push(member.initializer);
-      }
-    });
-    for (const target of targets) {
-      const r = findSideEffectInBody(target, methods, new Set);
-      if (r.found) {
-        result = { hasSideEffectCtor: true, reason: r.reason };
-        break;
-      }
-    }
-    if (!result.hasSideEffectCtor)
-      ts3.forEachChild(node, visit);
-  };
-  visit(sf);
-  return result;
-}, classifyAngularEdit = (file5) => {
-  const base = basename11(file5);
-  if (TEMPLATE_RE.test(file5)) {
-    return {
-      type: "template",
-      reason: `${base} \u2014 template edit`,
-      sourceFile: file5
-    };
-  }
-  if (COMPONENT_STYLE_RE.test(file5)) {
-    return {
-      type: "style-component",
-      reason: `${base} \u2014 component-scoped stylesheet edit`,
-      sourceFile: file5
-    };
-  }
-  if (STYLE_EXT_RE.test(file5)) {
-    return {
-      type: "reboot",
-      reason: `${base} \u2014 non-component-named stylesheet, falling back to reboot until scoping is verified`,
-      sourceFile: file5
-    };
-  }
-  if (ROUTES_RE.test(file5)) {
-    return {
-      type: "route",
-      reason: `${base} \u2014 router config, requires reboot`,
-      sourceFile: file5
-    };
-  }
-  if (SERVICE_RE.test(file5)) {
-    const a = analyzeServiceFile(file5);
-    if (a.hasSideEffectCtor) {
-      return {
-        type: "service-with-side-effects",
-        reason: `${base} \u2014 ${a.reason}`,
-        sourceFile: file5
-      };
-    }
-    return {
-      type: "service-method-only",
-      reason: `${base} \u2014 ${a.reason}`,
-      sourceFile: file5
-    };
-  }
-  if (COMPONENT_CLASS_RE.test(file5)) {
-    return {
-      type: "class-component",
-      reason: `${base} \u2014 component class edit`,
-      sourceFile: file5
-    };
-  }
-  if (PAGE_TS_RE.test(file5)) {
-    return {
-      type: "class-component",
-      reason: `${base} \u2014 page component edit`,
-      sourceFile: file5
-    };
-  }
-  return {
-    type: "reboot",
-    reason: `${base} \u2014 unrecognized angular file type, falling back to reboot`,
-    sourceFile: file5
-  };
-}, collapseClassifications = (classifications) => {
-  if (classifications.length === 0) {
-    return {
-      type: "reboot",
-      reason: "no classifiable files in batch",
-      sourceFile: ""
-    };
-  }
-  let winner = classifications[0];
-  for (let i = 1;i < classifications.length; i++) {
-    const candidate = classifications[i];
-    if (TYPE_PRIORITY[candidate.type] > TYPE_PRIORITY[winner.type]) {
-      winner = candidate;
-    }
-  }
-  return winner;
-};
-var init_editTypeDetection = __esm(() => {
-  TYPE_PRIORITY = {
-    template: 0,
-    "style-component": 1,
-    "service-method-only": 2,
-    "class-component": 3,
-    "service-with-side-effects": 4,
-    route: 5,
-    reboot: 6
-  };
-  STYLE_EXT_RE = /\.(css|scss|sass|less|styl|stylus|pcss|postcss)$/i;
-  COMPONENT_STYLE_RE = /\.component\.(css|scss|sass|less|styl|stylus|pcss|postcss)$/i;
-  TEMPLATE_RE = /\.html$/i;
-  COMPONENT_CLASS_RE = /\.component\.ts$/i;
-  SERVICE_RE = /\.service\.ts$/i;
-  ROUTES_RE = /(?:^|[\\/])(?:app\.)?routes\.ts$/i;
-  PAGE_TS_RE = /(?:^|[\\/])pages[\\/][^\\/]+\.ts$/i;
-  SIDE_EFFECT_CALL_NAMES = new Set([
-    "subscribe",
-    "setInterval",
-    "setTimeout",
-    "addEventListener",
-    "effect",
-    "afterNextRender",
-    "afterRender",
-    "afterEveryRender",
-    "requestAnimationFrame",
-    "requestIdleCallback"
-  ]);
-  SIDE_EFFECT_NEW_NAMES = new Set([
-    "Worker",
-    "SharedWorker",
-    "EventSource",
-    "WebSocket",
-    "BroadcastChannel"
-  ]);
-});
-
 // src/dev/moduleServer.ts
 var exports_moduleServer = {};
 __export(exports_moduleServer, {
@@ -16798,7 +16690,7 @@ __export(exports_moduleServer, {
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
 import { existsSync as existsSync25, readFileSync as readFileSync18, statSync as statSync2 } from "fs";
-import { basename as basename12, dirname as dirname16, extname as extname8, join as join28, resolve as resolve30, relative as relative11 } from "path";
+import { basename as basename11, dirname as dirname17, extname as extname8, join as join28, resolve as resolve31, relative as relative12 } from "path";
 var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPILABLE, ALL_EXPORTS_RE, STRING_CONTENTS_RE, preserveTypeExports = (originalSource, transpiled, valueExports) => {
   const codeOnly = originalSource.replace(STRING_CONTENTS_RE, '""');
   const allExports = [];
@@ -16818,7 +16710,7 @@ var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPIL
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const found = extensions.find((ext) => existsSync25(resolve30(projectRoot, srcPath + ext)));
+  const found = extensions.find((ext) => existsSync25(resolve31(projectRoot, srcPath + ext)));
   return found ? srcPath + found : srcPath;
 }, IMPORT_EXTENSIONS, SIDE_EFFECT_EXTENSIONS, MODULE_EXTENSIONS, RESOLVED_MODULE_EXTENSIONS, REACT_EXTENSIONS, escapeRegex3 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), buildImportRewriter = (vendorPaths) => {
   const entries = Object.entries(vendorPaths).sort(([a], [b2]) => b2.length - a.length);
@@ -16833,7 +16725,7 @@ ${stubs}
   return invalidationVersion > 0 ? `${mtime}.${invalidationVersion}` : `${mtime}`;
 }, srcUrl = (relPath, projectRoot) => {
   const base = `${SRC_PREFIX}${relPath.replace(/\\/g, "/")}`;
-  const absPath = resolve30(projectRoot, relPath);
+  const absPath = resolve31(projectRoot, relPath);
   const cached = mtimeCache.get(absPath);
   if (cached !== undefined)
     return `${base}?v=${buildVersion(cached, absPath)}`;
@@ -16845,12 +16737,12 @@ ${stubs}
     return base;
   }
 }, resolveRelativeImport = (relPath, fileDir, projectRoot, extensions) => {
-  const absPath = resolve30(fileDir, relPath);
-  const rel = relative11(projectRoot, absPath);
+  const absPath = resolve31(fileDir, relPath);
+  const rel = relative12(projectRoot, absPath);
   const extension = extname8(rel);
   let srcPath = RESOLVED_MODULE_EXTENSIONS.has(extension) ? rel : resolveRelativeExtension(rel, projectRoot, extensions);
   if (extname8(srcPath) === ".svelte") {
-    srcPath = relative11(projectRoot, resolveSvelteModulePath(resolve30(projectRoot, srcPath)));
+    srcPath = relative12(projectRoot, resolveSvelteModulePath(resolve31(projectRoot, srcPath)));
   }
   return srcUrl(srcPath, projectRoot);
 }, resolveAbsoluteSpecifier = (specifier, projectRoot) => {
@@ -16860,27 +16752,27 @@ ${stubs}
       "import"
     ]);
     if (fromExports)
-      return relative11(projectRoot, fromExports);
+      return relative12(projectRoot, fromExports);
     try {
       const isScoped = specifier.startsWith("@");
       const parts = specifier.split("/");
       const packageName = isScoped ? `${parts[0]}/${parts[1]}` : parts[0];
       const subpath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
       if (!subpath) {
-        const pkgDir = resolve30(projectRoot, "node_modules", packageName ?? "");
+        const pkgDir = resolve31(projectRoot, "node_modules", packageName ?? "");
         const pkgJsonPath = join28(pkgDir, "package.json");
         if (existsSync25(pkgJsonPath)) {
           const pkg = JSON.parse(readFileSync18(pkgJsonPath, "utf-8"));
           const esmEntry = typeof pkg.module === "string" && pkg.module || typeof pkg.browser === "string" && pkg.browser;
           if (esmEntry) {
-            const resolved = resolve30(pkgDir, esmEntry);
+            const resolved = resolve31(pkgDir, esmEntry);
             if (existsSync25(resolved))
-              return relative11(projectRoot, resolved);
+              return relative12(projectRoot, resolved);
           }
         }
       }
     } catch {}
-    return relative11(projectRoot, Bun.resolveSync(specifier, projectRoot));
+    return relative12(projectRoot, Bun.resolveSync(specifier, projectRoot));
   } catch {
     return;
   }
@@ -16905,26 +16797,26 @@ ${stubs}
   };
   result = result.replace(/^((?:import\s+[\s\S]+?\s+from|export\s+[\s\S]+?\s+from|import)\s*["'])([^"'./][^"']*)(["'])/gm, stubReplace);
   result = result.replace(/(import\s*\(\s*["'])([^"'./][^"']*)(["']\s*\))/g, stubReplace);
-  const fileDir = dirname16(filePath);
+  const fileDir = dirname17(filePath);
   result = result.replace(/(from\s*["'])(\.\.?\/[^"']+)(["'])/g, (_match, prefix, relPath, suffix) => `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, IMPORT_EXTENSIONS)}${suffix}`);
   result = result.replace(/(import\s*\(\s*["'])(\.\.?\/[^"']+)(["']\s*\))/g, (_match, prefix, relPath, suffix) => `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, IMPORT_EXTENSIONS)}${suffix}`);
   result = result.replace(/(import\s*["'])(\.\.?\/[^"']+)(["']\s*;?)/g, (_match, prefix, relPath, suffix) => `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, SIDE_EFFECT_EXTENSIONS)}${suffix}`);
   result = result.replace(/((?:from|import)\s*["'])(\/[^"']+\.(tsx?|jsx?|ts))(["'])/g, (_match, prefix, absPath, _ext, suffix) => {
     if (absPath.startsWith(projectRoot)) {
-      const rel2 = relative11(projectRoot, absPath).replace(/\\/g, "/");
+      const rel2 = relative12(projectRoot, absPath).replace(/\\/g, "/");
       return `${prefix}${srcUrl(rel2, projectRoot)}${suffix}`;
     }
-    const rel = relative11(projectRoot, absPath).replace(/\\/g, "/");
+    const rel = relative12(projectRoot, absPath).replace(/\\/g, "/");
     return `${prefix}${srcUrl(rel, projectRoot)}${suffix}`;
   });
   result = result.replace(/new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g, (_match, relPath) => {
-    const absPath = resolve30(fileDir, relPath);
-    const rel = relative11(projectRoot, absPath);
+    const absPath = resolve31(fileDir, relPath);
+    const rel = relative12(projectRoot, absPath);
     return `new URL('${srcUrl(rel, projectRoot)}', import.meta.url)`;
   });
   result = result.replace(/import\.meta\.resolve\(\s*["'](\.\.?\/[^"']+)["']\s*\)/g, (_match, relPath) => {
-    const absPath = resolve30(fileDir, relPath);
-    const rel = relative11(projectRoot, absPath);
+    const absPath = resolve31(fileDir, relPath);
+    const rel = relative12(projectRoot, absPath);
     return `'${srcUrl(rel, projectRoot)}'`;
   });
   return result;
@@ -16980,7 +16872,7 @@ ${code}`;
   transpiled = `var $RefreshReg$ = window.$RefreshReg$ || function(){};
 ` + `var $RefreshSig$ = window.$RefreshSig$ || function(){ return function(t){ return t; }; };
 ${transpiled}`;
-  const relPath = relative11(projectRoot, filePath).replace(/\\/g, "/");
+  const relPath = relative12(projectRoot, filePath).replace(/\\/g, "/");
   transpiled = transpiled.replace(/\binput\.tsx:/g, `${relPath}:`);
   transpiled += buildIslandMetadataExports(raw);
   return rewriteImports(transpiled, filePath, projectRoot, rewriter);
@@ -17141,11 +17033,11 @@ ${code}`;
   if (compiled.css?.code) {
     const cssPath = `${filePath}.css`;
     svelteExternalCss.set(cssPath, compiled.css.code);
-    const cssUrl = srcUrl(relative11(projectRoot, cssPath), projectRoot);
+    const cssUrl = srcUrl(relative12(projectRoot, cssPath), projectRoot);
     code = `import "${cssUrl}";
 ${code}`;
   }
-  const moduleUrl = `${SRC_PREFIX}${relative11(projectRoot, filePath).replace(/\\/g, "/")}`;
+  const moduleUrl = `${SRC_PREFIX}${relative12(projectRoot, filePath).replace(/\\/g, "/")}`;
   code = code.replace(/if\s*\(import\.meta\.hot\)\s*\{/, `if (typeof window !== "undefined") {
 ` + `  if (!window.__SVELTE_HMR_ACCEPT__) window.__SVELTE_HMR_ACCEPT__ = {};
 ` + `  var __hmr_accept = function(cb) { window.__SVELTE_HMR_ACCEPT__[${JSON.stringify(moduleUrl)}] = cb; };`);
@@ -17216,7 +17108,7 @@ ${code}`;
   if (!vueCompiler) {
     vueCompiler = await import("@vue/compiler-sfc");
   }
-  const fileName = basename12(filePath, ".vue");
+  const fileName = basename11(filePath, ".vue");
   const componentId = fileName.toLowerCase();
   const { descriptor } = vueCompiler.parse(raw, { filename: filePath });
   const hasScript = descriptor.script || descriptor.scriptSetup;
@@ -17234,8 +17126,8 @@ ${code}`;
   code = injectVueHmr(code, filePath, projectRoot, vueDir);
   return rewriteImports(code, filePath, projectRoot, rewriter);
 }, injectVueHmr = (code, filePath, projectRoot, vueDir) => {
-  const hmrBase = vueDir ? resolve30(vueDir) : projectRoot;
-  const hmrId = relative11(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
+  const hmrBase = vueDir ? resolve31(vueDir) : projectRoot;
+  const hmrId = relative12(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
   let result = code.replace(/export\s+default\s+/, "var __hmr_comp__ = ");
   result += [
     "",
@@ -17393,7 +17285,7 @@ export default {};
   const escaped = virtualCss.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return jsResponse(`var s=document.createElement('style');s.textContent=\`${escaped}\`;s.dataset.svelteHmr=${JSON.stringify(cssCheckPath)};var p=document.querySelector('style[data-svelte-hmr="${cssCheckPath}"]');if(p)p.remove();document.head.appendChild(s);`);
 }, resolveSourcePath = (relPath, projectRoot) => {
-  const filePath = resolve30(projectRoot, relPath);
+  const filePath = resolve31(projectRoot, relPath);
   const ext = extname8(filePath);
   if (ext === ".svelte")
     return { ext, filePath: resolveSvelteModulePath(filePath) };
@@ -17420,7 +17312,7 @@ export default {};
   if (!TRANSPILABLE.has(ext))
     return;
   const stat3 = statSync2(filePath);
-  const resolvedVueDir = vueDir ? resolve30(vueDir) : undefined;
+  const resolvedVueDir = vueDir ? resolve31(vueDir) : undefined;
   const content = REACT_EXTENSIONS.has(ext) ? transformReactFile(filePath, projectRoot, rewriter) : transformPlainFile(filePath, projectRoot, rewriter, resolvedVueDir);
   setTransformed(filePath, content, stat3.mtimeMs, extractImportedFiles(content, projectRoot));
   return jsResponse(content);
@@ -17451,7 +17343,7 @@ export default {};
     if (!pathname.startsWith(SRC_PREFIX))
       return;
     const relPath = pathname.slice(SRC_PREFIX.length);
-    const virtualCssResponse = handleVirtualSvelteCss(resolve30(projectRoot, relPath));
+    const virtualCssResponse = handleVirtualSvelteCss(resolve31(projectRoot, relPath));
     if (virtualCssResponse)
       return virtualCssResponse;
     const { filePath, ext } = resolveSourcePath(relPath, projectRoot);
@@ -17467,11 +17359,11 @@ export default {};
   SRC_IMPORT_RE.lastIndex = 0;
   while ((match = SRC_IMPORT_RE.exec(content)) !== null) {
     if (match[1])
-      files.push(resolve30(projectRoot, match[1]));
+      files.push(resolve31(projectRoot, match[1]));
   }
   return files;
 }, invalidateModule = (filePath) => {
-  const resolved = resolve30(filePath);
+  const resolved = resolve31(filePath);
   invalidate(filePath);
   if (resolved !== filePath)
     invalidate(resolved);
@@ -17586,70 +17478,1583 @@ var init_rewriteImports = __esm(() => {
   rewriteVendorDirectories2 = rewriteVendorDirectories;
 });
 
-// src/utils/ssrErrorPage.ts
-var ssrErrorPage = (framework, error) => {
-  const frameworkColors2 = {
-    angular: "#dd0031",
-    html: "#e34c26",
-    htmx: "#1a365d",
-    react: "#61dafb",
-    svelte: "#ff3e00",
-    vue: "#42b883"
+// src/dev/angular/resolveOwningComponents.ts
+var exports_resolveOwningComponents = {};
+__export(exports_resolveOwningComponents, {
+  resolveOwningComponents: () => resolveOwningComponents
+});
+import { readdirSync as readdirSync2, readFileSync as readFileSync19, statSync as statSync3 } from "fs";
+import { dirname as dirname18, extname as extname9, join as join29, resolve as resolve32 } from "path";
+import ts3 from "typescript";
+var isComponentTsFile = (file5) => file5.endsWith(".component.ts") || file5.endsWith(".component.tsx"), walkComponentTsFiles = (root) => {
+  const out = [];
+  const visit = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync2(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+      const full = join29(dir, entry.name);
+      if (entry.isDirectory()) {
+        visit(full);
+      } else if (entry.isFile() && isComponentTsFile(entry.name)) {
+        out.push(full);
+      }
+    }
   };
-  const accent = frameworkColors2[framework] ?? "#94a3b8";
-  const label = framework.charAt(0).toUpperCase() + framework.slice(1);
-  const message = error instanceof Error ? error.message : String(error);
-  return `<!DOCTYPE html>
-<html>
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>SSR Error - AbsoluteJS</title>
-<style>
-*{margin:0;padding:0;box-sizing:border-box}
-body{min-height:100vh;background:linear-gradient(135deg,rgba(15,23,42,0.98) 0%,rgba(30,41,59,0.98) 100%);color:#e2e8f0;font-family:"JetBrains Mono","Fira Code",ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;font-size:14px;line-height:1.6;display:flex;align-items:flex-start;justify-content:center;padding:32px}
-.card{max-width:720px;width:100%;background:rgba(30,41,59,0.6);border:1px solid rgba(71,85,105,0.5);border-radius:16px;box-shadow:0 25px 50px -12px rgba(0,0,0,0.5),0 0 0 1px rgba(255,255,255,0.05);overflow:hidden}
-.header{display:flex;align-items:center;justify-content:space-between;gap:16px;padding:20px 24px;background:rgba(15,23,42,0.5);border-bottom:1px solid rgba(71,85,105,0.4)}
-.brand{font-weight:700;font-size:20px;color:#fff;letter-spacing:-0.02em}
-.badge{padding:5px 10px;border-radius:8px;font-size:12px;font-weight:600;background:${accent};color:#fff;opacity:0.95;box-shadow:0 2px 4px rgba(0,0,0,0.2)}
-.kind{color:#94a3b8;font-size:13px;font-weight:500}
-.content{padding:24px}
-.label{font-size:11px;font-weight:600;text-transform:uppercase;letter-spacing:0.08em;color:#94a3b8;margin-bottom:8px}
-.message{margin:0;padding:16px 20px;background:rgba(239,68,68,0.12);border:1px solid rgba(239,68,68,0.25);border-radius:10px;overflow-x:auto;white-space:pre-wrap;word-break:break-word;color:#fca5a5;font-size:13px;line-height:1.5}
-.hint{margin-top:20px;padding:12px 20px;background:rgba(71,85,105,0.3);border-radius:10px;border:1px solid rgba(71,85,105,0.4);color:#cbd5e1;font-size:13px}
-</style>
-</head>
-<body>
-<div class="card">
-<div class="header">
-<div style="display:flex;align-items:center;gap:12px">
-<span class="brand">AbsoluteJS</span>
-<span class="badge">${label}</span>
-</div>
-<span class="kind">Server Render Error</span>
-</div>
-<div class="content">
-<div class="label">What went wrong</div>
-<pre class="message">${message.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}</pre>
-<div class="hint">A component threw during server-side rendering. Check the terminal for the full stack trace.</div>
-</div>
-</div>
-</body>
-</html>`;
-};
-
-// src/ember/pageHandler.ts
-import { pathToFileURL } from "url";
-var resolveRequestPathname = (request) => {
-  if (!request)
-    return;
-  try {
-    const parsed = new URL(request.url);
-    return `${parsed.pathname}${parsed.search}`;
-  } catch {
-    return;
+  visit(root);
+  return out;
+}, getStringPropertyValue = (obj, name) => {
+  for (const prop of obj.properties) {
+    if (!ts3.isPropertyAssignment(prop))
+      continue;
+    const propName = ts3.isIdentifier(prop.name) ? prop.name.text : ts3.isStringLiteral(prop.name) ? prop.name.text : null;
+    if (propName !== name)
+      continue;
+    const init = prop.initializer;
+    if (ts3.isStringLiteral(init) || ts3.isNoSubstitutionTemplateLiteral(init)) {
+      return init.text;
+    }
   }
-}, installSimpleDomGlobals = () => {
+  return null;
+}, getStringArrayProperty = (obj, name) => {
+  const out = [];
+  for (const prop of obj.properties) {
+    if (!ts3.isPropertyAssignment(prop))
+      continue;
+    const propName = ts3.isIdentifier(prop.name) ? prop.name.text : ts3.isStringLiteral(prop.name) ? prop.name.text : null;
+    if (propName !== name)
+      continue;
+    const init = prop.initializer;
+    if (!ts3.isArrayLiteralExpression(init))
+      continue;
+    for (const element of init.elements) {
+      if (ts3.isStringLiteral(element) || ts3.isNoSubstitutionTemplateLiteral(element)) {
+        out.push(element.text);
+      }
+    }
+  }
+  return out;
+}, parseComponentRefs = (filePath) => {
+  const refs = {
+    classNames: [],
+    templateUrls: [],
+    styleUrls: []
+  };
+  let source;
+  try {
+    source = readFileSync19(filePath, "utf8");
+  } catch {
+    return refs;
+  }
+  const sourceFile = ts3.createSourceFile(filePath, source, ts3.ScriptTarget.ES2022, true, ts3.ScriptKind.TS);
+  const visit = (node) => {
+    if (ts3.isClassDeclaration(node) && node.name) {
+      const decorators = ts3.getDecorators(node) ?? [];
+      for (const decorator of decorators) {
+        const expr = decorator.expression;
+        if (!ts3.isCallExpression(expr))
+          continue;
+        const fn2 = expr.expression;
+        if (!ts3.isIdentifier(fn2) || fn2.text !== "Component")
+          continue;
+        refs.classNames.push(node.name.text);
+        const arg = expr.arguments[0];
+        if (!arg || !ts3.isObjectLiteralExpression(arg))
+          continue;
+        const tplUrl = getStringPropertyValue(arg, "templateUrl");
+        if (tplUrl)
+          refs.templateUrls.push(tplUrl);
+        const styleUrl = getStringPropertyValue(arg, "styleUrl");
+        if (styleUrl)
+          refs.styleUrls.push(styleUrl);
+        refs.styleUrls.push(...getStringArrayProperty(arg, "styleUrls"));
+      }
+    }
+    ts3.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return refs;
+}, safeNormalize = (path) => resolve32(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
+  const { changedFilePath, userAngularRoot } = params;
+  const changedAbs = safeNormalize(changedFilePath);
+  const out = [];
+  if (changedAbs.endsWith(".component.ts")) {
+    const refs = parseComponentRefs(changedAbs);
+    for (const className of refs.classNames) {
+      out.push({ componentFilePath: changedAbs, className });
+    }
+    return out;
+  }
+  const ext = extname9(changedAbs).toLowerCase();
+  if (ext !== ".html" && ext !== ".css" && ext !== ".scss" && ext !== ".sass") {
+    return out;
+  }
+  let rootStat;
+  try {
+    rootStat = statSync3(userAngularRoot);
+  } catch {
+    return out;
+  }
+  if (!rootStat.isDirectory())
+    return out;
+  for (const componentTsPath of walkComponentTsFiles(userAngularRoot)) {
+    const refs = parseComponentRefs(componentTsPath);
+    const componentDir = dirname18(componentTsPath);
+    const matchesResource = (relativeUrl) => {
+      const abs = safeNormalize(resolve32(componentDir, relativeUrl));
+      return abs === changedAbs;
+    };
+    const referencesChanged = refs.templateUrls.some(matchesResource) || refs.styleUrls.some(matchesResource);
+    if (!referencesChanged)
+      continue;
+    for (const className of refs.classNames) {
+      out.push({
+        componentFilePath: componentTsPath,
+        className
+      });
+    }
+  }
+  return out;
+};
+var init_resolveOwningComponents = () => {};
+
+// src/dev/angular/hmrImportGenerator.ts
+import ts4 from "typescript";
+var createHmrImportGenerator = (namespaceMap) => ({
+  addImport(request) {
+    const ns = namespaceMap.get(request.exportModuleSpecifier);
+    if (!ns) {
+      throw new Error(`HMR import generator has no namespace mapping for ${request.exportModuleSpecifier}. ` + `Add it to namespaceDependencies before calling compileHmrUpdateCallback.`);
+    }
+    const namespaceId = ts4.factory.createIdentifier(ns);
+    if (request.exportSymbolName === null) {
+      return namespaceId;
+    }
+    return ts4.factory.createPropertyAccessExpression(namespaceId, ts4.factory.createIdentifier(request.exportSymbolName));
+  }
+});
+var init_hmrImportGenerator = () => {};
+
+// src/dev/angular/vendor/translator/context.ts
+class Context {
+  isStatement;
+  constructor(isStatement) {
+    this.isStatement = isStatement;
+  }
+  get withExpressionMode() {
+    return this.isStatement ? new Context(false) : this;
+  }
+  get withStatementMode() {
+    return !this.isStatement ? new Context(true) : this;
+  }
+}
+
+// src/dev/angular/vendor/translator/translator.ts
+import * as o from "@angular/compiler";
+
+class ExpressionTranslatorVisitor {
+  factory;
+  imports;
+  contextFile;
+  downlevelTaggedTemplates;
+  downlevelVariableDeclarations;
+  recordWrappedNode;
+  constructor(factory, imports, contextFile, options) {
+    this.factory = factory;
+    this.imports = imports;
+    this.contextFile = contextFile;
+    this.downlevelTaggedTemplates = options.downlevelTaggedTemplates === true;
+    this.downlevelVariableDeclarations = options.downlevelVariableDeclarations === true;
+    this.recordWrappedNode = options.recordWrappedNode || (() => {});
+  }
+  visitDeclareVarStmt(stmt, context) {
+    const varType = this.downlevelVariableDeclarations ? "var" : stmt.hasModifier(o.StmtModifier.Final) ? "const" : "let";
+    return this.attachComments(this.factory.createVariableDeclaration(stmt.name, stmt.value?.visitExpression(this, context.withExpressionMode), varType, stmt.type?.visitType(this, context)), stmt.leadingComments);
+  }
+  visitDeclareFunctionStmt(stmt, context) {
+    return this.attachComments(this.factory.createFunctionDeclaration(stmt.name, this.translateParams(stmt.params, context), this.factory.createBlock(this.visitStatements(stmt.statements, context.withStatementMode))), stmt.leadingComments);
+  }
+  visitExpressionStmt(stmt, context) {
+    return this.attachComments(this.factory.createExpressionStatement(stmt.expr.visitExpression(this, context.withStatementMode)), stmt.leadingComments);
+  }
+  visitReturnStmt(stmt, context) {
+    return this.attachComments(this.factory.createReturnStatement(stmt.value.visitExpression(this, context.withExpressionMode)), stmt.leadingComments);
+  }
+  visitIfStmt(stmt, context) {
+    return this.attachComments(this.factory.createIfStatement(stmt.condition.visitExpression(this, context), this.factory.createBlock(this.visitStatements(stmt.trueCase, context.withStatementMode)), stmt.falseCase.length > 0 ? this.factory.createBlock(this.visitStatements(stmt.falseCase, context.withStatementMode)) : null), stmt.leadingComments);
+  }
+  visitReadVarExpr(ast, _context) {
+    const identifier = this.factory.createIdentifier(ast.name);
+    this.setSourceMapRange(identifier, ast.sourceSpan);
+    return identifier;
+  }
+  visitInvokeFunctionExpr(ast, context) {
+    return this.setSourceMapRange(this.factory.createCallExpression(ast.fn.visitExpression(this, context), ast.args.map((arg) => arg.visitExpression(this, context)), ast.pure), ast.sourceSpan);
+  }
+  visitTaggedTemplateLiteralExpr(ast, context) {
+    return this.setSourceMapRange(this.createTaggedTemplateExpression(ast.tag.visitExpression(this, context), this.getTemplateLiteralFromAst(ast.template, context)), ast.sourceSpan);
+  }
+  visitTemplateLiteralExpr(ast, context) {
+    return this.setSourceMapRange(this.factory.createTemplateLiteral(this.getTemplateLiteralFromAst(ast, context)), ast.sourceSpan);
+  }
+  visitInstantiateExpr(ast, context) {
+    return this.factory.createNewExpression(ast.classExpr.visitExpression(this, context), ast.args.map((arg) => arg.visitExpression(this, context)));
+  }
+  visitLiteralExpr(ast, _context) {
+    return this.setSourceMapRange(this.factory.createLiteral(ast.value), ast.sourceSpan);
+  }
+  visitRegularExpressionLiteral(ast, context) {
+    return this.setSourceMapRange(this.factory.createRegularExpressionLiteral(ast.body, ast.flags), ast.sourceSpan);
+  }
+  visitLocalizedString(ast, context) {
+    const elements = [createTemplateElement(ast.serializeI18nHead())];
+    const expressions = [];
+    for (let i = 0;i < ast.expressions.length; i++) {
+      const placeholder = this.setSourceMapRange(ast.expressions[i].visitExpression(this, context), ast.getPlaceholderSourceSpan(i));
+      expressions.push(placeholder);
+      elements.push(createTemplateElement(ast.serializeI18nTemplatePart(i + 1)));
+    }
+    const localizeTag = this.factory.createIdentifier("$localize");
+    return this.setSourceMapRange(this.createTaggedTemplateExpression(localizeTag, { elements, expressions }), ast.sourceSpan);
+  }
+  visitBuiltinType(ast) {
+    let builtInType;
+    switch (ast.name) {
+      case o.BuiltinTypeName.Bool:
+        builtInType = "boolean";
+        break;
+      case o.BuiltinTypeName.String:
+        builtInType = "string";
+        break;
+      case o.BuiltinTypeName.Dynamic:
+        builtInType = "any";
+        break;
+      case o.BuiltinTypeName.Number:
+      case o.BuiltinTypeName.Int:
+        builtInType = "number";
+        break;
+      case o.BuiltinTypeName.Function:
+        builtInType = "function";
+        break;
+      case o.BuiltinTypeName.None:
+        builtInType = "never";
+        break;
+      case o.BuiltinTypeName.Inferred:
+        return null;
+    }
+    return this.factory.createBuiltInType(builtInType);
+  }
+  visitExpressionType(ast, context) {
+    return this.factory.createExpressionType(ast.value.visitExpression(this, context), ast.typeParams === null || ast.typeParams.length === 0 ? null : ast.typeParams.map((param) => param.visitType(this, context)));
+  }
+  visitArrayType(ast, context) {
+    return this.factory.createArrayType(ast.of.visitType(this, context));
+  }
+  visitMapType(ast, context) {
+    const valueType = ast.valueType === null ? this.factory.createBuiltInType("unknown") : ast.valueType.visitType(this, context);
+    return this.factory.createMapType(valueType);
+  }
+  visitTransplantedType(type) {
+    return this.factory.transplantType(type.type);
+  }
+  createTaggedTemplateExpression(tag, template) {
+    return this.downlevelTaggedTemplates ? this.createES5TaggedTemplateFunctionCall(tag, template) : this.factory.createTaggedTemplate(tag, template);
+  }
+  createES5TaggedTemplateFunctionCall(tagHandler, { elements, expressions }) {
+    const __makeTemplateObjectHelper = this.imports.addImport({
+      exportModuleSpecifier: "tslib",
+      exportSymbolName: "__makeTemplateObject",
+      requestedFile: this.contextFile
+    });
+    const cooked = [];
+    const raw = [];
+    for (const element of elements) {
+      cooked.push(this.factory.setSourceMapRange(this.factory.createLiteral(element.cooked), element.range));
+      raw.push(this.factory.setSourceMapRange(this.factory.createLiteral(element.raw), element.range));
+    }
+    const templateHelperCall = this.factory.createCallExpression(__makeTemplateObjectHelper, [this.factory.createArrayLiteral(cooked), this.factory.createArrayLiteral(raw)], false);
+    return this.factory.createCallExpression(tagHandler, [templateHelperCall, ...expressions], false);
+  }
+  visitExternalExpr(ast, _context) {
+    if (ast.value.name === null) {
+      if (ast.value.moduleName === null) {
+        throw new Error("Invalid import without name nor moduleName");
+      }
+      return this.imports.addImport({
+        exportModuleSpecifier: ast.value.moduleName,
+        exportSymbolName: null,
+        requestedFile: this.contextFile
+      });
+    }
+    if (ast.value.moduleName !== null) {
+      return this.imports.addImport({
+        exportModuleSpecifier: ast.value.moduleName,
+        exportSymbolName: ast.value.name,
+        requestedFile: this.contextFile
+      });
+    } else {
+      return this.factory.createIdentifier(ast.value.name);
+    }
+  }
+  visitConditionalExpr(ast, context) {
+    return this.factory.createConditional(ast.condition.visitExpression(this, context), ast.trueCase.visitExpression(this, context), ast.falseCase.visitExpression(this, context));
+  }
+  visitDynamicImportExpr(ast, context) {
+    const urlExpression = typeof ast.url === "string" ? this.factory.createLiteral(ast.url) : ast.url.visitExpression(this, context);
+    if (ast.urlComment) {
+      this.factory.attachComments(urlExpression, [o.leadingComment(ast.urlComment, true)]);
+    }
+    return this.factory.createDynamicImport(urlExpression);
+  }
+  visitNotExpr(ast, context) {
+    return this.factory.createUnaryExpression("!", ast.condition.visitExpression(this, context));
+  }
+  visitFunctionExpr(ast, context) {
+    return this.factory.createFunctionExpression(ast.name ?? null, this.translateParams(ast.params, context), this.factory.createBlock(this.visitStatements(ast.statements, context)));
+  }
+  visitArrowFunctionExpr(ast, context) {
+    return this.factory.createArrowFunctionExpression(this.translateParams(ast.params, context), Array.isArray(ast.body) ? this.factory.createBlock(this.visitStatements(ast.body, context)) : ast.body.visitExpression(this, context));
+  }
+  visitBinaryOperatorExpr(ast, context) {
+    if (!BINARY_OPERATORS.has(ast.operator)) {
+      throw new Error(`Unknown binary operator: ${o.BinaryOperator[ast.operator]}`);
+    }
+    const operator = BINARY_OPERATORS.get(ast.operator);
+    if (ast.isAssignment()) {
+      return this.factory.createAssignment(ast.lhs.visitExpression(this, context), operator, ast.rhs.visitExpression(this, context));
+    }
+    return this.factory.createBinaryExpression(ast.lhs.visitExpression(this, context), operator, ast.rhs.visitExpression(this, context));
+  }
+  visitReadPropExpr(ast, context) {
+    return this.factory.createPropertyAccess(ast.receiver.visitExpression(this, context), ast.name);
+  }
+  visitReadKeyExpr(ast, context) {
+    return this.factory.createElementAccess(ast.receiver.visitExpression(this, context), ast.index.visitExpression(this, context));
+  }
+  visitLiteralArrayExpr(ast, context) {
+    return this.factory.createArrayLiteral(ast.entries.map((expr) => this.setSourceMapRange(expr.visitExpression(this, context), ast.sourceSpan)));
+  }
+  visitLiteralMapExpr(ast, context) {
+    const properties = ast.entries.map((entry) => {
+      return entry instanceof o.LiteralMapPropertyAssignment ? {
+        kind: "property",
+        propertyName: entry.key,
+        quoted: entry.quoted,
+        value: entry.value.visitExpression(this, context)
+      } : {
+        kind: "spread",
+        expression: entry.expression.visitExpression(this, context)
+      };
+    });
+    return this.setSourceMapRange(this.factory.createObjectLiteral(properties), ast.sourceSpan);
+  }
+  visitCommaExpr(ast, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitTemplateLiteralElementExpr(ast, context) {
+    throw new Error("Method not implemented");
+  }
+  visitSpreadElementExpr(ast, context) {
+    const expression = ast.expression.visitExpression(this, context);
+    return this.setSourceMapRange(this.factory.createSpreadElement(expression), ast.sourceSpan);
+  }
+  visitWrappedNodeExpr(ast, _context) {
+    this.recordWrappedNode(ast);
+    return ast.node;
+  }
+  visitTypeofExpr(ast, context) {
+    return this.factory.createTypeOfExpression(ast.expr.visitExpression(this, context));
+  }
+  visitVoidExpr(ast, context) {
+    return this.factory.createVoidExpression(ast.expr.visitExpression(this, context));
+  }
+  visitUnaryOperatorExpr(ast, context) {
+    if (!UNARY_OPERATORS.has(ast.operator)) {
+      throw new Error(`Unknown unary operator: ${o.UnaryOperator[ast.operator]}`);
+    }
+    return this.factory.createUnaryExpression(UNARY_OPERATORS.get(ast.operator), ast.expr.visitExpression(this, context));
+  }
+  visitParenthesizedExpr(ast, context) {
+    const result = ast.expr.visitExpression(this, context);
+    return this.factory.createParenthesizedExpression(result);
+  }
+  visitStatements(statements, context) {
+    return statements.map((stmt) => stmt.visitStatement(this, context)).filter((stmt) => stmt !== undefined);
+  }
+  setSourceMapRange(ast, span) {
+    return this.factory.setSourceMapRange(ast, createRange(span));
+  }
+  attachComments(statement, leadingComments) {
+    if (leadingComments !== undefined) {
+      this.factory.attachComments(statement, leadingComments);
+    }
+    return statement;
+  }
+  getTemplateLiteralFromAst(ast, context) {
+    return {
+      elements: ast.elements.map((e) => createTemplateElement({
+        cooked: e.text,
+        raw: e.rawText,
+        range: e.sourceSpan ?? ast.sourceSpan
+      })),
+      expressions: ast.expressions.map((e) => e.visitExpression(this, context))
+    };
+  }
+  translateParams(params, context) {
+    return params.map((param) => ({
+      name: param.name,
+      type: param.type?.visitType(this, context)
+    }));
+  }
+}
+function createTemplateElement({
+  cooked,
+  raw,
+  range
+}) {
+  return { cooked, raw, range: createRange(range) };
+}
+function createRange(span) {
+  if (span === null) {
+    return null;
+  }
+  const { start, end } = span;
+  const { url, content } = start.file;
+  if (!url) {
+    return null;
+  }
+  return {
+    url,
+    content,
+    start: { offset: start.offset, line: start.line, column: start.col },
+    end: { offset: end.offset, line: end.line, column: end.col }
+  };
+}
+var UNARY_OPERATORS, BINARY_OPERATORS;
+var init_translator = __esm(() => {
+  UNARY_OPERATORS = /* @__PURE__ */ new Map([
+    [o.UnaryOperator.Minus, "-"],
+    [o.UnaryOperator.Plus, "+"]
+  ]);
+  BINARY_OPERATORS = /* @__PURE__ */ new Map([
+    [o.BinaryOperator.And, "&&"],
+    [o.BinaryOperator.Bigger, ">"],
+    [o.BinaryOperator.BiggerEquals, ">="],
+    [o.BinaryOperator.BitwiseAnd, "&"],
+    [o.BinaryOperator.BitwiseOr, "|"],
+    [o.BinaryOperator.Divide, "/"],
+    [o.BinaryOperator.Equals, "=="],
+    [o.BinaryOperator.Identical, "==="],
+    [o.BinaryOperator.Lower, "<"],
+    [o.BinaryOperator.LowerEquals, "<="],
+    [o.BinaryOperator.Minus, "-"],
+    [o.BinaryOperator.Modulo, "%"],
+    [o.BinaryOperator.Multiply, "*"],
+    [o.BinaryOperator.NotEquals, "!="],
+    [o.BinaryOperator.NotIdentical, "!=="],
+    [o.BinaryOperator.Or, "||"],
+    [o.BinaryOperator.Plus, "+"],
+    [o.BinaryOperator.NullishCoalesce, "??"],
+    [o.BinaryOperator.Exponentiation, "**"],
+    [o.BinaryOperator.In, "in"],
+    [o.BinaryOperator.InstanceOf, "instanceof"],
+    [o.BinaryOperator.Assign, "="],
+    [o.BinaryOperator.AdditionAssignment, "+="],
+    [o.BinaryOperator.SubtractionAssignment, "-="],
+    [o.BinaryOperator.MultiplicationAssignment, "*="],
+    [o.BinaryOperator.DivisionAssignment, "/="],
+    [o.BinaryOperator.RemainderAssignment, "%="],
+    [o.BinaryOperator.ExponentiationAssignment, "**="],
+    [o.BinaryOperator.AndAssignment, "&&="],
+    [o.BinaryOperator.OrAssignment, "||="],
+    [o.BinaryOperator.NullishCoalesceAssignment, "??="]
+  ]);
+});
+
+// src/dev/angular/vendor/translator/ts_util.ts
+import ts5 from "typescript";
+function tsNumericExpression(value) {
+  if (value < 0) {
+    const operand = ts5.factory.createNumericLiteral(Math.abs(value));
+    return ts5.factory.createPrefixUnaryExpression(ts5.SyntaxKind.MinusToken, operand);
+  }
+  return ts5.factory.createNumericLiteral(value);
+}
+var init_ts_util = __esm(() => {
+  /*!
+   * @license
+   * Copyright Google LLC All Rights Reserved.
+   *
+   * Use of this source code is governed by an MIT-style license that can be
+   * found in the LICENSE file at https://angular.dev/license
+   */
+});
+
+// src/dev/angular/vendor/translator/typescript_ast_factory.ts
+import ts6 from "typescript";
+
+class TypeScriptAstFactory {
+  annotateForClosureCompiler;
+  externalSourceFiles = new Map;
+  UNARY_OPERATORS = /* @__PURE__ */ (() => ({
+    "+": ts6.SyntaxKind.PlusToken,
+    "-": ts6.SyntaxKind.MinusToken,
+    "!": ts6.SyntaxKind.ExclamationToken
+  }))();
+  BINARY_OPERATORS = /* @__PURE__ */ (() => ({
+    "&&": ts6.SyntaxKind.AmpersandAmpersandToken,
+    ">": ts6.SyntaxKind.GreaterThanToken,
+    ">=": ts6.SyntaxKind.GreaterThanEqualsToken,
+    "&": ts6.SyntaxKind.AmpersandToken,
+    "|": ts6.SyntaxKind.BarToken,
+    "/": ts6.SyntaxKind.SlashToken,
+    "==": ts6.SyntaxKind.EqualsEqualsToken,
+    "===": ts6.SyntaxKind.EqualsEqualsEqualsToken,
+    "<": ts6.SyntaxKind.LessThanToken,
+    "<=": ts6.SyntaxKind.LessThanEqualsToken,
+    "-": ts6.SyntaxKind.MinusToken,
+    "%": ts6.SyntaxKind.PercentToken,
+    "*": ts6.SyntaxKind.AsteriskToken,
+    "**": ts6.SyntaxKind.AsteriskAsteriskToken,
+    "!=": ts6.SyntaxKind.ExclamationEqualsToken,
+    "!==": ts6.SyntaxKind.ExclamationEqualsEqualsToken,
+    "||": ts6.SyntaxKind.BarBarToken,
+    "+": ts6.SyntaxKind.PlusToken,
+    "??": ts6.SyntaxKind.QuestionQuestionToken,
+    "=": ts6.SyntaxKind.EqualsToken,
+    "+=": ts6.SyntaxKind.PlusEqualsToken,
+    "-=": ts6.SyntaxKind.MinusEqualsToken,
+    "*=": ts6.SyntaxKind.AsteriskEqualsToken,
+    "/=": ts6.SyntaxKind.SlashEqualsToken,
+    "%=": ts6.SyntaxKind.PercentEqualsToken,
+    "**=": ts6.SyntaxKind.AsteriskAsteriskEqualsToken,
+    "&&=": ts6.SyntaxKind.AmpersandAmpersandEqualsToken,
+    "||=": ts6.SyntaxKind.BarBarEqualsToken,
+    "??=": ts6.SyntaxKind.QuestionQuestionEqualsToken,
+    in: ts6.SyntaxKind.InKeyword,
+    instanceof: ts6.SyntaxKind.InstanceOfKeyword
+  }))();
+  VAR_TYPES = /* @__PURE__ */ (() => ({
+    const: ts6.NodeFlags.Const,
+    let: ts6.NodeFlags.Let,
+    var: ts6.NodeFlags.None
+  }))();
+  constructor(annotateForClosureCompiler) {
+    this.annotateForClosureCompiler = annotateForClosureCompiler;
+  }
+  attachComments = attachComments;
+  createArrayLiteral = ts6.factory.createArrayLiteralExpression;
+  createAssignment(target, operator, value) {
+    return ts6.factory.createBinaryExpression(target, this.BINARY_OPERATORS[operator], value);
+  }
+  createBinaryExpression(leftOperand, operator, rightOperand) {
+    return ts6.factory.createBinaryExpression(leftOperand, this.BINARY_OPERATORS[operator], rightOperand);
+  }
+  createBlock(body) {
+    return ts6.factory.createBlock(body);
+  }
+  createCallExpression(callee, args, pure) {
+    const call = ts6.factory.createCallExpression(callee, undefined, args);
+    if (pure) {
+      ts6.addSyntheticLeadingComment(call, ts6.SyntaxKind.MultiLineCommentTrivia, this.annotateForClosureCompiler ? "* @pureOrBreakMyCode " /* CLOSURE */ : "@__PURE__" /* TERSER */, false);
+    }
+    return call;
+  }
+  createConditional(condition, whenTrue, whenFalse) {
+    return ts6.factory.createConditionalExpression(condition, undefined, whenTrue, undefined, whenFalse);
+  }
+  createElementAccess = ts6.factory.createElementAccessExpression;
+  createExpressionStatement = ts6.factory.createExpressionStatement;
+  createDynamicImport(url) {
+    return ts6.factory.createCallExpression(ts6.factory.createToken(ts6.SyntaxKind.ImportKeyword), undefined, [typeof url === "string" ? ts6.factory.createStringLiteral(url) : url]);
+  }
+  createFunctionDeclaration(functionName, parameters, body) {
+    if (!ts6.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts6.SyntaxKind[body.kind]}.`);
+    }
+    return ts6.factory.createFunctionDeclaration(undefined, undefined, functionName, undefined, parameters.map((param) => this.createParameter(param)), undefined, body);
+  }
+  createFunctionExpression(functionName, parameters, body) {
+    if (!ts6.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts6.SyntaxKind[body.kind]}.`);
+    }
+    return ts6.factory.createFunctionExpression(undefined, undefined, functionName ?? undefined, undefined, parameters.map((param) => this.createParameter(param)), undefined, body);
+  }
+  createArrowFunctionExpression(parameters, body) {
+    if (ts6.isStatement(body) && !ts6.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts6.SyntaxKind[body.kind]}.`);
+    }
+    return ts6.factory.createArrowFunction(undefined, undefined, parameters.map((param) => this.createParameter(param)), undefined, undefined, body);
+  }
+  createParameter(param) {
+    return ts6.factory.createParameterDeclaration(undefined, undefined, param.name, undefined, param.type ?? undefined);
+  }
+  createIdentifier = ts6.factory.createIdentifier;
+  createIfStatement(condition, thenStatement, elseStatement) {
+    return ts6.factory.createIfStatement(condition, thenStatement, elseStatement ?? undefined);
+  }
+  createLiteral(value) {
+    if (value === undefined) {
+      return ts6.factory.createIdentifier("undefined");
+    } else if (value === null) {
+      return ts6.factory.createNull();
+    } else if (typeof value === "boolean") {
+      return value ? ts6.factory.createTrue() : ts6.factory.createFalse();
+    } else if (typeof value === "number") {
+      return tsNumericExpression(value);
+    } else {
+      return ts6.factory.createStringLiteral(value);
+    }
+  }
+  createNewExpression(expression, args) {
+    return ts6.factory.createNewExpression(expression, undefined, args);
+  }
+  createObjectLiteral(properties) {
+    return ts6.factory.createObjectLiteralExpression(properties.map((prop) => {
+      if (prop.kind === "spread") {
+        return ts6.factory.createSpreadAssignment(prop.expression);
+      }
+      return ts6.factory.createPropertyAssignment(prop.quoted ? ts6.factory.createStringLiteral(prop.propertyName) : ts6.factory.createIdentifier(prop.propertyName), prop.value);
+    }));
+  }
+  createParenthesizedExpression = ts6.factory.createParenthesizedExpression;
+  createPropertyAccess = ts6.factory.createPropertyAccessExpression;
+  createSpreadElement = ts6.factory.createSpreadElement;
+  createReturnStatement(expression) {
+    return ts6.factory.createReturnStatement(expression ?? undefined);
+  }
+  createTaggedTemplate(tag, template) {
+    return ts6.factory.createTaggedTemplateExpression(tag, undefined, this.createTemplateLiteral(template));
+  }
+  createTemplateLiteral(template) {
+    let templateLiteral;
+    const length = template.elements.length;
+    const head = template.elements[0];
+    if (length === 1) {
+      templateLiteral = ts6.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
+    } else {
+      const spans = [];
+      for (let i = 1;i < length - 1; i++) {
+        const { cooked, raw, range } = template.elements[i];
+        const middle = createTemplateMiddle(cooked, raw);
+        if (range !== null) {
+          this.setSourceMapRange(middle, range);
+        }
+        spans.push(ts6.factory.createTemplateSpan(template.expressions[i - 1], middle));
+      }
+      const resolvedExpression = template.expressions[length - 2];
+      const templatePart = template.elements[length - 1];
+      const templateTail = createTemplateTail(templatePart.cooked, templatePart.raw);
+      if (templatePart.range !== null) {
+        this.setSourceMapRange(templateTail, templatePart.range);
+      }
+      spans.push(ts6.factory.createTemplateSpan(resolvedExpression, templateTail));
+      templateLiteral = ts6.factory.createTemplateExpression(ts6.factory.createTemplateHead(head.cooked, head.raw), spans);
+    }
+    if (head.range !== null) {
+      this.setSourceMapRange(templateLiteral, head.range);
+    }
+    return templateLiteral;
+  }
+  createThrowStatement = ts6.factory.createThrowStatement;
+  createTypeOfExpression = ts6.factory.createTypeOfExpression;
+  createVoidExpression = ts6.factory.createVoidExpression;
+  createUnaryExpression(operator, operand) {
+    return ts6.factory.createPrefixUnaryExpression(this.UNARY_OPERATORS[operator], operand);
+  }
+  createVariableDeclaration(variableName, initializer, variableType, type) {
+    return ts6.factory.createVariableStatement(undefined, ts6.factory.createVariableDeclarationList([
+      ts6.factory.createVariableDeclaration(variableName, undefined, type ?? undefined, initializer ?? undefined)
+    ], this.VAR_TYPES[variableType]));
+  }
+  createRegularExpressionLiteral(body, flags) {
+    return ts6.factory.createRegularExpressionLiteral(`/${body}/${flags ?? ""}`);
+  }
+  setSourceMapRange(node, sourceMapRange) {
+    if (sourceMapRange === null) {
+      return node;
+    }
+    const url = sourceMapRange.url;
+    if (!this.externalSourceFiles.has(url)) {
+      this.externalSourceFiles.set(url, ts6.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
+    }
+    const source = this.externalSourceFiles.get(url);
+    ts6.setSourceMapRange(node, {
+      pos: sourceMapRange.start.offset,
+      end: sourceMapRange.end.offset,
+      source
+    });
+    return node;
+  }
+  createBuiltInType(type) {
+    switch (type) {
+      case "any":
+        return ts6.factory.createKeywordTypeNode(ts6.SyntaxKind.AnyKeyword);
+      case "boolean":
+        return ts6.factory.createKeywordTypeNode(ts6.SyntaxKind.BooleanKeyword);
+      case "number":
+        return ts6.factory.createKeywordTypeNode(ts6.SyntaxKind.NumberKeyword);
+      case "string":
+        return ts6.factory.createKeywordTypeNode(ts6.SyntaxKind.StringKeyword);
+      case "function":
+        return ts6.factory.createTypeReferenceNode(ts6.factory.createIdentifier("Function"));
+      case "never":
+        return ts6.factory.createKeywordTypeNode(ts6.SyntaxKind.NeverKeyword);
+      case "unknown":
+        return ts6.factory.createKeywordTypeNode(ts6.SyntaxKind.UnknownKeyword);
+    }
+  }
+  createExpressionType(expression, typeParams) {
+    const typeName = getEntityTypeFromExpression(expression);
+    return ts6.factory.createTypeReferenceNode(typeName, typeParams ?? undefined);
+  }
+  createArrayType(elementType) {
+    return ts6.factory.createArrayTypeNode(elementType);
+  }
+  createMapType(valueType) {
+    return ts6.factory.createTypeLiteralNode([
+      ts6.factory.createIndexSignature(undefined, [
+        ts6.factory.createParameterDeclaration(undefined, undefined, "key", undefined, ts6.factory.createKeywordTypeNode(ts6.SyntaxKind.StringKeyword))
+      ], valueType)
+    ]);
+  }
+  transplantType(type) {
+    if (typeof type.kind === "number" && typeof type.getSourceFile === "function" && ts6.isTypeNode(type)) {
+      return type;
+    }
+    throw new Error("Attempting to transplant a type node from a non-TypeScript AST: " + type);
+  }
+}
+function createTemplateMiddle(cooked, raw) {
+  const node = ts6.factory.createTemplateHead(cooked, raw);
+  node.kind = ts6.SyntaxKind.TemplateMiddle;
+  return node;
+}
+function createTemplateTail(cooked, raw) {
+  const node = ts6.factory.createTemplateHead(cooked, raw);
+  node.kind = ts6.SyntaxKind.TemplateTail;
+  return node;
+}
+function attachComments(statement, leadingComments) {
+  for (const comment of leadingComments) {
+    const commentKind = comment.multiline ? ts6.SyntaxKind.MultiLineCommentTrivia : ts6.SyntaxKind.SingleLineCommentTrivia;
+    if (comment.multiline) {
+      ts6.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
+    } else {
+      for (const line of comment.toString().split(`
+`)) {
+        ts6.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
+      }
+    }
+  }
+}
+function getEntityTypeFromExpression(expression) {
+  if (ts6.isIdentifier(expression)) {
+    return expression;
+  }
+  if (ts6.isPropertyAccessExpression(expression)) {
+    const left = getEntityTypeFromExpression(expression.expression);
+    if (!ts6.isIdentifier(expression.name)) {
+      throw new Error(`Unsupported property access for type reference: ${expression.name.text}`);
+    }
+    return ts6.factory.createQualifiedName(left, expression.name);
+  }
+  throw new Error(`Unsupported expression for type reference: ${ts6.SyntaxKind[expression.kind]}`);
+}
+var init_typescript_ast_factory = __esm(() => {
+  init_ts_util();
+});
+
+// src/dev/angular/vendor/translator/typescript_translator.ts
+function translateStatement(contextFile, statement, imports, options = {}) {
+  return statement.visitStatement(new ExpressionTranslatorVisitor(new TypeScriptAstFactory(options.annotateForClosureCompiler === true), imports, contextFile, options), new Context(true));
+}
+var init_typescript_translator = __esm(() => {
+  init_translator();
+  init_typescript_ast_factory();
+});
+
+// src/dev/angular/fastHmrCompiler.ts
+var exports_fastHmrCompiler = {};
+__export(exports_fastHmrCompiler, {
+  tryFastHmr: () => tryFastHmr,
+  recordFingerprint: () => recordFingerprint,
+  invalidateFingerprintCache: () => invalidateFingerprintCache
+});
+import { existsSync as existsSync26, readFileSync as readFileSync20 } from "fs";
+import { dirname as dirname19, relative as relative13, resolve as resolve33 } from "path";
+import ts7 from "typescript";
+var fail = (reason, detail) => ({ ok: false, reason, detail }), fingerprintCache, fingerprintsEqual = (a, b2) => {
+  if (a.className !== b2.className)
+    return false;
+  if (a.selector !== b2.selector)
+    return false;
+  if (a.standalone !== b2.standalone)
+    return false;
+  if (a.importsArity !== b2.importsArity)
+    return false;
+  if (a.hasProviders !== b2.hasProviders)
+    return false;
+  if (a.hasViewProviders !== b2.hasViewProviders)
+    return false;
+  if (a.ctorParamTypes.length !== b2.ctorParamTypes.length)
+    return false;
+  for (let i = 0;i < a.ctorParamTypes.length; i++) {
+    if (a.ctorParamTypes[i] !== b2.ctorParamTypes[i])
+      return false;
+  }
+  if (a.inputs.length !== b2.inputs.length)
+    return false;
+  for (let i = 0;i < a.inputs.length; i++) {
+    if (a.inputs[i] !== b2.inputs[i])
+      return false;
+  }
+  if (a.outputs.length !== b2.outputs.length)
+    return false;
+  for (let i = 0;i < a.outputs.length; i++) {
+    if (a.outputs[i] !== b2.outputs[i])
+      return false;
+  }
+  return true;
+}, recordFingerprint = (id, fp) => {
+  fingerprintCache.set(id, fp);
+}, invalidateFingerprintCache = () => {
+  fingerprintCache.clear();
+}, findClassDeclaration = (sourceFile, className) => {
+  let found = null;
+  const walk = (node) => {
+    if (found)
+      return;
+    if (ts7.isClassDeclaration(node) && node.name?.text === className) {
+      found = node;
+      return;
+    }
+    ts7.forEachChild(node, walk);
+  };
+  walk(sourceFile);
+  return found;
+}, getClassDecorators = (cls) => {
+  const modifiers = ts7.getDecorators(cls) ?? [];
+  return [...modifiers];
+}, findComponentDecorator = (cls) => {
+  for (const decorator of getClassDecorators(cls)) {
+    const expr = decorator.expression;
+    if (ts7.isCallExpression(expr)) {
+      const fn2 = expr.expression;
+      if (ts7.isIdentifier(fn2) && fn2.text === "Component") {
+        return decorator;
+      }
+    }
+  }
+  return null;
+}, getDecoratorArgsObject = (decorator) => {
+  const call = decorator.expression;
+  if (!ts7.isCallExpression(call))
+    return null;
+  const arg = call.arguments[0];
+  if (!arg || !ts7.isObjectLiteralExpression(arg))
+    return null;
+  return arg;
+}, getProperty = (obj, name) => {
+  for (const prop of obj.properties) {
+    if (ts7.isPropertyAssignment(prop) && (ts7.isIdentifier(prop.name) && prop.name.text === name || ts7.isStringLiteral(prop.name) && prop.name.text === name)) {
+      return prop.initializer;
+    }
+  }
+  return null;
+}, getStringProperty = (obj, name) => {
+  const expr = getProperty(obj, name);
+  if (!expr)
+    return null;
+  if (ts7.isStringLiteral(expr) || ts7.isNoSubstitutionTemplateLiteral(expr)) {
+    return expr.text;
+  }
+  return null;
+}, getBooleanProperty = (obj, name) => {
+  const expr = getProperty(obj, name);
+  if (!expr)
+    return null;
+  if (expr.kind === ts7.SyntaxKind.TrueKeyword)
+    return true;
+  if (expr.kind === ts7.SyntaxKind.FalseKeyword)
+    return false;
+  return null;
+}, inheritsDecoratedClass = (cls) => {
+  const heritage = cls.heritageClauses ?? [];
+  for (const clause of heritage) {
+    if (clause.token !== ts7.SyntaxKind.ExtendsKeyword)
+      continue;
+    if (clause.types.length > 0)
+      return true;
+  }
+  return false;
+}, readDecoratorMeta = (args) => {
+  const styleUrlsExpr = getProperty(args, "styleUrls");
+  const stylesExpr = getProperty(args, "styles");
+  const importsExpr = getProperty(args, "imports");
+  const styleUrls = [];
+  if (styleUrlsExpr && ts7.isArrayLiteralExpression(styleUrlsExpr)) {
+    for (const el of styleUrlsExpr.elements) {
+      if (ts7.isStringLiteral(el))
+        styleUrls.push(el.text);
+    }
+  }
+  const styles = [];
+  if (stylesExpr) {
+    if (ts7.isArrayLiteralExpression(stylesExpr)) {
+      for (const el of stylesExpr.elements) {
+        if (ts7.isStringLiteral(el) || ts7.isNoSubstitutionTemplateLiteral(el)) {
+          styles.push(el.text);
+        }
+      }
+    } else if (ts7.isStringLiteral(stylesExpr) || ts7.isNoSubstitutionTemplateLiteral(stylesExpr)) {
+      styles.push(stylesExpr.text);
+    }
+  }
+  return {
+    hasProviders: getProperty(args, "providers") !== null,
+    hasViewProviders: getProperty(args, "viewProviders") !== null,
+    importsExpr: importsExpr && ts7.isArrayLiteralExpression(importsExpr) ? importsExpr : null,
+    preserveWhitespaces: getBooleanProperty(args, "preserveWhitespaces") ?? false,
+    selector: getStringProperty(args, "selector"),
+    standalone: getBooleanProperty(args, "standalone") ?? true,
+    styleUrl: getStringProperty(args, "styleUrl"),
+    styleUrls,
+    styles,
+    template: getStringProperty(args, "template"),
+    templateUrl: getStringProperty(args, "templateUrl")
+  };
+}, extractDecoratorInput = (prop) => {
+  const decorators = ts7.getDecorators(prop) ?? [];
+  for (const decorator of decorators) {
+    const expr = decorator.expression;
+    if (!ts7.isCallExpression(expr))
+      continue;
+    const fn2 = expr.expression;
+    if (!ts7.isIdentifier(fn2) || fn2.text !== "Input")
+      continue;
+    const classPropertyName = prop.name.getText();
+    let bindingPropertyName = classPropertyName;
+    let required = false;
+    const arg = expr.arguments[0];
+    if (arg) {
+      if (ts7.isStringLiteral(arg)) {
+        bindingPropertyName = arg.text;
+      } else if (ts7.isObjectLiteralExpression(arg)) {
+        const aliasNode = getStringProperty(arg, "alias");
+        if (aliasNode !== null)
+          bindingPropertyName = aliasNode;
+        required = getBooleanProperty(arg, "required") ?? false;
+      }
+    }
+    return {
+      classPropertyName,
+      meta: {
+        classPropertyName,
+        bindingPropertyName,
+        required,
+        isSignal: false,
+        transformFunction: null
+      }
+    };
+  }
+  return null;
+}, isInputSignalCall = (init) => {
+  if (ts7.isCallExpression(init)) {
+    const fn2 = init.expression;
+    if (ts7.isIdentifier(fn2) && fn2.text === "input")
+      return true;
+    if (ts7.isPropertyAccessExpression(fn2) && ts7.isIdentifier(fn2.expression) && fn2.expression.text === "input") {
+      return true;
+    }
+  }
+  return false;
+}, extractSignalInput = (prop) => {
+  if (!prop.initializer || !isInputSignalCall(prop.initializer))
+    return null;
+  const classPropertyName = prop.name.getText();
+  const call = prop.initializer;
+  let required = false;
+  if (ts7.isPropertyAccessExpression(call.expression) && ts7.isIdentifier(call.expression.name) && call.expression.name.text === "required") {
+    required = true;
+  }
+  let bindingPropertyName = classPropertyName;
+  const optsArg = call.arguments[required ? 0 : 1];
+  if (optsArg && ts7.isObjectLiteralExpression(optsArg)) {
+    const aliasNode = getStringProperty(optsArg, "alias");
+    if (aliasNode !== null)
+      bindingPropertyName = aliasNode;
+  }
+  return {
+    classPropertyName,
+    meta: {
+      classPropertyName,
+      bindingPropertyName,
+      required,
+      isSignal: true,
+      transformFunction: null
+    }
+  };
+}, extractDecoratorOutput = (prop) => {
+  const decorators = ts7.getDecorators(prop) ?? [];
+  for (const decorator of decorators) {
+    const expr = decorator.expression;
+    if (!ts7.isCallExpression(expr))
+      continue;
+    const fn2 = expr.expression;
+    if (!ts7.isIdentifier(fn2) || fn2.text !== "Output")
+      continue;
+    const classPropertyName = prop.name.getText();
+    let bindingName = classPropertyName;
+    const arg = expr.arguments[0];
+    if (arg && ts7.isStringLiteral(arg))
+      bindingName = arg.text;
+    return { classPropertyName, bindingName };
+  }
+  return null;
+}, isOutputSignalCall = (init) => {
+  if (ts7.isCallExpression(init)) {
+    const fn2 = init.expression;
+    if (ts7.isIdentifier(fn2) && fn2.text === "output")
+      return true;
+    if (ts7.isPropertyAccessExpression(fn2) && ts7.isIdentifier(fn2.expression) && fn2.expression.text === "output") {
+      return true;
+    }
+  }
+  return false;
+}, extractSignalOutput = (prop) => {
+  if (!prop.initializer || !isOutputSignalCall(prop.initializer))
+    return null;
+  const classPropertyName = prop.name.getText();
+  const call = prop.initializer;
+  let bindingName = classPropertyName;
+  const optsArg = call.arguments[0];
+  if (optsArg && ts7.isObjectLiteralExpression(optsArg)) {
+    const aliasNode = getStringProperty(optsArg, "alias");
+    if (aliasNode !== null)
+      bindingName = aliasNode;
+  }
+  return { classPropertyName, bindingName };
+}, extractInputsAndOutputs = (cls) => {
+  const inputs = {};
+  const outputs = {};
+  for (const member of cls.members) {
+    if (!ts7.isPropertyDeclaration(member))
+      continue;
+    const decoratorIn = extractDecoratorInput(member);
+    if (decoratorIn) {
+      inputs[decoratorIn.classPropertyName] = decoratorIn.meta;
+      continue;
+    }
+    const signalIn = extractSignalInput(member);
+    if (signalIn) {
+      inputs[signalIn.classPropertyName] = signalIn.meta;
+      continue;
+    }
+    const decoratorOut = extractDecoratorOutput(member);
+    if (decoratorOut) {
+      outputs[decoratorOut.classPropertyName] = decoratorOut.bindingName;
+      continue;
+    }
+    const signalOut = extractSignalOutput(member);
+    if (signalOut) {
+      outputs[signalOut.classPropertyName] = signalOut.bindingName;
+    }
+  }
+  return { inputs, outputs };
+}, extractFingerprint = (cls, className, decoratorMeta, inputs, outputs) => {
+  const ctorParamTypes = [];
+  for (const member of cls.members) {
+    if (!ts7.isConstructorDeclaration(member))
+      continue;
+    for (const param of member.parameters) {
+      ctorParamTypes.push(param.type ? param.type.getText() : "");
+    }
+    break;
+  }
+  const inputNames = Object.keys(inputs).sort();
+  const outputNames = Object.keys(outputs).sort();
+  const importsArity = decoratorMeta.importsExpr ? decoratorMeta.importsExpr.elements.length : 0;
+  const hasProviders = decoratorMeta.hasProviders;
+  const hasViewProviders = decoratorMeta.hasViewProviders;
+  return {
+    className,
+    ctorParamTypes,
+    hasProviders,
+    hasViewProviders,
+    importsArity,
+    inputs: inputNames,
+    outputs: outputNames,
+    selector: decoratorMeta.selector,
+    standalone: decoratorMeta.standalone
+  };
+}, resolveAndReadResource = (componentDir, url) => {
+  const abs = resolve33(componentDir, url);
+  if (!existsSync26(abs))
+    return null;
+  return readFileSync20(abs, "utf8");
+}, collectStyles = (decoratorMeta, componentDir) => {
+  const styles = [...decoratorMeta.styles];
+  const urls = [];
+  if (decoratorMeta.styleUrl)
+    urls.push(decoratorMeta.styleUrl);
+  urls.push(...decoratorMeta.styleUrls);
+  for (const url of urls) {
+    const css = resolveAndReadResource(componentDir, url);
+    if (css === null)
+      return { styles, missing: url };
+    styles.push(css);
+  }
+  return { styles, missing: null };
+}, tryFastHmr = async (params) => {
+  const { componentFilePath, className } = params;
+  const projectRoot = params.projectRoot ?? process.cwd();
+  if (!existsSync26(componentFilePath)) {
+    return fail("file-not-found", componentFilePath);
+  }
+  let compiler;
+  try {
+    compiler = await import("@angular/compiler");
+  } catch (err) {
+    return fail("unexpected-error", `import @angular/compiler: ${err}`);
+  }
+  const tsSource = readFileSync20(componentFilePath, "utf8");
+  const sourceFile = ts7.createSourceFile(componentFilePath, tsSource, ts7.ScriptTarget.ES2022, true, ts7.ScriptKind.TS);
+  const classNode = findClassDeclaration(sourceFile, className);
+  if (!classNode) {
+    return fail("class-not-found", `${className} in ${componentFilePath}`);
+  }
+  if (inheritsDecoratedClass(classNode)) {
+    return fail("inherits-decorated-class");
+  }
+  const decorator = findComponentDecorator(classNode);
+  if (!decorator)
+    return fail("no-component-decorator");
+  const decoratorArgs = getDecoratorArgsObject(decorator);
+  if (!decoratorArgs)
+    return fail("unsupported-decorator-args");
+  const decoratorMeta = readDecoratorMeta(decoratorArgs);
+  if (!decoratorMeta.standalone)
+    return fail("not-standalone");
+  const componentDir = dirname19(componentFilePath);
+  let templateText;
+  let templatePath;
+  if (decoratorMeta.template !== null) {
+    templateText = decoratorMeta.template;
+    templatePath = componentFilePath;
+  } else if (decoratorMeta.templateUrl) {
+    const tplAbs = resolve33(componentDir, decoratorMeta.templateUrl);
+    if (!existsSync26(tplAbs)) {
+      return fail("template-resource-not-found", tplAbs);
+    }
+    templateText = readFileSync20(tplAbs, "utf8");
+    templatePath = tplAbs;
+  } else {
+    return fail("unsupported-decorator-args", "missing template/templateUrl");
+  }
+  const { styles, missing: missingStyle } = collectStyles(decoratorMeta, componentDir);
+  if (missingStyle) {
+    return fail("style-resource-not-found", missingStyle);
+  }
+  let parsed;
+  try {
+    parsed = compiler.parseTemplate(templateText, templatePath, {
+      preserveWhitespaces: decoratorMeta.preserveWhitespaces
+    });
+  } catch (err) {
+    return fail("template-parse-error", String(err));
+  }
+  if (parsed.errors && parsed.errors.length > 0) {
+    return fail("template-parse-error", parsed.errors.map((e) => e.toString()).join(`
+`));
+  }
+  const className_ = classNode.name;
+  if (!className_)
+    return fail("class-not-found", "anonymous class");
+  const wrappedClass = new compiler.WrappedNodeExpr(className_);
+  const { inputs, outputs } = extractInputsAndOutputs(classNode);
+  const projectRelPath = relative13(projectRoot, componentFilePath).replace(/\\/g, "/");
+  const fingerprintId = encodeURIComponent(`${projectRelPath}@${className}`);
+  const currentFingerprint = extractFingerprint(classNode, className, decoratorMeta, inputs, outputs);
+  const cachedFingerprint = fingerprintCache.get(fingerprintId);
+  if (cachedFingerprint && !fingerprintsEqual(cachedFingerprint, currentFingerprint)) {
+    return fail("structural-change", `fingerprint changed for ${className}; escalate to Tier 1`);
+  }
+  const sourceFileObj = new compiler.ParseSourceFile(tsSource, componentFilePath);
+  const zeroLoc = new compiler.ParseLocation(sourceFileObj, 0, 0, 0);
+  const typeSourceSpan = new compiler.ParseSourceSpan(zeroLoc, zeroLoc);
+  const importsArray = [];
+  if (decoratorMeta.importsExpr) {
+    for (const el of decoratorMeta.importsExpr.elements) {
+      importsArray.push(new compiler.WrappedNodeExpr(el));
+    }
+  }
+  const declarations = importsArray.map((expr) => ({
+    kind: 0,
+    type: expr,
+    selector: "",
+    inputs: [],
+    outputs: [],
+    exportAs: null,
+    isComponent: false
+  }));
+  const meta = {
+    name: className,
+    type: { value: wrappedClass, type: wrappedClass },
+    typeArgumentCount: 0,
+    typeSourceSpan,
+    deps: null,
+    selector: decoratorMeta.selector,
+    queries: [],
+    viewQueries: [],
+    host: {
+      attributes: {},
+      listeners: {},
+      properties: {},
+      specialAttributes: {}
+    },
+    lifecycle: { usesOnChanges: false },
+    inputs,
+    outputs,
+    usesInheritance: false,
+    controlCreate: null,
+    exportAs: null,
+    providers: null,
+    isStandalone: true,
+    isSignal: false,
+    hostDirectives: null,
+    template: {
+      nodes: parsed.nodes,
+      ngContentSelectors: parsed.ngContentSelectors ?? [],
+      preserveWhitespaces: decoratorMeta.preserveWhitespaces
+    },
+    declarations,
+    defer: { mode: 0, blocks: new Map },
+    declarationListEmitMode: 0,
+    styles,
+    encapsulation: 0,
+    animations: null,
+    viewProviders: null,
+    relativeContextFilePath: projectRelPath,
+    i18nUseExternalIds: false,
+    changeDetection: null,
+    relativeTemplatePath: null,
+    hasDirectiveDependencies: importsArray.length > 0
+  };
+  let compiled;
+  try {
+    const pool = new compiler.ConstantPool;
+    const bindingParser = compiler.makeBindingParser();
+    compiled = compiler.compileComponentFromMetadata(meta, pool, bindingParser);
+    const namespaceDependencies = [
+      { moduleName: "@angular/core", assignedName: "\u0275hmr0" }
+    ];
+    const callback = compiler.compileHmrUpdateCallback([
+      {
+        name: "\u0275cmp",
+        initializer: compiled.expression,
+        statements: compiled.statements ?? []
+      }
+    ], pool.statements, {
+      type: wrappedClass,
+      className,
+      filePath: projectRelPath,
+      namespaceDependencies,
+      localDependencies: []
+    });
+    const namespaceMap = new Map;
+    for (const dep of namespaceDependencies) {
+      namespaceMap.set(dep.moduleName, dep.assignedName);
+    }
+    const importGenerator = createHmrImportGenerator(namespaceMap);
+    const tsFunctionDecl = translateStatement(sourceFile, callback, importGenerator);
+    const exportedDecl = ts7.factory.updateFunctionDeclaration(tsFunctionDecl, [
+      ts7.factory.createToken(ts7.SyntaxKind.ExportKeyword),
+      ts7.factory.createToken(ts7.SyntaxKind.DefaultKeyword)
+    ], tsFunctionDecl.asteriskToken, tsFunctionDecl.name, tsFunctionDecl.typeParameters, tsFunctionDecl.parameters, tsFunctionDecl.type, tsFunctionDecl.body);
+    const printer = ts7.createPrinter({
+      newLine: ts7.NewLineKind.LineFeed,
+      removeComments: false
+    });
+    const tsSourceText = printer.printNode(ts7.EmitHint.Unspecified, exportedDecl, sourceFile);
+    const moduleText = ts7.transpileModule(tsSourceText, {
+      compilerOptions: {
+        module: ts7.ModuleKind.ES2022,
+        target: ts7.ScriptTarget.ES2022
+      },
+      fileName: componentFilePath,
+      reportDiagnostics: false
+    }).outputText;
+    fingerprintCache.set(fingerprintId, currentFingerprint);
+    return { ok: true, moduleText, componentSource: sourceFile };
+  } catch (err) {
+    return fail("unexpected-error", String(err));
+  }
+};
+var init_fastHmrCompiler = __esm(() => {
+  init_hmrImportGenerator();
+  init_typescript_translator();
+  fingerprintCache = new Map;
+});
+
+// src/dev/angular/hmrCompiler.ts
+var exports_hmrCompiler = {};
+__export(exports_hmrCompiler, {
+  getCachedHmrProgram: () => getCachedHmrProgram,
+  getApplyMetadataModule: () => getApplyMetadataModule,
+  findClassNodeById: () => findClassNodeById,
+  encodeHmrComponentId: () => encodeHmrComponentId,
+  compileAngularForHmr: () => compileAngularForHmr
+});
+import { existsSync as existsSync27 } from "fs";
+import { basename as basename12, dirname as dirname20, join as join30, relative as relative14, resolve as resolve34 } from "path";
+import { performance as performance2 } from "perf_hooks";
+import ts8 from "typescript";
+var globalCache, getCachedHmrProgram = () => globalCache.__ABSOLUTE_ANGULAR_HMR_PROGRAM__ ?? null, setCachedHmrProgram = (program) => {
+  globalCache.__ABSOLUTE_ANGULAR_HMR_PROGRAM__ = program;
+}, resolveTypescriptLibDirCached = null, resolveTypescriptLibDir = () => {
+  if (resolveTypescriptLibDirCached)
+    return resolveTypescriptLibDirCached;
+  const tsPath = __require.resolve("typescript");
+  const tsRootDir = dirname20(tsPath);
+  resolveTypescriptLibDirCached = tsRootDir.endsWith("lib") ? tsRootDir : resolve34(tsRootDir, "lib");
+  return resolveTypescriptLibDirCached;
+}, buildHmrCompilerOptions = (base) => ({
+  ...base,
+  emitDecoratorMetadata: true,
+  esModuleInterop: true,
+  experimentalDecorators: true,
+  module: ts8.ModuleKind.ESNext,
+  moduleResolution: ts8.ModuleResolutionKind.Bundler,
+  newLine: ts8.NewLineKind.LineFeed,
+  noEmit: false,
+  noLib: false,
+  rootDir: process.cwd(),
+  skipLibCheck: true,
+  target: ts8.ScriptTarget.ES2022,
+  _enableHmr: true,
+  enableHmr: true
+}), ANGULAR_COMPILER_OPTIONS_CACHE, loadAngularCompilerOptions = async () => {
+  if (ANGULAR_COMPILER_OPTIONS_CACHE.value) {
+    return ANGULAR_COMPILER_OPTIONS_CACHE.value;
+  }
+  const { readConfiguration } = await import("@angular/compiler-cli");
+  const config = readConfiguration("./tsconfig.json");
+  ANGULAR_COMPILER_OPTIONS_CACHE.value = config.options;
+  return config.options;
+}, cachedTsconfigMtime = 0, refreshAngularCompilerOptionsIfStale = async () => {
+  const tsconfigPath = resolve34(process.cwd(), "tsconfig.json");
+  if (!existsSync27(tsconfigPath))
+    return;
+  const stat3 = await import("fs/promises").then((m) => m.stat(tsconfigPath));
+  if (stat3.mtimeMs > cachedTsconfigMtime) {
+    ANGULAR_COMPILER_OPTIONS_CACHE.value = null;
+    cachedTsconfigMtime = stat3.mtimeMs;
+  }
+}, compileAngularForHmr = async (inputPaths, outDir, modifiedResourceFiles = null) => {
+  await refreshAngularCompilerOptionsIfStale();
+  await import("@angular/compiler");
+  const { performCompilation, EmitFlags } = await import("@angular/compiler-cli");
+  const baseOptions = await loadAngularCompilerOptions();
+  const options = buildHmrCompilerOptions(baseOptions);
+  options.outDir = outDir;
+  options.target = ts8.ScriptTarget.ES2022;
+  options.experimentalDecorators = true;
+  options.emitDecoratorMetadata = true;
+  options.newLine = ts8.NewLineKind.LineFeed;
+  options.incremental = false;
+  options.tsBuildInfoFile = undefined;
+  const tsLibDir = resolveTypescriptLibDir();
+  const host = ts8.createCompilerHost(options);
+  const originalGetDefaultLibLocation = host.getDefaultLibLocation;
+  host.getDefaultLibLocation = () => tsLibDir || (originalGetDefaultLibLocation ? originalGetDefaultLibLocation() : "");
+  const originalGetDefaultLibFileName = host.getDefaultLibFileName;
+  host.getDefaultLibFileName = (opts) => {
+    const fileName = originalGetDefaultLibFileName ? originalGetDefaultLibFileName(opts) : "lib.d.ts";
+    return basename12(fileName);
+  };
+  const originalGetSourceFile = host.getSourceFile;
+  host.getSourceFile = (fileName, languageVersion, onError) => {
+    if (fileName.startsWith("lib.") && fileName.endsWith(".d.ts") && tsLibDir) {
+      return originalGetSourceFile?.call(host, join30(tsLibDir, fileName), languageVersion, onError);
+    }
+    return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
+  };
+  const emitted = {};
+  const resolvedOutDir = resolve34(outDir);
+  host.writeFile = (fileName, text) => {
+    const normalized = fileName.replace(/\\/g, "/");
+    const rel = normalized.startsWith(resolvedOutDir.replace(/\\/g, "/")) ? relative14(resolvedOutDir, normalized).replace(/\\/g, "/") : relative14(process.cwd(), normalized).replace(/\\/g, "/");
+    emitted[rel] = text;
+  };
+  const oldProgram = getCachedHmrProgram();
+  const performArgs = {
+    emitFlags: EmitFlags.Default,
+    forceEmit: true,
+    host,
+    options,
+    rootNames: inputPaths
+  };
+  if (modifiedResourceFiles && modifiedResourceFiles.size > 0) {
+    performArgs.modifiedResourceFiles = new Set(modifiedResourceFiles);
+  }
+  if (oldProgram) {
+    performArgs.oldProgram = oldProgram;
+  }
+  const compileResult = performCompilation(performArgs);
+  const program = compileResult.program;
+  if (program)
+    setCachedHmrProgram(program);
+  return {
+    program,
+    emitted,
+    diagnostics: compileResult.diagnostics ?? []
+  };
+}, findClassNodeById = (program, encodedId) => {
+  const decoded = decodeURIComponent(encodedId);
+  const at2 = decoded.lastIndexOf("@");
+  if (at2 === -1)
+    return null;
+  const filePath = decoded.slice(0, at2);
+  const className = decoded.slice(at2 + 1);
+  const tsProgram = program.compiler.getCurrentProgram();
+  const absoluteCandidate = resolve34(process.cwd(), filePath).replace(/\\/g, "/");
+  const matchesPath = (sourceFileName) => {
+    const normalized = sourceFileName.replace(/\\/g, "/");
+    if (normalized === absoluteCandidate)
+      return true;
+    if (normalized === filePath)
+      return true;
+    return normalized.endsWith("/" + filePath) || normalized.endsWith(filePath);
+  };
+  let sourceFile = tsProgram.getSourceFile(absoluteCandidate) ?? null;
+  if (!sourceFile) {
+    for (const candidate of tsProgram.getSourceFiles()) {
+      if (matchesPath(candidate.fileName)) {
+        sourceFile = candidate;
+        break;
+      }
+    }
+  }
+  if (!sourceFile)
+    return null;
+  let found = null;
+  const walk = (node) => {
+    if (found)
+      return;
+    if (ts8.isClassDeclaration(node) && node.name?.text === className) {
+      found = node;
+      return;
+    }
+    ts8.forEachChild(node, walk);
+  };
+  walk(sourceFile);
+  return found;
+}, getApplyMetadataModule = async (encodedId) => {
+  const decoded = decodeURIComponent(encodedId);
+  const at2 = decoded.lastIndexOf("@");
+  if (at2 === -1)
+    return null;
+  const filePathRel = decoded.slice(0, at2);
+  const className = decoded.slice(at2 + 1);
+  const componentFilePath = resolve34(process.cwd(), filePathRel);
+  const fastStart = performance2.now();
+  const fast = await tryFastHmr({ componentFilePath, className });
+  if (fast.ok) {
+    logInfo(`[ng-hmr fast] ${className} ${(performance2.now() - fastStart).toFixed(1)}ms`);
+    return fast.moduleText;
+  }
+  logWarn(`[ng-hmr slow] ${className} fast path bailed (${fast.reason}${fast.detail ? `: ${fast.detail}` : ""}), falling back to ngtsc`);
+  const program = getCachedHmrProgram();
+  if (!program)
+    return null;
+  const node = findClassNodeById(program, encodedId);
+  if (!node)
+    return null;
+  return program.compiler.emitHmrUpdateModule(node);
+}, encodeHmrComponentId = (absoluteFilePath, className) => {
+  const projectRel = relative14(process.cwd(), absoluteFilePath).replace(/\\/g, "/");
+  return encodeURIComponent(`${projectRel}@${className}`);
+};
+var init_hmrCompiler = __esm(() => {
+  init_logger();
+  init_fastHmrCompiler();
+  globalCache = globalThis;
+  ANGULAR_COMPILER_OPTIONS_CACHE = {
+    value: null
+  };
+});
+
+// src/utils/ssrErrorPage.ts
+var ssrErrorPage = (framework, error) => {
+  const frameworkColors2 = {
+    angular: "#dd0031",
+    html: "#e34c26",
+    htmx: "#1a365d",
+    react: "#61dafb",
+    svelte: "#ff3e00",
+    vue: "#42b883"
+  };
+  const accent = frameworkColors2[framework] ?? "#94a3b8";
+  const label = framework.charAt(0).toUpperCase() + framework.slice(1);
+  const message = error instanceof Error ? error.message : String(error);
+  return `<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>SSR Error - AbsoluteJS</title>
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+body{min-height:100vh;background:linear-gradient(135deg,rgba(15,23,42,0.98) 0%,rgba(30,41,59,0.98) 100%);color:#e2e8f0;font-family:"JetBrains Mono","Fira Code",ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;font-size:14px;line-height:1.6;display:flex;align-items:flex-start;justify-content:center;padding:32px}
+.card{max-width:720px;width:100%;background:rgba(30,41,59,0.6);border:1px solid rgba(71,85,105,0.5);border-radius:16px;box-shadow:0 25px 50px -12px rgba(0,0,0,0.5),0 0 0 1px rgba(255,255,255,0.05);overflow:hidden}
+.header{display:flex;align-items:center;justify-content:space-between;gap:16px;padding:20px 24px;background:rgba(15,23,42,0.5);border-bottom:1px solid rgba(71,85,105,0.4)}
+.brand{font-weight:700;font-size:20px;color:#fff;letter-spacing:-0.02em}
+.badge{padding:5px 10px;border-radius:8px;font-size:12px;font-weight:600;background:${accent};color:#fff;opacity:0.95;box-shadow:0 2px 4px rgba(0,0,0,0.2)}
+.kind{color:#94a3b8;font-size:13px;font-weight:500}
+.content{padding:24px}
+.label{font-size:11px;font-weight:600;text-transform:uppercase;letter-spacing:0.08em;color:#94a3b8;margin-bottom:8px}
+.message{margin:0;padding:16px 20px;background:rgba(239,68,68,0.12);border:1px solid rgba(239,68,68,0.25);border-radius:10px;overflow-x:auto;white-space:pre-wrap;word-break:break-word;color:#fca5a5;font-size:13px;line-height:1.5}
+.hint{margin-top:20px;padding:12px 20px;background:rgba(71,85,105,0.3);border-radius:10px;border:1px solid rgba(71,85,105,0.4);color:#cbd5e1;font-size:13px}
+</style>
+</head>
+<body>
+<div class="card">
+<div class="header">
+<div style="display:flex;align-items:center;gap:12px">
+<span class="brand">AbsoluteJS</span>
+<span class="badge">${label}</span>
+</div>
+<span class="kind">Server Render Error</span>
+</div>
+<div class="content">
+<div class="label">What went wrong</div>
+<pre class="message">${message.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}</pre>
+<div class="hint">A component threw during server-side rendering. Check the terminal for the full stack trace.</div>
+</div>
+</div>
+</body>
+</html>`;
+};
+
+// src/ember/pageHandler.ts
+import { pathToFileURL } from "url";
+var resolveRequestPathname = (request) => {
+  if (!request)
+    return;
+  try {
+    const parsed = new URL(request.url);
+    return `${parsed.pathname}${parsed.search}`;
+  } catch {
+    return;
+  }
+}, installSimpleDomGlobals = () => {
   const g2 = globalThis;
   if (typeof g2.Element === "undefined") {
     g2.Element = class Element {
@@ -17717,11 +19122,11 @@ var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { resolve as resolve31 } from "path";
+import { resolve as resolve35 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve31(htmlFilePath);
+    const resolvedPath = resolve35(htmlFilePath);
     const file5 = Bun.file(resolvedPath);
     if (!await file5.exists()) {
       return null;
@@ -17747,11 +19152,11 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { resolve as resolve32 } from "path";
+import { resolve as resolve36 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve32(htmxFilePath);
+    const resolvedPath = resolve36(htmxFilePath);
     const file5 = Bun.file(resolvedPath);
     if (!await file5.exists()) {
       return null;
@@ -17773,8 +19178,8 @@ var handleHTMXUpdate = async (htmxFilePath) => {
 var init_simpleHTMXHMR = () => {};
 
 // src/dev/rebuildTrigger.ts
-import { existsSync as existsSync26 } from "fs";
-import { basename as basename13, dirname as dirname17, relative as relative12, resolve as resolve33 } from "path";
+import { existsSync as existsSync28 } from "fs";
+import { basename as basename13, dirname as dirname21, relative as relative15, resolve as resolve37 } from "path";
 var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequentially = (items, action) => items.reduce((chain, item) => chain.then(() => action(item)), Promise.resolve()), getStyleTransformConfig = (config) => createStyleTransformConfig(config.stylePreprocessors, config.postcss), recompileTailwindForFastPath = async (state, config, files) => {
   if (!config.tailwind)
     return;
@@ -17862,11 +19267,11 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     detectedFw = detected !== "ignored" ? detected : affectedFrameworks[0];
   }
   return { ...parsed, framework: detectedFw };
-}, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync26(affectedFile), collectDeletedFileAffected = (state, filePathInSet, processedFiles, validFiles) => {
+}, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync28(affectedFile), collectDeletedFileAffected = (state, filePathInSet, processedFiles, validFiles) => {
   state.fileHashes.delete(filePathInSet);
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, filePathInSet);
-    const deletedPathResolved = resolve33(filePathInSet);
+    const deletedPathResolved = resolve37(filePathInSet);
     affectedFiles.forEach((affectedFile) => {
       if (isValidDeletedAffectedFile(affectedFile, deletedPathResolved, processedFiles)) {
         validFiles.push(affectedFile);
@@ -17880,7 +19285,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     if (!dependents || dependents.size === 0) {
       return;
     }
-    const dependentFiles = Array.from(dependents).filter((file5) => existsSync26(file5));
+    const dependentFiles = Array.from(dependents).filter((file5) => existsSync28(file5));
     if (dependentFiles.length === 0) {
       return;
     }
@@ -17896,7 +19301,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, normalizedFilePath);
     affectedFiles.forEach((affectedFile) => {
-      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync26(affectedFile)) {
+      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync28(affectedFile)) {
         validFiles.push(affectedFile);
         processedFiles.add(affectedFile);
       }
@@ -17910,7 +19315,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (storedHash !== undefined && storedHash === fileHash) {
     return;
   }
-  const normalizedFilePath = resolve33(filePathInSet);
+  const normalizedFilePath = resolve37(filePathInSet);
   if (!processedFiles.has(normalizedFilePath)) {
     validFiles.push(normalizedFilePath);
     processedFiles.add(normalizedFilePath);
@@ -17921,7 +19326,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   collectChangedFileAffected(state, normalizedFilePath, processedFiles, validFiles);
 }, processFilePathSet = (state, filePathSet, processedFiles, validFiles) => {
   filePathSet.forEach((filePathInSet) => {
-    if (!existsSync26(filePathInSet)) {
+    if (!existsSync28(filePathInSet)) {
       collectDeletedFileAffected(state, filePathInSet, processedFiles, validFiles);
       return;
     }
@@ -18014,8 +19419,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return;
   }
   if (framework === "unknown") {
-    invalidate(resolve33(filePath));
-    const relPath = relative12(process.cwd(), filePath);
+    invalidate(resolve37(filePath));
+    const relPath = relative15(process.cwd(), filePath);
     logHmrUpdate(relPath);
     return;
   }
@@ -18041,7 +19446,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const userEditedFiles = new Set;
     state.fileChangeQueue.forEach((filePaths) => {
       for (const filePath2 of filePaths) {
-        userEditedFiles.add(resolve33(filePath2));
+        userEditedFiles.add(resolve37(filePath2));
       }
     });
     state.lastUserEditedFiles = userEditedFiles;
@@ -18065,12 +19470,12 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return componentFile;
   }
   const tsCounterpart = componentFile.replace(/\.html$/, ".ts");
-  if (existsSync26(tsCounterpart)) {
+  if (existsSync28(tsCounterpart)) {
     return tsCounterpart;
   }
   if (!graph)
     return componentFile;
-  const dependents = graph.dependents.get(resolve33(componentFile));
+  const dependents = graph.dependents.get(resolve37(componentFile));
   if (!dependents)
     return componentFile;
   for (const dep of dependents) {
@@ -18079,7 +19484,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   return componentFile;
 }, resolveAngularPageEntries = (state, angularFiles, angularPagesPath) => {
-  const pageEntries = angularFiles.filter((file5) => file5.endsWith(".ts") && resolve33(file5).startsWith(angularPagesPath));
+  const pageEntries = angularFiles.filter((file5) => file5.endsWith(".ts") && resolve37(file5).startsWith(angularPagesPath));
   if (pageEntries.length > 0 || !state.dependencyGraph) {
     return pageEntries;
   }
@@ -18088,7 +19493,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const lookupFile = resolveComponentLookupFile(componentFile, state.dependencyGraph);
     const affected = getAffectedFiles(state.dependencyGraph, lookupFile);
     affected.forEach((file5) => {
-      if (file5.endsWith(".ts") && resolve33(file5).startsWith(angularPagesPath)) {
+      if (file5.endsWith(".ts") && resolve37(file5).startsWith(angularPagesPath)) {
         resolvedPages.add(file5);
       }
     });
@@ -18113,12 +19518,15 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return;
   }
   state.manifest[toPascal(baseName)] = artifact.path;
-}, bundleAngularClient = async (state, clientPaths, buildDir) => {
+}, bundleAngularClient = async (state, clientPaths, buildDir, userAngularRoot) => {
   const { build: bunBuild9 } = await Promise.resolve(globalThis.Bun);
   const { generateManifest: generateManifest2 } = await Promise.resolve().then(() => (init_generateManifest(), exports_generateManifest));
   const { getAngularVendorPaths: getAngularVendorPaths2 } = await Promise.resolve().then(() => exports_devVendorPaths);
+  const { getFrameworkGeneratedDir: getFrameworkGeneratedDir2 } = await Promise.resolve().then(() => (init_generatedDir(), exports_generatedDir));
+  const { createAngularHmrInjectionPlugin: createAngularHmrInjectionPlugin2 } = await Promise.resolve().then(() => (init_hmrInjectionPlugin(), exports_hmrInjectionPlugin));
   const clientRoot = await computeClientRoot(state.resolvedPaths);
   const depVendorPaths = globalThis.__depVendorPaths ?? {};
+  const generatedAngularRoot = getFrameworkGeneratedDir2("angular");
   let angVendorPaths = getAngularVendorPaths2();
   if (!angVendorPaths) {
     const { computeAngularVendorPaths: computeAngularVendorPaths2 } = await Promise.resolve().then(() => (init_buildAngularVendor(), exports_buildAngularVendor));
@@ -18141,7 +19549,12 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     naming: "[dir]/[name].[hash].[ext]",
     outdir: buildDir,
     plugins: [
-      createStylePreprocessorPlugin(getStyleTransformConfig(state.config))
+      createStylePreprocessorPlugin(getStyleTransformConfig(state.config)),
+      createAngularHmrInjectionPlugin2({
+        generatedAngularRoot,
+        userAngularRoot,
+        projectRoot: process.cwd()
+      })
     ],
     root: clientRoot,
     target: "browser",
@@ -18160,37 +19573,72 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const clientManifest = generateManifest2(clientResult.outputs, buildDir);
   Object.assign(state.manifest, clientManifest);
   await populateAssetStore(state.assetStore, clientManifest, buildDir);
-}, filterToUserEdits = (candidates, userEditedFiles) => {
-  if (!userEditedFiles || userEditedFiles.size === 0)
-    return candidates;
-  const filtered = candidates.filter((file5) => userEditedFiles.has(resolve33(file5)));
-  return filtered.length > 0 ? filtered : candidates;
-}, broadcastAngularPageUpdates = (state, pagesToUpdate, manifest, startTime, classification) => {
-  pagesToUpdate.forEach((angularPagePath) => {
-    const fileName = basename13(angularPagePath);
-    const baseName = fileName.replace(/\.[tj]s$/, "");
-    const pascalName = toPascal(baseName);
-    const cssKey = `${pascalName}CSS`;
-    const cssUrl = manifest[cssKey] || null;
-    const duration = Date.now() - startTime;
-    logHmrUpdate(angularPagePath, "angular", duration);
+}, decideAngularTier = async (state, angularDir) => {
+  const userEdited = state.lastUserEditedFiles ?? new Set;
+  if (userEdited.size === 0)
+    return { queue: [], tier: 0 };
+  const { resolveOwningComponents: resolveOwningComponents2 } = await Promise.resolve().then(() => (init_resolveOwningComponents(), exports_resolveOwningComponents));
+  const { encodeHmrComponentId: encodeHmrComponentId2 } = await Promise.resolve().then(() => (init_hmrCompiler(), exports_hmrCompiler));
+  const { tryFastHmr: tryFastHmr2 } = await Promise.resolve().then(() => (init_fastHmrCompiler(), exports_fastHmrCompiler));
+  const queue = [];
+  const queueIds = new Set;
+  for (const editedFile of userEdited) {
+    const owners = resolveOwningComponents2({
+      changedFilePath: editedFile,
+      userAngularRoot: angularDir
+    });
+    if (owners.length === 0 && editedFile.endsWith(".component.ts")) {
+      return {
+        reason: `no @Component class found in ${editedFile}`,
+        tier: 1
+      };
+    }
+    for (const { componentFilePath, className } of owners) {
+      const id = encodeHmrComponentId2(componentFilePath, className);
+      if (queueIds.has(id))
+        continue;
+      const result = await tryFastHmr2({ className, componentFilePath });
+      if (!result.ok) {
+        return {
+          reason: `${className}: ${result.reason}${result.detail ? ` (${result.detail})` : ""}`,
+          tier: 1
+        };
+      }
+      queueIds.add(id);
+      queue.push({ className, id });
+    }
+  }
+  return { queue, tier: 0 };
+}, broadcastSurgical = (state, queue) => {
+  const timestamp = Date.now();
+  for (const { id, className } of queue) {
     broadcastToClients(state, {
-      data: {
-        cssBaseName: baseName,
-        cssUrl,
-        editSourceFile: classification.sourceFile,
-        framework: "angular",
-        manifest,
-        reason: classification.reason,
-        sourceFile: angularPagePath,
-        updateType: classification.type
-      },
-      type: "angular-update"
+      data: { id, timestamp },
+      type: "angular:component-update"
     });
+    logInfo(`[ng-hmr broadcast] ${className}`);
+  }
+}, broadcastRebootstrap = async (state, reason) => {
+  logInfo(`[ng-hmr tier-1 rebootstrap] ${reason}`);
+  broadcastToClients(state, {
+    data: {
+      manifest: state.manifest,
+      reason,
+      timestamp: Date.now()
+    },
+    type: "angular:rebootstrap"
   });
+  const { invalidateFingerprintCache: invalidateFingerprintCache2 } = await Promise.resolve().then(() => (init_fastHmrCompiler(), exports_fastHmrCompiler));
+  invalidateFingerprintCache2();
 }, compileAndBundleAngular = async (state, pageEntries, angularDir) => {
   const { compileAngular: compileAngular2 } = await Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular));
   const { clientPaths, serverPaths } = await compileAngular2(pageEntries, angularDir, true, getStyleTransformConfig(state.config));
+  try {
+    const { compileAngularForHmr: compileAngularForHmr2 } = await Promise.resolve().then(() => (init_hmrCompiler(), exports_hmrCompiler));
+    await compileAngularForHmr2(pageEntries, state.resolvedPaths.buildDir, state.lastUserEditedFiles ?? null);
+  } catch (err) {
+    logWarn(`[hmr] surgical-HMR shadow compile skipped: ${err instanceof Error ? err.message : String(err)}`);
+  }
   const { getAngularServerVendorPaths: getAngularServerVendorPaths2 } = await Promise.resolve().then(() => exports_devVendorPaths);
   const angServerVendorPaths = getAngularServerVendorPaths2();
   const ssrPaths = angServerVendorPaths ? serverPaths.map((serverPath) => serverPath.replace(/\.js$/, ".ssr.js")) : serverPaths;
@@ -18208,36 +19656,42 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   serverPaths.forEach((serverPath, idx) => {
     const fileBase = basename13(serverPath, ".js");
     const ssrPath = ssrPaths[idx] ?? serverPath;
-    state.manifest[toPascal(fileBase)] = resolve33(ssrPath);
+    state.manifest[toPascal(fileBase)] = resolve37(ssrPath);
   });
   if (clientPaths.length > 0) {
-    await bundleAngularClient(state, clientPaths, state.resolvedPaths.buildDir);
+    await bundleAngularClient(state, clientPaths, state.resolvedPaths.buildDir, angularDir);
   }
 }, handleAngularFastPath = async (state, config, filesToRebuild, startTime, onRebuildComplete) => {
   const angularDir = config.angularDirectory ?? "";
   const angularFiles = filesToRebuild.filter((file5) => detectFramework(file5, state.resolvedPaths) === "angular");
   for (const file5 of angularFiles) {
-    state.fileHashes.set(resolve33(file5), computeFileHash(file5));
+    state.fileHashes.set(resolve37(file5), computeFileHash(file5));
   }
-  const angularPagesPath = resolve33(angularDir, "pages");
+  const angularPagesPath = resolve37(angularDir, "pages");
   const pageEntries = resolveAngularPageEntries(state, angularFiles, angularPagesPath);
-  if (pageEntries.length > 0) {
+  const verdict = await decideAngularTier(state, angularDir);
+  const runBundle = async () => {
+    if (pageEntries.length === 0)
+      return;
     await compileAndBundleAngular(state, pageEntries, angularDir);
     markSsrCacheDirty("angular");
+  };
+  if (verdict.tier === 0) {
+    broadcastSurgical(state, verdict.queue);
+    runBundle().catch((err) => {
+      logWarn(`[ng-hmr async bundle] rebuild failed: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  } else {
+    await runBundle();
+    await broadcastRebootstrap(state, verdict.reason);
   }
   const { manifest } = state;
-  const angularHmrFiles = angularFiles.filter((file5) => file5.endsWith(".ts") || file5.endsWith(".html"));
-  const angularPageFiles = angularHmrFiles.filter((file5) => file5.replace(/\\/g, "/").includes("/pages/"));
-  const pagesToUpdate = angularPageFiles.length > 0 ? angularPageFiles : pageEntries;
-  const filesToClassify = filterToUserEdits(angularFiles, state.lastUserEditedFiles);
-  const classification = collapseClassifications(filesToClassify.map(classifyAngularEdit));
-  broadcastAngularPageUpdates(state, pagesToUpdate, manifest, startTime, classification);
   onRebuildComplete({ hmrState: state, manifest });
   return manifest;
 }, getModuleUrl = async (pageFile) => {
   const { invalidateModule: invalidateModule2, warmCache: warmCache2, SRC_URL_PREFIX: SRC_URL_PREFIX2 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
   invalidateModule2(pageFile);
-  const rel = relative12(process.cwd(), pageFile).replace(/\\/g, "/");
+  const rel = relative15(process.cwd(), pageFile).replace(/\\/g, "/");
   const url = `${SRC_URL_PREFIX2}${rel}`;
   warmCache2(url);
   return url;
@@ -18246,11 +19700,11 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (isComponentFile2)
     return primaryFile;
   const { findNearestComponent: findNearestComponent2 } = await Promise.resolve().then(() => (init_transformCache(), exports_transformCache));
-  const nearest = findNearestComponent2(resolve33(primaryFile));
+  const nearest = findNearestComponent2(resolve37(primaryFile));
   return nearest ?? primaryFile;
 }, handleReactModuleServerPath = async (state, reactFiles, startTime, onRebuildComplete) => {
   for (const file5 of reactFiles) {
-    state.fileHashes.set(resolve33(file5), computeFileHash(file5));
+    state.fileHashes.set(resolve37(file5), computeFileHash(file5));
   }
   markSsrCacheDirty("react");
   const primaryFile = reactFiles.find((file5) => !file5.replace(/\\/g, "/").includes("/pages/")) ?? reactFiles[0];
@@ -18269,7 +19723,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const pageModuleUrl = await getReactModuleUrl(broadcastTarget);
   if (pageModuleUrl) {
     const serverDuration = Date.now() - startTime;
-    state.lastHmrPath = relative12(process.cwd(), primaryFile).replace(/\\/g, "/");
+    state.lastHmrPath = relative15(process.cwd(), primaryFile).replace(/\\/g, "/");
     state.lastHmrFramework = "react";
     broadcastToClients(state, {
       data: {
@@ -18332,7 +19786,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, handleSvelteModuleServerPath = async (state, svelteFiles, startTime, onRebuildComplete) => {
   for (const file5 of svelteFiles) {
-    state.fileHashes.set(resolve33(file5), computeFileHash(file5));
+    state.fileHashes.set(resolve37(file5), computeFileHash(file5));
   }
   markSsrCacheDirty("svelte");
   const serverDuration = Date.now() - startTime;
@@ -18357,8 +19811,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const serverEntries = [...svelteServerPaths];
     const clientEntries = [...svelteIndexPaths, ...svelteClientPaths];
     const { getFrameworkGeneratedDir: getFrameworkGeneratedDir2 } = await Promise.resolve().then(() => (init_generatedDir(), exports_generatedDir));
-    const serverRoot = resolve33(getFrameworkGeneratedDir2("svelte"), "server");
-    const serverOutDir = resolve33(buildDir, basename13(svelteDir));
+    const serverRoot = resolve37(getFrameworkGeneratedDir2("svelte"), "server");
+    const serverOutDir = resolve37(buildDir, basename13(svelteDir));
     const [serverResult, clientResult] = await Promise.all([
       serverEntries.length > 0 ? bunBuild9({
         entrypoints: serverEntries,
@@ -18455,7 +19909,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, handleVueModuleServerPath = async (state, vueFiles, nonVueFiles, startTime, onRebuildComplete) => {
   for (const file5 of [...vueFiles, ...nonVueFiles]) {
-    state.fileHashes.set(resolve33(file5), computeFileHash(file5));
+    state.fileHashes.set(resolve37(file5), computeFileHash(file5));
   }
   markSsrCacheDirty("vue");
   await invalidateNonVueModules(nonVueFiles);
@@ -18483,7 +19937,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
       recursive: true,
       withFileTypes: true
     });
-    return entries.filter((entry) => entry.isFile() && EMBER_PAGE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))).map((entry) => resolve33(emberPagesPath, entry.name));
+    return entries.filter((entry) => entry.isFile() && EMBER_PAGE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))).map((entry) => resolve37(emberPagesPath, entry.name));
   } catch {
     return [];
   }
@@ -18495,10 +19949,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return state.manifest;
   }
   for (const file5 of emberFiles) {
-    state.fileHashes.set(resolve33(file5), computeFileHash(file5));
+    state.fileHashes.set(resolve37(file5), computeFileHash(file5));
   }
-  const emberPagesPath = resolve33(emberDir, "pages");
-  const directPageEntries = emberFiles.filter((file5) => resolve33(file5).startsWith(emberPagesPath));
+  const emberPagesPath = resolve37(emberDir, "pages");
+  const directPageEntries = emberFiles.filter((file5) => resolve37(file5).startsWith(emberPagesPath));
   const allPageEntries = directPageEntries.length > 0 ? directPageEntries : await collectAllEmberPages(emberPagesPath);
   if (allPageEntries.length === 0) {
     onRebuildComplete({ hmrState: state, manifest: state.manifest });
@@ -18508,14 +19962,14 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const { serverPaths } = await compileEmber2(allPageEntries, emberDir, process.cwd(), true);
   for (const serverPath of serverPaths) {
     const fileBase = basename13(serverPath, ".js");
-    state.manifest[toPascal(fileBase)] = resolve33(serverPath);
+    state.manifest[toPascal(fileBase)] = resolve37(serverPath);
   }
   const { invalidateEmberSsrCache: invalidateEmberSsrCache2 } = await Promise.resolve().then(() => (init_ember(), exports_ember));
   invalidateEmberSsrCache2();
   const duration = Date.now() - startTime;
   const [primary] = emberFiles;
   if (primary) {
-    state.lastHmrPath = relative12(process.cwd(), primary).replace(/\\/g, "/");
+    state.lastHmrPath = relative15(process.cwd(), primary).replace(/\\/g, "/");
     state.lastHmrFramework = "ember";
     logHmrUpdate(primary, "ember", duration);
   }
@@ -18600,8 +20054,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!buildReference?.source) {
     return;
   }
-  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve33(dirname17(buildInfo.resolvedRegistryPath), buildReference.source);
-  islandFiles.add(resolve33(sourcePath));
+  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve37(dirname21(buildInfo.resolvedRegistryPath), buildReference.source);
+  islandFiles.add(resolve37(sourcePath));
 }, resolveIslandSourceFiles = async (config) => {
   const registryPath = config.islands?.registry;
   if (!registryPath) {
@@ -18609,7 +20063,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   const buildInfo = await loadIslandRegistryBuildInfo(registryPath);
   const islandFiles = new Set([
-    resolve33(buildInfo.resolvedRegistryPath)
+    resolve37(buildInfo.resolvedRegistryPath)
   ]);
   for (const definition of buildInfo.definitions) {
     resolveIslandDefinitionSource(definition, buildInfo, islandFiles);
@@ -18620,7 +20074,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (islandFiles.size === 0) {
     return false;
   }
-  return filesToRebuild.some((file5) => islandFiles.has(resolve33(file5)));
+  return filesToRebuild.some((file5) => islandFiles.has(resolve37(file5)));
 }, handleIslandSourceReload = async (state, config, filesToRebuild, manifest) => {
   const shouldReload = await didStaticPagesNeedIslandRefresh(config, filesToRebuild);
   if (!shouldReload) {
@@ -18655,10 +20109,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
 }, computeOutputPagesDir = (state, config, framework) => {
   const isSingle = !config.reactDirectory && !config.svelteDirectory && !config.vueDirectory && (framework === "html" ? !config.htmxDirectory : !config.htmlDirectory);
   if (isSingle) {
-    return resolve33(state.resolvedPaths.buildDir, "pages");
+    return resolve37(state.resolvedPaths.buildDir, "pages");
   }
   const dirName = framework === "html" ? basename13(config.htmlDirectory ?? "html") : basename13(config.htmxDirectory ?? "htmx");
-  return resolve33(state.resolvedPaths.buildDir, dirName, "pages");
+  return resolve37(state.resolvedPaths.buildDir, dirName, "pages");
 }, processHtmlPageUpdate = async (state, pageFile, builtHtmlPagePath, manifest, duration) => {
   try {
     const { handleHTMLUpdate: handleHTMLUpdate2 } = await Promise.resolve().then(() => (init_simpleHTMLHMR(), exports_simpleHTMLHMR));
@@ -18697,7 +20151,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmlPages, "*.html") : htmlPageFiles;
   await runSequentially(pageFilesToUpdate, async (pageFile) => {
     const htmlPageName = basename13(pageFile);
-    const builtHtmlPagePath = resolve33(outputHtmlPages, htmlPageName);
+    const builtHtmlPagePath = resolve37(outputHtmlPages, htmlPageName);
     await processHtmlPageUpdate(state, pageFile, builtHtmlPagePath, manifest, duration);
   });
 }, handleVueCssOnlyUpdate = (state, vueCssFiles, manifest, duration) => {
@@ -18758,11 +20212,11 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const baseName = fileName.replace(/\.vue$/, "");
   const pascalName = toPascal(baseName);
   const vueRoot = config.vueDirectory;
-  const hmrId = vueRoot ? relative12(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
+  const hmrId = vueRoot ? relative15(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
   const cssKey = `${pascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
   const { vueHmrMetadata: vueHmrMetadata2 } = await Promise.resolve().then(() => (init_compileVue(), exports_compileVue));
-  const hmrMeta = vueHmrMetadata2.get(resolve33(vuePagePath));
+  const hmrMeta = vueHmrMetadata2.get(resolve37(vuePagePath));
   const changeType = hmrMeta?.changeType ?? "full";
   if (changeType === "style-only") {
     broadcastVueStyleOnly(state, vuePagePath, baseName, cssUrl, hmrId, manifest, duration);
@@ -18861,20 +20315,6 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   pagesToUpdate.forEach((sveltePagePath) => {
     broadcastSveltePageUpdate(state, sveltePagePath, manifest, duration);
   });
-}, collectAngularAffectedPages = (affected, resolvedPages) => {
-  affected.forEach((file5) => {
-    if (file5.replace(/\\/g, "/").includes("/pages/") && file5.endsWith(".ts")) {
-      resolvedPages.add(file5);
-    }
-  });
-}, resolveAngularPagesFromDependencyGraph = (state, angularFiles) => {
-  const resolvedPages = new Set;
-  angularFiles.forEach((componentFile) => {
-    const lookupFile = resolveComponentLookupFile(componentFile, state.dependencyGraph);
-    const affected = getAffectedFiles(state.dependencyGraph, lookupFile);
-    collectAngularAffectedPages(affected, resolvedPages);
-  });
-  return Array.from(resolvedPages);
 }, handleAngularCssOnlyUpdate = (state, angularCssFiles, manifest, duration) => {
   const [cssFile] = angularCssFiles;
   if (!cssFile) {
@@ -18896,57 +20336,17 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     },
     type: "angular-update"
   });
-}, broadcastAngularPageHmrUpdate = (state, angularPagePath, manifest, duration, classification) => {
-  try {
-    const fileName = basename13(angularPagePath);
-    const baseName = fileName.replace(/\.[tj]s$/, "");
-    const pascalName = toPascal(baseName);
-    const cssKey = `${pascalName}CSS`;
-    const cssUrl = manifest[cssKey] || null;
-    logHmrUpdate(angularPagePath, "angular", duration);
-    broadcastToClients(state, {
-      data: {
-        cssBaseName: baseName,
-        cssUrl,
-        editSourceFile: classification.sourceFile,
-        framework: "angular",
-        manifest,
-        reason: classification.reason,
-        sourceFile: angularPagePath,
-        updateType: classification.type
-      },
-      type: "angular-update"
-    });
-  } catch (err) {
-    sendTelemetryEvent("hmr:error", {
-      framework: "angular",
-      message: err instanceof Error ? err.message : String(err)
-    });
-  }
 }, handleAngularHMR = (state, config, filesToRebuild, manifest, duration) => {
-  if (!config.angularDirectory) {
+  if (!config.angularDirectory)
     return;
-  }
   const angularFiles = filesToRebuild.filter((file5) => detectFramework(file5, state.resolvedPaths) === "angular");
-  if (angularFiles.length === 0) {
+  if (angularFiles.length === 0)
     return;
-  }
   const angularCssFiles = angularFiles.filter(isStylePath);
   const isCssOnlyChange = angularFiles.every(isStylePath) && angularCssFiles.length > 0;
-  const angularPageFiles = angularFiles.filter((file5) => file5.replace(/\\/g, "/").includes("/pages/"));
-  let pagesToUpdate = angularPageFiles;
-  if (pagesToUpdate.length === 0 && state.dependencyGraph) {
-    pagesToUpdate = resolveAngularPagesFromDependencyGraph(state, angularFiles);
-  }
-  if (isCssOnlyChange && angularCssFiles.length > 0) {
+  if (isCssOnlyChange) {
     handleAngularCssOnlyUpdate(state, angularCssFiles, manifest, duration);
-    return;
   }
-  const filesToClassifySlow = filterToUserEdits(angularFiles, state.lastUserEditedFiles);
-  const classification = collapseClassifications(filesToClassifySlow.map(classifyAngularEdit));
-  pagesToUpdate.forEach((angularPagePath) => {
-    broadcastAngularPageHmrUpdate(state, angularPagePath, manifest, duration, classification);
-  });
 }, handleHTMXScriptHMR = (state, filesToRebuild, manifest, duration) => {
   if (!state.resolvedPaths.htmxDir) {
     return;
@@ -19001,7 +20401,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmxPages, "*.html") : htmxPageFiles;
   await runSequentially(pageFilesToUpdate, async (htmxPageFile) => {
     const htmxPageName = basename13(htmxPageFile);
-    const builtHtmxPagePath = resolve33(outputHtmxPages, htmxPageName);
+    const builtHtmxPagePath = resolve37(outputHtmxPages, htmxPageName);
     await processHtmxPageUpdate(state, htmxPageFile, builtHtmxPagePath, manifest, duration);
   });
 }, collectUpdatedModulePaths = (allModuleUpdates) => {
@@ -19110,7 +20510,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   html = html.slice(0, bodyClose.index) + hmrScript + html.slice(bodyClose.index);
   writeFs(destPath, html);
 }, processMarkupFileFastPath = async (state, sourceFile, outputDir, framework, startTime, updateAssetPaths2, handleUpdate, readFs, writeFs) => {
-  const destPath = resolve33(outputDir, basename13(sourceFile));
+  const destPath = resolve37(outputDir, basename13(sourceFile));
   const hmrScript = extractHmrScript(destPath, readFs);
   const source = await Bun.file(sourceFile).text();
   await Bun.write(destPath, source);
@@ -19356,7 +20756,6 @@ var init_rebuildTrigger = __esm(() => {
   init_compileTailwind();
   init_tailwindCompiler();
   init_ssrCache();
-  init_editTypeDetection();
   moduleServerPromise = Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
   getReactModuleUrl = getModuleUrl;
   EMBER_PAGE_EXTENSIONS = [".gts", ".gjs", ".ts", ".js"];
@@ -19370,7 +20769,7 @@ __export(exports_buildDepVendor, {
   buildDepVendor: () => buildDepVendor
 });
 import { mkdirSync as mkdirSync13 } from "fs";
-import { join as join29 } from "path";
+import { join as join31 } from "path";
 import { rm as rm10 } from "fs/promises";
 var {build: bunBuild9, Glob: Glob9 } = globalThis.Bun;
 var toSafeFileName6 = (specifier) => {
@@ -19424,7 +20823,7 @@ var toSafeFileName6 = (specifier) => {
     framework: Array.from(framework).filter(isResolvable4)
   };
 }, collectTransitiveImports = async (specs, alreadyVendored, alreadyScanned) => {
-  const { readFileSync: readFileSync19 } = await import("fs");
+  const { readFileSync: readFileSync21 } = await import("fs");
   const transpiler5 = new Bun.Transpiler({ loader: "js" });
   const newSpecs = new Set;
   for (const spec of specs) {
@@ -19439,7 +20838,7 @@ var toSafeFileName6 = (specifier) => {
     }
     let content;
     try {
-      content = readFileSync19(resolved, "utf-8");
+      content = readFileSync21(resolved, "utf-8");
     } catch {
       continue;
     }
@@ -19481,7 +20880,7 @@ var toSafeFileName6 = (specifier) => {
 }), buildDepVendorPass = async (specifiers, vendorDir, tmpDir) => {
   const entries = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName6(specifier);
-    const entryPath = join29(tmpDir, `${safeName}.ts`);
+    const entryPath = join31(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return { entryPath, specifier };
   }));
@@ -19542,9 +20941,9 @@ var toSafeFileName6 = (specifier) => {
   const { dep: initialSpecs, framework: frameworkRoots } = await scanBareImports(directories);
   if (initialSpecs.length === 0 && frameworkRoots.length === 0)
     return {};
-  const vendorDir = join29(buildDir, "vendor");
+  const vendorDir = join31(buildDir, "vendor");
   mkdirSync13(vendorDir, { recursive: true });
-  const tmpDir = join29(buildDir, "_dep_vendor_tmp");
+  const tmpDir = join31(buildDir, "_dep_vendor_tmp");
   mkdirSync13(tmpDir, { recursive: true });
   const allSpecs = new Set(initialSpecs);
   const alreadyScanned = new Set;
@@ -19626,8 +21025,8 @@ __export(exports_devBuild, {
   devBuild: () => devBuild
 });
 import { readdir as readdir5 } from "fs/promises";
-import { statSync as statSync3 } from "fs";
-import { resolve as resolve34 } from "path";
+import { statSync as statSync4 } from "fs";
+import { resolve as resolve38 } from "path";
 var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const configuredDirs = [
     config.reactDirectory,
@@ -19650,7 +21049,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return Object.keys(config).length > 0 ? config : null;
 }, reloadConfig = async () => {
   try {
-    const configPath2 = resolve34(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+    const configPath2 = resolve38(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
     const source = await Bun.file(configPath2).text();
     return parseDirectoryConfig(source);
   } catch {
@@ -19735,7 +21134,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     state.fileChangeQueue.clear();
   }
 }, handleCachedReload = async () => {
-  const serverMtime = statSync3(resolve34(Bun.main)).mtimeMs;
+  const serverMtime = statSync4(resolve38(Bun.main)).mtimeMs;
   const lastMtime = globalThis.__hmrServerMtime;
   globalThis.__hmrServerMtime = serverMtime;
   const cached = globalThis.__hmrDevResult;
@@ -19772,8 +21171,8 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return true;
 }, resolveAbsoluteVersion2 = async () => {
   const candidates = [
-    resolve34(import.meta.dir, "..", "..", "package.json"),
-    resolve34(import.meta.dir, "..", "package.json")
+    resolve38(import.meta.dir, "..", "..", "package.json"),
+    resolve38(import.meta.dir, "..", "package.json")
   ];
   const [candidate, ...remaining] = candidates;
   if (!candidate) {
@@ -19799,7 +21198,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const entries = await readdir5(vendorDir).catch(() => emptyStringArray);
   await Promise.all(entries.filter((entry) => entry.endsWith(".js")).map(async (entry) => {
     const webPath = `/${framework}/vendor/${entry}`;
-    const bytes = await Bun.file(resolve34(vendorDir, entry)).bytes();
+    const bytes = await Bun.file(resolve38(vendorDir, entry)).bytes();
     assetStore.set(webPath, bytes);
   }));
 }, devBuild = async (config) => {
@@ -19867,11 +21266,11 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   cleanStaleAssets(state.assetStore, manifest, state.resolvedPaths.buildDir);
   recordStep("populate asset store", stepStartedAt);
   stepStartedAt = performance.now();
-  const reactVendorDir = resolve34(state.resolvedPaths.buildDir, "react", "vendor");
-  const angularVendorDir = resolve34(state.resolvedPaths.buildDir, "angular", "vendor");
-  const svelteVendorDir = resolve34(state.resolvedPaths.buildDir, "svelte", "vendor");
-  const vueVendorDir = resolve34(state.resolvedPaths.buildDir, "vue", "vendor");
-  const depVendorDir = resolve34(state.resolvedPaths.buildDir, "vendor");
+  const reactVendorDir = resolve38(state.resolvedPaths.buildDir, "react", "vendor");
+  const angularVendorDir = resolve38(state.resolvedPaths.buildDir, "angular", "vendor");
+  const svelteVendorDir = resolve38(state.resolvedPaths.buildDir, "svelte", "vendor");
+  const vueVendorDir = resolve38(state.resolvedPaths.buildDir, "vue", "vendor");
+  const depVendorDir = resolve38(state.resolvedPaths.buildDir, "vendor");
   const { buildDepVendor: buildDepVendor2 } = await Promise.resolve().then(() => (init_buildDepVendor(), exports_buildDepVendor));
   const [, angularSpecs, , , , , depPaths] = await Promise.all([
     config.reactDirectory ? buildReactVendor(state.resolvedPaths.buildDir) : Promise.resolve(undefined),
@@ -19949,7 +21348,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     manifest
   };
   globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync3(resolve34(Bun.main)).mtimeMs;
+  globalThis.__hmrServerMtime = statSync4(resolve38(Bun.main)).mtimeMs;
   return result;
 };
 var init_devBuild = __esm(() => {
@@ -20095,7 +21494,49 @@ var STORE_KEY = "__elysiaStore", getGlobalValue = (key) => Reflect.get(globalThi
     await bridgeReactInternals();
   }
   return resolveDevAssetResponse(request, hmrState2, moduleServerHandler);
-}).get("/@src/*", ({ request }) => resolveDevAssetResponse(request, hmrState2, moduleServerHandler)).get("/@stub/*", ({ request }) => resolveDevAssetResponse(request, hmrState2, moduleServerHandler)).get("/@hmr/*", ({ request }) => resolveDevAssetResponse(request, hmrState2, moduleServerHandler)).ws("/hmr", {
+}).get("/@src/*", ({ request }) => resolveDevAssetResponse(request, hmrState2, moduleServerHandler)).get("/@stub/*", ({ request }) => resolveDevAssetResponse(request, hmrState2, moduleServerHandler)).get("/@hmr/*", ({ request }) => resolveDevAssetResponse(request, hmrState2, moduleServerHandler)).get("/@ng/*", async ({ request, query }) => {
+  const url = new URL(request.url);
+  const subPath = url.pathname.slice("/@ng/".length);
+  if (subPath === "debug") {
+    const { getCachedHmrProgram: getCachedHmrProgram2 } = await Promise.resolve().then(() => (init_hmrCompiler(), exports_hmrCompiler));
+    const program = getCachedHmrProgram2();
+    if (!program) {
+      return new Response(JSON.stringify({ error: "No cached program" }), {
+        headers: { "Content-Type": "application/json" },
+        status: 404
+      });
+    }
+    const tsProgram = program.compiler.getCurrentProgram();
+    const sourceFiles = tsProgram.getSourceFiles().map((sf) => sf.fileName).filter((fn2) => !fn2.includes("node_modules") && !fn2.endsWith(".d.ts")).slice(0, 50);
+    return new Response(JSON.stringify({
+      hasProgram: true,
+      sampleSourceFiles: sourceFiles,
+      totalSourceFiles: tsProgram.getSourceFiles().length
+    }, null, 2), {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  if (subPath === "component") {
+    const id = typeof query.c === "string" ? query.c : null;
+    if (!id) {
+      return new Response("Missing ?c=<id>", { status: 400 });
+    }
+    const { getApplyMetadataModule: getApplyMetadataModule2 } = await Promise.resolve().then(() => (init_hmrCompiler(), exports_hmrCompiler));
+    const module = await getApplyMetadataModule2(id);
+    if (module === null) {
+      return new Response(`No HMR module for id=${id}. The component may not be in the current program, or the program isn't built yet (rebuild on first save).`, { status: 404 });
+    }
+    return new Response(module, {
+      headers: {
+        "Cache-Control": "no-store",
+        "Content-Type": "text/javascript; charset=utf-8"
+      }
+    });
+  }
+  return new Response("Unknown @ng route", { status: 404 });
+}).ws("/hmr", {
   close: (ws) => handleClientDisconnect(hmrState2, ws),
   message: (ws, msg) => handleHMRMessage(hmrState2, ws, msg),
   open: (ws) => handleClientConnect(hmrState2, ws, manifest)
@@ -20122,17 +21563,17 @@ __export(exports_devtoolsJson, {
   normalizeDevtoolsWorkspaceRoot: () => normalizeDevtoolsWorkspaceRoot,
   devtoolsJson: () => devtoolsJson
 });
-import { existsSync as existsSync27, mkdirSync as mkdirSync14, readFileSync as readFileSync19, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname18, join as join30, resolve as resolve35 } from "path";
+import { existsSync as existsSync29, mkdirSync as mkdirSync14, readFileSync as readFileSync21, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname22, join as join32, resolve as resolve39 } from "path";
 import { Elysia as Elysia3 } from "elysia";
 var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_KEY = "__absoluteDevtoolsWorkspaceUuid", getGlobalUuid = () => Reflect.get(globalThis, UUID_CACHE_KEY), setGlobalUuid = (uuid) => {
   Reflect.set(globalThis, UUID_CACHE_KEY, uuid);
   return uuid;
-}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve35(uuidCachePath ?? join30(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
-  if (!existsSync27(cachePath))
+}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve39(uuidCachePath ?? join32(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
+  if (!existsSync29(cachePath))
     return null;
   try {
-    const value = readFileSync19(cachePath, "utf-8").trim();
+    const value = readFileSync21(cachePath, "utf-8").trim();
     return isUuidV4(value) ? value : null;
   } catch {
     return null;
@@ -20150,11 +21591,11 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   if (cachedUuid)
     return setGlobalUuid(cachedUuid);
   const uuid = crypto.randomUUID();
-  mkdirSync14(dirname18(cachePath), { recursive: true });
+  mkdirSync14(dirname22(cachePath), { recursive: true });
   writeFileSync9(cachePath, uuid, "utf-8");
   return setGlobalUuid(uuid);
 }, devtoolsJson = (buildDir, options = {}) => {
-  const rootPath = resolve35(options.projectRoot ?? process.cwd());
+  const rootPath = resolve39(options.projectRoot ?? process.cwd());
   const root = options.normalizeForWindowsContainer === false ? rootPath : normalizeDevtoolsWorkspaceRoot(rootPath);
   const uuid = getOrCreateUuid(buildDir, options);
   return new Elysia3({ name: "absolute-devtools-json" }).get(ENDPOINT, () => ({
@@ -20167,11 +21608,11 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   if (process.env.WSL_DISTRO_NAME) {
     const distro = process.env.WSL_DISTRO_NAME;
     const withoutLeadingSlash = root.replace(/^\//, "");
-    return join30("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
+    return join32("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
   }
   if (process.env.DOCKER_DESKTOP && !root.startsWith("\\\\")) {
     const withoutLeadingSlash = root.replace(/^\//, "");
-    return join30("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
+    return join32("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
   }
   return root;
 };
@@ -20182,13 +21623,13 @@ var exports_imageOptimizer = {};
 __export(exports_imageOptimizer, {
   imageOptimizer: () => imageOptimizer
 });
-import { existsSync as existsSync28 } from "fs";
-import { resolve as resolve36 } from "path";
+import { existsSync as existsSync30 } from "fs";
+import { resolve as resolve40 } from "path";
 import { Elysia as Elysia4 } from "elysia";
 var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avifInProgress, safeResolve = (path, baseDir) => {
   try {
     const resolved = validateSafePath(path, baseDir);
-    if (existsSync28(resolved))
+    if (existsSync30(resolved))
       return resolved;
     return null;
   } catch {
@@ -20196,7 +21637,7 @@ var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avi
   }
 }, resolveLocalImage = (url, buildDir) => {
   const cleanPath = url.startsWith("/") ? url.slice(1) : url;
-  return safeResolve(cleanPath, buildDir) ?? safeResolve(cleanPath, resolve36(process.cwd()));
+  return safeResolve(cleanPath, buildDir) ?? safeResolve(cleanPath, resolve40(process.cwd()));
 }, parseQueryParams = (query, allowedSizes, defaultQuality) => {
   const url = typeof query["url"] === "string" ? query["url"] : undefined;
   const wParam = typeof query["w"] === "string" ? query["w"] : undefined;
@@ -20487,15 +21928,15 @@ __export(exports_prerender, {
   prerender: () => prerender,
   PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER
 });
-import { mkdirSync as mkdirSync15, readFileSync as readFileSync20 } from "fs";
-import { join as join31 } from "path";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync22 } from "fs";
+import { join as join33 } from "path";
 var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_TIMEOUT_MS = 30000, PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass", routeToFilename = (route) => route === "/" ? "index.html" : `${route.slice(1).replace(/\//g, "-")}.html`, writeTimestamp = async (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   await Bun.write(metaPath, String(Date.now()));
 }, readTimestamp = (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   try {
-    const content = readFileSync20(metaPath, "utf-8");
+    const content = readFileSync22(metaPath, "utf-8");
     return Number(content) || 0;
   } catch {
     return 0;
@@ -20554,7 +21995,7 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
       return false;
     const html = await res.text();
     const fileName = routeToFilename(route);
-    const filePath = join31(prerenderDir, fileName);
+    const filePath = join33(prerenderDir, fileName);
     await Bun.write(filePath, html);
     await writeTimestamp(filePath);
     return true;
@@ -20580,13 +22021,13 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
   }
   const html = await res.text();
   const fileName = routeToFilename(route);
-  const filePath = join31(prerenderDir, fileName);
+  const filePath = join33(prerenderDir, fileName);
   await Bun.write(filePath, html);
   await writeTimestamp(filePath);
   result.routes.set(route, filePath);
   log2?.(`  Pre-rendered ${route} \u2192 ${fileName} (${html.length} bytes)`);
 }, prerender = async (port, outDir, staticConfig, log2) => {
-  const prerenderDir = join31(outDir, "_prerendered");
+  const prerenderDir = join33(outDir, "_prerendered");
   mkdirSync15(prerenderDir, { recursive: true });
   const baseUrl = `http://localhost:${port}`;
   let routes;
@@ -21182,8 +22623,8 @@ var handleHTMXPageRequest = async (pagePath) => {
   });
 };
 // src/core/prepare.ts
-import { existsSync as existsSync29, readdirSync, readFileSync as readFileSync21 } from "fs";
-import { basename as basename14, join as join32, relative as relative13, resolve as resolve37 } from "path";
+import { existsSync as existsSync31, readdirSync as readdirSync3, readFileSync as readFileSync23 } from "fs";
+import { basename as basename14, join as join34, relative as relative16, resolve as resolve41 } from "path";
 import { Elysia as Elysia5 } from "elysia";
 
 // src/utils/loadConfig.ts
@@ -21606,7 +23047,7 @@ var collectPrewarmFiles = async (prewarmDirs) => {
   for (const { dir, pattern } of prewarmDirs) {
     const glob = new Glob10(pattern);
     const matches = [
-      ...glob.scanSync({ absolute: true, cwd: resolve37(dir) })
+      ...glob.scanSync({ absolute: true, cwd: resolve41(dir) })
     ];
     files.push(...matches);
   }
@@ -21617,7 +23058,7 @@ var warmPrewarmDirs = async (prewarmDirs, warmCache2, SRC_URL_PREFIX2) => {
   for (const file5 of files) {
     if (file5.includes("/node_modules/"))
       continue;
-    const rel = relative13(process.cwd(), file5).replace(/\\/g, "/");
+    const rel = relative16(process.cwd(), file5).replace(/\\/g, "/");
     warmCache2(`${SRC_URL_PREFIX2}${rel}`);
   }
 };
@@ -21642,10 +23083,10 @@ var patchManifestIndexes = (manifest, devIndexDir, SRC_URL_PREFIX2) => {
     const fileName = resolveDevIndexFileName(manifest[key], baseName);
     if (!fileName)
       continue;
-    const srcPath = resolve37(devIndexDir, fileName);
-    if (!existsSync29(srcPath))
+    const srcPath = resolve41(devIndexDir, fileName);
+    if (!existsSync31(srcPath))
       continue;
-    const rel = relative13(process.cwd(), srcPath).replace(/\\/g, "/");
+    const rel = relative16(process.cwd(), srcPath).replace(/\\/g, "/");
     manifest[key] = `${SRC_URL_PREFIX2}${rel}`;
   }
 };
@@ -21715,7 +23156,7 @@ var prepareDev = async (config, buildDir) => {
   stepStartedAt = performance.now();
   const hmrPlugin = hmr2(result.hmrState, result.manifest, moduleHandler);
   const { devtoolsJson: devtoolsJson2 } = await Promise.resolve().then(() => (init_devtoolsJson(), exports_devtoolsJson));
-  const devIndexDir = resolve37(buildDir, "_src_indexes");
+  const devIndexDir = resolve41(buildDir, "_src_indexes");
   patchManifestIndexes(result.manifest, devIndexDir, SRC_URL_PREFIX2);
   recordStep("configure dev plugins", stepStartedAt);
   stepStartedAt = performance.now();
@@ -21751,11 +23192,11 @@ var prepareDev = async (config, buildDir) => {
 };
 var loadPrerenderMap = (prerenderDir) => {
   const map = new Map;
-  if (!existsSync29(prerenderDir))
+  if (!existsSync31(prerenderDir))
     return map;
   let entries;
   try {
-    entries = readdirSync(prerenderDir);
+    entries = readdirSync3(prerenderDir);
   } catch {
     return map;
   }
@@ -21764,7 +23205,7 @@ var loadPrerenderMap = (prerenderDir) => {
       continue;
     const name = basename14(entry, ".html");
     const route = name === "index" ? "/" : `/${name}`;
-    map.set(route, join32(prerenderDir, entry));
+    map.set(route, join34(prerenderDir, entry));
   }
   return map;
 };
@@ -21796,7 +23237,7 @@ var prepare = async (configOrPath) => {
   recordStep("load config", stepStartedAt);
   const nodeEnv = process.env["NODE_ENV"];
   const isDev3 = nodeEnv === "development";
-  const buildDir = resolve37(process.env.ABSOLUTE_BUILD_DIR ?? config.buildDirectory ?? "build");
+  const buildDir = resolve41(process.env.ABSOLUTE_BUILD_DIR ?? config.buildDirectory ?? "build");
   if (isDev3) {
     stepStartedAt = performance.now();
     const result = await prepareDev(config, buildDir);
@@ -21805,7 +23246,7 @@ var prepare = async (configOrPath) => {
     return result;
   }
   stepStartedAt = performance.now();
-  const manifest = JSON.parse(readFileSync21(`${buildDir}/manifest.json`, "utf-8"));
+  const manifest = JSON.parse(readFileSync23(`${buildDir}/manifest.json`, "utf-8"));
   setCurrentIslandManifest(manifest);
   if (config.islands?.registry) {
     setCurrentIslandRegistry(await loadIslandRegistry(config.islands.registry));
@@ -21813,9 +23254,9 @@ var prepare = async (configOrPath) => {
   setCurrentPageIslandMetadata(await loadPageIslandMetadata(config));
   recordStep("load production manifest and island metadata", stepStartedAt);
   stepStartedAt = performance.now();
-  const conventionsPath = join32(buildDir, "conventions.json");
-  if (existsSync29(conventionsPath)) {
-    const conventions2 = JSON.parse(readFileSync21(conventionsPath, "utf-8"));
+  const conventionsPath = join34(buildDir, "conventions.json");
+  if (existsSync31(conventionsPath)) {
+    const conventions2 = JSON.parse(readFileSync23(conventionsPath, "utf-8"));
     setConventions(conventions2);
   }
   recordStep("load production conventions", stepStartedAt);
@@ -21829,7 +23270,7 @@ var prepare = async (configOrPath) => {
   });
   recordStep("create static plugin", stepStartedAt);
   stepStartedAt = performance.now();
-  const prerenderDir = join32(buildDir, "_prerendered");
+  const prerenderDir = join34(buildDir, "_prerendered");
   const prerenderMap = loadPrerenderMap(prerenderDir);
   recordStep("load prerender map", stepStartedAt);
   if (prerenderMap.size > 0) {
@@ -21887,18 +23328,18 @@ import { argv } from "process";
 var {env: env4 } = globalThis.Bun;
 
 // src/dev/devCert.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync16, readFileSync as readFileSync22, rmSync as rmSync3 } from "fs";
-import { join as join33 } from "path";
-var CERT_DIR = join33(process.cwd(), ".absolutejs");
-var CERT_PATH = join33(CERT_DIR, "cert.pem");
-var KEY_PATH = join33(CERT_DIR, "key.pem");
+import { existsSync as existsSync32, mkdirSync as mkdirSync16, readFileSync as readFileSync24, rmSync as rmSync3 } from "fs";
+import { join as join35 } from "path";
+var CERT_DIR = join35(process.cwd(), ".absolutejs");
+var CERT_PATH = join35(CERT_DIR, "cert.pem");
+var KEY_PATH = join35(CERT_DIR, "key.pem");
 var CERT_VALIDITY_DAYS = 365;
 var devLog = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[36m[dev]\x1B[0m ${msg}`);
 var devWarn = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[33m[dev]\x1B[0m \x1B[33m${msg}\x1B[0m`);
-var certFilesExist = () => existsSync30(CERT_PATH) && existsSync30(KEY_PATH);
+var certFilesExist = () => existsSync32(CERT_PATH) && existsSync32(KEY_PATH);
 var isCertExpired = () => {
   try {
-    const certPem = readFileSync22(CERT_PATH, "utf-8");
+    const certPem = readFileSync24(CERT_PATH, "utf-8");
     const proc = Bun.spawnSync(["openssl", "x509", "-enddate", "-noout"], {
       stdin: new TextEncoder().encode(certPem)
     });
@@ -21994,8 +23435,8 @@ var loadDevCert = () => {
     return null;
   try {
     return {
-      cert: readFileSync22(paths.cert, "utf-8"),
-      key: readFileSync22(paths.key, "utf-8")
+      cert: readFileSync24(paths.cert, "utf-8"),
+      key: readFileSync24(paths.key, "utf-8")
     };
   } catch {
     return null;
@@ -22223,8 +23664,8 @@ var jsonLd2 = (schema) => {
 };
 // src/utils/defineEnv.ts
 var {env: bunEnv } = globalThis.Bun;
-import { existsSync as existsSync31, readFileSync as readFileSync23 } from "fs";
-import { resolve as resolve38 } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync25 } from "fs";
+import { resolve as resolve42 } from "path";
 
 // node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
 var exports_value = {};
@@ -28259,19 +29700,19 @@ ${lines.join(`
 };
 var checkEnvFileSecurity = (properties) => {
   const cwd2 = process.cwd();
-  const envPath = resolve38(cwd2, ".env");
-  if (!existsSync31(envPath))
+  const envPath = resolve42(cwd2, ".env");
+  if (!existsSync33(envPath))
     return;
   const sensitiveKeys = Object.keys(properties).filter(isSensitive);
   if (sensitiveKeys.length === 0)
     return;
-  const envContent = readFileSync23(envPath, "utf-8");
+  const envContent = readFileSync25(envPath, "utf-8");
   const presentKeys = sensitiveKeys.filter((key) => envContent.includes(`${key}=`));
   if (presentKeys.length === 0)
     return;
-  const gitignorePath = resolve38(cwd2, ".gitignore");
-  if (existsSync31(gitignorePath)) {
-    const gitignore = readFileSync23(gitignorePath, "utf-8");
+  const gitignorePath = resolve42(cwd2, ".gitignore");
+  if (existsSync33(gitignorePath)) {
+    const gitignore = readFileSync25(gitignorePath, "utf-8");
     if (gitignore.split(`
 `).some((line) => line.trim() === ".env"))
       return;
@@ -28509,5 +29950,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=354081F729C5E09864756E2164756E21
+//# debugId=1AAD42B006C96FC764756E2164756E21
 //# sourceMappingURL=index.js.map