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

package/dist/build.js

@@ -215,6 +215,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 = () => {
@@ -9552,19 +9554,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 resolve12 } 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 = resolve12(generatedAngularRoot).replace(/\\/g, "/");
+  return {
+    name: "absolute-angular-hmr-injection",
+    setup(build) {
+      build.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 = resolve12(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 resolve12 } from "path";
+import { resolve as resolve13 } from "path";
 var {Glob: Glob5 } = globalThis.Bun;
 var HASHED_FILE_PATTERN, cleanStaleOutputs = async (buildPath, currentOutputPaths) => {
-  const currentPaths = new Set(currentOutputPaths.map((path) => resolve12(path)));
+  const currentPaths = new Set(currentOutputPaths.map((path) => resolve13(path)));
   const glob = new Glob5("**/*");
   const removals = [];
-  for (const relative6 of glob.scanSync({ cwd: buildPath })) {
-    const absolute = resolve12(buildPath, relative6);
+  for (const relative7 of glob.scanSync({ cwd: buildPath })) {
+    const absolute = resolve13(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 }));
   }
@@ -9793,11 +9863,11 @@ var init_buildDirectoryLock = __esm(() => {
 });
 
 // src/utils/validateSafePath.ts
-import { resolve as resolve13, relative as relative6 } from "path";
+import { resolve as resolve14, relative as relative7 } from "path";
 var validateSafePath = (targetPath, baseDirectory) => {
-  const absoluteBase = resolve13(baseDirectory);
-  const absoluteTarget = resolve13(baseDirectory, targetPath);
-  const relativePath = normalizePath(relative6(absoluteBase, absoluteTarget));
+  const absoluteBase = resolve14(baseDirectory);
+  const absoluteTarget = resolve14(baseDirectory, targetPath);
+  const relativePath = normalizePath(relative7(absoluteBase, absoluteTarget));
   if (relativePath.startsWith("../") || relativePath === "..") {
     throw new Error(`Unsafe path: ${targetPath}`);
   }
@@ -9951,22 +10021,22 @@ import {
   join as join15,
   basename as basename4,
   extname as extname5,
-  resolve as resolve14,
-  relative as relative7,
+  resolve as resolve15,
+  relative as relative8,
   sep as sep2
 } from "path";
 import { env } from "process";
 var {write, file, Transpiler } = globalThis.Bun;
 var resolveDevClientDir2 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve14(import.meta.dir, "../dev/client");
+  const fromSource = resolve15(import.meta.dir, "../dev/client");
   if (existsSync14(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve14(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve15(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync14(fromNodeModules))
     return fromNodeModules;
-  return resolve14(import.meta.dir, "./dev/client");
+  return resolve15(import.meta.dir, "./dev/client");
 }, devClientDir2, hmrClientPath3, persistentCache, sourceHashCache, clearSvelteCompilerCache = () => {
   persistentCache.clear();
   sourceHashCache.clear();
@@ -9996,7 +10066,7 @@ var resolveDevClientDir2 = () => {
 }, resolveRelativeModule2 = async (spec, from) => {
   if (!spec.startsWith("."))
     return null;
-  const basePath = resolve14(dirname9(from), spec);
+  const basePath = resolve15(dirname9(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -10023,7 +10093,7 @@ var resolveDevClientDir2 = () => {
     const resolved = resolvePackageImport(spec);
     return resolved && /\.svelte(\.(?:ts|js))?$/.test(resolved) ? resolved : null;
   }
-  const basePath = resolve14(dirname9(from), spec);
+  const basePath = resolve15(dirname9(from), spec);
   const explicit = /\.(svelte|svelte\.(?:ts|js))$/.test(basePath);
   if (!explicit) {
     const extensions = [".svelte", ".svelte.ts", ".svelte.js"];
@@ -10044,8 +10114,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}`
@@ -10083,8 +10153,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 = dirname9(relative7(svelteRoot, src)).replace(/\\/g, "/");
-    const relDir = rawRel.startsWith("..") ? `_ext/${relative7(process.cwd(), dirname9(src)).replace(/\\/g, "/")}` : rawRel;
+    const rawRel = dirname9(relative8(svelteRoot, src)).replace(/\\/g, "/");
+    const relDir = rawRel.startsWith("..") ? `_ext/${relative8(process.cwd(), dirname9(src)).replace(/\\/g, "/")}` : rawRel;
     const baseName = basename4(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)));
@@ -10105,15 +10175,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}`
@@ -10147,7 +10217,7 @@ var resolveDevClientDir2 = () => {
       }).js.code;
       let code = compiled.replace(/\.svelte(?:\.(?:ts|js))?(['"])/g, ".js$1");
       if (mode === "client" && isDev) {
-        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; };`);
@@ -10190,10 +10260,10 @@ var resolveDevClientDir2 = () => {
   };
   const roots = await Promise.all(entryPoints.map(build));
   await Promise.all(roots.map(async ({ client, hasAwaitSlot }) => {
-    const relClientDir = dirname9(relative7(clientDir, client));
+    const relClientDir = dirname9(relative8(clientDir, client));
     const name = basename4(client, extname5(client));
     const indexPath = join15(indexDir, relClientDir, `${name}.js`);
-    const importRaw = relative7(dirname9(indexPath), client).split(sep2).join("/");
+    const importRaw = relative8(dirname9(indexPath), client).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev ? `window.__HMR_FRAMEWORK__ = "svelte";
 import "${hmrClientPath3}";
@@ -10270,7 +10340,7 @@ if (typeof window !== "undefined") {
   return {
     svelteClientPaths: roots.map(({ client }) => client),
     svelteIndexPaths: roots.map(({ client }) => {
-      const rel = dirname9(relative7(clientDir, client));
+      const rel = dirname9(relative8(clientDir, client));
       return join15(indexDir, rel, basename4(client));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
@@ -10359,20 +10429,20 @@ import {
   dirname as dirname10,
   isAbsolute as isAbsolute3,
   join as join16,
-  relative as relative8,
-  resolve as resolve15
+  relative as relative9,
+  resolve as resolve16
 } from "path";
 var {file: file2, write: write2, Transpiler: Transpiler2 } = globalThis.Bun;
 var resolveDevClientDir3 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve15(import.meta.dir, "../dev/client");
+  const fromSource = resolve16(import.meta.dir, "../dev/client");
   if (existsSync15(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve15(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve16(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync15(fromNodeModules))
     return fromNodeModules;
-  return resolve15(import.meta.dir, "./dev/client");
+  return resolve16(import.meta.dir, "./dev/client");
 }, devClientDir3, hmrClientPath4, transpiler3, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, clearVueHmrCaches = () => {
   scriptCache.clear();
   scriptSetupCache.clear();
@@ -10411,14 +10481,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 resolve15(sourceDir, filePath);
+      return resolve16(sourceDir, filePath);
     }
     return filePath;
   }
@@ -10444,7 +10514,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 = basename5(sourceFilePath, ".vue");
   const componentId = toKebab(fileBaseName);
@@ -10482,12 +10552,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 : resolve15(dirname10(sourceFilePath), path));
+  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute3(path)) && isStylePath(path)).map((path) => isAbsolute3(path) ? path : resolve16(dirname10(sourceFilePath), path));
   for (const stylePath of stylePathsImported) {
     addStyleImporter(sourceFilePath, stylePath);
   }
   const childBuildResults = await Promise.all([
-    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve15(dirname10(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
+    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve16(dirname10(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;
@@ -10578,7 +10648,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(dirname10(outputPath), targetPath).replace(/\\/g, "/");
+      let rel = relative9(dirname10(outputPath), targetPath).replace(/\\/g, "/");
       if (!rel.startsWith("."))
         rel = `./${rel}`;
       result2 = result2.replaceAll(bareImport, rel);
@@ -10596,7 +10666,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     hmrId,
     serverPath: serverOutputPath,
     tsHelperPaths: [
-      ...helperModulePaths.map((helper) => resolve15(dirname10(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
+      ...helperModulePaths.map((helper) => resolve16(dirname10(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
       ...childBuildResults.flatMap((child) => child.tsHelperPaths)
     ]
   };
@@ -10619,7 +10689,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(resolve15(entryPath), {
+    const result = await compileVueFile(resolve16(entryPath), {
       client: clientOutputDir,
       css: cssOutputDir,
       server: serverOutputDir
@@ -10627,7 +10697,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     result.tsHelperPaths.forEach((path) => allTsHelperPaths.add(path));
     const entryBaseName = basename5(entryPath, ".vue");
     const indexOutputFile = join16(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join16(clientOutputDir, relative8(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    const clientOutputFile = join16(clientOutputDir, relative9(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
     await mkdir4(dirname10(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
@@ -10635,7 +10705,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     ] : [];
     await write2(indexOutputFile, [
       ...vueHmrImports,
-      `import Comp, * as PageModule from "${relative8(dirname10(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
+      `import Comp, * as PageModule from "${relative9(dirname10(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
       'import { createSSRApp, createApp } from "vue";',
       "",
       "// HMR State Preservation: Check for preserved state from HMR",
@@ -10779,7 +10849,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   await Promise.all(Array.from(allTsHelperPaths).map(async (tsPath) => {
     const sourceCode = await file2(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 = join16(clientOutputDir, relativeJsPath);
     const outServerPath = join16(serverOutputDir, relativeJsPath);
     await mkdir4(dirname10(outClientPath), { recursive: true });
@@ -11284,17 +11354,17 @@ __export(exports_compileAngular, {
   compileAngular: () => compileAngular
 });
 import { existsSync as existsSync16, readFileSync as readFileSync11, promises as fs } from "fs";
-import { join as join17, basename as basename6, sep as sep3, dirname as dirname11, resolve as resolve16, relative as relative9 } from "path";
+import { join as join17, basename as basename6, sep as sep3, dirname as dirname11, resolve as resolve17, relative as relative10 } from "path";
 import ts2 from "typescript";
 var traceAngularPhase = async (name, fn2, metadata) => {
   const tracePhase = globalThis.__absoluteBuildTracePhase;
   return tracePhase ? tracePhase(`compile/angular/${name}`, fn2, metadata) : await fn2();
 }, readTsconfigPathAliases = () => {
   try {
-    const configPath2 = resolve16(process.cwd(), "tsconfig.json");
+    const configPath2 = resolve17(process.cwd(), "tsconfig.json");
     const config = ts2.readConfigFile(configPath2, ts2.sys.readFile).config;
     const compilerOptions = config?.compilerOptions ?? {};
-    const baseUrl = resolve16(process.cwd(), compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve17(process.cwd(), compilerOptions.baseUrl ?? ".");
     const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
     return { aliases, baseUrl };
   } catch {
@@ -11314,7 +11384,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     const wildcardValue = exactMatch ? "" : specifier.slice(prefix.length, specifier.length - suffix.length);
     for (const replacement of alias.replacements) {
       const candidate = replacement.replace("*", wildcardValue);
-      const resolved = resolveSourceFile(resolve16(baseUrl, candidate));
+      const resolved = resolveSourceFile(resolve17(baseUrl, candidate));
       if (resolved)
         return resolved;
     }
@@ -11333,13 +11403,13 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   ];
   return candidates.find((file3) => existsSync16(file3));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
-  const baseDir = resolve16(rootDir);
+  const baseDir = resolve17(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(resolve16(fromDir, specifier));
+      return resolveSourceFile(resolve17(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile);
     if (aliased)
@@ -11348,7 +11418,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve16(resolved);
+      const absolute = resolve17(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile(absolute);
@@ -11364,7 +11434,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
         usesLegacyAnimations: false
       });
     }
-    const resolved = resolve16(actualPath);
+    const resolved = resolve17(actualPath);
     const cached = scanCache.get(resolved);
     if (cached)
       return cached;
@@ -11393,7 +11463,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     const actualPath = resolveSourceFile(filePath);
     if (!actualPath)
       return false;
-    const resolved = resolve16(actualPath);
+    const resolved = resolve17(actualPath);
     if (visited.has(resolved))
       return false;
     visited.add(resolved);
@@ -11411,34 +11481,15 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   return (entryPath) => visit(entryPath);
 }, resolveDevClientDir4 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve16(import.meta.dir, "../dev/client");
+  const fromSource = resolve17(import.meta.dir, "../dev/client");
   if (existsSync16(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve16(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve17(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync16(fromNodeModules))
     return fromNodeModules;
-  return resolve16(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 resolve17(import.meta.dir, "./dev/client");
+}, devClientDir4, hmrClientPath5, formatDiagnosticMessage = (diagnostic) => {
   try {
     return ts2.flattenDiagnosticMessageText(diagnostic.messageText, `
 `);
@@ -11480,11 +11531,11 @@ ${registrations}
   if (hasJsLikeExtension(path))
     return `${path}${query}`;
   const importerDir = dirname11(importerOutputPath);
-  const fileCandidate = resolve16(importerDir, `${path}.js`);
+  const fileCandidate = resolve17(importerDir, `${path}.js`);
   if (outputFiles?.has(fileCandidate) || existsSync16(fileCandidate)) {
     return `${path}.js${query}`;
   }
-  const indexCandidate = resolve16(importerDir, path, "index.js");
+  const indexCandidate = resolve17(importerDir, path, "index.js");
   if (outputFiles?.has(indexCandidate) || existsSync16(indexCandidate)) {
     return `${path}/index.js${query}`;
   }
@@ -11512,7 +11563,7 @@ ${registrations}
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve16(dirname11(fromFile), specifier);
+  const basePath = resolve17(dirname11(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
@@ -11523,9 +11574,9 @@ ${registrations}
     join17(basePath, "index.mts"),
     join17(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve16(candidate)).find((candidate) => existsSync16(candidate) && !candidate.endsWith(".d.ts")) ?? null;
-}, readFileForAotTransform = async (fileName, readFile5) => {
-  const hostSource = readFile5?.(fileName);
+  return candidates.map((candidate) => resolve17(candidate)).find((candidate) => existsSync16(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");
@@ -11558,7 +11609,7 @@ ${registrations}
       paths.push(join17(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
-  return paths.map((path) => resolve16(path));
+  return paths.map((path) => resolve17(path));
 }, readResourceCacheFile = async (cachePath) => {
   try {
     const entry = JSON.parse(await fs.readFile(cachePath, "utf-8"));
@@ -11590,7 +11641,7 @@ ${registrations}
   ].join("\x00");
   const cacheKey2 = Bun.hash(cacheInput).toString(BASE_36_RADIX);
   return join17(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 = {
@@ -11600,14 +11651,14 @@ ${registrations}
     transformedFiles: 0
   };
   const transformFile = async (filePath) => {
-    const resolvedPath = resolve16(filePath);
+    const resolvedPath = resolve17(filePath);
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
     if (!existsSync16(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;
@@ -11635,7 +11686,7 @@ ${registrations}
   return { stats, transformedSources };
 }, compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
   const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
-    const outputPath = resolve16(join17(outDir, relative9(process.cwd(), resolve16(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve17(join17(outDir, relative10(process.cwd(), resolve17(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
       buildIslandMetadataExports(readFileSync11(inputPath, "utf-8"))
@@ -11646,7 +11697,7 @@ ${registrations}
   const tsLibDir = await traceAngularPhase("aot/resolve-typescript-lib", () => {
     const tsPath = __require.resolve("typescript");
     const tsRootDir = dirname11(tsPath);
-    return tsRootDir.endsWith("lib") ? tsRootDir : resolve16(tsRootDir, "lib");
+    return tsRootDir.endsWith("lib") ? tsRootDir : resolve17(tsRootDir, "lib");
   });
   const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
   const options = {
@@ -11688,7 +11739,7 @@ ${registrations}
     return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
   };
   const emitted = {};
-  const resolvedOutDir = resolve16(outDir);
+  const resolvedOutDir = resolve17(outDir);
   host.writeFile = (fileName, text) => {
     const relativePath = resolveRelativePath(fileName, resolvedOutDir, outDir);
     emitted[relativePath] = text;
@@ -11710,12 +11761,12 @@ ${registrations}
     if (!fileName.endsWith(".ts") || fileName.endsWith(".d.ts")) {
       return source;
     }
-    const resolvedPath = resolve16(fileName);
+    const resolvedPath = resolve17(fileName);
     return transformedSources.get(resolvedPath) ?? source;
   };
   const originalGetSourceFileForCompile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
-    const source = transformedSources.get(resolve16(fileName));
+    const source = transformedSources.get(resolve17(fileName));
     if (source) {
       return ts2.createSourceFile(fileName, source, languageVersion, true);
     }
@@ -11739,7 +11790,7 @@ ${registrations}
       content,
       target: join17(outDir, fileName)
     }));
-    const outputFiles = new Set(rawEntries.map(({ target }) => resolve16(target)));
+    const outputFiles = new Set(rawEntries.map(({ target }) => resolve17(target)));
     return rawEntries.map(({ content, target }) => {
       let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
         const rewritten = rewriteRelativeJsSpecifier(target, path, outputFiles);
@@ -11754,7 +11805,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(resolve16(target)) ?? "";
+      processedContent += islandMetadataByOutputPath.get(resolve17(target)) ?? "";
       return { content: processedContent, target };
     });
   });
@@ -11775,7 +11826,7 @@ ${registrations}
   }
   return null;
 }, resolveAngularDeferImportSpecifier = () => {
-  const sourceEntry = resolve16(import.meta.dir, "../angular/components/index.ts");
+  const sourceEntry = resolve17(import.meta.dir, "../angular/components/index.ts");
   if (existsSync16(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
@@ -12005,10 +12056,10 @@ ${fields}
     source: result
   };
 }, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors, cacheBuster) => {
-  const entryPath = resolve16(inputPath);
+  const entryPath = resolve17(inputPath);
   const allOutputs = [];
   const visited = new Set;
-  const baseDir = resolve16(rootDir ?? process.cwd());
+  const baseDir = resolve17(rootDir ?? process.cwd());
   let usesLegacyAnimations = false;
   const angularTranspiler = new Bun.Transpiler({
     loader: "ts",
@@ -12035,7 +12086,7 @@ ${fields}
   };
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile2(resolve16(fromDir, specifier));
+      return resolveSourceFile2(resolve17(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile2);
     if (aliased)
@@ -12044,7 +12095,7 @@ ${fields}
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve16(resolved);
+      const absolute = resolve17(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile2(absolute);
@@ -12093,13 +12144,13 @@ ${fields}
         return `${prefix}${dots}`;
       return `${prefix}../${dots}`;
     });
-    if (resolve16(actualPath) === entryPath) {
+    if (resolve17(actualPath) === entryPath) {
       processedContent += buildIslandMetadataExports(sourceCode);
     }
     return processedContent;
   };
   const transpileFile = async (filePath) => {
-    const resolved = resolve16(filePath);
+    const resolved = resolve17(filePath);
     if (visited.has(resolved))
       return;
     visited.add(resolved);
@@ -12136,7 +12187,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;
@@ -12176,11 +12227,11 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
   const compiledRoot = compiledParent;
   const indexesDir = join17(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) => resolve16(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
+  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve17(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
   const compileTasks = entryPoints.map(async (entry) => {
-    const resolvedEntry = resolve16(entry);
-    const relativeEntry = relative9(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
+    const resolvedEntry = resolve17(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
@@ -12191,10 +12242,10 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
       join17(compiledRoot, relativeEntry),
       join17(compiledRoot, "pages", jsName),
       join17(compiledRoot, jsName)
-    ].map((file3) => resolve16(file3));
+    ].map((file3) => resolve17(file3));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
-        ...candidatePaths.map((file3) => resolve16(file3)),
+        ...candidatePaths.map((file3) => resolve17(file3)),
         ...compiledFallbackPaths
       ];
       let candidate = normalizedCandidates.find((file3) => existsSync16(file3) && file3.endsWith(`${sep3}pages${sep3}${jsName}`));
@@ -12261,14 +12312,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}
@@ -12310,68 +12357,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}';
+// 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());
+};
 
-// 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);
+if (window.__ANGULAR_APP__) {
+    try { window.__ANGULAR_APP__.destroy(); } catch (_err) { /* ignore */ }
+    window.__ANGULAR_APP__ = null;
 }
 
-// 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));
-    }
+// 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;
+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) {
+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';
@@ -12473,7 +12518,6 @@ var init_compileAngular = __esm(() => {
   init_generatedDir();
   devClientDir4 = resolveDevClientDir4();
   hmrClientPath5 = join17(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
-  hmrRuntimePath = join17(devClientDir4, "handlers", "angularRuntime.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
 });
@@ -12927,7 +12971,7 @@ __export(exports_compileEmber, {
 });
 import { existsSync as existsSync17 } from "fs";
 import { mkdir as mkdir5, rm as rm4 } from "fs/promises";
-import { basename as basename7, dirname as dirname12, extname as extname6, join as join18, resolve as resolve17 } from "path";
+import { basename as basename7, dirname as dirname12, extname as extname6, join as join18, resolve as resolve18 } from "path";
 var {build: bunBuild2, Transpiler: Transpiler3, write: write3, file: file3 } = globalThis.Bun;
 var cachedPreprocessor = null, getPreprocessor = async () => {
   if (cachedPreprocessor)
@@ -13023,7 +13067,7 @@ export const importSync = (specifier) => {
         const originalImporter = stagedSourceMap.get(args.importer);
         if (!originalImporter)
           return;
-        const candidateBase = resolve17(dirname12(originalImporter), args.path);
+        const candidateBase = resolve18(dirname12(originalImporter), args.path);
         const extensionsToTry = ["", ".gts", ".gjs", ".ts", ".js"];
         for (const ext of extensionsToTry) {
           const candidate = candidateBase + ext;
@@ -13082,7 +13126,7 @@ export const renderToHTML = (props = {}) => {
 export { PageComponent };
 export default PageComponent;
 `, compileEmberFile = async (entry, compiledRoot, cwd = process.cwd()) => {
-  const resolvedEntry = resolve17(entry);
+  const resolvedEntry = resolve18(entry);
   const source = await file3(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -13102,8 +13146,8 @@ export default PageComponent;
     mkdir5(serverDir, { recursive: true }),
     mkdir5(clientDir, { recursive: true })
   ]);
-  const tmpPagePath = resolve17(join18(tmpDir, `${baseName}.module.js`));
-  const tmpHarnessPath = resolve17(join18(tmpDir, `${baseName}.harness.js`));
+  const tmpPagePath = resolve18(join18(tmpDir, `${baseName}.module.js`));
+  const tmpHarnessPath = resolve18(join18(tmpDir, `${baseName}.harness.js`));
   await Promise.all([
     write3(tmpPagePath, transpiled),
     write3(tmpHarnessPath, generateServerHarness(tmpPagePath))
@@ -13145,7 +13189,7 @@ export default PageComponent;
     serverPaths: outputs.map((o) => o.serverPath)
   };
 }, compileEmberFileSource = async (entry) => {
-  const resolvedEntry = resolve17(entry);
+  const resolvedEntry = resolve18(entry);
   const source = await file3(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -13178,24 +13222,24 @@ __export(exports_buildReactVendor, {
   buildReactVendor: () => buildReactVendor
 });
 import { existsSync as existsSync18, mkdirSync as mkdirSync7 } from "fs";
-import { join as join19, resolve as resolve18 } from "path";
+import { join as join19, resolve as resolve19 } from "path";
 import { rm as rm5 } from "fs/promises";
 var {build: bunBuild3 } = globalThis.Bun;
 var resolveJsxDevRuntimeCompatPath = () => {
   const candidates = [
-    resolve18(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
-    resolve18(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve18(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve18(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve18(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve18(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve19(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
+    resolve19(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve19(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve19(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve19(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve19(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
     if (existsSync18(candidate)) {
       return candidate.replace(/\\/g, "/");
     }
   }
-  return (candidates[0] ?? resolve18(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
+  return (candidates[0] ?? resolve19(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
 }, jsxDevRuntimeCompatPath, reactSpecifiers, isResolvable = (specifier) => {
   try {
     Bun.resolveSync(specifier, process.cwd());
@@ -13845,7 +13889,7 @@ import {
   statSync,
   writeFileSync as writeFileSync7
 } from "fs";
-import { basename as basename8, dirname as dirname13, extname as extname7, join as join24, relative as relative10, resolve as resolve19 } from "path";
+import { basename as basename8, dirname as dirname13, extname as extname7, join as join24, relative as relative11, resolve as resolve20 } from "path";
 import { cwd, env as env2, exit } from "process";
 var {build: bunBuild7, Glob: Glob7 } = globalThis.Bun;
 var isDev, isBuildTraceEnabled = () => {
@@ -13936,8 +13980,8 @@ var isDev, isBuildTraceEnabled = () => {
   }
 }, resolveAbsoluteVersion = async () => {
   const candidates = [
-    resolve19(import.meta.dir, "..", "..", "package.json"),
-    resolve19(import.meta.dir, "..", "package.json")
+    resolve20(import.meta.dir, "..", "..", "package.json"),
+    resolve20(import.meta.dir, "..", "package.json")
   ];
   const resolveCandidate = async (remaining) => {
     const [candidate, ...rest] = remaining;
@@ -13953,7 +13997,7 @@ var isDev, isBuildTraceEnabled = () => {
   };
   await resolveCandidate(candidates);
 }, SKIP_DIRS, addWorkerPathIfExists = (file4, relPath, workerPaths) => {
-  const absPath = resolve19(file4, "..", relPath);
+  const absPath = resolve20(file4, "..", relPath);
   try {
     statSync(absPath);
     workerPaths.add(absPath);
@@ -14015,7 +14059,7 @@ var isDev, isBuildTraceEnabled = () => {
     return;
   }
   const indexFiles = readDir(reactIndexesPath).filter((file4) => file4.endsWith(".tsx"));
-  const pagesRel = relative10(process.cwd(), resolve19(reactPagesPath)).replace(/\\/g, "/");
+  const pagesRel = relative11(process.cwd(), resolve20(reactPagesPath)).replace(/\\/g, "/");
   for (const file4 of indexFiles) {
     let content = readFileSync12(join24(reactIndexesPath, file4), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
@@ -14023,27 +14067,27 @@ var isDev, isBuildTraceEnabled = () => {
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
   const svelteIndexDir = join24(getFrameworkGeneratedDir("svelte"), "indexes");
-  const sveltePageEntries = svelteEntries.filter((file4) => resolve19(file4).startsWith(resolve19(sveltePagesPath)));
+  const sveltePageEntries = svelteEntries.filter((file4) => resolve20(file4).startsWith(resolve20(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename8(entry).replace(/\.svelte(\.(ts|js))?$/, "");
     const indexFile = join24(svelteIndexDir, "pages", `${name}.js`);
     if (!existsSync19(indexFile))
       continue;
     let content = readFileSync12(indexFile, "utf-8");
-    const srcRel = relative10(process.cwd(), resolve19(entry)).replace(/\\/g, "/");
+    const srcRel = relative11(process.cwd(), resolve20(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
     writeFileSync7(join24(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
   const vueIndexDir = join24(getFrameworkGeneratedDir("vue"), "indexes");
-  const vuePageEntries = vueEntries.filter((file4) => resolve19(file4).startsWith(resolve19(vuePagesPath)));
+  const vuePageEntries = vueEntries.filter((file4) => resolve20(file4).startsWith(resolve20(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename8(entry, ".vue");
     const indexFile = join24(vueIndexDir, `${name}.js`);
     if (!existsSync19(indexFile))
       continue;
     let content = readFileSync12(indexFile, "utf-8");
-    const srcRel = relative10(process.cwd(), resolve19(entry)).replace(/\\/g, "/");
+    const srcRel = relative11(process.cwd(), resolve20(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}"`));
     writeFileSync7(join24(devIndexDir, `${name}.vue.js`), content);
   }
@@ -14056,7 +14100,7 @@ var isDev, isBuildTraceEnabled = () => {
   const last = allComments[allComments.length - 1];
   if (!last?.[1])
     return JSON.stringify(outputPath);
-  const srcPath = resolve19(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
+  const srcPath = resolve20(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
   return JSON.stringify(srcPath);
 }, QUOTE_CHARS, OPEN_BRACES, CLOSE_BRACES, findFunctionExpressionEnd = (content, startPos) => {
   let depth = 0;
@@ -14118,7 +14162,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 = basename8(srcPath);
     const mtime = Math.round(statSync(srcPath).mtimeMs);
     const url = `/@src/${rel}?v=${mtime}`;
@@ -14133,7 +14177,7 @@ ${content.slice(firstUseIdx)}`;
     const output = nonReactClientOutputs.find((artifact) => basename8(artifact.path).startsWith(`${srcBase}.`));
     if (!output)
       continue;
-    urlFileMap.set(basename8(srcPath), `/${relative10(buildPath, output.path).replace(/\\/g, "/")}`);
+    urlFileMap.set(basename8(srcPath), `/${relative11(buildPath, output.path).replace(/\\/g, "/")}`);
   }
   return urlFileMap;
 }, buildUrlFileMap = (urlReferencedFiles, hmr, projectRoot, buildPath, nonReactClientOutputs) => {
@@ -14381,13 +14425,13 @@ ${content.slice(firstUseIdx)}`;
   const filterToIncrementalEntries = (entryPoints, mapToSource) => {
     if (!isIncremental || !incrementalFiles)
       return entryPoints;
-    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve19(f2)));
+    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve20(f2)));
     const matchingEntries = [];
     for (const entry of entryPoints) {
       const sourceFile = mapToSource(entry);
       if (!sourceFile)
         continue;
-      if (!normalizedIncremental.has(resolve19(sourceFile)))
+      if (!normalizedIncremental.has(resolve20(sourceFile)))
         continue;
       matchingEntries.push(entry);
     }
@@ -14449,7 +14493,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(resolve19(reactIndexesPath))) {
+    if (entry.startsWith(resolve20(reactIndexesPath))) {
       const pageName = basename8(entry, ".tsx");
       return join24(reactPagesPath, `${pageName}.tsx`);
     }
@@ -14528,7 +14572,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandSvelteClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandSvelteClientPathMap.set(resolve19(sourcePath), clientPath);
+    islandSvelteClientPathMap.set(resolve20(sourcePath), clientPath);
   }
   const islandVueClientPathMap = new Map;
   for (let idx = 0;idx < islandVueSources.length; idx++) {
@@ -14536,7 +14580,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandVueClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandVueClientPathMap.set(resolve19(sourcePath), clientPath);
+    islandVueClientPathMap.set(resolve20(sourcePath), clientPath);
   }
   const islandAngularClientPathMap = new Map;
   for (let idx = 0;idx < islandAngularSources.length; idx++) {
@@ -14544,7 +14588,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandAngularClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandAngularClientPathMap.set(resolve19(sourcePath), clientPath);
+    islandAngularClientPathMap.set(resolve20(sourcePath), clientPath);
   }
   const reactConventionSources = collectConventionSourceFiles(conventionsMap.react);
   const svelteConventionSources = collectConventionSourceFiles(conventionsMap.svelte);
@@ -14857,6 +14901,13 @@ ${content.slice(firstUseIdx)}`;
       outdir: buildPath,
       plugins: [
         stylePreprocessorPlugin2,
+        ...angularDir && hmr ? [
+          createAngularHmrInjectionPlugin({
+            generatedAngularRoot: getFrameworkGeneratedDir("angular", projectRoot),
+            projectRoot,
+            userAngularRoot: angularDir
+          })
+        ] : [],
         ...angularDir ? [createAngularLinkerPlugin(hmr)] : [],
         ...htmlScriptPlugin ? [htmlScriptPlugin] : []
       ],
@@ -14877,6 +14928,13 @@ ${content.slice(firstUseIdx)}`;
       outdir: buildPath,
       plugins: [
         stylePreprocessorPlugin2,
+        ...angularDir && hmr ? [
+          createAngularHmrInjectionPlugin({
+            generatedAngularRoot: getFrameworkGeneratedDir("angular", projectRoot),
+            projectRoot,
+            userAngularRoot: angularDir
+          })
+        ] : [],
         ...angularDir ? [createAngularLinkerPlugin(hmr)] : []
       ],
       root: islandEntryResult.generatedRoot,
@@ -14967,7 +15025,7 @@ ${content.slice(firstUseIdx)}`;
       const fileDir = dirname13(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;
@@ -15172,6 +15230,7 @@ var init_build = __esm(() => {
   init_rewriteReactImports();
   init_telemetryEvent();
   init_angularLinkerPlugin();
+  init_hmrInjectionPlugin();
   init_cleanStaleOutputs();
   init_cleanup();
   init_commonAncestor();
@@ -15386,7 +15445,7 @@ var init_buildEmberVendor = __esm(() => {
 // src/dev/dependencyGraph.ts
 import { existsSync as existsSync21, readFileSync as readFileSync13 } from "fs";
 var {Glob: Glob8 } = globalThis.Bun;
-import { resolve as resolve20 } from "path";
+import { resolve as resolve21 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
   const lower = filePath.toLowerCase();
   if (lower.endsWith(".ts") || lower.endsWith(".tsx") || lower.endsWith(".jsx"))
@@ -15400,8 +15459,8 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
     return null;
   }
-  const fromDir = resolve20(fromFile, "..");
-  const normalized = resolve20(fromDir, importPath);
+  const fromDir = resolve21(fromFile, "..");
+  const normalized = resolve21(fromDir, importPath);
   const extensions = [
     ".ts",
     ".tsx",
@@ -15431,7 +15490,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     dependents.delete(normalizedPath);
   }
 }, addFileToGraph = (graph, filePath) => {
-  const normalizedPath = resolve20(filePath);
+  const normalizedPath = resolve21(filePath);
   if (!existsSync21(normalizedPath))
     return;
   const dependencies = extractDependencies(normalizedPath);
@@ -15448,10 +15507,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) => resolve20(dir)).filter((dir) => existsSync21(dir));
+  const resolvedDirs = directories.map((dir) => resolve21(dir)).filter((dir) => existsSync21(dir));
   const allFiles = resolvedDirs.flatMap((dir) => Array.from(glob.scanSync({ absolute: true, cwd: dir })));
   for (const file4 of allFiles) {
-    const fullPath = resolve20(file4);
+    const fullPath = resolve21(file4);
     if (IGNORED_SEGMENTS.some((seg) => fullPath.includes(seg)))
       continue;
     if (processedFiles.has(fullPath))
@@ -15564,7 +15623,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     return [];
   }
 }, getAffectedFiles = (graph, changedFile) => {
-  const normalizedPath = resolve20(changedFile);
+  const normalizedPath = resolve21(changedFile);
   const affected = new Set;
   const toProcess = [normalizedPath];
   const processNode = (current) => {
@@ -15604,7 +15663,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   }
   graph.dependents.delete(normalizedPath);
 }, removeFileFromGraph = (graph, filePath) => {
-  const normalizedPath = resolve20(filePath);
+  const normalizedPath = resolve21(filePath);
   removeDepsForFile(graph, normalizedPath);
   removeDependentsForFile(graph, normalizedPath);
 };
@@ -15647,12 +15706,12 @@ var globalVersionCounter = 0, createModuleVersionTracker = () => new Map, getNex
 };
 
 // src/dev/configResolver.ts
-import { resolve as resolve21 } from "path";
+import { resolve as resolve22 } from "path";
 var resolveBuildPaths = (config) => {
   const cwd2 = process.cwd();
   const normalize = (path) => path.replace(/\\/g, "/");
-  const withDefault = (value, fallback) => normalize(resolve21(cwd2, value ?? fallback));
-  const optional = (value) => value ? normalize(resolve21(cwd2, value)) : undefined;
+  const withDefault = (value, fallback) => normalize(resolve22(cwd2, value ?? fallback));
+  const optional = (value) => value ? normalize(resolve22(cwd2, value)) : undefined;
   return {
     angularDir: optional(config.angularDirectory),
     assetsDir: optional(config.assetsDirectory),
@@ -15704,8 +15763,8 @@ var init_clientManager = __esm(() => {
 });
 
 // src/dev/pathUtils.ts
-import { existsSync as existsSync22 } from "fs";
-import { resolve as resolve22 } from "path";
+import { existsSync as existsSync22, readdirSync, readFileSync as readFileSync14 } from "fs";
+import { dirname as dirname14, resolve as resolve23 } from "path";
 var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   if (shouldIgnorePath(filePath, resolved)) {
     return "ignored";
@@ -15779,13 +15838,80 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
     return "assets";
   }
   return "unknown";
+}, collectAngularResourceDirs = (angularDir) => {
+  const out = new Set;
+  const angularRoot = resolve23(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 = resolve23(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".component.ts")) {
+        continue;
+      }
+      let source;
+      try {
+        source = readFileSync14(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 = dirname14(full);
+      for (const ref of refs) {
+        const refAbs = normalizePath(resolve23(componentDir, ref));
+        const refDir = normalizePath(dirname14(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(resolve22(cwd2, path));
+    const abs = normalizePath(resolve23(cwd2, path));
     if (!roots.includes(abs))
       roots.push(abs);
   };
@@ -15810,13 +15936,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(resolve22(cwd2, candidate));
+    const abs = normalizePath(resolve23(cwd2, candidate));
     if (existsSync22(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);
@@ -15874,7 +16007,7 @@ var init_pathUtils = __esm(() => {
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
 import { existsSync as existsSync23 } from "fs";
-import { join as join26, resolve as resolve23 } from "path";
+import { join as join26, resolve as resolve24 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -15919,7 +16052,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
 }, addFileWatchers = (state, paths, onFileChange) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
-    const absolutePath = resolve23(path).replace(/\\/g, "/");
+    const absolutePath = resolve24(path).replace(/\\/g, "/");
     if (!existsSync23(absolutePath)) {
       return;
     }
@@ -15930,7 +16063,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const watchPaths = getWatchPaths(config, state.resolvedPaths);
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
-    const absolutePath = resolve23(path).replace(/\\/g, "/");
+    const absolutePath = resolve24(path).replace(/\\/g, "/");
     if (!existsSync23(absolutePath)) {
       return;
     }
@@ -15945,13 +16078,13 @@ var init_fileWatcher = __esm(() => {
 });
 
 // src/dev/assetStore.ts
-import { resolve as resolve24 } from "path";
+import { resolve as resolve25 } 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 = resolve24(dir, entry.name);
+  const fullPath = resolve25(dir, entry.name);
   if (entry.isDirectory()) {
     return walkAndClean(fullPath);
   }
@@ -15967,10 +16100,10 @@ var mimeTypes, getMimeType = (filePath) => {
 }, cleanStaleAssets = async (store, manifest, buildDir) => {
   const liveByIdentity = new Map;
   for (const webPath of store.keys()) {
-    const diskPath = resolve24(buildDir, webPath.slice(1));
+    const diskPath = resolve25(buildDir, webPath.slice(1));
     liveByIdentity.set(stripHash(diskPath), diskPath);
   }
-  const absBuildDir = resolve24(buildDir);
+  const absBuildDir = resolve25(buildDir);
   Object.values(manifest).forEach((val) => {
     if (!HASHED_FILE_RE.test(val))
       return;
@@ -15988,7 +16121,7 @@ var mimeTypes, getMimeType = (filePath) => {
   } catch {}
 }, lookupAsset = (store, path) => store.get(path), processScanEntry = (entry, dir, prefix, store, scanDir) => {
   if (entry.isDirectory()) {
-    return scanDir(resolve24(dir, entry.name), `${prefix}${entry.name}/`);
+    return scanDir(resolve25(dir, entry.name), `${prefix}${entry.name}/`);
   }
   if (!entry.name.startsWith("chunk-")) {
     return null;
@@ -15997,7 +16130,7 @@ var mimeTypes, getMimeType = (filePath) => {
   if (store.has(webPath)) {
     return null;
   }
-  return Bun.file(resolve24(dir, entry.name)).bytes().then((bytes) => {
+  return Bun.file(resolve25(dir, entry.name)).bytes().then((bytes) => {
     store.set(webPath, bytes);
     return;
   }).catch(() => {});
@@ -16019,7 +16152,7 @@ var mimeTypes, getMimeType = (filePath) => {
   for (const webPath of newIdentities.values()) {
     if (store.has(webPath))
       continue;
-    loadPromises.push(Bun.file(resolve24(buildDir, webPath.slice(1))).bytes().then((bytes) => {
+    loadPromises.push(Bun.file(resolve25(buildDir, webPath.slice(1))).bytes().then((bytes) => {
       store.set(webPath, bytes);
       return;
     }).catch(() => {}));
@@ -16049,8 +16182,8 @@ var init_assetStore = __esm(() => {
 });
 
 // src/islands/pageMetadata.ts
-import { readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname14, resolve as resolve25 } from "path";
+import { readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname15, resolve as resolve26 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
   { dir: config.emberDirectory, framework: "ember" },
@@ -16070,15 +16203,15 @@ var pagePatterns, getPageDirs = (config) => [
     const source = definition.buildReference?.source;
     if (!source)
       continue;
-    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve25(dirname14(buildInfo.resolvedRegistryPath), source);
-    lookup.set(`${definition.framework}:${definition.component}`, resolve25(resolvedSource));
+    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve26(dirname15(buildInfo.resolvedRegistryPath), source);
+    lookup.set(`${definition.framework}:${definition.component}`, resolve26(resolvedSource));
   }
   return lookup;
 }, getCurrentPageIslandMetadata = () => globalThis.__absolutePageIslandMetadata ?? new Map, metadataUsesSource = (metadata, target) => metadata.islands.some((usage) => {
   const candidate = usage.source;
-  return candidate ? resolve25(candidate) === target : false;
+  return candidate ? resolve26(candidate) === target : false;
 }), getPagesUsingIslandSource = (sourcePath) => {
-  const target = resolve25(sourcePath);
+  const target = resolve26(sourcePath);
   return [...getCurrentPageIslandMetadata().values()].filter((metadata) => metadataUsesSource(metadata, target)).map((metadata) => metadata.pagePath);
 }, resolveIslandUsages = (islands, islandSourceLookup) => islands.map((usage) => {
   const sourcePath = islandSourceLookup.get(`${usage.framework}:${usage.component}`);
@@ -16090,13 +16223,13 @@ var pagePatterns, getPageDirs = (config) => [
   const pattern = pagePatterns[entry.framework];
   if (!pattern)
     return;
-  const files = await scanEntryPoints(resolve25(entry.dir), pattern);
+  const files = await scanEntryPoints(resolve26(entry.dir), pattern);
   for (const filePath of files) {
-    const source = readFileSync14(filePath, "utf-8");
+    const source = readFileSync15(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
-    pageMetadata.set(resolve25(filePath), {
+    pageMetadata.set(resolve26(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
-      pagePath: resolve25(filePath)
+      pagePath: resolve26(filePath)
     });
   }
 }, loadPageIslandMetadata = async (config) => {
@@ -16123,10 +16256,10 @@ var init_pageMetadata = __esm(() => {
 });
 
 // src/dev/fileHashTracker.ts
-import { readFileSync as readFileSync15 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 var computeFileHash = (filePath) => {
   try {
-    const fileContent = readFileSync15(filePath);
+    const fileContent = readFileSync16(filePath);
     return Number(Bun.hash(fileContent));
   } catch {
     return UNFOUND_INDEX;
@@ -16206,9 +16339,9 @@ var init_transformCache = __esm(() => {
 });
 
 // src/dev/reactComponentClassifier.ts
-import { resolve as resolve26 } from "path";
+import { resolve as resolve27 } from "path";
 var classifyComponent = (filePath) => {
-  const normalizedPath = resolve26(filePath);
+  const normalizedPath = resolve27(filePath);
   if (normalizedPath.includes("/react/pages/")) {
     return "server";
   }
@@ -16220,7 +16353,7 @@ var classifyComponent = (filePath) => {
 var init_reactComponentClassifier = () => {};
 
 // src/dev/moduleMapper.ts
-import { basename as basename9, resolve as resolve27 } from "path";
+import { basename as basename9, resolve as resolve28 } from "path";
 var buildModulePaths = (moduleKeys, manifest) => {
   const modulePaths = {};
   moduleKeys.forEach((key) => {
@@ -16230,7 +16363,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return modulePaths;
 }, processChangedFile = (sourceFile, framework, manifest, resolvedPaths, processedFiles) => {
-  const normalizedFile = resolve27(sourceFile);
+  const normalizedFile = resolve28(sourceFile);
   const normalizedPath = normalizedFile.replace(/\\/g, "/");
   if (processedFiles.has(normalizedFile)) {
     return null;
@@ -16266,7 +16399,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return grouped;
 }, mapSourceFileToManifestKeys = (sourceFile, framework, resolvedPaths) => {
-  const normalizedFile = resolve27(sourceFile);
+  const normalizedFile = resolve28(sourceFile);
   const fileName = basename9(normalizedFile);
   const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|css|html)$/, "");
   const pascalName = toPascal(baseName);
@@ -16448,247 +16581,6 @@ var init_ssrCache = __esm(() => {
   dirtyFrameworks = new Set;
 });
 
-// src/dev/angular/editTypeDetection.ts
-import { readFileSync as readFileSync16 } from "fs";
-import { basename as basename10 } 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 = (file4) => {
-  let source;
-  try {
-    source = readFileSync16(file4, "utf8");
-  } catch {
-    return {
-      hasSideEffectCtor: true,
-      reason: "service file unreadable \u2014 defaulting to reboot"
-    };
-  }
-  const sf = ts3.createSourceFile(file4, 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 = (file4) => {
-  const base = basename10(file4);
-  if (TEMPLATE_RE.test(file4)) {
-    return {
-      type: "template",
-      reason: `${base} \u2014 template edit`,
-      sourceFile: file4
-    };
-  }
-  if (COMPONENT_STYLE_RE.test(file4)) {
-    return {
-      type: "style-component",
-      reason: `${base} \u2014 component-scoped stylesheet edit`,
-      sourceFile: file4
-    };
-  }
-  if (STYLE_EXT_RE.test(file4)) {
-    return {
-      type: "reboot",
-      reason: `${base} \u2014 non-component-named stylesheet, falling back to reboot until scoping is verified`,
-      sourceFile: file4
-    };
-  }
-  if (ROUTES_RE.test(file4)) {
-    return {
-      type: "route",
-      reason: `${base} \u2014 router config, requires reboot`,
-      sourceFile: file4
-    };
-  }
-  if (SERVICE_RE.test(file4)) {
-    const a = analyzeServiceFile(file4);
-    if (a.hasSideEffectCtor) {
-      return {
-        type: "service-with-side-effects",
-        reason: `${base} \u2014 ${a.reason}`,
-        sourceFile: file4
-      };
-    }
-    return {
-      type: "service-method-only",
-      reason: `${base} \u2014 ${a.reason}`,
-      sourceFile: file4
-    };
-  }
-  if (COMPONENT_CLASS_RE.test(file4)) {
-    return {
-      type: "class-component",
-      reason: `${base} \u2014 component class edit`,
-      sourceFile: file4
-    };
-  }
-  if (PAGE_TS_RE.test(file4)) {
-    return {
-      type: "class-component",
-      reason: `${base} \u2014 page component edit`,
-      sourceFile: file4
-    };
-  }
-  return {
-    type: "reboot",
-    reason: `${base} \u2014 unrecognized angular file type, falling back to reboot`,
-    sourceFile: file4
-  };
-}, 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, {
@@ -16701,7 +16593,7 @@ __export(exports_moduleServer, {
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
 import { existsSync as existsSync24, readFileSync as readFileSync17, statSync as statSync2 } from "fs";
-import { basename as basename11, dirname as dirname15, extname as extname8, join as join27, resolve as resolve28, relative as relative11 } from "path";
+import { basename as basename10, dirname as dirname16, extname as extname8, join as join27, resolve as resolve29, 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 = [];
@@ -16721,7 +16613,7 @@ var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPIL
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const found = extensions.find((ext) => existsSync24(resolve28(projectRoot, srcPath + ext)));
+  const found = extensions.find((ext) => existsSync24(resolve29(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);
@@ -16736,7 +16628,7 @@ ${stubs}
   return invalidationVersion > 0 ? `${mtime}.${invalidationVersion}` : `${mtime}`;
 }, srcUrl = (relPath, projectRoot) => {
   const base = `${SRC_PREFIX}${relPath.replace(/\\/g, "/")}`;
-  const absPath = resolve28(projectRoot, relPath);
+  const absPath = resolve29(projectRoot, relPath);
   const cached = mtimeCache.get(absPath);
   if (cached !== undefined)
     return `${base}?v=${buildVersion(cached, absPath)}`;
@@ -16748,12 +16640,12 @@ ${stubs}
     return base;
   }
 }, resolveRelativeImport = (relPath, fileDir, projectRoot, extensions) => {
-  const absPath = resolve28(fileDir, relPath);
-  const rel = relative11(projectRoot, absPath);
+  const absPath = resolve29(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(resolve28(projectRoot, srcPath)));
+    srcPath = relative12(projectRoot, resolveSvelteModulePath(resolve29(projectRoot, srcPath)));
   }
   return srcUrl(srcPath, projectRoot);
 }, resolveAbsoluteSpecifier = (specifier, projectRoot) => {
@@ -16763,27 +16655,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 = resolve28(projectRoot, "node_modules", packageName ?? "");
+        const pkgDir = resolve29(projectRoot, "node_modules", packageName ?? "");
         const pkgJsonPath = join27(pkgDir, "package.json");
         if (existsSync24(pkgJsonPath)) {
           const pkg = JSON.parse(readFileSync17(pkgJsonPath, "utf-8"));
           const esmEntry = typeof pkg.module === "string" && pkg.module || typeof pkg.browser === "string" && pkg.browser;
           if (esmEntry) {
-            const resolved = resolve28(pkgDir, esmEntry);
+            const resolved = resolve29(pkgDir, esmEntry);
             if (existsSync24(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;
   }
@@ -16808,26 +16700,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 = dirname15(filePath);
+  const fileDir = dirname16(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 = resolve28(fileDir, relPath);
-    const rel = relative11(projectRoot, absPath);
+    const absPath = resolve29(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 = resolve28(fileDir, relPath);
-    const rel = relative11(projectRoot, absPath);
+    const absPath = resolve29(fileDir, relPath);
+    const rel = relative12(projectRoot, absPath);
     return `'${srcUrl(rel, projectRoot)}'`;
   });
   return result;
@@ -16883,7 +16775,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);
@@ -17044,11 +16936,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; };`);
@@ -17119,7 +17011,7 @@ ${code}`;
   if (!vueCompiler) {
     vueCompiler = await import("@vue/compiler-sfc");
   }
-  const fileName = basename11(filePath, ".vue");
+  const fileName = basename10(filePath, ".vue");
   const componentId = fileName.toLowerCase();
   const { descriptor } = vueCompiler.parse(raw, { filename: filePath });
   const hasScript = descriptor.script || descriptor.scriptSetup;
@@ -17137,8 +17029,8 @@ ${code}`;
   code = injectVueHmr(code, filePath, projectRoot, vueDir);
   return rewriteImports(code, filePath, projectRoot, rewriter);
 }, injectVueHmr = (code, filePath, projectRoot, vueDir) => {
-  const hmrBase = vueDir ? resolve28(vueDir) : projectRoot;
-  const hmrId = relative11(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
+  const hmrBase = vueDir ? resolve29(vueDir) : projectRoot;
+  const hmrId = relative12(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
   let result = code.replace(/export\s+default\s+/, "var __hmr_comp__ = ");
   result += [
     "",
@@ -17296,7 +17188,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 = resolve28(projectRoot, relPath);
+  const filePath = resolve29(projectRoot, relPath);
   const ext = extname8(filePath);
   if (ext === ".svelte")
     return { ext, filePath: resolveSvelteModulePath(filePath) };
@@ -17323,7 +17215,7 @@ export default {};
   if (!TRANSPILABLE.has(ext))
     return;
   const stat3 = statSync2(filePath);
-  const resolvedVueDir = vueDir ? resolve28(vueDir) : undefined;
+  const resolvedVueDir = vueDir ? resolve29(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);
@@ -17354,7 +17246,7 @@ export default {};
     if (!pathname.startsWith(SRC_PREFIX))
       return;
     const relPath = pathname.slice(SRC_PREFIX.length);
-    const virtualCssResponse = handleVirtualSvelteCss(resolve28(projectRoot, relPath));
+    const virtualCssResponse = handleVirtualSvelteCss(resolve29(projectRoot, relPath));
     if (virtualCssResponse)
       return virtualCssResponse;
     const { filePath, ext } = resolveSourcePath(relPath, projectRoot);
@@ -17370,11 +17262,11 @@ export default {};
   SRC_IMPORT_RE.lastIndex = 0;
   while ((match = SRC_IMPORT_RE.exec(content)) !== null) {
     if (match[1])
-      files.push(resolve28(projectRoot, match[1]));
+      files.push(resolve29(projectRoot, match[1]));
   }
   return files;
 }, invalidateModule = (filePath) => {
-  const resolved = resolve28(filePath);
+  const resolved = resolve29(filePath);
   invalidate(filePath);
   if (resolved !== filePath)
     invalidate(resolved);
@@ -17489,71 +17381,1584 @@ 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 readFileSync18, statSync as statSync3 } from "fs";
+import { dirname as dirname17, extname as extname9, join as join28, resolve as resolve30 } from "path";
+import ts3 from "typescript";
+var isComponentTsFile = (file4) => file4.endsWith(".component.ts") || file4.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 = join28(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 = () => {
-  const g2 = globalThis;
+  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 = readFileSync18(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) => resolve30(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 = dirname17(componentTsPath);
+    const matchesResource = (relativeUrl) => {
+      const abs = safeNormalize(resolve30(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 existsSync25, readFileSync as readFileSync19 } from "fs";
+import { dirname as dirname18, relative as relative13, resolve as resolve31 } 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 = resolve31(componentDir, url);
+  if (!existsSync25(abs))
+    return null;
+  return readFileSync19(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 (!existsSync25(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 = readFileSync19(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 = dirname18(componentFilePath);
+  let templateText;
+  let templatePath;
+  if (decoratorMeta.template !== null) {
+    templateText = decoratorMeta.template;
+    templatePath = componentFilePath;
+  } else if (decoratorMeta.templateUrl) {
+    const tplAbs = resolve31(componentDir, decoratorMeta.templateUrl);
+    if (!existsSync25(tplAbs)) {
+      return fail("template-resource-not-found", tplAbs);
+    }
+    templateText = readFileSync19(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 existsSync26 } from "fs";
+import { basename as basename11, dirname as dirname19, join as join29, relative as relative14, resolve as resolve32 } 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 = dirname19(tsPath);
+  resolveTypescriptLibDirCached = tsRootDir.endsWith("lib") ? tsRootDir : resolve32(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 = resolve32(process.cwd(), "tsconfig.json");
+  if (!existsSync26(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 basename11(fileName);
+  };
+  const originalGetSourceFile = host.getSourceFile;
+  host.getSourceFile = (fileName, languageVersion, onError) => {
+    if (fileName.startsWith("lib.") && fileName.endsWith(".d.ts") && tsLibDir) {
+      return originalGetSourceFile?.call(host, join29(tsLibDir, fileName), languageVersion, onError);
+    }
+    return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
+  };
+  const emitted = {};
+  const resolvedOutDir = resolve32(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 = resolve32(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 = resolve32(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 {
     };
@@ -17620,11 +19025,11 @@ var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { resolve as resolve29 } from "path";
+import { resolve as resolve33 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve29(htmlFilePath);
+    const resolvedPath = resolve33(htmlFilePath);
     const file4 = Bun.file(resolvedPath);
     if (!await file4.exists()) {
       return null;
@@ -17650,11 +19055,11 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { resolve as resolve30 } from "path";
+import { resolve as resolve34 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve30(htmxFilePath);
+    const resolvedPath = resolve34(htmxFilePath);
     const file4 = Bun.file(resolvedPath);
     if (!await file4.exists()) {
       return null;
@@ -17676,8 +19081,8 @@ var handleHTMXUpdate = async (htmxFilePath) => {
 var init_simpleHTMXHMR = () => {};
 
 // src/dev/rebuildTrigger.ts
-import { existsSync as existsSync25 } from "fs";
-import { basename as basename12, dirname as dirname16, relative as relative12, resolve as resolve31 } from "path";
+import { existsSync as existsSync27 } from "fs";
+import { basename as basename12, dirname as dirname20, relative as relative15, resolve as resolve35 } 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;
@@ -17765,11 +19170,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) && existsSync25(affectedFile), collectDeletedFileAffected = (state, filePathInSet, processedFiles, validFiles) => {
+}, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync27(affectedFile), collectDeletedFileAffected = (state, filePathInSet, processedFiles, validFiles) => {
   state.fileHashes.delete(filePathInSet);
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, filePathInSet);
-    const deletedPathResolved = resolve31(filePathInSet);
+    const deletedPathResolved = resolve35(filePathInSet);
     affectedFiles.forEach((affectedFile) => {
       if (isValidDeletedAffectedFile(affectedFile, deletedPathResolved, processedFiles)) {
         validFiles.push(affectedFile);
@@ -17783,7 +19188,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     if (!dependents || dependents.size === 0) {
       return;
     }
-    const dependentFiles = Array.from(dependents).filter((file4) => existsSync25(file4));
+    const dependentFiles = Array.from(dependents).filter((file4) => existsSync27(file4));
     if (dependentFiles.length === 0) {
       return;
     }
@@ -17799,7 +19204,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, normalizedFilePath);
     affectedFiles.forEach((affectedFile) => {
-      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync25(affectedFile)) {
+      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync27(affectedFile)) {
         validFiles.push(affectedFile);
         processedFiles.add(affectedFile);
       }
@@ -17813,7 +19218,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (storedHash !== undefined && storedHash === fileHash) {
     return;
   }
-  const normalizedFilePath = resolve31(filePathInSet);
+  const normalizedFilePath = resolve35(filePathInSet);
   if (!processedFiles.has(normalizedFilePath)) {
     validFiles.push(normalizedFilePath);
     processedFiles.add(normalizedFilePath);
@@ -17824,7 +19229,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   collectChangedFileAffected(state, normalizedFilePath, processedFiles, validFiles);
 }, processFilePathSet = (state, filePathSet, processedFiles, validFiles) => {
   filePathSet.forEach((filePathInSet) => {
-    if (!existsSync25(filePathInSet)) {
+    if (!existsSync27(filePathInSet)) {
       collectDeletedFileAffected(state, filePathInSet, processedFiles, validFiles);
       return;
     }
@@ -17917,8 +19322,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return;
   }
   if (framework === "unknown") {
-    invalidate(resolve31(filePath));
-    const relPath = relative12(process.cwd(), filePath);
+    invalidate(resolve35(filePath));
+    const relPath = relative15(process.cwd(), filePath);
     logHmrUpdate(relPath);
     return;
   }
@@ -17944,7 +19349,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const userEditedFiles = new Set;
     state.fileChangeQueue.forEach((filePaths) => {
       for (const filePath2 of filePaths) {
-        userEditedFiles.add(resolve31(filePath2));
+        userEditedFiles.add(resolve35(filePath2));
       }
     });
     state.lastUserEditedFiles = userEditedFiles;
@@ -17968,12 +19373,12 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return componentFile;
   }
   const tsCounterpart = componentFile.replace(/\.html$/, ".ts");
-  if (existsSync25(tsCounterpart)) {
+  if (existsSync27(tsCounterpart)) {
     return tsCounterpart;
   }
   if (!graph)
     return componentFile;
-  const dependents = graph.dependents.get(resolve31(componentFile));
+  const dependents = graph.dependents.get(resolve35(componentFile));
   if (!dependents)
     return componentFile;
   for (const dep of dependents) {
@@ -17982,7 +19387,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   return componentFile;
 }, resolveAngularPageEntries = (state, angularFiles, angularPagesPath) => {
-  const pageEntries = angularFiles.filter((file4) => file4.endsWith(".ts") && resolve31(file4).startsWith(angularPagesPath));
+  const pageEntries = angularFiles.filter((file4) => file4.endsWith(".ts") && resolve35(file4).startsWith(angularPagesPath));
   if (pageEntries.length > 0 || !state.dependencyGraph) {
     return pageEntries;
   }
@@ -17991,7 +19396,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const lookupFile = resolveComponentLookupFile(componentFile, state.dependencyGraph);
     const affected = getAffectedFiles(state.dependencyGraph, lookupFile);
     affected.forEach((file4) => {
-      if (file4.endsWith(".ts") && resolve31(file4).startsWith(angularPagesPath)) {
+      if (file4.endsWith(".ts") && resolve35(file4).startsWith(angularPagesPath)) {
         resolvedPages.add(file4);
       }
     });
@@ -18016,12 +19421,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));
@@ -18044,7 +19452,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",
@@ -18063,37 +19476,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((file4) => userEditedFiles.has(resolve31(file4)));
-  return filtered.length > 0 ? filtered : candidates;
-}, broadcastAngularPageUpdates = (state, pagesToUpdate, manifest, startTime, classification) => {
-  pagesToUpdate.forEach((angularPagePath) => {
-    const fileName = basename12(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;
@@ -18111,36 +19559,42 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   serverPaths.forEach((serverPath, idx) => {
     const fileBase = basename12(serverPath, ".js");
     const ssrPath = ssrPaths[idx] ?? serverPath;
-    state.manifest[toPascal(fileBase)] = resolve31(ssrPath);
+    state.manifest[toPascal(fileBase)] = resolve35(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((file4) => detectFramework(file4, state.resolvedPaths) === "angular");
   for (const file4 of angularFiles) {
-    state.fileHashes.set(resolve31(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve35(file4), computeFileHash(file4));
   }
-  const angularPagesPath = resolve31(angularDir, "pages");
+  const angularPagesPath = resolve35(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((file4) => file4.endsWith(".ts") || file4.endsWith(".html"));
-  const angularPageFiles = angularHmrFiles.filter((file4) => file4.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;
@@ -18149,11 +19603,11 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (isComponentFile2)
     return primaryFile;
   const { findNearestComponent: findNearestComponent2 } = await Promise.resolve().then(() => (init_transformCache(), exports_transformCache));
-  const nearest = findNearestComponent2(resolve31(primaryFile));
+  const nearest = findNearestComponent2(resolve35(primaryFile));
   return nearest ?? primaryFile;
 }, handleReactModuleServerPath = async (state, reactFiles, startTime, onRebuildComplete) => {
   for (const file4 of reactFiles) {
-    state.fileHashes.set(resolve31(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve35(file4), computeFileHash(file4));
   }
   markSsrCacheDirty("react");
   const primaryFile = reactFiles.find((file4) => !file4.replace(/\\/g, "/").includes("/pages/")) ?? reactFiles[0];
@@ -18172,7 +19626,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: {
@@ -18235,7 +19689,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, handleSvelteModuleServerPath = async (state, svelteFiles, startTime, onRebuildComplete) => {
   for (const file4 of svelteFiles) {
-    state.fileHashes.set(resolve31(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve35(file4), computeFileHash(file4));
   }
   markSsrCacheDirty("svelte");
   const serverDuration = Date.now() - startTime;
@@ -18260,8 +19714,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 = resolve31(getFrameworkGeneratedDir2("svelte"), "server");
-    const serverOutDir = resolve31(buildDir, basename12(svelteDir));
+    const serverRoot = resolve35(getFrameworkGeneratedDir2("svelte"), "server");
+    const serverOutDir = resolve35(buildDir, basename12(svelteDir));
     const [serverResult, clientResult] = await Promise.all([
       serverEntries.length > 0 ? bunBuild9({
         entrypoints: serverEntries,
@@ -18358,7 +19812,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, handleVueModuleServerPath = async (state, vueFiles, nonVueFiles, startTime, onRebuildComplete) => {
   for (const file4 of [...vueFiles, ...nonVueFiles]) {
-    state.fileHashes.set(resolve31(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve35(file4), computeFileHash(file4));
   }
   markSsrCacheDirty("vue");
   await invalidateNonVueModules(nonVueFiles);
@@ -18386,7 +19840,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) => resolve31(emberPagesPath, entry.name));
+    return entries.filter((entry) => entry.isFile() && EMBER_PAGE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))).map((entry) => resolve35(emberPagesPath, entry.name));
   } catch {
     return [];
   }
@@ -18398,10 +19852,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return state.manifest;
   }
   for (const file4 of emberFiles) {
-    state.fileHashes.set(resolve31(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve35(file4), computeFileHash(file4));
   }
-  const emberPagesPath = resolve31(emberDir, "pages");
-  const directPageEntries = emberFiles.filter((file4) => resolve31(file4).startsWith(emberPagesPath));
+  const emberPagesPath = resolve35(emberDir, "pages");
+  const directPageEntries = emberFiles.filter((file4) => resolve35(file4).startsWith(emberPagesPath));
   const allPageEntries = directPageEntries.length > 0 ? directPageEntries : await collectAllEmberPages(emberPagesPath);
   if (allPageEntries.length === 0) {
     onRebuildComplete({ hmrState: state, manifest: state.manifest });
@@ -18411,14 +19865,14 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const { serverPaths } = await compileEmber2(allPageEntries, emberDir, process.cwd(), true);
   for (const serverPath of serverPaths) {
     const fileBase = basename12(serverPath, ".js");
-    state.manifest[toPascal(fileBase)] = resolve31(serverPath);
+    state.manifest[toPascal(fileBase)] = resolve35(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);
   }
@@ -18503,8 +19957,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!buildReference?.source) {
     return;
   }
-  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve31(dirname16(buildInfo.resolvedRegistryPath), buildReference.source);
-  islandFiles.add(resolve31(sourcePath));
+  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve35(dirname20(buildInfo.resolvedRegistryPath), buildReference.source);
+  islandFiles.add(resolve35(sourcePath));
 }, resolveIslandSourceFiles = async (config) => {
   const registryPath = config.islands?.registry;
   if (!registryPath) {
@@ -18512,7 +19966,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   const buildInfo = await loadIslandRegistryBuildInfo(registryPath);
   const islandFiles = new Set([
-    resolve31(buildInfo.resolvedRegistryPath)
+    resolve35(buildInfo.resolvedRegistryPath)
   ]);
   for (const definition of buildInfo.definitions) {
     resolveIslandDefinitionSource(definition, buildInfo, islandFiles);
@@ -18523,7 +19977,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (islandFiles.size === 0) {
     return false;
   }
-  return filesToRebuild.some((file4) => islandFiles.has(resolve31(file4)));
+  return filesToRebuild.some((file4) => islandFiles.has(resolve35(file4)));
 }, handleIslandSourceReload = async (state, config, filesToRebuild, manifest) => {
   const shouldReload = await didStaticPagesNeedIslandRefresh(config, filesToRebuild);
   if (!shouldReload) {
@@ -18558,10 +20012,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 resolve31(state.resolvedPaths.buildDir, "pages");
+    return resolve35(state.resolvedPaths.buildDir, "pages");
   }
   const dirName = framework === "html" ? basename12(config.htmlDirectory ?? "html") : basename12(config.htmxDirectory ?? "htmx");
-  return resolve31(state.resolvedPaths.buildDir, dirName, "pages");
+  return resolve35(state.resolvedPaths.buildDir, dirName, "pages");
 }, processHtmlPageUpdate = async (state, pageFile, builtHtmlPagePath, manifest, duration) => {
   try {
     const { handleHTMLUpdate: handleHTMLUpdate2 } = await Promise.resolve().then(() => (init_simpleHTMLHMR(), exports_simpleHTMLHMR));
@@ -18600,7 +20054,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmlPages, "*.html") : htmlPageFiles;
   await runSequentially(pageFilesToUpdate, async (pageFile) => {
     const htmlPageName = basename12(pageFile);
-    const builtHtmlPagePath = resolve31(outputHtmlPages, htmlPageName);
+    const builtHtmlPagePath = resolve35(outputHtmlPages, htmlPageName);
     await processHtmlPageUpdate(state, pageFile, builtHtmlPagePath, manifest, duration);
   });
 }, handleVueCssOnlyUpdate = (state, vueCssFiles, manifest, duration) => {
@@ -18661,11 +20115,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(resolve31(vuePagePath));
+  const hmrMeta = vueHmrMetadata2.get(resolve35(vuePagePath));
   const changeType = hmrMeta?.changeType ?? "full";
   if (changeType === "style-only") {
     broadcastVueStyleOnly(state, vuePagePath, baseName, cssUrl, hmrId, manifest, duration);
@@ -18764,20 +20218,6 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   pagesToUpdate.forEach((sveltePagePath) => {
     broadcastSveltePageUpdate(state, sveltePagePath, manifest, duration);
   });
-}, collectAngularAffectedPages = (affected, resolvedPages) => {
-  affected.forEach((file4) => {
-    if (file4.replace(/\\/g, "/").includes("/pages/") && file4.endsWith(".ts")) {
-      resolvedPages.add(file4);
-    }
-  });
-}, 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) {
@@ -18799,57 +20239,17 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     },
     type: "angular-update"
   });
-}, broadcastAngularPageHmrUpdate = (state, angularPagePath, manifest, duration, classification) => {
-  try {
-    const fileName = basename12(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((file4) => detectFramework(file4, 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((file4) => file4.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;
@@ -18904,7 +20304,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmxPages, "*.html") : htmxPageFiles;
   await runSequentially(pageFilesToUpdate, async (htmxPageFile) => {
     const htmxPageName = basename12(htmxPageFile);
-    const builtHtmxPagePath = resolve31(outputHtmxPages, htmxPageName);
+    const builtHtmxPagePath = resolve35(outputHtmxPages, htmxPageName);
     await processHtmxPageUpdate(state, htmxPageFile, builtHtmxPagePath, manifest, duration);
   });
 }, collectUpdatedModulePaths = (allModuleUpdates) => {
@@ -19013,7 +20413,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 = resolve31(outputDir, basename12(sourceFile));
+  const destPath = resolve35(outputDir, basename12(sourceFile));
   const hmrScript = extractHmrScript(destPath, readFs);
   const source = await Bun.file(sourceFile).text();
   await Bun.write(destPath, source);
@@ -19259,7 +20659,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"];
@@ -19293,7 +20692,7 @@ __export(exports_buildDepVendor, {
   buildDepVendor: () => buildDepVendor
 });
 import { mkdirSync as mkdirSync13 } from "fs";
-import { join as join28 } from "path";
+import { join as join30 } from "path";
 import { rm as rm10 } from "fs/promises";
 var {build: bunBuild9, Glob: Glob9 } = globalThis.Bun;
 var toSafeFileName6 = (specifier) => {
@@ -19347,7 +20746,7 @@ var toSafeFileName6 = (specifier) => {
     framework: Array.from(framework).filter(isResolvable4)
   };
 }, collectTransitiveImports = async (specs, alreadyVendored, alreadyScanned) => {
-  const { readFileSync: readFileSync18 } = await import("fs");
+  const { readFileSync: readFileSync20 } = await import("fs");
   const transpiler5 = new Bun.Transpiler({ loader: "js" });
   const newSpecs = new Set;
   for (const spec of specs) {
@@ -19362,7 +20761,7 @@ var toSafeFileName6 = (specifier) => {
     }
     let content;
     try {
-      content = readFileSync18(resolved, "utf-8");
+      content = readFileSync20(resolved, "utf-8");
     } catch {
       continue;
     }
@@ -19404,7 +20803,7 @@ var toSafeFileName6 = (specifier) => {
 }), buildDepVendorPass = async (specifiers, vendorDir, tmpDir) => {
   const entries = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName6(specifier);
-    const entryPath = join28(tmpDir, `${safeName}.ts`);
+    const entryPath = join30(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return { entryPath, specifier };
   }));
@@ -19465,9 +20864,9 @@ var toSafeFileName6 = (specifier) => {
   const { dep: initialSpecs, framework: frameworkRoots } = await scanBareImports(directories);
   if (initialSpecs.length === 0 && frameworkRoots.length === 0)
     return {};
-  const vendorDir = join28(buildDir, "vendor");
+  const vendorDir = join30(buildDir, "vendor");
   mkdirSync13(vendorDir, { recursive: true });
-  const tmpDir = join28(buildDir, "_dep_vendor_tmp");
+  const tmpDir = join30(buildDir, "_dep_vendor_tmp");
   mkdirSync13(tmpDir, { recursive: true });
   const allSpecs = new Set(initialSpecs);
   const alreadyScanned = new Set;
@@ -19549,8 +20948,8 @@ __export(exports_devBuild, {
   devBuild: () => devBuild
 });
 import { readdir as readdir5 } from "fs/promises";
-import { statSync as statSync3 } from "fs";
-import { resolve as resolve32 } from "path";
+import { statSync as statSync4 } from "fs";
+import { resolve as resolve36 } from "path";
 var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const configuredDirs = [
     config.reactDirectory,
@@ -19573,7 +20972,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return Object.keys(config).length > 0 ? config : null;
 }, reloadConfig = async () => {
   try {
-    const configPath2 = resolve32(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+    const configPath2 = resolve36(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
     const source = await Bun.file(configPath2).text();
     return parseDirectoryConfig(source);
   } catch {
@@ -19658,7 +21057,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     state.fileChangeQueue.clear();
   }
 }, handleCachedReload = async () => {
-  const serverMtime = statSync3(resolve32(Bun.main)).mtimeMs;
+  const serverMtime = statSync4(resolve36(Bun.main)).mtimeMs;
   const lastMtime = globalThis.__hmrServerMtime;
   globalThis.__hmrServerMtime = serverMtime;
   const cached = globalThis.__hmrDevResult;
@@ -19695,8 +21094,8 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return true;
 }, resolveAbsoluteVersion2 = async () => {
   const candidates = [
-    resolve32(import.meta.dir, "..", "..", "package.json"),
-    resolve32(import.meta.dir, "..", "package.json")
+    resolve36(import.meta.dir, "..", "..", "package.json"),
+    resolve36(import.meta.dir, "..", "package.json")
   ];
   const [candidate, ...remaining] = candidates;
   if (!candidate) {
@@ -19722,7 +21121,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(resolve32(vendorDir, entry)).bytes();
+    const bytes = await Bun.file(resolve36(vendorDir, entry)).bytes();
     assetStore.set(webPath, bytes);
   }));
 }, devBuild = async (config) => {
@@ -19790,11 +21189,11 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   cleanStaleAssets(state.assetStore, manifest, state.resolvedPaths.buildDir);
   recordStep("populate asset store", stepStartedAt);
   stepStartedAt = performance.now();
-  const reactVendorDir = resolve32(state.resolvedPaths.buildDir, "react", "vendor");
-  const angularVendorDir = resolve32(state.resolvedPaths.buildDir, "angular", "vendor");
-  const svelteVendorDir = resolve32(state.resolvedPaths.buildDir, "svelte", "vendor");
-  const vueVendorDir = resolve32(state.resolvedPaths.buildDir, "vue", "vendor");
-  const depVendorDir = resolve32(state.resolvedPaths.buildDir, "vendor");
+  const reactVendorDir = resolve36(state.resolvedPaths.buildDir, "react", "vendor");
+  const angularVendorDir = resolve36(state.resolvedPaths.buildDir, "angular", "vendor");
+  const svelteVendorDir = resolve36(state.resolvedPaths.buildDir, "svelte", "vendor");
+  const vueVendorDir = resolve36(state.resolvedPaths.buildDir, "vue", "vendor");
+  const depVendorDir = resolve36(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),
@@ -19872,7 +21271,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     manifest
   };
   globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync3(resolve32(Bun.main)).mtimeMs;
+  globalThis.__hmrServerMtime = statSync4(resolve36(Bun.main)).mtimeMs;
   return result;
 };
 var init_devBuild = __esm(() => {
@@ -19909,5 +21308,5 @@ export {
   build
 };
 
-//# debugId=C3AE2CB9A404DDCA64756E2164756E21
+//# debugId=A6EDFBBC6FF9BB9264756E2164756E21
 //# sourceMappingURL=build.js.map