@absolutejs/absolute 0.19.0-beta.950 → 0.19.0-beta.951

package/dist/build.js

@@ -2645,7 +2645,7 @@ import {
   relative as relative3,
   resolve as resolve6
 } from "path";
-import { fileURLToPath } from "url";
+import { fileURLToPath, pathToFileURL } from "url";
 var CSS_EXTENSION_PATTERN, STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATTERN, importOptionalPeer, requireOptionalPeer, requireFromCwd, isPreprocessableStylePath = (filePath) => STYLE_EXTENSION_PATTERN.test(filePath), isStyleModulePath = (filePath) => STYLE_MODULE_EXTENSION_PATTERN.test(filePath), isStylePath = (filePath) => /\.(css|s[ac]ss|less|styl(?:us)?)$/i.test(filePath), getStyleBaseName = (filePath) => filePath.replace(/\.(css|s[ac]ss|less|styl(?:us)?)$/i, ""), getStyleLanguage = (filePathOrLanguage) => {
   const normalized = filePathOrLanguage.toLowerCase();
   if (normalized === "scss" || normalized.endsWith(".scss"))
@@ -2879,7 +2879,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   canonicalize(specifier, options) {
     const fromDirectory = options.containingUrl ? dirname2(fileURLToPath(options.containingUrl)) : dirname2(entryFile);
     const resolved = resolveImportPath(specifier, fromDirectory, loadPaths, language, config);
-    return resolved ? new URL(`file://${resolved}`) : null;
+    return resolved ? new URL(pathToFileURL(resolve6(resolved)).href) : null;
   },
   load(canonicalUrl) {
     const filePath = fileURLToPath(canonicalUrl);
@@ -2997,7 +2997,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
         loadPaths,
         style: "expanded",
         syntax: language === "sass" ? "indented" : "scss",
-        url: new URL(`file://${filePath}`)
+        url: new URL(pathToFileURL(resolve6(filePath)).href)
       });
       const css = await runPostcss(result.css, filePath, config);
       const loadedUrls = result.loadedUrls ?? [];
@@ -3184,7 +3184,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
       loadPaths,
       style: "expanded",
       syntax: language === "sass" ? "indented" : "scss",
-      url: new URL(`file://${filePath}`)
+      url: new URL(pathToFileURL(resolve6(filePath)).href)
     });
     const loadedUrls = result.loadedUrls ?? [];
     for (const url of loadedUrls) {
@@ -9801,6 +9801,45 @@ var init_angularLinkerPlugin = __esm(() => {
   angularLinkerPlugin = createAngularLinkerPlugin(false);
 });
 
+// src/build/externalAssetPlugin.ts
+import { copyFileSync, existsSync as existsSync14, mkdirSync as mkdirSync6, statSync } from "fs";
+import { basename as basename4, dirname as dirname9, join as join13, resolve as resolve15 } from "path";
+var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
+  name: "absolute-external-asset",
+  setup(bld) {
+    const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
+    const skipRoots = userSourceRoots.map((root) => resolve15(root));
+    const isUserSource = (path) => skipRoots.some((root) => path.startsWith(`${root}/`));
+    bld.onLoad({ filter: /\.[mc]?[jt]sx?$/ }, async (args) => {
+      if (isUserSource(args.path))
+        return;
+      const source = await Bun.file(args.path).text();
+      if (!source.includes("import.meta.url"))
+        return;
+      urlPattern.lastIndex = 0;
+      let match;
+      const sourceDir = dirname9(args.path);
+      while ((match = urlPattern.exec(source)) !== null) {
+        const relPath = match[1];
+        if (!relPath)
+          continue;
+        const assetPath = resolve15(sourceDir, relPath);
+        if (!existsSync14(assetPath))
+          continue;
+        if (!statSync(assetPath).isFile())
+          continue;
+        const targetPath = join13(outDir, basename4(assetPath));
+        if (existsSync14(targetPath))
+          continue;
+        mkdirSync6(dirname9(targetPath), { recursive: true });
+        copyFileSync(assetPath, targetPath);
+      }
+      return;
+    });
+  }
+});
+var init_externalAssetPlugin = () => {};
+
 // src/dev/angular/hmrInjectionPlugin.ts
 var exports_hmrInjectionPlugin = {};
 __export(exports_hmrInjectionPlugin, {
@@ -9808,7 +9847,7 @@ __export(exports_hmrInjectionPlugin, {
   applyAngularHmrInjection: () => applyAngularHmrInjection
 });
 import { readFile as readFile5 } from "fs/promises";
-import { relative as relative7, resolve as resolve15 } from "path";
+import { relative as relative7, resolve as resolve16 } from "path";
 var ENTITY_DECORATOR_RE, IMPORT_RE, TOP_LEVEL_DECL_RE, extractAllTopLevelNames = (jsSource) => {
   const names = new Set;
   IMPORT_RE.lastIndex = 0;
@@ -9971,7 +10010,7 @@ var ENTITY_DECORATOR_RE, IMPORT_RE, TOP_LEVEL_DECL_RE, extractAllTopLevelNames =
 }
 `, applyAngularHmrInjection = (jsSource, componentJsAbsPath, params) => {
   const { generatedAngularRoot, userAngularRoot, projectRoot } = params;
-  const normalizedGenRoot = resolve15(generatedAngularRoot).replace(/\\/g, "/");
+  const normalizedGenRoot = resolve16(generatedAngularRoot).replace(/\\/g, "/");
   const normalizedPath = componentJsAbsPath.replace(/\\/g, "/");
   if (!normalizedPath.startsWith(normalizedGenRoot + "/"))
     return;
@@ -9989,7 +10028,7 @@ var ENTITY_DECORATOR_RE, IMPORT_RE, TOP_LEVEL_DECL_RE, extractAllTopLevelNames =
   if (classNames.length === 0)
     return;
   const relFromGenRoot = relative7(generatedAngularRoot, componentJsAbsPath).replace(/\\/g, "/");
-  const userTsPath = resolve15(userAngularRoot, relFromGenRoot.replace(/\.js$/, ".ts"));
+  const userTsPath = resolve16(userAngularRoot, relFromGenRoot.replace(/\.js$/, ".ts"));
   const projectRel = relative7(projectRoot, userTsPath).replace(/\\/g, "/");
   const tail = classNames.map((className) => {
     const id = `${projectRel}@${className}`;
@@ -10024,14 +10063,14 @@ var init_hmrInjectionPlugin = __esm(() => {
 
 // src/utils/cleanStaleOutputs.ts
 import { rm as rm2 } from "fs/promises";
-import { resolve as resolve16 } from "path";
+import { resolve as resolve17 } from "path";
 var {Glob: Glob5 } = globalThis.Bun;
 var HASHED_FILE_PATTERN, cleanStaleOutputs = async (buildPath, currentOutputPaths) => {
-  const currentPaths = new Set(currentOutputPaths.map((path) => resolve16(path)));
+  const currentPaths = new Set(currentOutputPaths.map((path) => resolve17(path)));
   const glob = new Glob5("**/*");
   const removals = [];
   for (const relative8 of glob.scanSync({ cwd: buildPath })) {
-    const absolute = resolve16(buildPath, relative8);
+    const absolute = resolve17(buildPath, relative8);
     if (currentPaths.has(absolute))
       continue;
     if (!HASHED_FILE_PATTERN.test(relative8))
@@ -10050,20 +10089,20 @@ __export(exports_generatedDir, {
   getGeneratedRoot: () => getGeneratedRoot,
   getFrameworkGeneratedDir: () => getFrameworkGeneratedDir
 });
-import { join as join13 } from "path";
-var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getGeneratedRoot = (projectRoot = process.cwd()) => join13(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME), getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join13(getGeneratedRoot(projectRoot), framework);
+import { join as join14 } from "path";
+var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getGeneratedRoot = (projectRoot = process.cwd()) => join14(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME), getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join14(getGeneratedRoot(projectRoot), framework);
 var init_generatedDir = () => {};
 
 // src/utils/cleanup.ts
 import { rm as rm3 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var removeIfExists = (path) => rm3(path, { force: true, recursive: true }), cleanFramework = (framework, frameworkDir, skipGenerated = false) => {
   const tasks = [];
   if (!skipGenerated) {
     tasks.push(removeIfExists(getFrameworkGeneratedDir(framework)));
   }
   if (frameworkDir)
-    tasks.push(removeIfExists(join14(frameworkDir, "generated")));
+    tasks.push(removeIfExists(join15(frameworkDir, "generated")));
   return Promise.all(tasks);
 }, cleanup = async ({
   angularDir,
@@ -10101,8 +10140,8 @@ var commonAncestor = (paths, fallback) => {
 var init_commonAncestor = () => {};
 
 // src/utils/buildDirectoryLock.ts
-import { mkdirSync as mkdirSync6, unlinkSync, writeFileSync as writeFileSync6, readFileSync as readFileSync10 } from "fs";
-import { dirname as dirname9, join as join15 } from "path";
+import { mkdirSync as mkdirSync7, unlinkSync, writeFileSync as writeFileSync6, readFileSync as readFileSync10 } from "fs";
+import { dirname as dirname10, join as join16 } from "path";
 var heldLocks, HELD_LOCKS_ENV = "ABSOLUTE_HELD_BUILD_DIRECTORY_LOCKS", exitHandlersRegistered = false, registerExitHandlersOnce = () => {
   if (exitHandlersRegistered)
     return;
@@ -10128,7 +10167,7 @@ var heldLocks, HELD_LOCKS_ENV = "ABSOLUTE_HELD_BUILD_DIRECTORY_LOCKS", exitHandl
     releaseAllSync();
     throw err;
   });
-}, isAlreadyExistsError = (error) => error instanceof Error && ("code" in error) && error.code === "EEXIST", lockPathForBuildDirectory = (buildDirectory) => join15(dirname9(buildDirectory), ".absolutejs", "build.lock"), readHeldLockEnv = () => new Set((process.env[HELD_LOCKS_ENV] ?? "").split(`
+}, isAlreadyExistsError = (error) => error instanceof Error && ("code" in error) && error.code === "EEXIST", lockPathForBuildDirectory = (buildDirectory) => join16(dirname10(buildDirectory), ".absolutejs", "build.lock"), readHeldLockEnv = () => new Set((process.env[HELD_LOCKS_ENV] ?? "").split(`
 `).filter((entry) => entry.length > 0)), writeHeldLockEnv = (locks) => {
   if (locks.size === 0) {
     delete process.env[HELD_LOCKS_ENV];
@@ -10145,7 +10184,7 @@ var heldLocks, HELD_LOCKS_ENV = "ABSOLUTE_HELD_BUILD_DIRECTORY_LOCKS", exitHandl
   locks.delete(buildDirectory);
   writeHeldLockEnv(locks);
 }, writeLockFileSync = (lockPath, metadata) => {
-  mkdirSync6(dirname9(lockPath), { recursive: true });
+  mkdirSync7(dirname10(lockPath), { recursive: true });
   writeFileSync6(lockPath, JSON.stringify(metadata, null, 2), { flag: "wx" });
 }, readLockMetadata = (lockPath) => {
   try {
@@ -10265,10 +10304,10 @@ var init_buildDirectoryLock = __esm(() => {
 });
 
 // src/utils/validateSafePath.ts
-import { resolve as resolve17, relative as relative8 } from "path";
+import { resolve as resolve18, relative as relative8 } from "path";
 var validateSafePath = (targetPath, baseDirectory) => {
-  const absoluteBase = resolve17(baseDirectory);
-  const absoluteTarget = resolve17(baseDirectory, targetPath);
+  const absoluteBase = resolve18(baseDirectory);
+  const absoluteTarget = resolve18(baseDirectory, targetPath);
   const relativePath = normalizePath(relative8(absoluteBase, absoluteTarget));
   if (relativePath.startsWith("../") || relativePath === "..") {
     throw new Error(`Unsafe path: ${targetPath}`);
@@ -10416,14 +10455,14 @@ __export(exports_compileSvelte, {
   compileSvelte: () => compileSvelte,
   clearSvelteCompilerCache: () => clearSvelteCompilerCache
 });
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { mkdir as mkdir4, stat as stat2 } from "fs/promises";
 import {
-  dirname as dirname10,
-  join as join16,
-  basename as basename4,
+  dirname as dirname11,
+  join as join17,
+  basename as basename5,
   extname as extname5,
-  resolve as resolve18,
+  resolve as resolve19,
   relative as relative9,
   sep as sep2
 } from "path";
@@ -10431,14 +10470,14 @@ import { env } from "process";
 var {write, file, Transpiler: Transpiler2 } = globalThis.Bun;
 var resolveDevClientDir2 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve18(import.meta.dir, "../dev/client");
-  if (existsSync14(fromSource) && fromSource.startsWith(projectRoot)) {
+  const fromSource = resolve19(import.meta.dir, "../dev/client");
+  if (existsSync15(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve18(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync14(fromNodeModules))
+  const fromNodeModules = resolve19(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  if (existsSync15(fromNodeModules))
     return fromNodeModules;
-  return resolve18(import.meta.dir, "./dev/client");
+  return resolve19(import.meta.dir, "./dev/client");
 }, devClientDir2, hmrClientPath3, persistentCache, sourceHashCache, clearSvelteCompilerCache = () => {
   persistentCache.clear();
   sourceHashCache.clear();
@@ -10468,7 +10507,7 @@ var resolveDevClientDir2 = () => {
 }, resolveRelativeModule2 = async (spec, from) => {
   if (!spec.startsWith("."))
     return null;
-  const basePath = resolve18(dirname10(from), spec);
+  const basePath = resolve19(dirname11(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -10479,14 +10518,14 @@ var resolveDevClientDir2 = () => {
     `${basePath}.svelte`,
     `${basePath}.svelte.ts`,
     `${basePath}.svelte.js`,
-    join16(basePath, "index.ts"),
-    join16(basePath, "index.js"),
-    join16(basePath, "index.mjs"),
-    join16(basePath, "index.cjs"),
-    join16(basePath, "index.json"),
-    join16(basePath, "index.svelte"),
-    join16(basePath, "index.svelte.ts"),
-    join16(basePath, "index.svelte.js")
+    join17(basePath, "index.ts"),
+    join17(basePath, "index.js"),
+    join17(basePath, "index.mjs"),
+    join17(basePath, "index.cjs"),
+    join17(basePath, "index.json"),
+    join17(basePath, "index.svelte"),
+    join17(basePath, "index.svelte.ts"),
+    join17(basePath, "index.svelte.js")
   ];
   const checks = await Promise.all(candidates.map(exists));
   return candidates.find((_2, index) => checks[index]) ?? null;
@@ -10495,7 +10534,7 @@ var resolveDevClientDir2 = () => {
     const resolved = resolvePackageImport(spec);
     return resolved && /\.svelte(\.(?:ts|js))?$/.test(resolved) ? resolved : null;
   }
-  const basePath = resolve18(dirname10(from), spec);
+  const basePath = resolve19(dirname11(from), spec);
   const explicit = /\.(svelte|svelte\.(?:ts|js))$/.test(basePath);
   if (!explicit) {
     const extensions = [".svelte", ".svelte.ts", ".svelte.js"];
@@ -10525,9 +10564,9 @@ var resolveDevClientDir2 = () => {
 }, compileSvelte = async (entryPoints, svelteRoot, cache = new Map, isDev = false, stylePreprocessors) => {
   const { compile, compileModule, preprocess } = await import("svelte/compiler");
   const generatedDir = getFrameworkGeneratedDir("svelte");
-  const clientDir = join16(generatedDir, "client");
-  const indexDir = join16(generatedDir, "indexes");
-  const serverDir = join16(generatedDir, "server");
+  const clientDir = join17(generatedDir, "client");
+  const indexDir = join17(generatedDir, "indexes");
+  const serverDir = join17(generatedDir, "server");
   await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir4(dir, { recursive: true })));
   const dev = env.NODE_ENV !== "production";
   const build = async (src) => {
@@ -10539,7 +10578,7 @@ var resolveDevClientDir2 = () => {
     const contentHash = Bun.hash(raw).toString(BASE_36_RADIX);
     const prevHash = sourceHashCache.get(src);
     const persistent = persistentCache.get(src);
-    if (prevHash === contentHash && persistent && existsSync14(persistent.ssr) && existsSync14(persistent.client)) {
+    if (prevHash === contentHash && persistent && existsSync15(persistent.ssr) && existsSync15(persistent.client)) {
       cache.set(src, persistent);
       return persistent;
     }
@@ -10555,9 +10594,9 @@ var resolveDevClientDir2 = () => {
     const preprocessedClient = isModule ? loweredClientSource.code : (await preprocess(loweredClientSource.code, svelteStylePreprocessor)).code;
     const transpiledServer = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler3.transformSync(preprocessedServer) : preprocessedServer;
     const transpiledClient = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler3.transformSync(preprocessedClient) : preprocessedClient;
-    const rawRel = dirname10(relative9(svelteRoot, src)).replace(/\\/g, "/");
-    const relDir = rawRel.startsWith("..") ? `_ext/${relative9(process.cwd(), dirname10(src)).replace(/\\/g, "/")}` : rawRel;
-    const baseName = basename4(src).replace(/\.svelte(\.(ts|js))?$/, "");
+    const rawRel = dirname11(relative9(svelteRoot, src)).replace(/\\/g, "/");
+    const relDir = rawRel.startsWith("..") ? `_ext/${relative9(process.cwd(), dirname11(src)).replace(/\\/g, "/")}` : rawRel;
+    const baseName = basename5(src).replace(/\.svelte(\.(ts|js))?$/, "");
     const importPaths = Array.from(transpiledServer.matchAll(/from\s+['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((path) => path !== undefined);
     const resolvedModuleImports = await Promise.all(importPaths.map((importPath) => resolveRelativeModule2(importPath, src)));
     const resolvedImports = await Promise.all(importPaths.map((importPath) => resolveSvelte(importPath, src)));
@@ -10565,8 +10604,8 @@ var resolveDevClientDir2 = () => {
     const childBuilt = await Promise.all(childSources.map((child) => build(child)));
     const hasAwaitSlotFromChildren = childBuilt.some((child) => child.hasAwaitSlot);
     const externalRewrites = new Map;
-    const ssrOutputDir = dirname10(join16(serverDir, relDir, `${baseName}.js`));
-    const clientOutputDir = dirname10(join16(clientDir, relDir, `${baseName}.js`));
+    const ssrOutputDir = dirname11(join17(serverDir, relDir, `${baseName}.js`));
+    const clientOutputDir = dirname11(join17(clientDir, relDir, `${baseName}.js`));
     for (let idx = 0;idx < importPaths.length; idx++) {
       const rawSpec = importPaths[idx];
       if (!rawSpec)
@@ -10601,13 +10640,13 @@ var resolveDevClientDir2 = () => {
     };
     const generate = (mode) => {
       const transpiled = mode === "server" ? transpiledServer : transpiledClient;
-      const compiled = isModule ? compileModule(transpiled, {
+      const compiledJs = isModule ? compileModule(transpiled, {
         dev: mode === "client" && dev,
         experimental: {
           async: transformedByLowering
         },
         filename: src
-      }).js.code : compile(transpiled, {
+      }).js : compile(transpiled, {
         css: "injected",
         dev: mode === "client" && dev,
         experimental: {
@@ -10616,8 +10655,8 @@ var resolveDevClientDir2 = () => {
         filename: src,
         generate: mode,
         hmr: mode === "client" && isDev
-      }).js.code;
-      let code = compiled.replace(/\.svelte(?:\.(?:ts|js))?(['"])/g, ".js$1");
+      }).js;
+      let code = compiledJs.code.replace(/\.svelte(?:\.(?:ts|js))?(['"])/g, ".js$1");
       if (mode === "client" && isDev) {
         const moduleKey = `/@src/${relative9(process.cwd(), src).replace(/\\/g, "/")}`;
         code = code.replace(/if\s*\(import\.meta\.hot\)\s*\{/, `if (typeof window !== "undefined") {
@@ -10629,23 +10668,29 @@ var resolveDevClientDir2 = () => {
         code = removeUnusedRequireHelper(code);
       }
       code += islandMetadataExports;
-      return code;
+      return { code, map: compiledJs.map };
     };
-    const ssrPath = join16(serverDir, relDir, `${baseName}.js`);
-    const clientPath = join16(clientDir, relDir, `${baseName}.js`);
+    const ssrPath = join17(serverDir, relDir, `${baseName}.js`);
+    const clientPath = join17(clientDir, relDir, `${baseName}.js`);
     await Promise.all([
-      mkdir4(dirname10(ssrPath), { recursive: true }),
-      mkdir4(dirname10(clientPath), { recursive: true })
+      mkdir4(dirname11(ssrPath), { recursive: true }),
+      mkdir4(dirname11(clientPath), { recursive: true })
     ]);
+    const inlineMap = (map) => map ? `
+//# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(map)).toString("base64")}
+` : "";
     if (isModule) {
-      const bundle = rewriteExternalImports(generate("client"), "client");
+      const generated = generate("client");
+      const bundle = rewriteExternalImports(generated.code, "client") + inlineMap(generated.map);
       await Promise.all([
         write(ssrPath, bundle),
         write(clientPath, bundle)
       ]);
     } else {
-      const serverBundle = rewriteExternalImports(generate("server"), "server");
-      const clientBundle = rewriteExternalImports(generate("client"), "client");
+      const serverGen = generate("server");
+      const clientGen = generate("client");
+      const serverBundle = rewriteExternalImports(serverGen.code, "server") + inlineMap(serverGen.map);
+      const clientBundle = rewriteExternalImports(clientGen.code, "client") + inlineMap(clientGen.map);
       await Promise.all([
         write(ssrPath, serverBundle),
         write(clientPath, clientBundle)
@@ -10662,10 +10707,10 @@ var resolveDevClientDir2 = () => {
   };
   const roots = await Promise.all(entryPoints.map(build));
   await Promise.all(roots.map(async ({ client, hasAwaitSlot }) => {
-    const relClientDir = dirname10(relative9(clientDir, client));
-    const name = basename4(client, extname5(client));
-    const indexPath = join16(indexDir, relClientDir, `${name}.js`);
-    const importRaw = relative9(dirname10(indexPath), client).split(sep2).join("/");
+    const relClientDir = dirname11(relative9(clientDir, client));
+    const name = basename5(client, extname5(client));
+    const indexPath = join17(indexDir, relClientDir, `${name}.js`);
+    const importRaw = relative9(dirname11(indexPath), client).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev ? `window.__HMR_FRAMEWORK__ = "svelte";
 import "${hmrClientPath3}";
@@ -10736,14 +10781,14 @@ if (typeof window !== "undefined") {
     setTimeout(releaseStreamingSlots, 0);
   }
 }`;
-    await mkdir4(dirname10(indexPath), { recursive: true });
+    await mkdir4(dirname11(indexPath), { recursive: true });
     return write(indexPath, bootstrap);
   }));
   return {
     svelteClientPaths: roots.map(({ client }) => client),
     svelteIndexPaths: roots.map(({ client }) => {
-      const rel = dirname10(relative9(clientDir, client));
-      return join16(indexDir, rel, basename4(client));
+      const rel = dirname11(relative9(clientDir, client));
+      return join17(indexDir, rel, basename5(client));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
   };
@@ -10758,12 +10803,338 @@ var init_compileSvelte = __esm(() => {
   init_lowerAwaitSlotSyntax();
   init_renderToReadableStream();
   devClientDir2 = resolveDevClientDir2();
-  hmrClientPath3 = join16(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath3 = join17(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
   persistentCache = new Map;
   sourceHashCache = new Map;
   transpiler3 = new Transpiler2({ loader: "ts", target: "browser" });
 });
 
+// src/build/chainInlineSourcemaps.ts
+var exports_chainInlineSourcemaps = {};
+__export(exports_chainInlineSourcemaps, {
+  remapGeneratedLines: () => remapGeneratedLines,
+  inlineLineMapComment: () => inlineLineMapComment,
+  chainSourcemap: () => chainSourcemap,
+  chainBundleInlineSourcemap: () => chainBundleInlineSourcemap,
+  buildLineRemap: () => buildLineRemap
+});
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "fs";
+var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", BASE64_TO_INT, decodeVlq = (str, startPos) => {
+  let result = 0;
+  let shift = 0;
+  let pos = startPos;
+  while (true) {
+    const digit = BASE64_TO_INT[str.charCodeAt(pos++)];
+    if (digit === undefined || digit < 0) {
+      throw new Error(`chainInlineSourcemaps: invalid base64 char at ${pos - 1}`);
+    }
+    result |= (digit & 31) << shift;
+    shift += 5;
+    if (!(digit & 32))
+      break;
+  }
+  const negative = result & 1;
+  const value = result >>> 1;
+  return { pos, value: negative ? -value : value };
+}, encodeVlq = (value) => {
+  let v2 = value < 0 ? -value << 1 | 1 : value << 1;
+  let result = "";
+  do {
+    let digit = v2 & 31;
+    v2 >>>= 5;
+    if (v2)
+      digit |= 32;
+    result += BASE64_CHARS[digit];
+  } while (v2);
+  return result;
+}, decodeMappings = (mappings) => {
+  const lines = [];
+  let current = [];
+  let lastGenCol = 0;
+  let lastSourceIdx = 0;
+  let lastSourceLine = 0;
+  let lastSourceCol = 0;
+  let pos = 0;
+  const len = mappings.length;
+  while (pos < len) {
+    const ch = mappings[pos];
+    if (ch === ";") {
+      lines.push(current);
+      current = [];
+      lastGenCol = 0;
+      pos++;
+      continue;
+    }
+    if (ch === ",") {
+      pos++;
+      continue;
+    }
+    const d1 = decodeVlq(mappings, pos);
+    pos = d1.pos;
+    lastGenCol += d1.value;
+    const segment = { genCol: lastGenCol };
+    if (pos < len && mappings[pos] !== "," && mappings[pos] !== ";") {
+      const d2 = decodeVlq(mappings, pos);
+      pos = d2.pos;
+      const d3 = decodeVlq(mappings, pos);
+      pos = d3.pos;
+      const d4 = decodeVlq(mappings, pos);
+      pos = d4.pos;
+      lastSourceIdx += d2.value;
+      lastSourceLine += d3.value;
+      lastSourceCol += d4.value;
+      segment.sourceIdx = lastSourceIdx;
+      segment.sourceLine = lastSourceLine;
+      segment.sourceCol = lastSourceCol;
+      while (pos < len && mappings[pos] !== "," && mappings[pos] !== ";") {
+        pos = decodeVlq(mappings, pos).pos;
+      }
+    }
+    current.push(segment);
+  }
+  lines.push(current);
+  return lines;
+}, encodeMappings = (lines) => {
+  let lastSourceIdx = 0;
+  let lastSourceLine = 0;
+  let lastSourceCol = 0;
+  const parts = [];
+  for (const line of lines) {
+    let lastGenCol = 0;
+    const segs = [];
+    for (const seg of line) {
+      let s2 = encodeVlq(seg.genCol - lastGenCol);
+      lastGenCol = seg.genCol;
+      if (seg.sourceIdx !== undefined) {
+        s2 += encodeVlq(seg.sourceIdx - lastSourceIdx);
+        s2 += encodeVlq(seg.sourceLine - lastSourceLine);
+        s2 += encodeVlq(seg.sourceCol - lastSourceCol);
+        lastSourceIdx = seg.sourceIdx;
+        lastSourceLine = seg.sourceLine;
+        lastSourceCol = seg.sourceCol;
+      }
+      segs.push(s2);
+    }
+    parts.push(segs.join(","));
+  }
+  return parts.join(";");
+}, traceInner = (innerLines, targetLine, targetCol) => {
+  if (targetLine < 0 || targetLine >= innerLines.length)
+    return null;
+  const targetLineSegs = innerLines[targetLine];
+  if (!targetLineSegs)
+    return null;
+  for (let i = targetLineSegs.length - 1;i >= 0; i--) {
+    const seg = targetLineSegs[i];
+    if (seg && seg.genCol <= targetCol && seg.sourceIdx !== undefined) {
+      return {
+        col: seg.sourceCol,
+        line: seg.sourceLine,
+        sourceIdx: seg.sourceIdx
+      };
+    }
+  }
+  for (const seg of targetLineSegs) {
+    if (seg.sourceIdx !== undefined) {
+      return {
+        col: seg.sourceCol,
+        line: seg.sourceLine,
+        sourceIdx: seg.sourceIdx
+      };
+    }
+  }
+  for (let li2 = targetLine - 1;li2 >= 0; li2--) {
+    const line = innerLines[li2];
+    if (!line)
+      continue;
+    for (let i = line.length - 1;i >= 0; i--) {
+      const seg = line[i];
+      if (seg && seg.sourceIdx !== undefined) {
+        return {
+          col: seg.sourceCol,
+          line: seg.sourceLine,
+          sourceIdx: seg.sourceIdx
+        };
+      }
+    }
+  }
+  return null;
+}, SOURCEMAP_INLINE_RE, extractInlineMap = (text) => {
+  const match = text.match(SOURCEMAP_INLINE_RE);
+  if (!match)
+    return null;
+  const encoded = match[1];
+  if (!encoded)
+    return null;
+  try {
+    return JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));
+  } catch {
+    return null;
+  }
+}, buildLineRemap = (before, after) => {
+  const bLines = before.split(`
+`);
+  const aLines = after.split(`
+`);
+  const norm = (s2) => s2.trim().replace(/["']/g, "`").replace(/;\s*$/, "");
+  const isVueImport = (s2) => /^\s*import\s+.*\bfrom\s+["']vue["']\s*;?\s*$/.test(s2);
+  const mergedVueImportLine = aLines.findIndex(isVueImport);
+  const remap = new Array(bLines.length).fill(-1);
+  let ai2 = 0;
+  for (let bi2 = 0;bi2 < bLines.length; bi2++) {
+    const bLine = bLines[bi2];
+    if (bLine === undefined || bLine.trim() === "")
+      continue;
+    if (isVueImport(bLine)) {
+      remap[bi2] = mergedVueImportLine;
+      continue;
+    }
+    const bNorm = norm(bLine);
+    const horizon = Math.min(aLines.length, ai2 + 30);
+    for (let probe = ai2;probe < horizon; probe++) {
+      const aLine = aLines[probe];
+      if (aLine !== undefined && norm(aLine) === bNorm) {
+        remap[bi2] = probe;
+        ai2 = probe + 1;
+        break;
+      }
+    }
+  }
+  return remap;
+}, inlineLineMapComment = (sourcePath, sourceContent, generatedContent) => {
+  const remap = buildLineRemap(sourceContent, generatedContent);
+  const generatedLineCount = generatedContent.split(`
+`).length;
+  const segs = Array.from({ length: generatedLineCount }, () => []);
+  for (let srcLine = 0;srcLine < remap.length; srcLine++) {
+    const genLine = remap[srcLine];
+    if (genLine === undefined || genLine < 0 || genLine >= generatedLineCount)
+      continue;
+    const segLine = segs[genLine];
+    if (!segLine)
+      continue;
+    segLine.push({
+      genCol: 0,
+      sourceCol: 0,
+      sourceIdx: 0,
+      sourceLine: srcLine
+    });
+  }
+  const map = {
+    mappings: encodeMappings(segs),
+    names: [],
+    sources: [sourcePath],
+    sourcesContent: [sourceContent],
+    version: 3
+  };
+  return `
+//# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(map)).toString("base64")}
+`;
+}, remapGeneratedLines = (mappings, lineRemap) => {
+  const decoded = decodeMappings(mappings);
+  const remapped = [];
+  for (let origLine = 0;origLine < decoded.length; origLine++) {
+    const newLine = lineRemap[origLine];
+    if (newLine === undefined || newLine < 0)
+      continue;
+    const origSegs = decoded[origLine];
+    if (!origSegs)
+      continue;
+    while (remapped.length < newLine)
+      remapped.push([]);
+    remapped[newLine] = origSegs;
+  }
+  return encodeMappings(remapped);
+}, chainSourcemap = (outer, fetchInner) => {
+  const outerSegs = decodeMappings(outer.mappings);
+  const innerMaps = outer.sources.map((s2) => s2 ? fetchInner(s2) : null);
+  const innerDecoded = innerMaps.map((m) => m ? decodeMappings(m.mappings) : null);
+  const newSources = [];
+  const newSourcesContent = [];
+  const addSource = (src, content) => {
+    const existing = newSources.indexOf(src);
+    if (existing >= 0)
+      return existing;
+    newSources.push(src);
+    newSourcesContent.push(content);
+    return newSources.length - 1;
+  };
+  const innerSrcRemap = [];
+  const outerFallbackIdx = [];
+  outer.sources.forEach((src, i) => {
+    const inner = innerMaps[i];
+    if (inner) {
+      innerSrcRemap[i] = inner.sources.map((innerSrc, j2) => innerSrc === null ? -1 : addSource(innerSrc, inner.sourcesContent?.[j2] ?? null));
+    } else {
+      innerSrcRemap[i] = [];
+    }
+    outerFallbackIdx[i] = src === null ? -1 : addSource(src, outer.sourcesContent?.[i] ?? null);
+  });
+  const chained = outerSegs.map((line) => line.map((seg) => {
+    if (seg.sourceIdx === undefined)
+      return { genCol: seg.genCol };
+    const fallbackIdx = outerFallbackIdx[seg.sourceIdx] ?? -1;
+    const innerLines = innerDecoded[seg.sourceIdx];
+    if (innerLines) {
+      const t = traceInner(innerLines, seg.sourceLine, seg.sourceCol);
+      if (t) {
+        const innerRemap = innerSrcRemap[seg.sourceIdx];
+        const remappedIdx = innerRemap?.[t.sourceIdx] ?? -1;
+        return {
+          genCol: seg.genCol,
+          sourceCol: t.col,
+          sourceIdx: remappedIdx,
+          sourceLine: t.line
+        };
+      }
+      return {
+        genCol: seg.genCol,
+        sourceCol: seg.sourceCol,
+        sourceIdx: fallbackIdx,
+        sourceLine: seg.sourceLine
+      };
+    }
+    return {
+      genCol: seg.genCol,
+      sourceCol: seg.sourceCol,
+      sourceIdx: fallbackIdx,
+      sourceLine: seg.sourceLine
+    };
+  }));
+  return {
+    mappings: encodeMappings(chained),
+    names: outer.names,
+    sources: newSources,
+    sourcesContent: newSourcesContent,
+    version: 3
+  };
+}, chainBundleInlineSourcemap = (bundleFilePath) => {
+  const text = readFileSync11(bundleFilePath, "utf-8");
+  const outerMap = extractInlineMap(text);
+  if (!outerMap)
+    return;
+  const chained = chainSourcemap(outerMap, (src) => {
+    const idx = outerMap.sources.indexOf(src);
+    if (idx < 0)
+      return null;
+    const content = outerMap.sourcesContent?.[idx];
+    if (!content)
+      return null;
+    return extractInlineMap(content);
+  });
+  const stripped = text.replace(SOURCEMAP_INLINE_RE, "");
+  const inline = `
+//# sourceMappingURL=data:application/json;base64,` + Buffer.from(JSON.stringify(chained)).toString("base64");
+  writeFileSync7(bundleFilePath, stripped + inline);
+};
+var init_chainInlineSourcemaps = __esm(() => {
+  BASE64_TO_INT = new Int8Array(128).fill(-1);
+  for (let i = 0;i < BASE64_CHARS.length; i++) {
+    BASE64_TO_INT[BASE64_CHARS.charCodeAt(i)] = i;
+  }
+  SOURCEMAP_INLINE_RE = /\n?\/\/# sourceMappingURL=data:application\/json(?:;[^,]+)?;base64,([A-Za-z0-9+/=]+)\s*$/;
+});
+
 // src/build/vueAutoRouterTransform.ts
 var SCRIPT_REGEX, ROUTES_EXPORT_REGEX, SENTINEL = "__ABSOLUTE_AUTO_ROUTER__", SETUP_APP_DECLARATION_REGEX, SETUP_APP_FUNCTION_REGEX, addAutoRouterSetupApp = (sourceContent) => {
   if (!ROUTES_EXPORT_REGEX.test(sourceContent))
@@ -10824,27 +11195,27 @@ __export(exports_compileVue, {
   compileVue: () => compileVue,
   clearVueHmrCaches: () => clearVueHmrCaches
 });
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { mkdir as mkdir5 } from "fs/promises";
 import {
-  basename as basename5,
-  dirname as dirname11,
+  basename as basename6,
+  dirname as dirname12,
   isAbsolute as isAbsolute3,
-  join as join17,
+  join as join18,
   relative as relative10,
-  resolve as resolve19
+  resolve as resolve20
 } from "path";
 var {file: file2, write: write2, Transpiler: Transpiler3 } = globalThis.Bun;
 var resolveDevClientDir3 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve19(import.meta.dir, "../dev/client");
-  if (existsSync15(fromSource) && fromSource.startsWith(projectRoot)) {
+  const fromSource = resolve20(import.meta.dir, "../dev/client");
+  if (existsSync16(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve19(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync15(fromNodeModules))
+  const fromNodeModules = resolve20(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  if (existsSync16(fromNodeModules))
     return fromNodeModules;
-  return resolve19(import.meta.dir, "./dev/client");
+  return resolve20(import.meta.dir, "./dev/client");
 }, devClientDir3, hmrClientPath4, transpiler4, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, clearVueHmrCaches = () => {
   scriptCache.clear();
   scriptSetupCache.clear();
@@ -10890,7 +11261,7 @@ var resolveDevClientDir3 = () => {
     return filePath.replace(/\.ts$/, ".js");
   if (isStylePath(filePath)) {
     if (sourceDir && (filePath.startsWith("./") || filePath.startsWith("../"))) {
-      return resolve19(sourceDir, filePath);
+      return resolve20(sourceDir, filePath);
     }
     return filePath;
   }
@@ -10918,7 +11289,7 @@ var resolveDevClientDir3 = () => {
     return cachedResult;
   const relativeFilePath = relative10(vueRootDir, sourceFilePath).replace(/\\/g, "/");
   const relativeWithoutExtension = relativeFilePath.replace(/\.vue$/, "");
-  const fileBaseName = basename5(sourceFilePath, ".vue");
+  const fileBaseName = basename6(sourceFilePath, ".vue");
   const componentId = toKebab(fileBaseName);
   const rawSourceContent = await file2(sourceFilePath).text();
   const sourceContent = isEntryPoint ? addAutoRouterSetupApp(rawSourceContent) : rawSourceContent;
@@ -10926,7 +11297,7 @@ var resolveDevClientDir3 = () => {
   const contentHash = Bun.hash(sourceContent).toString(BASE_36_RADIX);
   const prevHash = vueSourceHashCache.get(sourceFilePath);
   const persistent = persistentBuildCache.get(sourceFilePath);
-  if (prevHash === contentHash && persistent && existsSync15(persistent.clientPath) && existsSync15(persistent.serverPath)) {
+  if (prevHash === contentHash && persistent && existsSync16(persistent.clientPath) && existsSync16(persistent.serverPath)) {
     cacheMap.set(sourceFilePath, persistent);
     return persistent;
   }
@@ -10954,21 +11325,22 @@ 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 : resolve19(dirname11(sourceFilePath), path));
+  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute3(path)) && isStylePath(path)).map((path) => isAbsolute3(path) ? path : resolve20(dirname12(sourceFilePath), path));
   for (const stylePath of stylePathsImported) {
     addStyleImporter(sourceFilePath, stylePath);
   }
   const childBuildResults = await Promise.all([
-    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve19(dirname11(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
+    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve20(dirname12(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
     ...packageComponentPaths.map(([, absolutePath]) => compileVueFile(absolutePath, outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors))
   ]);
   const hasScript = descriptor.script || descriptor.scriptSetup;
   const compiledScript = hasScript ? compiler.compileScript(descriptor, {
     id: componentId,
-    inlineTemplate: false
-  }) : { bindings: {}, content: "export default {};" };
+    inlineTemplate: false,
+    sourceMap: true
+  }) : { bindings: {}, content: "export default {};", map: undefined };
   const strippedScript = stripExports2(compiledScript.content);
-  const sourceDir = dirname11(sourceFilePath);
+  const sourceDir = dirname12(sourceFilePath);
   const transpiledScript = transpiler4.transformSync(strippedScript).replace(/(['"])(\.{1,2}\/[^'"]+)(['"])/g, (_2, quoteStart, relativeImport, quoteEnd) => `${quoteStart}${toJs(relativeImport, sourceDir)}${quoteEnd}`);
   const packageImportRewrites = new Map;
   for (const [bareImport, absolutePath] of packageComponentPaths) {
@@ -11007,8 +11379,8 @@ var resolveDevClientDir3 = () => {
   ];
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
-    const cssOutputFile = join17(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
-    await mkdir5(dirname11(cssOutputFile), { recursive: true });
+    const cssOutputFile = join18(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
+    await mkdir5(dirname12(cssOutputFile), { recursive: true });
     await write2(cssOutputFile, allCss.join(`
 `));
     cssOutputPaths = [cssOutputFile];
@@ -11038,9 +11410,9 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
   const clientCode = assembleModule(generateRenderFunction(false), "render", true) + islandMetadataExports;
   const serverCode = assembleModule(generateRenderFunction(true), "ssrRender", false) + islandMetadataExports;
-  const clientOutputPath = join17(outputDirs.client, `${relativeWithoutExtension}.js`);
-  const serverOutputPath = join17(outputDirs.server, `${relativeWithoutExtension}.js`);
-  const relDir = dirname11(relativeFilePath);
+  const clientOutputPath = join18(outputDirs.client, `${relativeWithoutExtension}.js`);
+  const serverOutputPath = join18(outputDirs.server, `${relativeWithoutExtension}.js`);
+  const relDir = dirname12(relativeFilePath);
   const relDepth = relDir === "." ? 0 : relDir.split("/").length;
   const adjustImports = (code) => code.replace(/(from\s+['"])(\.\.\/(?:\.\.\/)*)/g, (_2, prefix, dots) => {
     const upCount = dots.split("/").length - 1;
@@ -11052,17 +11424,29 @@ 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 = relative10(dirname11(outputPath), targetPath).replace(/\\/g, "/");
+      let rel = relative10(dirname12(outputPath), targetPath).replace(/\\/g, "/");
       if (!rel.startsWith("."))
         rel = `./${rel}`;
       result2 = result2.replaceAll(bareImport, rel);
     }
     return result2;
   };
-  await mkdir5(dirname11(clientOutputPath), { recursive: true });
-  await mkdir5(dirname11(serverOutputPath), { recursive: true });
-  await write2(clientOutputPath, rewritePackageImports(adjustImports(clientCode), clientOutputPath, "client"));
-  await write2(serverOutputPath, rewritePackageImports(adjustImports(serverCode), serverOutputPath, "server"));
+  await mkdir5(dirname12(clientOutputPath), { recursive: true });
+  await mkdir5(dirname12(serverOutputPath), { recursive: true });
+  const clientFinal = rewritePackageImports(adjustImports(clientCode), clientOutputPath, "client");
+  const serverFinal = rewritePackageImports(adjustImports(serverCode), serverOutputPath, "server");
+  const inlineSourceMapFor = (finalContent) => {
+    if (!compiledScript.map || !hasScript)
+      return "";
+    const remap = buildLineRemap(strippedScript, finalContent);
+    const mappings = remapGeneratedLines(compiledScript.map.mappings, remap);
+    const map = { ...compiledScript.map, mappings };
+    return `
+//# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(map)).toString("base64")}
+`;
+  };
+  await write2(clientOutputPath, clientFinal + inlineSourceMapFor(clientFinal));
+  await write2(serverOutputPath, serverFinal + inlineSourceMapFor(serverFinal));
   const result = {
     clientPath: clientOutputPath,
     cssCodes: allCss,
@@ -11070,7 +11454,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     hmrId,
     serverPath: serverOutputPath,
     tsHelperPaths: [
-      ...helperModulePaths.map((helper) => resolve19(dirname11(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
+      ...helperModulePaths.map((helper) => resolve20(dirname12(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
       ...childBuildResults.flatMap((child) => child.tsHelperPaths)
     ]
   };
@@ -11080,10 +11464,10 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
 }, compileVue = async (entryPoints, vueRootDir, isDev = false, stylePreprocessors) => {
   const compiler = await import("@vue/compiler-sfc");
   const generatedDir = getFrameworkGeneratedDir("vue");
-  const clientOutputDir = join17(generatedDir, "client");
-  const indexOutputDir = join17(generatedDir, "indexes");
-  const serverOutputDir = join17(generatedDir, "server");
-  const cssOutputDir = join17(generatedDir, "compiled");
+  const clientOutputDir = join18(generatedDir, "client");
+  const indexOutputDir = join18(generatedDir, "indexes");
+  const serverOutputDir = join18(generatedDir, "server");
+  const cssOutputDir = join18(generatedDir, "compiled");
   await Promise.all([
     mkdir5(clientOutputDir, { recursive: true }),
     mkdir5(indexOutputDir, { recursive: true }),
@@ -11093,23 +11477,23 @@ 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(resolve19(entryPath), {
+    const result = await compileVueFile(resolve20(entryPath), {
       client: clientOutputDir,
       css: cssOutputDir,
       server: serverOutputDir
     }, buildCache, true, vueRootDir, compiler, stylePreprocessors);
     result.tsHelperPaths.forEach((path) => allTsHelperPaths.add(path));
-    const entryBaseName = basename5(entryPath, ".vue");
-    const indexOutputFile = join17(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join17(clientOutputDir, relative10(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
-    await mkdir5(dirname11(indexOutputFile), { recursive: true });
+    const entryBaseName = basename6(entryPath, ".vue");
+    const indexOutputFile = join18(indexOutputDir, `${entryBaseName}.js`);
+    const clientOutputFile = join18(clientOutputDir, relative10(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    await mkdir5(dirname12(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
       `import "${hmrClientPath4}";`
     ] : [];
     await write2(indexOutputFile, [
       ...vueHmrImports,
-      `import Comp, * as PageModule from "${relative10(dirname11(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
+      `import Comp, * as PageModule from "${relative10(dirname12(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
       'import { createSSRApp, createApp } from "vue";',
       "",
       "// HMR State Preservation: Check for preserved state from HMR",
@@ -11254,10 +11638,10 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     const sourceCode = await file2(tsPath).text();
     const transpiledCode = transpiler4.transformSync(sourceCode);
     const relativeJsPath = relative10(vueRootDir, tsPath).replace(/\.ts$/, ".js");
-    const outClientPath = join17(clientOutputDir, relativeJsPath);
-    const outServerPath = join17(serverOutputDir, relativeJsPath);
-    await mkdir5(dirname11(outClientPath), { recursive: true });
-    await mkdir5(dirname11(outServerPath), { recursive: true });
+    const outClientPath = join18(clientOutputDir, relativeJsPath);
+    const outServerPath = join18(serverOutputDir, relativeJsPath);
+    await mkdir5(dirname12(outClientPath), { recursive: true });
+    await mkdir5(dirname12(outServerPath), { recursive: true });
     await write2(outClientPath, transpiledCode);
     await write2(outServerPath, transpiledCode);
   }));
@@ -11274,10 +11658,11 @@ var init_compileVue = __esm(() => {
   init_generatedDir();
   init_resolvePackageImport();
   init_sourceMetadata();
+  init_chainInlineSourcemaps();
   init_vueAutoRouterTransform();
   init_stylePreprocessor();
   devClientDir3 = resolveDevClientDir3();
-  hmrClientPath4 = join17(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath4 = join18(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
   transpiler4 = new Transpiler3({ loader: "ts", target: "browser" });
   scriptCache = new Map;
   scriptSetupCache = new Map;
@@ -11758,8 +12143,8 @@ __export(exports_compileAngular, {
   compileAngularFile: () => compileAngularFile,
   compileAngular: () => compileAngular
 });
-import { existsSync as existsSync16, readFileSync as readFileSync11, promises as fs } from "fs";
-import { join as join18, basename as basename6, sep as sep3, dirname as dirname12, resolve as resolve20, relative as relative11 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync12, promises as fs } from "fs";
+import { join as join19, basename as basename7, sep as sep3, dirname as dirname13, resolve as resolve21, relative as relative11 } from "path";
 var {Glob: Glob6 } = globalThis.Bun;
 import ts2 from "typescript";
 var traceAngularPhase = async (name, fn2, metadata) => {
@@ -11767,10 +12152,10 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   return tracePhase ? tracePhase(`compile/angular/${name}`, fn2, metadata) : await fn2();
 }, readTsconfigPathAliases = () => {
   try {
-    const configPath2 = resolve20(process.cwd(), "tsconfig.json");
+    const configPath2 = resolve21(process.cwd(), "tsconfig.json");
     const config = ts2.readConfigFile(configPath2, ts2.sys.readFile).config;
     const compilerOptions = config?.compilerOptions ?? {};
-    const baseUrl = resolve20(process.cwd(), compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve21(process.cwd(), compilerOptions.baseUrl ?? ".");
     const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
     return { aliases, baseUrl };
   } catch {
@@ -11790,7 +12175,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(resolve20(baseUrl, candidate));
+      const resolved = resolveSourceFile(resolve21(baseUrl, candidate));
       if (resolved)
         return resolved;
     }
@@ -11802,20 +12187,20 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     `${candidate}.tsx`,
     `${candidate}.js`,
     `${candidate}.jsx`,
-    join18(candidate, "index.ts"),
-    join18(candidate, "index.tsx"),
-    join18(candidate, "index.js"),
-    join18(candidate, "index.jsx")
+    join19(candidate, "index.ts"),
+    join19(candidate, "index.tsx"),
+    join19(candidate, "index.js"),
+    join19(candidate, "index.jsx")
   ];
-  return candidates.find((file3) => existsSync16(file3));
+  return candidates.find((file3) => existsSync17(file3));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
-  const baseDir = resolve20(rootDir);
+  const baseDir = resolve21(rootDir);
   const tsconfigAliases = readTsconfigPathAliases();
   const transpiler5 = new Bun.Transpiler({ loader: "tsx" });
   const scanCache = new Map;
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile(resolve20(fromDir, specifier));
+      return resolveSourceFile(resolve21(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile);
     if (aliased)
@@ -11824,7 +12209,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve20(resolved);
+      const absolute = resolve21(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile(absolute);
@@ -11840,7 +12225,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
         usesLegacyAnimations: false
       });
     }
-    const resolved = resolve20(actualPath);
+    const resolved = resolve21(actualPath);
     const cached = scanCache.get(resolved);
     if (cached)
       return cached;
@@ -11869,7 +12254,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     const actualPath = resolveSourceFile(filePath);
     if (!actualPath)
       return false;
-    const resolved = resolve20(actualPath);
+    const resolved = resolve21(actualPath);
     if (visited.has(resolved))
       return false;
     visited.add(resolved);
@@ -11877,7 +12262,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     if (scan.usesLegacyAnimations)
       return true;
     for (const specifier of scan.imports) {
-      const importedPath = resolveLocalImport(specifier, dirname12(resolved));
+      const importedPath = resolveLocalImport(specifier, dirname13(resolved));
       if (importedPath && await visit(importedPath, visited)) {
         return true;
       }
@@ -11887,14 +12272,14 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   return (entryPath) => visit(entryPath);
 }, resolveDevClientDir4 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve20(import.meta.dir, "../dev/client");
-  if (existsSync16(fromSource) && fromSource.startsWith(projectRoot)) {
+  const fromSource = resolve21(import.meta.dir, "../dev/client");
+  if (existsSync17(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve20(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync16(fromNodeModules))
+  const fromNodeModules = resolve21(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  if (existsSync17(fromNodeModules))
     return fromNodeModules;
-  return resolve20(import.meta.dir, "./dev/client");
+  return resolve21(import.meta.dir, "./dev/client");
 }, devClientDir4, hmrClientPath5, formatDiagnosticMessage = (diagnostic) => {
   try {
     return ts2.flattenDiagnosticMessageText(diagnostic.messageText, `
@@ -11936,13 +12321,13 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     return `${path.replace(/\.ts$/, ".js")}${query}`;
   if (hasJsLikeExtension(path))
     return `${path}${query}`;
-  const importerDir = dirname12(importerOutputPath);
-  const fileCandidate = resolve20(importerDir, `${path}.js`);
-  if (outputFiles?.has(fileCandidate) || existsSync16(fileCandidate)) {
+  const importerDir = dirname13(importerOutputPath);
+  const fileCandidate = resolve21(importerDir, `${path}.js`);
+  if (outputFiles?.has(fileCandidate) || existsSync17(fileCandidate)) {
     return `${path}.js${query}`;
   }
-  const indexCandidate = resolve20(importerDir, path, "index.js");
-  if (outputFiles?.has(indexCandidate) || existsSync16(indexCandidate)) {
+  const indexCandidate = resolve21(importerDir, path, "index.js");
+  if (outputFiles?.has(indexCandidate) || existsSync17(indexCandidate)) {
     return `${path}/index.js${query}`;
   }
   return `${path}.js${query}`;
@@ -11969,18 +12354,18 @@ var traceAngularPhase = async (name, fn2, metadata) => {
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve20(dirname12(fromFile), specifier);
+  const basePath = resolve21(dirname13(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join18(basePath, "index.ts"),
-    join18(basePath, "index.tsx"),
-    join18(basePath, "index.mts"),
-    join18(basePath, "index.cts")
+    join19(basePath, "index.ts"),
+    join19(basePath, "index.tsx"),
+    join19(basePath, "index.mts"),
+    join19(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve20(candidate)).find((candidate) => existsSync16(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+  return candidates.map((candidate) => resolve21(candidate)).find((candidate) => existsSync17(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile6) => {
   const hostSource = readFile6?.(fileName);
   if (typeof hostSource === "string")
@@ -12004,18 +12389,18 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   const paths = [];
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1])
-    paths.push(join18(fileDir, templateUrlMatch[1]));
+    paths.push(join19(fileDir, templateUrlMatch[1]));
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (styleUrlMatch?.[1])
-    paths.push(join18(fileDir, styleUrlMatch[1]));
+    paths.push(join19(fileDir, styleUrlMatch[1]));
   const styleUrlsMatch = findUncommentedMatch(source, /styleUrls\s*:\s*\[([^\]]+)\]/);
   const urlMatches = styleUrlsMatch?.[1]?.match(/['"]([^'"]+)['"]/g);
   if (urlMatches) {
     for (const urlMatch of urlMatches) {
-      paths.push(join18(fileDir, urlMatch.replace(/['"]/g, "")));
+      paths.push(join19(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
-  return paths.map((path) => resolve20(path));
+  return paths.map((path) => resolve21(path));
 }, readResourceCacheFile = async (cachePath) => {
   try {
     const entry = JSON.parse(await fs.readFile(cachePath, "utf-8"));
@@ -12027,13 +12412,13 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     return null;
   }
 }, writeResourceCacheFile = async (cachePath, source) => {
-  await fs.mkdir(dirname12(cachePath), { recursive: true });
+  await fs.mkdir(dirname13(cachePath), { recursive: true });
   await fs.writeFile(cachePath, JSON.stringify({
     source,
     version: 1
   }), "utf-8");
 }, resolveResourceTransformCachePath = async (filePath, source, stylePreprocessors) => {
-  const resourcePaths = collectAngularResourcePaths(source, dirname12(filePath));
+  const resourcePaths = collectAngularResourcePaths(source, dirname13(filePath));
   const resourceContents = await Promise.all(resourcePaths.map(async (resourcePath) => {
     const content = await fs.readFile(resourcePath, "utf-8");
     return `${resourcePath}\x00${content}`;
@@ -12046,7 +12431,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     safeStableStringify(stylePreprocessors ?? null)
   ].join("\x00");
   const cacheKey2 = Bun.hash(cacheInput).toString(BASE_36_RADIX);
-  return join18(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
+  return join19(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
 }, precomputeAotResourceTransforms = async (inputPaths, readFile6, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
@@ -12057,11 +12442,11 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     transformedFiles: 0
   };
   const transformFile = async (filePath) => {
-    const resolvedPath = resolve20(filePath);
+    const resolvedPath = resolve21(filePath);
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
-    if (!existsSync16(resolvedPath) || resolvedPath.endsWith(".d.ts"))
+    if (!existsSync17(resolvedPath) || resolvedPath.endsWith(".d.ts"))
       return;
     stats.filesVisited += 1;
     const source = await readFileForAotTransform(resolvedPath, readFile6);
@@ -12073,7 +12458,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
       transformedSource = cached.source;
     } else {
       stats.cacheMisses += 1;
-      const transformed = await inlineResources(source, dirname12(resolvedPath), stylePreprocessors);
+      const transformed = await inlineResources(source, dirname13(resolvedPath), stylePreprocessors);
       transformedSource = transformed.source;
       await writeResourceCacheFile(cachePath, transformedSource);
     }
@@ -12092,18 +12477,18 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   return { stats, transformedSources };
 }, compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
   const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
-    const outputPath = resolve20(join18(outDir, relative11(process.cwd(), resolve20(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve21(join19(outDir, relative11(process.cwd(), resolve21(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
-      buildIslandMetadataExports(readFileSync11(inputPath, "utf-8"))
+      buildIslandMetadataExports(readFileSync12(inputPath, "utf-8"))
     ];
   })), { entries: inputPaths.length });
   await traceAngularPhase("aot/preload-compiler", () => import("@angular/compiler"));
   const { readConfiguration, performCompilation, EmitFlags } = await traceAngularPhase("aot/import-compiler-cli", () => import("@angular/compiler-cli"));
   const tsLibDir = await traceAngularPhase("aot/resolve-typescript-lib", () => {
     const tsPath = __require.resolve("typescript");
-    const tsRootDir = dirname12(tsPath);
-    return tsRootDir.endsWith("lib") ? tsRootDir : resolve20(tsRootDir, "lib");
+    const tsRootDir = dirname13(tsPath);
+    return tsRootDir.endsWith("lib") ? tsRootDir : resolve21(tsRootDir, "lib");
   });
   const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
   const options = {
@@ -12134,18 +12519,18 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   const originalGetDefaultLibFileName = host.getDefaultLibFileName;
   host.getDefaultLibFileName = (opts) => {
     const fileName = originalGetDefaultLibFileName ? originalGetDefaultLibFileName(opts) : "lib.d.ts";
-    return basename6(fileName);
+    return basename7(fileName);
   };
   const originalGetSourceFile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
     if (fileName.startsWith("lib.") && fileName.endsWith(".d.ts") && tsLibDir) {
-      const resolvedPath = join18(tsLibDir, fileName);
+      const resolvedPath = join19(tsLibDir, fileName);
       return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
     }
     return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
   };
   const emitted = {};
-  const resolvedOutDir = resolve20(outDir);
+  const resolvedOutDir = resolve21(outDir);
   host.writeFile = (fileName, text) => {
     const relativePath = resolveRelativePath(fileName, resolvedOutDir, outDir);
     emitted[relativePath] = text;
@@ -12167,12 +12552,12 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     if (!fileName.endsWith(".ts") || fileName.endsWith(".d.ts")) {
       return source;
     }
-    const resolvedPath = resolve20(fileName);
+    const resolvedPath = resolve21(fileName);
     return transformedSources.get(resolvedPath) ?? source;
   };
   const originalGetSourceFileForCompile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
-    const source = transformedSources.get(resolve20(fileName));
+    const source = transformedSources.get(resolve21(fileName));
     if (source) {
       return ts2.createSourceFile(fileName, source, languageVersion, true);
     }
@@ -12194,9 +12579,9 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   const entries = await traceAngularPhase("aot/postprocess-emitted-js", () => {
     const rawEntries = Object.entries(emitted).filter(([fileName]) => fileName.endsWith(".js")).map(([fileName, content]) => ({
       content,
-      target: join18(outDir, fileName)
+      target: join19(outDir, fileName)
     }));
-    const outputFiles = new Set(rawEntries.map(({ target }) => resolve20(target)));
+    const outputFiles = new Set(rawEntries.map(({ target }) => resolve21(target)));
     return rawEntries.map(({ content, target }) => {
       let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
         const rewritten = rewriteRelativeJsSpecifier(target, path, outputFiles);
@@ -12211,17 +12596,17 @@ var traceAngularPhase = async (name, fn2, metadata) => {
         return cleaned ? `import { ${cleaned}, InternalInjectFlags } from '@angular/core'` : `import { InternalInjectFlags } from '@angular/core'`;
       });
       processedContent = processedContent.replace(/\b(?<!Internal)InjectFlags\b/g, "InternalInjectFlags");
-      processedContent += islandMetadataByOutputPath.get(resolve20(target)) ?? "";
+      processedContent += islandMetadataByOutputPath.get(resolve21(target)) ?? "";
       return { content: processedContent, target };
     });
   });
   await traceAngularPhase("aot/write-output", () => Promise.all(entries.map(async ({ target, content }) => {
-    await fs.mkdir(dirname12(target), { recursive: true });
+    await fs.mkdir(dirname13(target), { recursive: true });
     await fs.writeFile(target, content, "utf-8");
   })), { outputs: entries.length });
   return await traceAngularPhase("aot/collect-output-paths", () => entries.map(({ target }) => target), { outputs: entries.length });
 }, compileAngularFile = async (inputPath, outDir, stylePreprocessors) => compileAngularFiles([inputPath], outDir, stylePreprocessors), jitContentCache, invalidateAngularJitCache = (filePath) => {
-  jitContentCache.delete(resolve20(filePath));
+  jitContentCache.delete(resolve21(filePath));
 }, wrapperOutputCache, escapeTemplateContent = (content) => content.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${"), findUncommentedMatch = (source, pattern) => {
   const re2 = new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g");
   let match;
@@ -12234,8 +12619,8 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   }
   return null;
 }, resolveAngularDeferImportSpecifier = () => {
-  const sourceEntry = resolve20(import.meta.dir, "../angular/components/index.ts");
-  if (existsSync16(sourceEntry)) {
+  const sourceEntry = resolve21(import.meta.dir, "../angular/components/index.ts");
+  if (existsSync17(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
   return "@absolutejs/absolute/angular/components";
@@ -12363,7 +12748,7 @@ ${slot.resolvedBindings.map((binding) => `		"${binding.key}": this.__absoluteDef
 ${fields}
 `);
 }, readAndEscapeFile = async (filePath, stylePreprocessors) => {
-  if (!existsSync16(filePath)) {
+  if (!existsSync17(filePath)) {
     throw new Error(`Unable to inline Angular style resource: file not found at ${filePath}`);
   }
   const content = await compileStyleFileIfNeeded(filePath, stylePreprocessors);
@@ -12371,8 +12756,8 @@ ${fields}
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join18(fileDir, templateUrlMatch[1]);
-    if (!existsSync16(templatePath)) {
+    const templatePath = join19(fileDir, templateUrlMatch[1]);
+    if (!existsSync17(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
     const templateRaw2 = await fs.readFile(templatePath, "utf-8");
@@ -12402,11 +12787,11 @@ ${fields}
 }, inlineTemplateAndLowerDeferSync = (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join18(fileDir, templateUrlMatch[1]);
-    if (!existsSync16(templatePath)) {
+    const templatePath = join19(fileDir, templateUrlMatch[1]);
+    if (!existsSync17(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
-    const templateRaw2 = readFileSync11(templatePath, "utf-8");
+    const templateRaw2 = readFileSync12(templatePath, "utf-8");
     const lowered2 = lowerAngularDeferSyntax(templateRaw2);
     const escaped2 = escapeTemplateContent(lowered2.template);
     const replacedSource2 = source.slice(0, templateUrlMatch.index) + `template: \`${escaped2}\`` + source.slice(templateUrlMatch.index + templateUrlMatch[0].length);
@@ -12439,7 +12824,7 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join18(fileDir, styleUrl), stylePreprocessors);
+    return readAndEscapeFile(join19(fileDir, styleUrl), stylePreprocessors);
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -12450,7 +12835,7 @@ ${fields}
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join18(fileDir, styleUrlMatch[1]), stylePreprocessors);
+  const escaped = await readAndEscapeFile(join19(fileDir, styleUrlMatch[1]), stylePreprocessors);
   if (!escaped)
     return source;
   return source.slice(0, styleUrlMatch.index) + `styles: [\`${escaped}\`]` + source.slice(styleUrlMatch.index + styleUrlMatch[0].length);
@@ -12464,10 +12849,10 @@ ${fields}
     source: result
   };
 }, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors, cacheBuster) => {
-  const entryPath = resolve20(inputPath);
+  const entryPath = resolve21(inputPath);
   const allOutputs = [];
   const visited = new Set;
-  const baseDir = resolve20(rootDir ?? process.cwd());
+  const baseDir = resolve21(rootDir ?? process.cwd());
   let usesLegacyAnimations = false;
   const angularTranspiler = new Bun.Transpiler({
     loader: "ts",
@@ -12486,16 +12871,16 @@ ${fields}
       `${candidate}.js`,
       `${candidate}.jsx`,
       `${candidate}.json`,
-      join18(candidate, "index.ts"),
-      join18(candidate, "index.tsx"),
-      join18(candidate, "index.js"),
-      join18(candidate, "index.jsx")
+      join19(candidate, "index.ts"),
+      join19(candidate, "index.tsx"),
+      join19(candidate, "index.js"),
+      join19(candidate, "index.jsx")
     ];
-    return candidates.find((file3) => existsSync16(file3));
+    return candidates.find((file3) => existsSync17(file3));
   };
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile2(resolve20(fromDir, specifier));
+      return resolveSourceFile2(resolve21(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile2);
     if (aliased)
@@ -12504,7 +12889,7 @@ ${fields}
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve20(resolved);
+      const absolute = resolve21(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile2(absolute);
@@ -12513,10 +12898,10 @@ ${fields}
     }
   };
   const toOutputPath = (sourcePath) => {
-    const inputDir = dirname12(sourcePath);
+    const inputDir = dirname13(sourcePath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
-    const fileBase = basename6(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    return join18(outDir, relativeDir, fileBase);
+    const fileBase = basename7(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
+    return join19(outDir, relativeDir, fileBase);
   };
   const withCacheBuster = (specifier) => {
     if (!cacheBuster)
@@ -12553,21 +12938,21 @@ ${fields}
         return `${prefix}${dots}`;
       return `${prefix}../${dots}`;
     });
-    if (resolve20(actualPath) === entryPath) {
+    if (resolve21(actualPath) === entryPath) {
       processedContent += buildIslandMetadataExports(sourceCode);
     }
     return processedContent;
   };
   const transpileFile = async (filePath) => {
-    const resolved = resolve20(filePath);
+    const resolved = resolve21(filePath);
     if (visited.has(resolved))
       return;
     visited.add(resolved);
-    if (resolved.endsWith(".json") && existsSync16(resolved)) {
-      const inputDir2 = dirname12(resolved);
+    if (resolved.endsWith(".json") && existsSync17(resolved)) {
+      const inputDir2 = dirname13(resolved);
       const relativeDir2 = inputDir2.startsWith(baseDir) ? inputDir2.substring(baseDir.length + 1) : inputDir2;
-      const targetDir2 = join18(outDir, relativeDir2);
-      const targetPath2 = join18(targetDir2, basename6(resolved));
+      const targetDir2 = join19(outDir, relativeDir2);
+      const targetPath2 = join19(targetDir2, basename7(resolved));
       await fs.mkdir(targetDir2, { recursive: true });
       await fs.copyFile(resolved, targetPath2);
       allOutputs.push(targetPath2);
@@ -12576,15 +12961,15 @@ ${fields}
     let actualPath = resolved;
     if (!actualPath.endsWith(".ts"))
       actualPath += ".ts";
-    if (!existsSync16(actualPath))
+    if (!existsSync17(actualPath))
       return;
     let sourceCode = await fs.readFile(actualPath, "utf-8");
-    const inlined = await inlineResources(sourceCode, dirname12(actualPath), stylePreprocessors);
-    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname12(actualPath)).source;
-    const inputDir = dirname12(actualPath);
+    const inlined = await inlineResources(sourceCode, dirname13(actualPath), stylePreprocessors);
+    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname13(actualPath)).source;
+    const inputDir = dirname13(actualPath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
-    const fileBase = basename6(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    const targetDir = join18(outDir, relativeDir);
+    const fileBase = basename7(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
+    const targetDir = join19(outDir, relativeDir);
     const targetPath = toOutputPath(actualPath);
     const localImports = [];
     const importRewrites = new Map;
@@ -12611,10 +12996,10 @@ ${fields}
       importRewrites.set(specifier, relativeRewrite);
       return resolved2;
     }).filter((path) => Boolean(path));
-    const isEntry = resolve20(actualPath) === resolve20(entryPath);
+    const isEntry = resolve21(actualPath) === resolve21(entryPath);
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey2 = actualPath;
-    const shouldWriteFile = cacheBuster && isEntry ? true : jitContentCache.get(cacheKey2) !== contentHash || !existsSync16(targetPath);
+    const shouldWriteFile = cacheBuster && isEntry ? true : jitContentCache.get(cacheKey2) !== contentHash || !existsSync17(targetPath);
     if (shouldWriteFile) {
       const processedContent = transpileAndRewrite(sourceCode, relativeDir, actualPath, importRewrites);
       await fs.mkdir(targetDir, { recursive: true });
@@ -12626,7 +13011,7 @@ ${fields}
   };
   await transpileFile(inputPath);
   const entryOutputPath = toOutputPath(entryPath);
-  if (existsSync16(entryOutputPath)) {
+  if (existsSync17(entryOutputPath)) {
     const entryOutput = await fs.readFile(entryOutputPath, "utf-8");
     const withoutLegacyFlag = entryOutput.replace(/\nexport const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;\n?/g, `
 `);
@@ -12645,57 +13030,57 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join18(compiledParent, "indexes");
+  const indexesDir = join19(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) => resolve20(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
+  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve21(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   if (!hmr) {
     await traceAngularPhase("aot/copy-json-resources", async () => {
       const cwd = process.cwd();
-      const angularSrcDir = resolve20(outRoot);
-      if (!existsSync16(angularSrcDir))
+      const angularSrcDir = resolve21(outRoot);
+      if (!existsSync17(angularSrcDir))
         return;
       const jsonGlob = new Glob6("**/*.json");
       for (const rel of jsonGlob.scanSync({
         absolute: false,
         cwd: angularSrcDir
       })) {
-        const sourcePath = join18(angularSrcDir, rel);
+        const sourcePath = join19(angularSrcDir, rel);
         const cwdRel = relative11(cwd, sourcePath);
-        const targetPath = join18(compiledRoot, cwdRel);
-        await fs.mkdir(dirname12(targetPath), { recursive: true });
+        const targetPath = join19(compiledRoot, cwdRel);
+        await fs.mkdir(dirname13(targetPath), { recursive: true });
         await fs.copyFile(sourcePath, targetPath);
       }
     });
   }
   const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
   const compileTasks = entryPoints.map(async (entry) => {
-    const resolvedEntry = resolve20(entry);
+    const resolvedEntry = resolve21(entry);
     const relativeEntry = relative11(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
     const compileEntry = () => compileAngularFileJIT(resolvedEntry, compiledRoot, outRoot, stylePreprocessors);
     let outputs = hmr ? await traceAngularPhase("jit/compile-entry", compileEntry, {
       entry: resolvedEntry
     }) : aotOutputs;
-    const fileBase = basename6(resolvedEntry).replace(/\.[tj]s$/, "");
+    const fileBase = basename7(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
     const compiledFallbackPaths = [
-      join18(compiledRoot, relativeEntry),
-      join18(compiledRoot, "pages", jsName),
-      join18(compiledRoot, jsName)
-    ].map((file3) => resolve20(file3));
+      join19(compiledRoot, relativeEntry),
+      join19(compiledRoot, "pages", jsName),
+      join19(compiledRoot, jsName)
+    ].map((file3) => resolve21(file3));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
-        ...candidatePaths.map((file3) => resolve20(file3)),
+        ...candidatePaths.map((file3) => resolve21(file3)),
         ...compiledFallbackPaths
       ];
-      let candidate = normalizedCandidates.find((file3) => existsSync16(file3) && file3.endsWith(`${sep3}${relativeEntry}`));
+      let candidate = normalizedCandidates.find((file3) => existsSync17(file3) && file3.endsWith(`${sep3}${relativeEntry}`));
       if (!candidate) {
-        candidate = normalizedCandidates.find((file3) => existsSync16(file3) && file3.endsWith(`${sep3}pages${sep3}${jsName}`));
+        candidate = normalizedCandidates.find((file3) => existsSync17(file3) && file3.endsWith(`${sep3}pages${sep3}${jsName}`));
       }
       if (!candidate) {
-        candidate = normalizedCandidates.find((file3) => existsSync16(file3) && file3.endsWith(`${sep3}${jsName}`));
+        candidate = normalizedCandidates.find((file3) => existsSync17(file3) && file3.endsWith(`${sep3}${jsName}`));
       }
       if (!candidate) {
-        candidate = normalizedCandidates.find((file3) => existsSync16(file3));
+        candidate = normalizedCandidates.find((file3) => existsSync17(file3));
       }
       return candidate;
     };
@@ -12703,11 +13088,11 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     if (!rawServerFile) {
       rawServerFile = await traceAngularPhase("wrapper/resolve-server-output-fallback", () => resolveRawServerFile([]), { entry: resolvedEntry });
     }
-    if (rawServerFile && !existsSync16(rawServerFile)) {
+    if (rawServerFile && !existsSync17(rawServerFile)) {
       outputs = hmr ? await compileEntry() : aotOutputs;
       rawServerFile = await traceAngularPhase("wrapper/resolve-server-output-retry", () => resolveRawServerFile(outputs), { entry: resolvedEntry });
     }
-    if (!rawServerFile || !existsSync16(rawServerFile)) {
+    if (!rawServerFile || !existsSync17(rawServerFile)) {
       throw new Error(`Compiled output not found for ${entry}. Looking for: ${jsName}. Available: ${[
         ...outputs,
         ...compiledFallbackPaths
@@ -12728,8 +13113,8 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const usesLegacyAnimations = await traceAngularPhase("wrapper/detect-legacy-animations", () => usesLegacyAngularAnimations(resolvedEntry), { entry: resolvedEntry });
     const serverContentHash = Bun.hash(original).toString(BASE_36_RADIX);
     const cachedWrapper = wrapperOutputCache.get(resolvedEntry);
-    const clientFile = join18(indexesDir, jsName);
-    if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync16(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
+    const clientFile = join19(indexesDir, jsName);
+    if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync17(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
       return {
         clientPath: clientFile,
         indexUnchanged: true,
@@ -12958,7 +13343,7 @@ var init_compileAngular = __esm(() => {
   init_stylePreprocessor();
   init_generatedDir();
   devClientDir4 = resolveDevClientDir4();
-  hmrClientPath5 = join18(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath5 = join19(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
 });
@@ -13055,7 +13440,10 @@ class ExpressionTranslatorVisitor {
     ];
     const expressions = [];
     for (let i = 0;i < ast.expressions.length; i++) {
-      const placeholder = this.setSourceMapRange(ast.expressions[i].visitExpression(this, context), ast.getPlaceholderSourceSpan(i));
+      const expression = ast.expressions[i];
+      if (expression === undefined)
+        continue;
+      const placeholder = this.setSourceMapRange(expression.visitExpression(this, context), ast.getPlaceholderSourceSpan(i));
       expressions.push(placeholder);
       elements.push(createTemplateElement(ast.serializeI18nTemplatePart(i + 1)));
     }
@@ -13505,20 +13893,31 @@ class TypeScriptAstFactory {
     let templateLiteral;
     const length = template.elements.length;
     const head = template.elements[0];
+    if (head === undefined) {
+      throw new Error("createTemplateLiteral: template has no elements");
+    }
     if (length === 1) {
       templateLiteral = ts5.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 element = template.elements[i];
+        const expression = template.expressions[i - 1];
+        if (element === undefined || expression === undefined) {
+          throw new Error(`createTemplateLiteral: missing element/expression at index ${i}`);
+        }
+        const { cooked, raw, range } = element;
         const middle = createTemplateMiddle(cooked, raw);
         if (range !== null) {
           this.setSourceMapRange(middle, range);
         }
-        spans.push(ts5.factory.createTemplateSpan(template.expressions[i - 1], middle));
+        spans.push(ts5.factory.createTemplateSpan(expression, middle));
       }
       const resolvedExpression = template.expressions[length - 2];
       const templatePart = template.elements[length - 1];
+      if (resolvedExpression === undefined || templatePart === undefined) {
+        throw new Error("createTemplateLiteral: missing tail element/expression");
+      }
       const templateTail = createTemplateTail(templatePart.cooked, templatePart.raw);
       if (templatePart.range !== null) {
         this.setSourceMapRange(templateTail, templatePart.range);
@@ -13667,8 +14066,8 @@ __export(exports_fastHmrCompiler, {
   primeComponentFingerprint: () => primeComponentFingerprint,
   invalidateFingerprintCache: () => invalidateFingerprintCache
 });
-import { existsSync as existsSync17, readFileSync as readFileSync12, statSync } from "fs";
-import { dirname as dirname13, extname as extname6, relative as relative12, resolve as resolve21 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync13, statSync as statSync2 } from "fs";
+import { dirname as dirname14, extname as extname6, relative as relative12, resolve as resolve22 } from "path";
 import ts6 from "typescript";
 var fail = (reason, detail, location) => ({
   ok: false,
@@ -13796,7 +14195,7 @@ var fail = (reason, detail, location) => ({
         continue;
       const decoratorMeta = readDecoratorMeta(args);
       const { inputs, outputs } = extractInputsAndOutputs(stmt, null);
-      const componentDir = dirname13(componentFilePath);
+      const componentDir = dirname14(componentFilePath);
       const fingerprint = extractFingerprint(stmt, className, decoratorMeta, inputs, outputs, sourceFile, componentDir);
       fingerprintCache.set(id, fingerprint);
     } else {
@@ -13972,7 +14371,7 @@ var fail = (reason, detail, location) => ({
     if (!spec.startsWith(".") && !spec.startsWith("/")) {
       return true;
     }
-    const base = resolve21(componentDir, spec);
+    const base = resolve22(componentDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -13980,11 +14379,11 @@ var fail = (reason, detail, location) => ({
       `${base}/index.tsx`
     ];
     for (const candidate of candidates) {
-      if (!existsSync17(candidate))
+      if (!existsSync18(candidate))
         continue;
       let content;
       try {
-        content = readFileSync12(candidate, "utf-8");
+        content = readFileSync13(candidate, "utf-8");
       } catch {
         continue;
       }
@@ -14299,6 +14698,8 @@ var fail = (reason, detail, location) => ({
   }
 }, mergeMemberHostDecorators = (host, cls) => {
   for (const member of cls.members) {
+    if (!ts6.canHaveDecorators(member))
+      continue;
     const decorators = ts6.getDecorators(member) ?? [];
     for (const dec of decorators) {
       const expr = dec.expression;
@@ -14552,7 +14953,7 @@ var fail = (reason, detail, location) => ({
   const cacheKey2 = `ts:${filePath}:${className}`;
   let stat3;
   try {
-    stat3 = statSync(filePath);
+    stat3 = statSync2(filePath);
   } catch {
     return null;
   }
@@ -14561,7 +14962,7 @@ var fail = (reason, detail, location) => ({
     return cached.info;
   let source;
   try {
-    source = readFileSync12(filePath, "utf-8");
+    source = readFileSync13(filePath, "utf-8");
   } catch {
     childComponentInfoCache.set(cacheKey2, {
       info: null,
@@ -14606,7 +15007,7 @@ var fail = (reason, detail, location) => ({
   const cacheKey2 = `dts:${dtsPath}:${className}`;
   let stat3;
   try {
-    stat3 = statSync(dtsPath);
+    stat3 = statSync2(dtsPath);
   } catch {
     return null;
   }
@@ -14615,7 +15016,7 @@ var fail = (reason, detail, location) => ({
     return cached.info;
   let content;
   try {
-    content = readFileSync12(dtsPath, "utf-8");
+    content = readFileSync13(dtsPath, "utf-8");
   } catch {
     childComponentInfoCache.set(cacheKey2, {
       info: null,
@@ -14731,11 +15132,11 @@ var fail = (reason, detail, location) => ({
   if (visited.has(startDtsPath))
     return null;
   visited.add(startDtsPath);
-  if (!existsSync17(startDtsPath))
+  if (!existsSync18(startDtsPath))
     return null;
   let content;
   try {
-    content = readFileSync12(startDtsPath, "utf-8");
+    content = readFileSync13(startDtsPath, "utf-8");
   } catch {
     return null;
   }
@@ -14754,7 +15155,7 @@ var fail = (reason, detail, location) => ({
     });
     if (!names.includes(className))
       continue;
-    const nextDts = resolveDtsFromSpec(fromPath, dirname13(startDtsPath));
+    const nextDts = resolveDtsFromSpec(fromPath, dirname14(startDtsPath));
     if (!nextDts)
       continue;
     const found = findDtsContainingClass(nextDts, className, visited);
@@ -14764,7 +15165,7 @@ var fail = (reason, detail, location) => ({
   const starReExportRe = /export\s*\*\s*from\s*["']([^"']+)["']/g;
   while ((m = starReExportRe.exec(content)) !== null) {
     const fromPath = m[1] || "";
-    const nextDts = resolveDtsFromSpec(fromPath, dirname13(startDtsPath));
+    const nextDts = resolveDtsFromSpec(fromPath, dirname14(startDtsPath));
     if (!nextDts)
       continue;
     const found = findDtsContainingClass(nextDts, className, visited);
@@ -14774,7 +15175,7 @@ var fail = (reason, detail, location) => ({
   return null;
 }, resolveDtsFromSpec = (spec, fromDir) => {
   const stripped = spec.replace(/\.[mc]?js$/, "");
-  const base = resolve21(fromDir, stripped);
+  const base = resolve22(fromDir, stripped);
   const candidates = [
     `${base}.d.ts`,
     `${base}.d.mts`,
@@ -14784,21 +15185,21 @@ var fail = (reason, detail, location) => ({
     `${base}/index.d.cts`
   ];
   for (const c of candidates) {
-    if (existsSync17(c))
+    if (existsSync18(c))
       return c;
   }
   return null;
 }, findPackageDtsForJs = (jsPath) => {
   const sibling = jsPath.replace(/\.[mc]?js$/, ".d.ts");
-  if (existsSync17(sibling))
+  if (existsSync18(sibling))
     return sibling;
   const mirror = jsPath.replace(/\/dist\//, "/dist/src/").replace(/\.[mc]?js$/, ".d.ts");
-  if (existsSync17(mirror))
+  if (existsSync18(mirror))
     return mirror;
   return null;
 }, resolveChildComponentInfo = (className, spec, componentDir, projectRoot) => {
   if (spec.startsWith(".") || spec.startsWith("/")) {
-    const base = resolve21(componentDir, spec);
+    const base = resolve22(componentDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -14806,7 +15207,7 @@ var fail = (reason, detail, location) => ({
       `${base}/index.tsx`
     ];
     for (const candidate of candidates) {
-      if (!existsSync17(candidate))
+      if (!existsSync18(candidate))
         continue;
       const info = getChildComponentInfoFromTsSource(candidate, className);
       if (info)
@@ -14915,6 +15316,8 @@ var fail = (reason, detail, location) => ({
 }, INPUT_OUTPUT_DECORATORS, extractMemberDecoratorSig = (cls) => {
   const entries = [];
   for (const member of cls.members) {
+    if (!ts6.canHaveDecorators(member))
+      continue;
     const decorators = ts6.getDecorators(member) ?? [];
     if (decorators.length === 0)
       continue;
@@ -14942,7 +15345,7 @@ var fail = (reason, detail, location) => ({
 }, providerProbeCache, fileHasModuleProviders = (filePath) => {
   let stat3;
   try {
-    stat3 = statSync(filePath);
+    stat3 = statSync2(filePath);
   } catch {
     return true;
   }
@@ -14951,7 +15354,7 @@ var fail = (reason, detail, location) => ({
     return cached.hasProviders;
   let source;
   try {
-    source = readFileSync12(filePath, "utf8");
+    source = readFileSync13(filePath, "utf8");
   } catch {
     return true;
   }
@@ -15015,14 +15418,14 @@ var fail = (reason, detail, location) => ({
     }
     if (!matches)
       continue;
-    const resolved = resolve21(componentDir, spec);
+    const resolved = resolve22(componentDir, spec);
     for (const ext of TS_EXTENSIONS) {
       const candidate = resolved + ext;
-      if (existsSync17(candidate))
+      if (existsSync18(candidate))
         return candidate;
     }
-    const indexCandidate = resolve21(resolved, "index.ts");
-    if (existsSync17(indexCandidate))
+    const indexCandidate = resolve22(resolved, "index.ts");
+    if (existsSync18(indexCandidate))
       return indexCandidate;
   }
   return null;
@@ -15185,13 +15588,13 @@ var fail = (reason, detail, location) => ({
   const printer = ts6.createPrinter({ removeComments: true });
   for (const member of classNode.members) {
     if (ts6.isPropertyDeclaration(member)) {
-      const modifiers = (ts6.getModifiers(member) ?? []).filter((m) => m.kind !== ts6.SyntaxKind.Decorator && m.kind !== ts6.SyntaxKind.PrivateKeyword && m.kind !== ts6.SyntaxKind.PublicKeyword && m.kind !== ts6.SyntaxKind.ProtectedKeyword && m.kind !== ts6.SyntaxKind.ReadonlyKeyword && m.kind !== ts6.SyntaxKind.OverrideKeyword);
+      const modifiers = (ts6.getModifiers(member) ?? []).filter((m) => m.kind !== ts6.SyntaxKind.PrivateKeyword && m.kind !== ts6.SyntaxKind.PublicKeyword && m.kind !== ts6.SyntaxKind.ProtectedKeyword && m.kind !== ts6.SyntaxKind.ReadonlyKeyword && m.kind !== ts6.SyntaxKind.OverrideKeyword);
       const cleaned = ts6.factory.createPropertyDeclaration(modifiers, member.name, undefined, undefined, member.initializer);
       memberSources.push(printer.printNode(ts6.EmitHint.Unspecified, cleaned, classNode.getSourceFile()));
       continue;
     }
     if (ts6.isConstructorDeclaration(member)) {
-      const cleanedParams = member.parameters.map((param) => ts6.factory.updateParameterDeclaration(param, (ts6.getModifiers(param) ?? []).filter((m) => m.kind !== ts6.SyntaxKind.Decorator && m.kind !== ts6.SyntaxKind.PrivateKeyword && m.kind !== ts6.SyntaxKind.PublicKeyword && m.kind !== ts6.SyntaxKind.ProtectedKeyword && m.kind !== ts6.SyntaxKind.ReadonlyKeyword && m.kind !== ts6.SyntaxKind.OverrideKeyword), param.dotDotDotToken, param.name, param.questionToken, param.type, param.initializer));
+      const cleanedParams = member.parameters.map((param) => ts6.factory.updateParameterDeclaration(param, (ts6.getModifiers(param) ?? []).filter((m) => m.kind !== ts6.SyntaxKind.PrivateKeyword && m.kind !== ts6.SyntaxKind.PublicKeyword && m.kind !== ts6.SyntaxKind.ProtectedKeyword && m.kind !== ts6.SyntaxKind.ReadonlyKeyword && m.kind !== ts6.SyntaxKind.OverrideKeyword), param.dotDotDotToken, param.name, param.questionToken, param.type, param.initializer));
       const cleaned = ts6.factory.createConstructorDeclaration([], cleanedParams, member.body);
       memberSources.push(printer.printNode(ts6.EmitHint.Unspecified, cleaned, classNode.getSourceFile()));
       continue;
@@ -15201,14 +15604,14 @@ var fail = (reason, detail, location) => ({
       const isStatic = modifiers.some((m) => m.kind === ts6.SyntaxKind.StaticKeyword);
       if (isStatic)
         hasStatic = true;
-      const cleanedParams = member.parameters.map((param) => ts6.factory.updateParameterDeclaration(param, (ts6.getModifiers(param) ?? []).filter((m) => m.kind !== ts6.SyntaxKind.Decorator), param.dotDotDotToken, param.name, param.questionToken, param.type, param.initializer));
+      const cleanedParams = member.parameters.map((param) => ts6.factory.updateParameterDeclaration(param, ts6.getModifiers(param) ?? [], param.dotDotDotToken, param.name, param.questionToken, param.type, param.initializer));
       let cleaned;
       if (ts6.isMethodDeclaration(member)) {
-        cleaned = ts6.factory.createMethodDeclaration(modifiers.filter((m) => m.kind !== ts6.SyntaxKind.Decorator), member.asteriskToken, member.name, member.questionToken, member.typeParameters, cleanedParams, member.type, member.body);
+        cleaned = ts6.factory.createMethodDeclaration(modifiers, member.asteriskToken, member.name, member.questionToken, member.typeParameters, cleanedParams, member.type, member.body);
       } else if (ts6.isGetAccessorDeclaration(member)) {
-        cleaned = ts6.factory.createGetAccessorDeclaration(modifiers.filter((m) => m.kind !== ts6.SyntaxKind.Decorator), member.name, cleanedParams, member.type, member.body);
+        cleaned = ts6.factory.createGetAccessorDeclaration(modifiers, member.name, cleanedParams, member.type, member.body);
       } else {
-        cleaned = ts6.factory.createSetAccessorDeclaration(modifiers.filter((m) => m.kind !== ts6.SyntaxKind.Decorator), member.name, cleanedParams, member.body);
+        cleaned = ts6.factory.createSetAccessorDeclaration(modifiers, member.name, cleanedParams, member.body);
       }
       const printed = printer.printNode(ts6.EmitHint.Unspecified, cleaned, classNode.getSourceFile());
       memberSources.push(printed);
@@ -15254,12 +15657,12 @@ ${transpiled}
     }
 }${staticPatch}`;
 }, STYLE_PREPROCESSED_EXT, resolveAndReadStyleResource = (componentDir, url) => {
-  const abs = resolve21(componentDir, url);
-  if (!existsSync17(abs))
+  const abs = resolve22(componentDir, url);
+  if (!existsSync18(abs))
     return null;
   const ext = extname6(abs).toLowerCase();
   if (!STYLE_PREPROCESSED_EXT.has(ext) || ext === ".css") {
-    return readFileSync12(abs, "utf8");
+    return readFileSync13(abs, "utf8");
   }
   try {
     const { compileStyleFileIfNeededSync: compileStyleFileIfNeededSync2 } = (init_stylePreprocessor(), __toCommonJS(exports_stylePreprocessor));
@@ -15294,11 +15697,11 @@ ${block}
   const cached = projectOptionsCache.get(projectRoot);
   if (cached !== undefined)
     return cached;
-  const tsconfigPath = resolve21(projectRoot, "tsconfig.json");
+  const tsconfigPath = resolve22(projectRoot, "tsconfig.json");
   const opts = {};
-  if (existsSync17(tsconfigPath)) {
+  if (existsSync18(tsconfigPath)) {
     try {
-      const text = readFileSync12(tsconfigPath, "utf8");
+      const text = readFileSync13(tsconfigPath, "utf8");
       const parsed = ts6.parseConfigFileTextToJson(tsconfigPath, text);
       if (!parsed.error && parsed.config) {
         const cfg = parsed.config;
@@ -15323,7 +15726,7 @@ ${block}
 }, tryFastHmr = async (params) => {
   const { componentFilePath, className } = params;
   const projectRoot = params.projectRoot ?? process.cwd();
-  if (!existsSync17(componentFilePath)) {
+  if (!existsSync18(componentFilePath)) {
     return fail("file-not-found", componentFilePath);
   }
   let compiler;
@@ -15332,7 +15735,7 @@ ${block}
   } catch (err) {
     return fail("unexpected-error", `import @angular/compiler: ${err}`);
   }
-  const tsSource = readFileSync12(componentFilePath, "utf8");
+  const tsSource = readFileSync13(componentFilePath, "utf8");
   const sourceFile = ts6.createSourceFile(componentFilePath, tsSource, ts6.ScriptTarget.ES2022, true, ts6.ScriptKind.TS);
   const classNode = findClassDeclaration(sourceFile, className);
   if (!classNode) {
@@ -15359,7 +15762,7 @@ ${block}
       rebootstrapRequired: false
     };
   }
-  if (inheritsDecoratedClass(classNode, sourceFile, dirname13(componentFilePath), projectRoot)) {
+  if (inheritsDecoratedClass(classNode, sourceFile, dirname14(componentFilePath), projectRoot)) {
     return fail("inherits-decorated-class");
   }
   const decorator = findComponentDecorator(classNode);
@@ -15371,18 +15774,18 @@ ${block}
   const projectDefaults = readProjectAngularCompilerOptions(projectRoot);
   const decoratorMeta = readDecoratorMeta(decoratorArgs, projectDefaults);
   const advancedMetadata = extractAdvancedMetadata(classNode, decoratorArgs, compiler);
-  const componentDir = dirname13(componentFilePath);
+  const componentDir = dirname14(componentFilePath);
   let templateText;
   let templatePath;
   if (decoratorMeta.template !== null) {
     templateText = decoratorMeta.template;
     templatePath = componentFilePath;
   } else if (decoratorMeta.templateUrl) {
-    const tplAbs = resolve21(componentDir, decoratorMeta.templateUrl);
-    if (!existsSync17(tplAbs)) {
+    const tplAbs = resolve22(componentDir, decoratorMeta.templateUrl);
+    if (!existsSync18(tplAbs)) {
       return fail("template-resource-not-found", `Template file not found: ${tplAbs}`, { file: componentFilePath });
     }
-    templateText = readFileSync12(tplAbs, "utf8");
+    templateText = readFileSync13(tplAbs, "utf8");
     templatePath = tplAbs;
   } else {
     return fail("unsupported-decorator-args", "missing template/templateUrl");
@@ -16132,16 +16535,16 @@ __export(exports_compileEmber, {
   getEmberServerCompiledDir: () => getEmberServerCompiledDir,
   getEmberCompiledRoot: () => getEmberCompiledRoot,
   getEmberClientCompiledDir: () => getEmberClientCompiledDir,
-  dirname: () => dirname14,
+  dirname: () => dirname15,
   compileEmberFileSource: () => compileEmberFileSource,
   compileEmberFile: () => compileEmberFile,
   compileEmber: () => compileEmber,
   clearEmberCompilerCache: () => clearEmberCompilerCache,
-  basename: () => basename7
+  basename: () => basename8
 });
-import { existsSync as existsSync18 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 import { mkdir as mkdir6, rm as rm4 } from "fs/promises";
-import { basename as basename7, dirname as dirname14, extname as extname7, join as join19, resolve as resolve22 } from "path";
+import { basename as basename8, dirname as dirname15, extname as extname7, join as join20, resolve as resolve23 } from "path";
 var {build: bunBuild2, Transpiler: Transpiler4, write: write3, file: file3 } = globalThis.Bun;
 var cachedPreprocessor = null, getPreprocessor = async () => {
   if (cachedPreprocessor)
@@ -16237,11 +16640,11 @@ export const importSync = (specifier) => {
         const originalImporter = stagedSourceMap.get(args.importer);
         if (!originalImporter)
           return;
-        const candidateBase = resolve22(dirname14(originalImporter), args.path);
+        const candidateBase = resolve23(dirname15(originalImporter), args.path);
         const extensionsToTry = ["", ".gts", ".gjs", ".ts", ".js"];
         for (const ext of extensionsToTry) {
           const candidate = candidateBase + ext;
-          if (existsSync18(candidate))
+          if (existsSync19(candidate))
             return { path: candidate };
         }
         return;
@@ -16260,8 +16663,8 @@ export const importSync = (specifier) => {
     build.onResolve({ filter: /^@(?:ember|glimmer|simple-dom)\// }, (args) => {
       if (standalonePackages.has(args.path))
         return;
-      const internal = join19(cwd, "node_modules/ember-source/dist/packages", args.path, "index.js");
-      if (existsSync18(internal))
+      const internal = join20(cwd, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      if (existsSync19(internal))
         return { path: internal };
       return;
     });
@@ -16296,7 +16699,7 @@ export const renderToHTML = (props = {}) => {
 export { PageComponent };
 export default PageComponent;
 `, compileEmberFile = async (entry, compiledRoot, cwd = process.cwd()) => {
-  const resolvedEntry = resolve22(entry);
+  const resolvedEntry = resolve23(entry);
   const source = await file3(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -16307,17 +16710,17 @@ export default PageComponent;
     preprocessed = rewriteTemplateEvalToScope(result.code);
   }
   const transpiled = transpiler5.transformSync(preprocessed);
-  const baseName = basename7(resolvedEntry).replace(/\.(gjs|gts|ts|js)$/, "");
-  const tmpDir = join19(compiledRoot, "_tmp");
-  const serverDir = join19(compiledRoot, "server");
-  const clientDir = join19(compiledRoot, "client");
+  const baseName = basename8(resolvedEntry).replace(/\.(gjs|gts|ts|js)$/, "");
+  const tmpDir = join20(compiledRoot, "_tmp");
+  const serverDir = join20(compiledRoot, "server");
+  const clientDir = join20(compiledRoot, "client");
   await Promise.all([
     mkdir6(tmpDir, { recursive: true }),
     mkdir6(serverDir, { recursive: true }),
     mkdir6(clientDir, { recursive: true })
   ]);
-  const tmpPagePath = resolve22(join19(tmpDir, `${baseName}.module.js`));
-  const tmpHarnessPath = resolve22(join19(tmpDir, `${baseName}.harness.js`));
+  const tmpPagePath = resolve23(join20(tmpDir, `${baseName}.module.js`));
+  const tmpHarnessPath = resolve23(join20(tmpDir, `${baseName}.harness.js`));
   await Promise.all([
     write3(tmpPagePath, transpiled),
     write3(tmpHarnessPath, generateServerHarness(tmpPagePath))
@@ -16325,7 +16728,7 @@ export default PageComponent;
   const stagedSourceMap = new Map([
     [tmpPagePath, resolvedEntry]
   ]);
-  const serverPath = join19(serverDir, `${baseName}.js`);
+  const serverPath = join20(serverDir, `${baseName}.js`);
   const buildResult = await bunBuild2({
     entrypoints: [tmpHarnessPath],
     format: "esm",
@@ -16342,7 +16745,7 @@ export default PageComponent;
     console.warn(`\u26A0\uFE0F Ember server build for ${baseName} had errors:`, buildResult.logs);
   }
   await rm4(tmpDir, { force: true, recursive: true });
-  const clientPath = join19(clientDir, `${baseName}.js`);
+  const clientPath = join20(clientDir, `${baseName}.js`);
   await write3(clientPath, transpiled);
   return { clientPath, serverPath };
 }, compileEmber = async (entries, emberDir, cwd = process.cwd(), _hmr = false) => {
@@ -16359,7 +16762,7 @@ export default PageComponent;
     serverPaths: outputs.map((o3) => o3.serverPath)
   };
 }, compileEmberFileSource = async (entry) => {
-  const resolvedEntry = resolve22(entry);
+  const resolvedEntry = resolve23(entry);
   const source = await file3(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -16370,7 +16773,7 @@ export default PageComponent;
     preprocessed = rewriteTemplateEvalToScope(result.code);
   }
   return transpiler5.transformSync(preprocessed);
-}, clearEmberCompilerCache = () => {}, getEmberCompiledRoot = (_emberDir) => getFrameworkGeneratedDir("ember"), getEmberServerCompiledDir = (emberDir) => join19(getEmberCompiledRoot(emberDir), "server"), getEmberClientCompiledDir = (emberDir) => join19(getEmberCompiledRoot(emberDir), "client");
+}, clearEmberCompilerCache = () => {}, getEmberCompiledRoot = (_emberDir) => getFrameworkGeneratedDir("ember"), getEmberServerCompiledDir = (emberDir) => join20(getEmberCompiledRoot(emberDir), "server"), getEmberClientCompiledDir = (emberDir) => join20(getEmberCompiledRoot(emberDir), "client");
 var init_compileEmber = __esm(() => {
   init_generatedDir();
   transpiler5 = new Transpiler4({
@@ -16391,25 +16794,25 @@ __export(exports_buildReactVendor, {
   computeVendorPaths: () => computeVendorPaths,
   buildReactVendor: () => buildReactVendor
 });
-import { existsSync as existsSync19, mkdirSync as mkdirSync7 } from "fs";
-import { join as join20, resolve as resolve23 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync8 } from "fs";
+import { join as join21, resolve as resolve24 } from "path";
 import { rm as rm5 } from "fs/promises";
 var {build: bunBuild3 } = globalThis.Bun;
 var resolveJsxDevRuntimeCompatPath = () => {
   const candidates = [
-    resolve23(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
-    resolve23(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve23(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve23(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve23(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve23(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve24(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
+    resolve24(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve24(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve24(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve24(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve24(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
-    if (existsSync19(candidate)) {
+    if (existsSync20(candidate)) {
       return candidate.replace(/\\/g, "/");
     }
   }
-  return (candidates[0] ?? resolve23(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
+  return (candidates[0] ?? resolve24(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
 }, jsxDevRuntimeCompatPath, reactSpecifiers, isResolvable = (specifier) => {
   try {
     Bun.resolveSync(specifier, process.cwd());
@@ -16446,14 +16849,14 @@ var resolveJsxDevRuntimeCompatPath = () => {
 `)}
 `;
 }, buildReactVendor = async (buildDir) => {
-  const vendorDir = join20(buildDir, "react", "vendor");
-  mkdirSync7(vendorDir, { recursive: true });
-  const tmpDir = join20(buildDir, "_vendor_tmp");
-  mkdirSync7(tmpDir, { recursive: true });
+  const vendorDir = join21(buildDir, "react", "vendor");
+  mkdirSync8(vendorDir, { recursive: true });
+  const tmpDir = join21(buildDir, "_vendor_tmp");
+  mkdirSync8(tmpDir, { recursive: true });
   const specifiers = resolveVendorSpecifiers();
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName(specifier);
-    const entryPath = join20(tmpDir, `${safeName}.ts`);
+    const entryPath = join21(tmpDir, `${safeName}.ts`);
     const source = await generateEntrySource(specifier);
     await Bun.write(entryPath, source);
     return entryPath;
@@ -16517,8 +16920,8 @@ __export(exports_buildAngularVendor, {
   buildAngularVendor: () => buildAngularVendor,
   buildAngularServerVendor: () => buildAngularServerVendor
 });
-import { mkdirSync as mkdirSync8 } from "fs";
-import { join as join21 } from "path";
+import { mkdirSync as mkdirSync9 } from "fs";
+import { join as join22 } from "path";
 import { rm as rm6 } from "fs/promises";
 var {build: bunBuild4, Glob: Glob7 } = globalThis.Bun;
 var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => jitMode ? [...REQUIRED_ANGULAR_SPECIFIERS_BASE, "@angular/compiler"] : REQUIRED_ANGULAR_SPECIFIERS_BASE, SERVER_ONLY_ANGULAR_SPECIFIERS, BUILD_ONLY_ANGULAR_SPECIFIER_PREFIXES, isBuildOnlyAngularSpecifier = (spec) => BUILD_ONLY_ANGULAR_SPECIFIER_PREFIXES.some((prefix) => spec === prefix || spec.startsWith(`${prefix}/`)), SCAN_SKIP_DIRS, isResolvable2 = (specifier) => {
@@ -16555,7 +16958,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   }
   return { angular, transitiveRoots };
 }, PARTIAL_DECL_MARKERS, containsPartialDeclarations = (source) => PARTIAL_DECL_MARKERS.some((marker) => source.includes(marker)), collectTransitiveAngularSpecs = async (roots, angularFound) => {
-  const { readFileSync: readFileSync13 } = await import("fs");
+  const { readFileSync: readFileSync14 } = await import("fs");
   const transpiler6 = new Bun.Transpiler({ loader: "js" });
   const visited = new Set;
   const frontier = [];
@@ -16576,7 +16979,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
       }
       let content;
       try {
-        content = readFileSync13(resolved, "utf-8");
+        content = readFileSync14(resolved, "utf-8");
       } catch {
         continue;
       }
@@ -16615,14 +17018,14 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   await collectTransitiveAngularSpecs([...angular, ...transitiveRoots], angular);
   return Array.from(angular).filter(isResolvable2);
 }, buildAngularVendor = async (buildDir, directories = [], linkerJitMode = false, depVendorSpecifiers = []) => {
-  const vendorDir = join21(buildDir, "angular", "vendor");
-  mkdirSync8(vendorDir, { recursive: true });
-  const tmpDir = join21(buildDir, "_angular_vendor_tmp");
-  mkdirSync8(tmpDir, { recursive: true });
+  const vendorDir = join22(buildDir, "angular", "vendor");
+  mkdirSync9(vendorDir, { recursive: true });
+  const tmpDir = join22(buildDir, "_angular_vendor_tmp");
+  mkdirSync9(tmpDir, { recursive: true });
   const specifiers = await resolveAngularSpecifiers(directories, linkerJitMode);
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
-    const entryPath = join21(tmpDir, `${safeName}.ts`);
+    const entryPath = join22(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -16653,10 +17056,10 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   const specifiers = await resolveAngularSpecifiers(directories, linkerJitMode);
   return computeAngularVendorPaths(specifiers);
 }, buildAngularServerVendor = async (buildDir, directories = [], linkerJitMode = false) => {
-  const vendorDir = join21(buildDir, "angular", "vendor", "server");
-  mkdirSync8(vendorDir, { recursive: true });
-  const tmpDir = join21(buildDir, "_angular_server_vendor_tmp");
-  mkdirSync8(tmpDir, { recursive: true });
+  const vendorDir = join22(buildDir, "angular", "vendor", "server");
+  mkdirSync9(vendorDir, { recursive: true });
+  const tmpDir = join22(buildDir, "_angular_server_vendor_tmp");
+  mkdirSync9(tmpDir, { recursive: true });
   const browserSpecs = await resolveAngularSpecifiers(directories, linkerJitMode);
   const allSpecs = new Set(browserSpecs);
   for (const spec of SERVER_ONLY_ANGULAR_SPECIFIERS) {
@@ -16666,7 +17069,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   const specifiers = Array.from(allSpecs);
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
-    const entryPath = join21(tmpDir, `${safeName}.ts`);
+    const entryPath = join22(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -16688,9 +17091,9 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   return specifiers;
 }, computeAngularServerVendorPaths = (buildDir, specifiers) => {
   const paths = {};
-  const vendorDir = join21(buildDir, "angular", "vendor", "server");
+  const vendorDir = join22(buildDir, "angular", "vendor", "server");
   for (const specifier of specifiers) {
-    paths[specifier] = join21(vendorDir, `${toSafeFileName2(specifier)}.js`);
+    paths[specifier] = join22(vendorDir, `${toSafeFileName2(specifier)}.js`);
   }
   return paths;
 }, computeAngularServerVendorPathsAsync = async (buildDir, directories = [], linkerJitMode = true) => {
@@ -16745,18 +17148,18 @@ __export(exports_buildVueVendor, {
   computeVueVendorPaths: () => computeVueVendorPaths,
   buildVueVendor: () => buildVueVendor
 });
-import { mkdirSync as mkdirSync9 } from "fs";
-import { join as join22 } from "path";
+import { mkdirSync as mkdirSync10 } from "fs";
+import { join as join23 } from "path";
 import { rm as rm7 } from "fs/promises";
 var {build: bunBuild5 } = globalThis.Bun;
 var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"), buildVueVendor = async (buildDir) => {
-  const vendorDir = join22(buildDir, "vue", "vendor");
-  mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join22(buildDir, "_vue_vendor_tmp");
-  mkdirSync9(tmpDir, { recursive: true });
+  const vendorDir = join23(buildDir, "vue", "vendor");
+  mkdirSync10(vendorDir, { recursive: true });
+  const tmpDir = join23(buildDir, "_vue_vendor_tmp");
+  mkdirSync10(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(vueSpecifiers.map(async (specifier) => {
     const safeName = toSafeFileName3(specifier);
-    const entryPath = join22(tmpDir, `${safeName}.ts`);
+    const entryPath = join23(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -16781,17 +17184,17 @@ var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"
     console.warn("\u26A0\uFE0F Vue vendor build had errors:", result.logs);
     return;
   }
-  const { readFileSync: readFileSync13, writeFileSync: writeFileSync7, readdirSync } = await import("fs");
+  const { readFileSync: readFileSync14, writeFileSync: writeFileSync8, readdirSync } = await import("fs");
   const files = readdirSync(vendorDir).filter((f2) => f2.endsWith(".js"));
   for (const file4 of files) {
-    const filePath = join22(vendorDir, file4);
-    const content = readFileSync13(filePath, "utf-8");
+    const filePath = join23(vendorDir, file4);
+    const content = readFileSync14(filePath, "utf-8");
     if (!content.includes("__VUE_HMR_RUNTIME__"))
       continue;
     const patched = content.replace(/getGlobalThis\(\)\.__VUE_HMR_RUNTIME__\s*=\s*\{/, "getGlobalThis().__VUE_HMR_RUNTIME__ = getGlobalThis().__VUE_HMR_RUNTIME__ || {");
     if (patched === content)
       continue;
-    writeFileSync7(filePath, patched);
+    writeFileSync8(filePath, patched);
   }
 }, computeVueVendorPaths = () => {
   const paths = {};
@@ -16810,8 +17213,8 @@ __export(exports_buildSvelteVendor, {
   computeSvelteVendorPaths: () => computeSvelteVendorPaths,
   buildSvelteVendor: () => buildSvelteVendor
 });
-import { mkdirSync as mkdirSync10 } from "fs";
-import { join as join23 } from "path";
+import { mkdirSync as mkdirSync11 } from "fs";
+import { join as join24 } from "path";
 import { rm as rm8 } from "fs/promises";
 var {build: bunBuild6 } = globalThis.Bun;
 var svelteSpecifiers, isResolvable3 = (specifier) => {
@@ -16825,13 +17228,13 @@ var svelteSpecifiers, isResolvable3 = (specifier) => {
   const specifiers = resolveVendorSpecifiers2();
   if (specifiers.length === 0)
     return;
-  const vendorDir = join23(buildDir, "svelte", "vendor");
-  mkdirSync10(vendorDir, { recursive: true });
-  const tmpDir = join23(buildDir, "_svelte_vendor_tmp");
-  mkdirSync10(tmpDir, { recursive: true });
+  const vendorDir = join24(buildDir, "svelte", "vendor");
+  mkdirSync11(vendorDir, { recursive: true });
+  const tmpDir = join24(buildDir, "_svelte_vendor_tmp");
+  mkdirSync11(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName4(specifier);
-    const entryPath = join23(tmpDir, `${safeName}.ts`);
+    const entryPath = join24(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -16881,7 +17284,7 @@ __export(exports_rewriteImportsPlugin, {
   buildWithImportRewrite: () => buildWithImportRewrite
 });
 import { readdir as readdir3 } from "fs/promises";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 var escapeRegex2 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewriteImports = (content, replacements) => {
   let result = content;
   for (const [specifier, webPath] of replacements) {
@@ -17010,7 +17413,7 @@ ${content}`;
       const entries = await readdir3(dir);
       for (const entry of entries) {
         if (entry.endsWith(".js"))
-          allFiles.push(join24(dir, entry));
+          allFiles.push(join25(dir, entry));
       }
     } catch {}
   }
@@ -17050,16 +17453,16 @@ var init_rewriteImportsPlugin = __esm(() => {
 
 // src/core/build.ts
 import {
-  copyFileSync,
+  copyFileSync as copyFileSync2,
   cpSync,
-  existsSync as existsSync20,
-  mkdirSync as mkdirSync11,
-  readFileSync as readFileSync13,
+  existsSync as existsSync21,
+  mkdirSync as mkdirSync12,
+  readFileSync as readFileSync14,
   rmSync as rmSync2,
-  statSync as statSync2,
-  writeFileSync as writeFileSync7
+  statSync as statSync3,
+  writeFileSync as writeFileSync8
 } from "fs";
-import { basename as basename8, dirname as dirname15, extname as extname8, join as join25, relative as relative13, resolve as resolve24 } from "path";
+import { basename as basename9, dirname as dirname16, extname as extname8, join as join26, relative as relative13, resolve as resolve25 } from "path";
 import { cwd, env as env2, exit } from "process";
 var {build: bunBuild7, Glob: Glob8 } = globalThis.Bun;
 var isDev, isBuildTraceEnabled = () => {
@@ -17134,12 +17537,12 @@ var isDev, isBuildTraceEnabled = () => {
     throw err;
   exit(1);
 }, copyHtmxVendor = (htmxDir, htmxDestDir) => {
-  mkdirSync11(htmxDestDir, { recursive: true });
+  mkdirSync12(htmxDestDir, { recursive: true });
   const glob = new Glob8("htmx*.min.js");
   for (const relPath of glob.scanSync({ cwd: htmxDir })) {
-    const src = join25(htmxDir, relPath);
-    const dest = join25(htmxDestDir, "htmx.min.js");
-    copyFileSync(src, dest);
+    const src = join26(htmxDir, relPath);
+    const dest = join26(htmxDestDir, "htmx.min.js");
+    copyFileSync2(src, dest);
     return;
   }
 }, tryReadPackageJson = async (path) => {
@@ -17150,8 +17553,8 @@ var isDev, isBuildTraceEnabled = () => {
   }
 }, resolveAbsoluteVersion = async () => {
   const candidates = [
-    resolve24(import.meta.dir, "..", "..", "package.json"),
-    resolve24(import.meta.dir, "..", "package.json")
+    resolve25(import.meta.dir, "..", "..", "package.json"),
+    resolve25(import.meta.dir, "..", "package.json")
   ];
   const resolveCandidate = async (remaining) => {
     const [candidate, ...rest] = remaining;
@@ -17167,9 +17570,9 @@ var isDev, isBuildTraceEnabled = () => {
   };
   await resolveCandidate(candidates);
 }, SKIP_DIRS, addWorkerPathIfExists = (file4, relPath, workerPaths) => {
-  const absPath = resolve24(file4, "..", relPath);
+  const absPath = resolve25(file4, "..", relPath);
   try {
-    statSync2(absPath);
+    statSync3(absPath);
     workerPaths.add(absPath);
   } catch {}
 }, collectWorkerPathsFromContent = (content, pattern, file4, workerPaths) => {
@@ -17182,7 +17585,7 @@ var isDev, isBuildTraceEnabled = () => {
     addWorkerPathIfExists(file4, relPath, workerPaths);
   }
 }, collectWorkerPathsFromFile = (file4, patterns, workerPaths) => {
-  const content = readFileSync13(file4, "utf-8");
+  const content = readFileSync14(file4, "utf-8");
   for (const pattern of patterns) {
     collectWorkerPathsFromContent(content, pattern, file4, workerPaths);
   }
@@ -17213,8 +17616,8 @@ var isDev, isBuildTraceEnabled = () => {
   vuePagesPath
 }) => {
   const { readdirSync: readDir } = await import("fs");
-  const devIndexDir = join25(buildPath, "_src_indexes");
-  mkdirSync11(devIndexDir, { recursive: true });
+  const devIndexDir = join26(buildPath, "_src_indexes");
+  mkdirSync12(devIndexDir, { recursive: true });
   if (reactIndexesPath && reactPagesPath) {
     copyReactDevIndexes(reactIndexesPath, reactPagesPath, devIndexDir, readDir);
   }
@@ -17225,41 +17628,41 @@ var isDev, isBuildTraceEnabled = () => {
     copyVueDevIndexes(vueDir, vuePagesPath, vueEntries, devIndexDir);
   }
 }, copyReactDevIndexes = (reactIndexesPath, reactPagesPath, devIndexDir, readDir) => {
-  if (!existsSync20(reactIndexesPath)) {
+  if (!existsSync21(reactIndexesPath)) {
     return;
   }
   const indexFiles = readDir(reactIndexesPath).filter((file4) => file4.endsWith(".tsx"));
-  const pagesRel = relative13(process.cwd(), resolve24(reactPagesPath)).replace(/\\/g, "/");
+  const pagesRel = relative13(process.cwd(), resolve25(reactPagesPath)).replace(/\\/g, "/");
   for (const file4 of indexFiles) {
-    let content = readFileSync13(join25(reactIndexesPath, file4), "utf-8");
+    let content = readFileSync14(join26(reactIndexesPath, file4), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
-    writeFileSync7(join25(devIndexDir, file4), content);
+    writeFileSync8(join26(devIndexDir, file4), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
-  const svelteIndexDir = join25(getFrameworkGeneratedDir("svelte"), "indexes");
-  const sveltePageEntries = svelteEntries.filter((file4) => resolve24(file4).startsWith(resolve24(sveltePagesPath)));
+  const svelteIndexDir = join26(getFrameworkGeneratedDir("svelte"), "indexes");
+  const sveltePageEntries = svelteEntries.filter((file4) => resolve25(file4).startsWith(resolve25(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
-    const name = basename8(entry).replace(/\.svelte(\.(ts|js))?$/, "");
-    const indexFile = join25(svelteIndexDir, "pages", `${name}.js`);
-    if (!existsSync20(indexFile))
+    const name = basename9(entry).replace(/\.svelte(\.(ts|js))?$/, "");
+    const indexFile = join26(svelteIndexDir, "pages", `${name}.js`);
+    if (!existsSync21(indexFile))
       continue;
-    let content = readFileSync13(indexFile, "utf-8");
-    const srcRel = relative13(process.cwd(), resolve24(entry)).replace(/\\/g, "/");
+    let content = readFileSync14(indexFile, "utf-8");
+    const srcRel = relative13(process.cwd(), resolve25(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
-    writeFileSync7(join25(devIndexDir, `${name}.svelte.js`), content);
+    writeFileSync8(join26(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
-  const vueIndexDir = join25(getFrameworkGeneratedDir("vue"), "indexes");
-  const vuePageEntries = vueEntries.filter((file4) => resolve24(file4).startsWith(resolve24(vuePagesPath)));
+  const vueIndexDir = join26(getFrameworkGeneratedDir("vue"), "indexes");
+  const vuePageEntries = vueEntries.filter((file4) => resolve25(file4).startsWith(resolve25(vuePagesPath)));
   for (const entry of vuePageEntries) {
-    const name = basename8(entry, ".vue");
-    const indexFile = join25(vueIndexDir, `${name}.js`);
-    if (!existsSync20(indexFile))
+    const name = basename9(entry, ".vue");
+    const indexFile = join26(vueIndexDir, `${name}.js`);
+    if (!existsSync21(indexFile))
       continue;
-    let content = readFileSync13(indexFile, "utf-8");
-    const srcRel = relative13(process.cwd(), resolve24(entry)).replace(/\\/g, "/");
+    let content = readFileSync14(indexFile, "utf-8");
+    const srcRel = relative13(process.cwd(), resolve25(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(join25(devIndexDir, `${name}.vue.js`), content);
+    writeFileSync8(join26(devIndexDir, `${name}.vue.js`), content);
   }
 }, resolveVueRuntimeId = (content, firstUseName, outputPath, projectRoot) => {
   const varIdx = content.indexOf(`var ${firstUseName} =`);
@@ -17270,7 +17673,7 @@ var isDev, isBuildTraceEnabled = () => {
   const last = allComments[allComments.length - 1];
   if (!last?.[1])
     return JSON.stringify(outputPath);
-  const srcPath = resolve24(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
+  const srcPath = resolve25(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
   return JSON.stringify(srcPath);
 }, QUOTE_CHARS, OPEN_BRACES, CLOSE_BRACES, findFunctionExpressionEnd = (content, startPos) => {
   let depth = 0;
@@ -17307,7 +17710,7 @@ var isDev, isBuildTraceEnabled = () => {
   }
   return result;
 }, VUE_HMR_RUNTIME, injectVueComposableTracking = (outputPath, projectRoot) => {
-  let content = readFileSync13(outputPath, "utf-8");
+  let content = readFileSync14(outputPath, "utf-8");
   const usePattern = /^var\s+(use[A-Z]\w*)\s*=/gm;
   const useNames = [];
   let match;
@@ -17328,13 +17731,13 @@ var isDev, isBuildTraceEnabled = () => {
   content = `${content.slice(0, firstUseIdx) + runtime}
 ${content.slice(firstUseIdx)}`;
   content = wrapUseFunctions(content, useNames);
-  writeFileSync7(outputPath, content);
+  writeFileSync8(outputPath, content);
 }, buildDevUrlFileMap = (urlReferencedFiles, projectRoot) => {
   const urlFileMap = new Map;
   for (const srcPath of urlReferencedFiles) {
     const rel = relative13(projectRoot, srcPath).replace(/\\/g, "/");
-    const name = basename8(srcPath);
-    const mtime = Math.round(statSync2(srcPath).mtimeMs);
+    const name = basename9(srcPath);
+    const mtime = Math.round(statSync3(srcPath).mtimeMs);
     const url = `/@src/${rel}?v=${mtime}`;
     urlFileMap.set(name, url);
     urlFileMap.set(name.replace(/\.tsx?$/, ".js"), url);
@@ -17343,11 +17746,11 @@ ${content.slice(firstUseIdx)}`;
 }, buildProdUrlFileMap = (urlReferencedFiles, buildPath, nonReactClientOutputs) => {
   const urlFileMap = new Map;
   for (const srcPath of urlReferencedFiles) {
-    const srcBase = basename8(srcPath).replace(/\.[^.]+$/, "");
-    const output = nonReactClientOutputs.find((artifact) => basename8(artifact.path).startsWith(`${srcBase}.`));
+    const srcBase = basename9(srcPath).replace(/\.[^.]+$/, "");
+    const output = nonReactClientOutputs.find((artifact) => basename9(artifact.path).startsWith(`${srcBase}.`));
     if (!output)
       continue;
-    urlFileMap.set(basename8(srcPath), `/${relative13(buildPath, output.path).replace(/\\/g, "/")}`);
+    urlFileMap.set(basename9(srcPath), `/${relative13(buildPath, output.path).replace(/\\/g, "/")}`);
   }
   return urlFileMap;
 }, buildUrlFileMap = (urlReferencedFiles, hmr, projectRoot, buildPath, nonReactClientOutputs) => {
@@ -17357,10 +17760,10 @@ ${content.slice(firstUseIdx)}`;
 }, rewriteUrlReferences = (outputPaths, urlFileMap) => {
   const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
   for (const outputPath of outputPaths) {
-    let content = readFileSync13(outputPath, "utf-8");
+    let content = readFileSync14(outputPath, "utf-8");
     let changed = false;
     content = content.replace(urlPattern, (_match, relPath) => {
-      const targetName = basename8(relPath);
+      const targetName = basename9(relPath);
       const resolvedPath = urlFileMap.get(targetName);
       if (!resolvedPath)
         return _match;
@@ -17368,7 +17771,7 @@ ${content.slice(firstUseIdx)}`;
       return `new URL('${resolvedPath}', import.meta.url)`;
     });
     if (changed)
-      writeFileSync7(outputPath, content);
+      writeFileSync8(outputPath, content);
   }
 }, vueFeatureFlags, bunBuildPassKeys, bunBuildPassKeySet, reservedBunBuildConfigKeys, passLockedKeys, isObject = (value) => typeof value === "object" && value !== null, isBunBuildPassConfig = (config) => isObject(config) && Object.keys(config).some((key) => bunBuildPassKeySet.has(key)), sanitizeBunBuildOverride = (override, extraReservedKeys = new Set) => {
   if (!override)
@@ -17481,10 +17884,10 @@ ${content.slice(firstUseIdx)}`;
       restoreTracePhase();
       return;
     }
-    const traceDir = join25(buildPath2, ".absolute-trace");
+    const traceDir = join26(buildPath2, ".absolute-trace");
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    mkdirSync11(traceDir, { recursive: true });
-    writeFileSync7(join25(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
+    mkdirSync12(traceDir, { recursive: true });
+    writeFileSync8(join26(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
       events: traceEvents,
       frameworks: traceFrameworkNames,
       generatedAt: new Date().toISOString(),
@@ -17515,15 +17918,15 @@ ${content.slice(firstUseIdx)}`;
   const stylesPath = typeof stylesConfig === "string" ? stylesConfig : stylesConfig?.path;
   const stylesIgnore = typeof stylesConfig === "object" ? stylesConfig.ignore : undefined;
   const stylesDir = stylesPath && validateSafePath(stylesPath, projectRoot);
-  const reactIndexesPath = reactDir && join25(getFrameworkGeneratedDir("react"), "indexes");
-  const reactPagesPath = reactDir && join25(reactDir, "pages");
-  const htmlPagesPath = htmlDir && join25(htmlDir, "pages");
-  const htmlScriptsPath = htmlDir && join25(htmlDir, "scripts");
-  const sveltePagesPath = svelteDir && join25(svelteDir, "pages");
-  const vuePagesPath = vueDir && join25(vueDir, "pages");
-  const htmxPagesPath = htmxDir && join25(htmxDir, "pages");
-  const angularPagesPath = angularDir && join25(angularDir, "pages");
-  const emberPagesPath = emberDir && join25(emberDir, "pages");
+  const reactIndexesPath = reactDir && join26(getFrameworkGeneratedDir("react"), "indexes");
+  const reactPagesPath = reactDir && join26(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join26(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join26(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join26(svelteDir, "pages");
+  const vuePagesPath = vueDir && join26(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join26(htmxDir, "pages");
+  const angularPagesPath = angularDir && join26(angularDir, "pages");
+  const emberPagesPath = emberDir && join26(emberDir, "pages");
   const frontends = [
     reactDir,
     htmlDir,
@@ -17554,7 +17957,7 @@ ${content.slice(firstUseIdx)}`;
   const sourceClientRoots = [
     htmlDir,
     htmxDir,
-    islandBootstrapPath && dirname15(islandBootstrapPath)
+    islandBootstrapPath && dirname16(islandBootstrapPath)
   ].filter((dir) => Boolean(dir));
   const usesGenerated = Boolean(reactDir) || Boolean(svelteDir) || Boolean(vueDir) || Boolean(angularDir);
   if (usesGenerated)
@@ -17582,26 +17985,26 @@ ${content.slice(firstUseIdx)}`;
     const [firstEntry] = serverDirMap;
     if (!firstEntry)
       throw new Error("Expected at least one server directory entry");
-    serverRoot = join25(firstEntry.dir, firstEntry.subdir);
-    serverOutDir = join25(buildPath, basename8(firstEntry.dir));
+    serverRoot = join26(firstEntry.dir, firstEntry.subdir);
+    serverOutDir = join26(buildPath, basename9(firstEntry.dir));
   } else if (serverDirMap.length > 1) {
     serverRoot = commonAncestor(serverDirMap.map((entry) => entry.dir), projectRoot);
     serverOutDir = buildPath;
   }
   const publicPath = publicDirectory && validateSafePath(publicDirectory, projectRoot);
-  await tracePhase("build-dir/create", () => mkdirSync11(buildPath, { recursive: true }));
+  await tracePhase("build-dir/create", () => mkdirSync12(buildPath, { recursive: true }));
   if (publicPath)
     await tracePhase("public/copy", () => cpSync(publicPath, buildPath, { force: true, recursive: true }));
   const filterToIncrementalEntries = (entryPoints, mapToSource) => {
     if (!isIncremental || !incrementalFiles)
       return entryPoints;
-    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve24(f2)));
+    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve25(f2)));
     const matchingEntries = [];
     for (const entry of entryPoints) {
       const sourceFile = mapToSource(entry);
       if (!sourceFile)
         continue;
-      if (!normalizedIncremental.has(resolve24(sourceFile)))
+      if (!normalizedIncremental.has(resolve25(sourceFile)))
         continue;
       matchingEntries.push(entry);
     }
@@ -17611,7 +18014,7 @@ ${content.slice(firstUseIdx)}`;
     await tracePhase("react/index-generation", () => generateReactIndexFiles(reactPagesPath, reactIndexesPath, hmr));
   }
   if (assetsPath && (!isIncremental || normalizedIncrementalFiles?.some((f2) => f2.includes("/assets/")))) {
-    await tracePhase("assets/copy", () => cpSync(assetsPath, join25(buildPath, "assets"), {
+    await tracePhase("assets/copy", () => cpSync(assetsPath, join26(buildPath, "assets"), {
       force: true,
       recursive: true
     }));
@@ -17721,11 +18124,11 @@ ${content.slice(firstUseIdx)}`;
     }
   }
   if (htmlDefaults.error || htmlDefaults.notFound || htmlDefaults.loading || Object.keys(htmlPages).length > 0) {
-    const htmlConventionsOutDir = join25(buildPath, "conventions", "html");
-    mkdirSync11(htmlConventionsOutDir, { recursive: true });
+    const htmlConventionsOutDir = join26(buildPath, "conventions", "html");
+    mkdirSync12(htmlConventionsOutDir, { recursive: true });
     const htmlPathRemap = new Map;
     for (const sourcePath of htmlConventionSources) {
-      const dest = join25(htmlConventionsOutDir, basename8(sourcePath));
+      const dest = join26(htmlConventionsOutDir, basename9(sourcePath));
       cpSync(sourcePath, dest, { force: true });
       htmlPathRemap.set(sourcePath, dest);
     }
@@ -17766,9 +18169,9 @@ ${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(resolve24(reactIndexesPath))) {
-      const pageName = basename8(entry, ".tsx");
-      return join25(reactPagesPath, `${pageName}.tsx`);
+    if (entry.startsWith(resolve25(reactIndexesPath))) {
+      const pageName = basename9(entry, ".tsx");
+      return join26(reactPagesPath, `${pageName}.tsx`);
     }
     return null;
   }) : allReactEntries;
@@ -17828,14 +18231,14 @@ ${content.slice(firstUseIdx)}`;
         try {
           const { primeComponentFingerprint: primeComponentFingerprint2 } = await Promise.resolve().then(() => (init_fastHmrCompiler(), exports_fastHmrCompiler));
           const { readdir: readdir4 } = await import("fs/promises");
-          const { join: join26 } = await import("path");
+          const { join: join27 } = await import("path");
           const walk = async (dir) => {
             const entries = await readdir4(dir, {
               withFileTypes: true
             });
             const out = [];
             for (const entry of entries) {
-              const full = join26(dir, entry.name);
+              const full = join27(dir, entry.name);
               if (entry.isDirectory()) {
                 out.push(...await walk(full));
               } else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
@@ -17873,7 +18276,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandSvelteClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandSvelteClientPathMap.set(resolve24(sourcePath), clientPath);
+    islandSvelteClientPathMap.set(resolve25(sourcePath), clientPath);
   }
   const islandVueClientPathMap = new Map;
   for (let idx = 0;idx < islandVueSources.length; idx++) {
@@ -17881,7 +18284,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandVueClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandVueClientPathMap.set(resolve24(sourcePath), clientPath);
+    islandVueClientPathMap.set(resolve25(sourcePath), clientPath);
   }
   const islandAngularClientPathMap = new Map;
   for (let idx = 0;idx < islandAngularSources.length; idx++) {
@@ -17889,7 +18292,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandAngularClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandAngularClientPathMap.set(resolve24(sourcePath), clientPath);
+    islandAngularClientPathMap.set(resolve25(sourcePath), clientPath);
   }
   const reactConventionSources = collectConventionSourceFiles(conventionsMap.react);
   const svelteConventionSources = collectConventionSourceFiles(conventionsMap.svelte);
@@ -17900,9 +18303,9 @@ ${content.slice(firstUseIdx)}`;
     const compileReactConventions = async () => {
       if (reactConventionSources.length === 0)
         return emptyStringArray;
-      const destDir = join25(buildPath, "conventions", "react");
+      const destDir = join26(buildPath, "conventions", "react");
       rmSync2(destDir, { force: true, recursive: true });
-      mkdirSync11(destDir, { recursive: true });
+      mkdirSync12(destDir, { recursive: true });
       const destPaths = [];
       for (let idx = 0;idx < reactConventionSources.length; idx++) {
         const source = reactConventionSources[idx];
@@ -17916,7 +18319,7 @@ ${content.slice(firstUseIdx)}`;
           naming: `${idx}-[name].[ext]`,
           outdir: destDir,
           plugins: [stylePreprocessorPlugin2],
-          root: dirname15(source),
+          root: dirname16(source),
           target: "bun",
           throw: false,
           tsconfig: "./tsconfig.json"
@@ -17944,15 +18347,15 @@ ${content.slice(firstUseIdx)}`;
       angularConventionSources.length > 0 && angularDir ? tracePhase("compile/convention-angular", () => Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular)).then((mod) => mod.compileAngular(angularConventionSources, angularDir, hmr, styleTransformConfig))) : { serverPaths: emptyStringArray }
     ]);
     const bundleConventionFiles = async (framework, compiledPaths) => {
-      const destDir = join25(buildPath, "conventions", framework);
+      const destDir = join26(buildPath, "conventions", framework);
       rmSync2(destDir, { force: true, recursive: true });
-      mkdirSync11(destDir, { recursive: true });
+      mkdirSync12(destDir, { recursive: true });
       const destPaths = [];
       for (let idx = 0;idx < compiledPaths.length; idx++) {
         const compiledPath = compiledPaths[idx];
         if (!compiledPath)
           continue;
-        const name = basename8(compiledPath).replace(/\.[^.]+$/, "");
+        const name = basename9(compiledPath).replace(/\.[^.]+$/, "");
         const result = await bunBuild7({
           entrypoints: [compiledPath],
           format: "esm",
@@ -18018,7 +18421,7 @@ ${content.slice(firstUseIdx)}`;
     }
   })) : {
     entries: [],
-    generatedRoot: join25(buildPath, "_island_entries")
+    generatedRoot: join26(buildPath, "_island_entries")
   };
   const islandClientEntryPoints = islandEntryResult.entries.map((entry) => entry.entryPath);
   if (serverEntryPoints.length === 0 && reactClientEntryPoints.length === 0 && nonReactClientEntryPoints.length === 0 && islandClientEntryPoints.length === 0 && htmxDir === undefined && htmlDir === undefined) {
@@ -18054,7 +18457,7 @@ ${content.slice(firstUseIdx)}`;
     return {};
   }
   if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
-    const refreshEntry = join25(reactIndexesPath, "_refresh.tsx");
+    const refreshEntry = join26(reactIndexesPath, "_refresh.tsx");
     if (!reactClientEntryPoints.includes(refreshEntry))
       reactClientEntryPoints.push(refreshEntry);
   }
@@ -18156,19 +18559,19 @@ ${content.slice(firstUseIdx)}`;
     throw: false
   }, resolveBunBuildOverride(bunBuildConfig, "reactClient")) : undefined;
   if (reactDir && reactClientEntryPoints.length > 0) {
-    rmSync2(join25(buildPath, "react", "generated", "indexes"), {
+    rmSync2(join26(buildPath, "react", "generated", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (angularDir && angularClientPaths.length > 0) {
-    rmSync2(join25(buildPath, "angular", "indexes"), {
+    rmSync2(join26(buildPath, "angular", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (islandClientEntryPoints.length > 0) {
-    rmSync2(join25(buildPath, "islands"), {
+    rmSync2(join26(buildPath, "islands"), {
       force: true,
       recursive: true
     });
@@ -18188,8 +18591,14 @@ ${content.slice(firstUseIdx)}`;
       format: "esm",
       naming: `[dir]/[name].[hash].[ext]`,
       outdir: serverOutDir,
-      plugins: [stylePreprocessorPlugin2],
+      plugins: [
+        stylePreprocessorPlugin2,
+        ...serverOutDir ? [
+          createExternalAssetPlugin(serverOutDir, allFrameworkDirs)
+        ] : []
+      ],
       root: serverRoot,
+      sourcemap: isDev ? "inline" : "none",
       target: "bun",
       throw: false,
       tsconfig: "./tsconfig.json"
@@ -18251,7 +18660,7 @@ ${content.slice(firstUseIdx)}`;
     globalCssEntries.length > 0 ? tracePhase("bun/global-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: globalCssEntries,
       naming: `[dir]/[name].[hash].[ext]`,
-      outdir: stylesDir ? join25(buildPath, basename8(stylesDir)) : buildPath,
+      outdir: stylesDir ? join26(buildPath, basename9(stylesDir)) : buildPath,
       plugins: [stylePreprocessorPlugin2],
       root: stylesDir || clientRoot,
       target: "browser",
@@ -18260,13 +18669,20 @@ ${content.slice(firstUseIdx)}`;
     vueCssPaths.length > 0 ? tracePhase("bun/vue-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: vueCssPaths,
       naming: `[name].[hash].[ext]`,
-      outdir: join25(buildPath, assetsPath ? basename8(assetsPath) : "assets", "css"),
+      outdir: join26(buildPath, assetsPath ? basename9(assetsPath) : "assets", "css"),
       target: "browser",
       throw: false
     }, resolveBunBuildOverride(bunBuildConfig, "vueCss")))) : undefined
   ]);
   const serverLogs = serverResult?.logs ?? [];
   const serverOutputs = serverResult?.outputs ?? [];
+  if (isDev && serverResult?.success) {
+    const { chainBundleInlineSourcemap: chainBundleInlineSourcemap2 } = await Promise.resolve().then(() => (init_chainInlineSourcemaps(), exports_chainInlineSourcemaps));
+    for (const out of serverOutputs) {
+      if (out.path.endsWith(".js"))
+        chainBundleInlineSourcemap2(out.path);
+    }
+  }
   if (serverResult && !serverResult.success && serverLogs.length > 0) {
     extractBuildError(serverLogs, "server", "Server", frameworkNames, isIncremental, throwOnError);
   }
@@ -18327,7 +18743,7 @@ ${content.slice(firstUseIdx)}`;
   if (serverOutputs.length > 0 && angularServerVendorPaths2 && Object.keys(angularServerVendorPaths2).length > 0) {
     const { rewriteBuildOutputsWith: rewriteBuildOutputsWith2 } = await Promise.resolve().then(() => (init_rewriteImportsPlugin(), exports_rewriteImportsPlugin));
     await tracePhase("postprocess/server-angular-vendor-imports", () => rewriteBuildOutputsWith2(serverOutputs, (artifact) => {
-      const fileDir = dirname15(artifact.path);
+      const fileDir = dirname16(artifact.path);
       const relativePaths = {};
       for (const [specifier, absolute] of Object.entries(angularServerVendorPaths2)) {
         const rel = relative13(fileDir, absolute);
@@ -18386,23 +18802,26 @@ ${content.slice(firstUseIdx)}`;
   for (const artifact of serverOutputs) {
     if (extname8(artifact.path) !== ".js")
       continue;
-    const fileWithHash = basename8(artifact.path);
+    const fileWithHash = basename9(artifact.path);
     const [baseName] = fileWithHash.split(`.${artifact.hash}.`);
     if (!baseName)
       continue;
     manifest[toPascal(baseName)] = artifact.path;
   }
   for (const serverPath of emberServerPaths) {
-    const fileBase = basename8(serverPath, ".js");
+    const fileBase = basename9(serverPath, ".js");
     manifest[toPascal(fileBase)] = serverPath;
   }
   if (skipAngularClientBundle) {
     for (const clientPath of angularClientPaths) {
-      const fileBase = basename8(clientPath, ".js");
+      const fileBase = basename9(clientPath, ".js");
       const relFromCwd = relative13(projectRoot, clientPath).replace(/\\/g, "/");
       manifest[`${toPascal(fileBase)}Index`] = `/@src/${relFromCwd}`;
     }
   }
+  const warnManifestKeyCollision = (key, previousPath, nextPath) => {
+    logWarn(`Manifest key collision: "${key}" was "${previousPath}" and will be overwritten by "${nextPath}". Rename one of the conflicting pages so each manifest key is unique across html/htmx (and other framework) directories.`);
+  };
   const shouldCopyHtmx = !isIncremental || normalizedIncrementalFiles?.some((f2) => f2.includes("/htmx/") && f2.endsWith(".html"));
   const shouldUpdateHtmlAssetPaths = !isIncremental || normalizedIncrementalFiles?.some((f2) => f2.includes("/html/") && (f2.endsWith(".html") || isStylePath(f2)));
   const shouldUpdateHtmxAssetPaths = !isIncremental || normalizedIncrementalFiles?.some((f2) => f2.includes("/htmx/") && (f2.endsWith(".html") || isStylePath(f2)));
@@ -18410,19 +18829,19 @@ ${content.slice(firstUseIdx)}`;
   const injectHMRIntoHTMLFile = (filePath, framework) => {
     if (!hmrClientBundle)
       return;
-    let html = readFileSync13(filePath, "utf-8");
+    let html = readFileSync14(filePath, "utf-8");
     if (html.includes("data-hmr-client"))
       return;
     const tag = `<script>window.__HMR_FRAMEWORK__="${framework}";</script><script data-hmr-client>${hmrClientBundle}</script>`;
     const bodyClose = /<\/body\s*>/i.exec(html);
     html = bodyClose ? html.slice(0, bodyClose.index) + tag + html.slice(bodyClose.index) : html + tag;
-    writeFileSync7(filePath, html);
+    writeFileSync8(filePath, html);
   };
   const processHtmlPages = async () => {
     if (!(htmlDir && htmlPagesPath))
       return;
-    const outputHtmlPages = isSingle ? join25(buildPath, "pages") : join25(buildPath, basename8(htmlDir), "pages");
-    mkdirSync11(outputHtmlPages, { recursive: true });
+    const outputHtmlPages = isSingle ? join26(buildPath, "pages") : join26(buildPath, basename9(htmlDir), "pages");
+    mkdirSync12(outputHtmlPages, { recursive: true });
     cpSync(htmlPagesPath, outputHtmlPages, {
       force: true,
       recursive: true
@@ -18436,21 +18855,24 @@ ${content.slice(firstUseIdx)}`;
     for (const htmlFile of htmlPageFiles) {
       if (hmr)
         injectHMRIntoHTMLFile(htmlFile, "html");
-      const fileName = basename8(htmlFile, ".html");
+      const fileName = basename9(htmlFile, ".html");
+      if (manifest[fileName] && manifest[fileName] !== htmlFile) {
+        warnManifestKeyCollision(fileName, manifest[fileName], htmlFile);
+      }
       manifest[fileName] = htmlFile;
     }
   };
   const processHtmxPages = async () => {
     if (!(htmxDir && htmxPagesPath))
       return;
-    const outputHtmxPages = isSingle ? join25(buildPath, "pages") : join25(buildPath, basename8(htmxDir), "pages");
-    mkdirSync11(outputHtmxPages, { recursive: true });
+    const outputHtmxPages = isSingle ? join26(buildPath, "pages") : join26(buildPath, basename9(htmxDir), "pages");
+    mkdirSync12(outputHtmxPages, { recursive: true });
     cpSync(htmxPagesPath, outputHtmxPages, {
       force: true,
       recursive: true
     });
     if (shouldCopyHtmx) {
-      const htmxDestDir = isSingle ? buildPath : join25(buildPath, basename8(htmxDir));
+      const htmxDestDir = isSingle ? buildPath : join26(buildPath, basename9(htmxDir));
       copyHtmxVendor(htmxDir, htmxDestDir);
     }
     if (shouldUpdateHtmxAssetPaths) {
@@ -18462,7 +18884,10 @@ ${content.slice(firstUseIdx)}`;
     for (const htmxFile of htmxPageFiles) {
       if (hmr)
         injectHMRIntoHTMLFile(htmxFile, "htmx");
-      const fileName = basename8(htmxFile, ".html");
+      const fileName = basename9(htmxFile, ".html");
+      if (manifest[fileName] && manifest[fileName] !== htmxFile) {
+        warnManifestKeyCollision(fileName, manifest[fileName], htmxFile);
+      }
       manifest[fileName] = htmxFile;
     }
   };
@@ -18512,9 +18937,9 @@ ${content.slice(firstUseIdx)}`;
     writeBuildTrace(buildPath);
     return { conventions: conventionsMap, manifest };
   }
-  writeFileSync7(join25(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
+  writeFileSync8(join26(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
   if (Object.keys(conventionsMap).length > 0) {
-    writeFileSync7(join25(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
+    writeFileSync8(join26(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
   }
   writeBuildTrace(buildPath);
   if (tailwind && mode === "production") {
@@ -18547,6 +18972,7 @@ var init_build = __esm(() => {
   init_rewriteReactImports();
   init_telemetryEvent();
   init_angularLinkerPlugin();
+  init_externalAssetPlugin();
   init_hmrInjectionPlugin();
   init_cleanStaleOutputs();
   init_cleanup();
@@ -18614,8 +19040,8 @@ var init_build = __esm(() => {
 });
 
 // src/build/buildEmberVendor.ts
-import { mkdirSync as mkdirSync12, existsSync as existsSync21 } from "fs";
-import { join as join26 } from "path";
+import { mkdirSync as mkdirSync13, existsSync as existsSync22 } from "fs";
+import { join as join27 } from "path";
 import { rm as rm9 } from "fs/promises";
 var {build: bunBuild8 } = globalThis.Bun;
 var toSafeFileName5 = (specifier) => specifier.replace(/^@/, "").replace(/\//g, "_"), generateMacrosShim = () => `// Generated shim for @embroider/macros \u2014 provides minimal runtime
@@ -18667,8 +19093,8 @@ export const importSync = (specifier) => {
   if (standaloneSpecifiers.has(specifier)) {
     return { resolveTo: specifier, specifier };
   }
-  const emberInternalPath = join26(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
-  if (!existsSync21(emberInternalPath)) {
+  const emberInternalPath = join27(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
+  if (!existsSync22(emberInternalPath)) {
     throw new Error(`Ember vendor build: cannot find ${specifier} at ${emberInternalPath}. ` + `Is ember-source installed and at least 6.12?`);
   }
   return { resolveTo: emberInternalPath, specifier };
@@ -18699,24 +19125,24 @@ export const importSync = (specifier) => {
       if (standalonePackages.has(args.path)) {
         return;
       }
-      const internal = join26(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
-      if (existsSync21(internal)) {
+      const internal = join27(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      if (existsSync22(internal)) {
         return { path: internal };
       }
       return;
     });
   }
 }), buildEmberVendor = async (buildDir, cwd2 = process.cwd()) => {
-  const vendorDir = join26(buildDir, "ember", "vendor");
-  mkdirSync12(vendorDir, { recursive: true });
-  const tmpDir = join26(buildDir, "_ember_vendor_tmp");
-  mkdirSync12(tmpDir, { recursive: true });
-  const macrosShimPath = join26(tmpDir, "embroider_macros_shim.js");
+  const vendorDir = join27(buildDir, "ember", "vendor");
+  mkdirSync13(vendorDir, { recursive: true });
+  const tmpDir = join27(buildDir, "_ember_vendor_tmp");
+  mkdirSync13(tmpDir, { recursive: true });
+  const macrosShimPath = join27(tmpDir, "embroider_macros_shim.js");
   await Bun.write(macrosShimPath, generateMacrosShim());
   const resolutions = REQUIRED_EMBER_SPECIFIERS.map((specifier) => resolveEmberSpecifier(specifier, cwd2));
   const entrypoints = await Promise.all(resolutions.map(async (resolution) => {
     const safeName = toSafeFileName5(resolution.specifier);
-    const entryPath = join26(tmpDir, `${safeName}.js`);
+    const entryPath = join27(tmpDir, `${safeName}.js`);
     const source = resolution.specifier === "@embroider/macros" ? `export * from ${JSON.stringify(macrosShimPath)};
 ` : generateVendorEntrySource2(resolution);
     await Bun.write(entryPath, source);
@@ -18769,9 +19195,9 @@ __export(exports_dependencyGraph, {
   buildInitialDependencyGraph: () => buildInitialDependencyGraph,
   addFileToGraph: () => addFileToGraph
 });
-import { existsSync as existsSync22, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync15 } from "fs";
 var {Glob: Glob9 } = globalThis.Bun;
-import { resolve as resolve25 } from "path";
+import { resolve as resolve26 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
   const lower = filePath.toLowerCase();
   if (lower.endsWith(".ts") || lower.endsWith(".tsx") || lower.endsWith(".jsx"))
@@ -18785,8 +19211,8 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
     return null;
   }
-  const fromDir = resolve25(fromFile, "..");
-  const normalized = resolve25(fromDir, importPath);
+  const fromDir = resolve26(fromFile, "..");
+  const normalized = resolve26(fromDir, importPath);
   const extensions = [
     ".ts",
     ".tsx",
@@ -18799,10 +19225,10 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   ];
   for (const ext of extensions) {
     const withExt = normalized + ext;
-    if (existsSync22(withExt))
+    if (existsSync23(withExt))
       return withExt;
   }
-  if (existsSync22(normalized))
+  if (existsSync23(normalized))
     return normalized;
   return null;
 }, clearExistingDependents = (graph, normalizedPath) => {
@@ -18816,8 +19242,8 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     dependents.delete(normalizedPath);
   }
 }, addFileToGraph = (graph, filePath) => {
-  const normalizedPath = resolve25(filePath);
-  if (!existsSync22(normalizedPath))
+  const normalizedPath = resolve26(filePath);
+  if (!existsSync23(normalizedPath))
     return;
   const dependencies = extractDependencies(normalizedPath);
   clearExistingDependents(graph, normalizedPath);
@@ -18843,10 +19269,10 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
 }, IGNORED_SEGMENTS, buildInitialDependencyGraph = (graph, directories) => {
   const processedFiles = new Set;
   const glob = new Glob9("**/*.{ts,tsx,js,jsx,vue,svelte,html,htm}");
-  const resolvedDirs = directories.map((dir) => resolve25(dir)).filter((dir) => existsSync22(dir));
+  const resolvedDirs = directories.map((dir) => resolve26(dir)).filter((dir) => existsSync23(dir));
   const allFiles = resolvedDirs.flatMap((dir) => Array.from(glob.scanSync({ absolute: true, cwd: dir })));
   for (const file4 of allFiles) {
-    const fullPath = resolve25(file4);
+    const fullPath = resolve26(file4);
     if (IGNORED_SEGMENTS.some((seg) => fullPath.includes(seg)))
       continue;
     if (processedFiles.has(fullPath))
@@ -18940,15 +19366,15 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   const lowerPath = filePath.toLowerCase();
   const isSvelteOrVue = lowerPath.endsWith(".svelte") || lowerPath.endsWith(".vue");
   if (loader === "html") {
-    const content = readFileSync14(filePath, "utf-8");
+    const content = readFileSync15(filePath, "utf-8");
     return extractHtmlDependencies(filePath, content);
   }
   if (loader === "tsx" || loader === "js") {
-    const content = readFileSync14(filePath, "utf-8");
+    const content = readFileSync15(filePath, "utf-8");
     return extractJsDependencies(filePath, content, loader);
   }
   if (isSvelteOrVue) {
-    const content = readFileSync14(filePath, "utf-8");
+    const content = readFileSync15(filePath, "utf-8");
     return extractSvelteVueDependencies(filePath, content);
   }
   return [];
@@ -18959,7 +19385,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     return [];
   }
 }, getAffectedFiles = (graph, changedFile) => {
-  const normalizedPath = resolve25(changedFile);
+  const normalizedPath = resolve26(changedFile);
   const affected = new Set;
   const toProcess = [normalizedPath];
   const processNode = (current) => {
@@ -18990,7 +19416,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
 }, removeDependentsForFile = (graph, normalizedPath) => {
   graph.dependents.delete(normalizedPath);
 }, removeFileFromGraph = (graph, filePath) => {
-  const normalizedPath = resolve25(filePath);
+  const normalizedPath = resolve26(filePath);
   removeDepsForFile(graph, normalizedPath);
   removeDependentsForFile(graph, normalizedPath);
 };
@@ -19033,12 +19459,12 @@ var globalVersionCounter = 0, createModuleVersionTracker = () => new Map, getNex
 };
 
 // src/dev/configResolver.ts
-import { resolve as resolve26 } from "path";
+import { resolve as resolve27 } from "path";
 var resolveBuildPaths = (config) => {
   const cwd2 = process.cwd();
   const normalize = (path) => path.replace(/\\/g, "/");
-  const withDefault = (value, fallback) => normalize(resolve26(cwd2, value ?? fallback));
-  const optional = (value) => value ? normalize(resolve26(cwd2, value)) : undefined;
+  const withDefault = (value, fallback) => normalize(resolve27(cwd2, value ?? fallback));
+  const optional = (value) => value ? normalize(resolve27(cwd2, value)) : undefined;
   return {
     angularDir: optional(config.angularDirectory),
     assetsDir: optional(config.assetsDirectory),
@@ -19091,8 +19517,8 @@ var init_clientManager = __esm(() => {
 });
 
 // src/dev/pathUtils.ts
-import { existsSync as existsSync23, readdirSync, readFileSync as readFileSync15 } from "fs";
-import { dirname as dirname16, resolve as resolve27 } from "path";
+import { existsSync as existsSync24, readdirSync, readFileSync as readFileSync16 } from "fs";
+import { dirname as dirname17, resolve as resolve28 } from "path";
 var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   if (shouldIgnorePath(filePath, resolved)) {
     return "ignored";
@@ -19168,7 +19594,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   return "unknown";
 }, collectAngularResourceDirs = (angularDir) => {
   const out = new Set;
-  const angularRoot = resolve27(angularDir);
+  const angularRoot = resolve28(angularDir);
   const angularRootNormalized = normalizePath(angularRoot);
   const walk = (dir) => {
     let entries;
@@ -19181,7 +19607,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const full = resolve27(dir, entry.name);
+      const full = resolve28(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
         continue;
@@ -19191,7 +19617,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
       }
       let source;
       try {
-        source = readFileSync15(full, "utf8");
+        source = readFileSync16(full, "utf8");
       } catch {
         continue;
       }
@@ -19220,10 +19646,10 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
             refs.push(strMatch[1]);
         }
       }
-      const componentDir = dirname16(full);
+      const componentDir = dirname17(full);
       for (const ref of refs) {
-        const refAbs = normalizePath(resolve27(componentDir, ref));
-        const refDir = normalizePath(dirname16(refAbs));
+        const refAbs = normalizePath(resolve28(componentDir, ref));
+        const refDir = normalizePath(dirname17(refAbs));
         if (refDir === angularRootNormalized || refDir.startsWith(angularRootNormalized + "/")) {
           continue;
         }
@@ -19239,7 +19665,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   const push = (path) => {
     if (!path)
       return;
-    const abs = normalizePath(resolve27(cwd2, path));
+    const abs = normalizePath(resolve28(cwd2, path));
     if (!roots.includes(abs))
       roots.push(abs);
   };
@@ -19264,8 +19690,8 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   push(cfg.assetsDir);
   push(cfg.stylesDir);
   for (const candidate of ["src", "db", "assets", "styles"]) {
-    const abs = normalizePath(resolve27(cwd2, candidate));
-    if (existsSync23(abs) && !roots.includes(abs))
+    const abs = normalizePath(resolve28(cwd2, candidate));
+    if (existsSync24(abs) && !roots.includes(abs))
       roots.push(abs);
   }
   try {
@@ -19276,7 +19702,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
         continue;
       if (entry.name.startsWith("."))
         continue;
-      const abs = normalizePath(resolve27(cwd2, entry.name));
+      const abs = normalizePath(resolve28(cwd2, entry.name));
       if (roots.includes(abs))
         continue;
       if (shouldIgnorePath(abs, resolved))
@@ -19350,8 +19776,8 @@ var init_pathUtils = __esm(() => {
 
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
-import { existsSync as existsSync24, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
-import { dirname as dirname17, join as join27, resolve as resolve28 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync2, statSync as statSync4 } from "fs";
+import { dirname as dirname18, join as join28, resolve as resolve29 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -19384,10 +19810,10 @@ var safeRemoveFromGraph = (graph, fullPath) => {
     for (const name of entries) {
       if (shouldSkipFilename(name, isStylesDir))
         continue;
-      const child = join27(eventDir, name).replace(/\\/g, "/");
+      const child = join28(eventDir, name).replace(/\\/g, "/");
       let st2;
       try {
-        st2 = statSync3(child);
+        st2 = statSync4(child);
       } catch {
         continue;
       }
@@ -19409,21 +19835,21 @@ var safeRemoveFromGraph = (graph, fullPath) => {
       return;
     if (shouldSkipFilename(filename, isStylesDir)) {
       if (event === "rename") {
-        const eventDir = dirname17(join27(absolutePath, filename)).replace(/\\/g, "/");
+        const eventDir = dirname18(join28(absolutePath, filename)).replace(/\\/g, "/");
         atomicRecoveryScan(eventDir);
       }
       return;
     }
-    const fullPath = join27(absolutePath, filename).replace(/\\/g, "/");
+    const fullPath = join28(absolutePath, filename).replace(/\\/g, "/");
     if (shouldIgnorePath(fullPath, state.resolvedPaths)) {
       return;
     }
-    if (event === "rename" && !existsSync24(fullPath)) {
+    if (event === "rename" && !existsSync25(fullPath)) {
       safeRemoveFromGraph(state.dependencyGraph, fullPath);
       onFileChange(fullPath);
       return;
     }
-    if (existsSync24(fullPath)) {
+    if (existsSync25(fullPath)) {
       onFileChange(fullPath);
       safeAddToGraph(state.dependencyGraph, fullPath);
     }
@@ -19432,8 +19858,8 @@ var safeRemoveFromGraph = (graph, fullPath) => {
 }, addFileWatchers = (state, paths, onFileChange) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
-    const absolutePath = resolve28(path).replace(/\\/g, "/");
-    if (!existsSync24(absolutePath)) {
+    const absolutePath = resolve29(path).replace(/\\/g, "/");
+    if (!existsSync25(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -19443,8 +19869,8 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const watchPaths = getWatchPaths(config, state.resolvedPaths);
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
-    const absolutePath = resolve28(path).replace(/\\/g, "/");
-    if (!existsSync24(absolutePath)) {
+    const absolutePath = resolve29(path).replace(/\\/g, "/");
+    if (!existsSync25(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -19457,19 +19883,18 @@ var init_fileWatcher = __esm(() => {
   init_pathUtils();
   ATOMIC_WRITE_TEMP_PATTERNS = [
     /(^|\/)sed[A-Za-z0-9]{6,}$/,
-    /(^|\/)4913$/,
-    /(^|\/)\.absolutejs-hmr-/
+    /(^|\/)4913$/
   ];
 });
 
 // src/dev/assetStore.ts
-import { resolve as resolve29 } from "path";
+import { resolve as resolve30 } 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 = resolve29(dir, entry.name);
+  const fullPath = resolve30(dir, entry.name);
   if (entry.isDirectory()) {
     return walkAndClean(fullPath);
   }
@@ -19485,10 +19910,10 @@ var mimeTypes, getMimeType = (filePath) => {
 }, cleanStaleAssets = async (store, manifest, buildDir) => {
   const liveByIdentity = new Map;
   for (const webPath of store.keys()) {
-    const diskPath = resolve29(buildDir, webPath.slice(1));
+    const diskPath = resolve30(buildDir, webPath.slice(1));
     liveByIdentity.set(stripHash(diskPath), diskPath);
   }
-  const absBuildDir = resolve29(buildDir);
+  const absBuildDir = resolve30(buildDir);
   Object.values(manifest).forEach((val) => {
     if (!HASHED_FILE_RE.test(val))
       return;
@@ -19506,7 +19931,7 @@ var mimeTypes, getMimeType = (filePath) => {
   } catch {}
 }, lookupAsset = (store, path) => store.get(path), processScanEntry = (entry, dir, prefix, store, scanDir) => {
   if (entry.isDirectory()) {
-    return scanDir(resolve29(dir, entry.name), `${prefix}${entry.name}/`);
+    return scanDir(resolve30(dir, entry.name), `${prefix}${entry.name}/`);
   }
   if (!entry.name.startsWith("chunk-")) {
     return null;
@@ -19515,7 +19940,7 @@ var mimeTypes, getMimeType = (filePath) => {
   if (store.has(webPath)) {
     return null;
   }
-  return Bun.file(resolve29(dir, entry.name)).bytes().then((bytes) => {
+  return Bun.file(resolve30(dir, entry.name)).bytes().then((bytes) => {
     store.set(webPath, bytes);
     return;
   }).catch(() => {});
@@ -19537,7 +19962,7 @@ var mimeTypes, getMimeType = (filePath) => {
   for (const webPath of newIdentities.values()) {
     if (store.has(webPath))
       continue;
-    loadPromises.push(Bun.file(resolve29(buildDir, webPath.slice(1))).bytes().then((bytes) => {
+    loadPromises.push(Bun.file(resolve30(buildDir, webPath.slice(1))).bytes().then((bytes) => {
       store.set(webPath, bytes);
       return;
     }).catch(() => {}));
@@ -19567,8 +19992,8 @@ var init_assetStore = __esm(() => {
 });
 
 // src/islands/pageMetadata.ts
-import { readFileSync as readFileSync16 } from "fs";
-import { dirname as dirname18, resolve as resolve30 } from "path";
+import { readFileSync as readFileSync17 } from "fs";
+import { dirname as dirname19, resolve as resolve31 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
   { dir: config.emberDirectory, framework: "ember" },
@@ -19588,15 +20013,15 @@ var pagePatterns, getPageDirs = (config) => [
     const source = definition.buildReference?.source;
     if (!source)
       continue;
-    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve30(dirname18(buildInfo.resolvedRegistryPath), source);
-    lookup.set(`${definition.framework}:${definition.component}`, resolve30(resolvedSource));
+    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve31(dirname19(buildInfo.resolvedRegistryPath), source);
+    lookup.set(`${definition.framework}:${definition.component}`, resolve31(resolvedSource));
   }
   return lookup;
 }, getCurrentPageIslandMetadata = () => globalThis.__absolutePageIslandMetadata ?? new Map, metadataUsesSource = (metadata, target) => metadata.islands.some((usage) => {
   const candidate = usage.source;
-  return candidate ? resolve30(candidate) === target : false;
+  return candidate ? resolve31(candidate) === target : false;
 }), getPagesUsingIslandSource = (sourcePath) => {
-  const target = resolve30(sourcePath);
+  const target = resolve31(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}`);
@@ -19608,13 +20033,13 @@ var pagePatterns, getPageDirs = (config) => [
   const pattern = pagePatterns[entry.framework];
   if (!pattern)
     return;
-  const files = await scanEntryPoints(resolve30(entry.dir), pattern);
+  const files = await scanEntryPoints(resolve31(entry.dir), pattern);
   for (const filePath of files) {
-    const source = readFileSync16(filePath, "utf-8");
+    const source = readFileSync17(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
-    pageMetadata.set(resolve30(filePath), {
+    pageMetadata.set(resolve31(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
-      pagePath: resolve30(filePath)
+      pagePath: resolve31(filePath)
     });
   }
 }, loadPageIslandMetadata = async (config) => {
@@ -19641,10 +20066,10 @@ var init_pageMetadata = __esm(() => {
 });
 
 // src/dev/fileHashTracker.ts
-import { readFileSync as readFileSync17 } from "fs";
+import { readFileSync as readFileSync18 } from "fs";
 var computeFileHash = (filePath) => {
   try {
-    const fileContent = readFileSync17(filePath);
+    const fileContent = readFileSync18(filePath);
     return Number(Bun.hash(fileContent));
   } catch {
     return UNFOUND_INDEX;
@@ -19737,9 +20162,9 @@ var init_transformCache = __esm(() => {
 });
 
 // src/dev/reactComponentClassifier.ts
-import { resolve as resolve31 } from "path";
+import { resolve as resolve32 } from "path";
 var classifyComponent = (filePath) => {
-  const normalizedPath = resolve31(filePath);
+  const normalizedPath = resolve32(filePath);
   if (normalizedPath.includes("/react/pages/")) {
     return "server";
   }
@@ -19751,7 +20176,7 @@ var classifyComponent = (filePath) => {
 var init_reactComponentClassifier = () => {};
 
 // src/dev/moduleMapper.ts
-import { basename as basename9, resolve as resolve32 } from "path";
+import { basename as basename10, resolve as resolve33 } from "path";
 var buildModulePaths = (moduleKeys, manifest) => {
   const modulePaths = {};
   moduleKeys.forEach((key) => {
@@ -19761,7 +20186,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return modulePaths;
 }, processChangedFile = (sourceFile, framework, manifest, resolvedPaths, processedFiles) => {
-  const normalizedFile = resolve32(sourceFile);
+  const normalizedFile = resolve33(sourceFile);
   const normalizedPath = normalizedFile.replace(/\\/g, "/");
   if (processedFiles.has(normalizedFile)) {
     return null;
@@ -19797,8 +20222,8 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return grouped;
 }, mapSourceFileToManifestKeys = (sourceFile, framework, resolvedPaths) => {
-  const normalizedFile = resolve32(sourceFile);
-  const fileName = basename9(normalizedFile);
+  const normalizedFile = resolve33(sourceFile);
+  const fileName = basename10(normalizedFile);
   const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|css|html)$/, "");
   const pascalName = toPascal(baseName);
   const keys = [];
@@ -19858,8 +20283,8 @@ __export(exports_resolveOwningComponents, {
   resolveDescendantsOfParent: () => resolveDescendantsOfParent,
   invalidateResourceIndex: () => invalidateResourceIndex
 });
-import { readdirSync as readdirSync3, readFileSync as readFileSync18, statSync as statSync4 } from "fs";
-import { dirname as dirname19, extname as extname9, join as join28, resolve as resolve33 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync19, statSync as statSync5 } from "fs";
+import { dirname as dirname20, extname as extname9, join as join29, resolve as resolve34 } from "path";
 import ts7 from "typescript";
 var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") || file4.endsWith(".tsx"), walkAngularSourceFiles = (root) => {
   const out = [];
@@ -19874,7 +20299,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const full = join28(dir, entry.name);
+      const full = join29(dir, entry.name);
       if (entry.isDirectory()) {
         visit(full);
       } else if (entry.isFile() && isAngularSourceFile(entry.name)) {
@@ -19918,7 +20343,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
 }, parseDecoratedClasses = (filePath) => {
   let source;
   try {
-    source = readFileSync18(filePath, "utf8");
+    source = readFileSync19(filePath, "utf8");
   } catch {
     return [];
   }
@@ -19972,7 +20397,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
   };
   visit(sourceFile);
   return out;
-}, safeNormalize = (path) => resolve33(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
+}, safeNormalize = (path) => resolve34(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
   const { changedFilePath, userAngularRoot } = params;
   const changedAbs = safeNormalize(changedFilePath);
   const out = [];
@@ -19993,7 +20418,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
   }
   let rootStat;
   try {
-    rootStat = statSync4(userAngularRoot);
+    rootStat = statSync5(userAngularRoot);
   } catch {
     return out;
   }
@@ -20008,12 +20433,12 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
 }, indexByRoot, resolveParentClassFile = (parentName, childFilePath, angularRoot) => {
   let source;
   try {
-    source = readFileSync18(childFilePath, "utf8");
+    source = readFileSync19(childFilePath, "utf8");
   } catch {
     return null;
   }
   const sf = ts7.createSourceFile(childFilePath, source, ts7.ScriptTarget.ES2022, true, ts7.ScriptKind.TS);
-  const childDir = dirname19(childFilePath);
+  const childDir = dirname20(childFilePath);
   for (const stmt of sf.statements) {
     if (!ts7.isImportDeclaration(stmt))
       continue;
@@ -20041,7 +20466,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
     if (!spec.startsWith(".") && !spec.startsWith("/")) {
       return null;
     }
-    const base = resolve33(childDir, spec);
+    const base = resolve34(childDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -20051,7 +20476,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
     const angularRootNorm = safeNormalize(angularRoot);
     for (const candidate of candidates) {
       try {
-        if (statSync4(candidate).isFile()) {
+        if (statSync5(candidate).isFile()) {
           const norm = safeNormalize(candidate);
           if (!norm.startsWith(angularRootNorm))
             return null;
@@ -20070,7 +20495,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
   const parentFile = new Map;
   for (const tsPath of walkAngularSourceFiles(userAngularRoot)) {
     const classes = parseDecoratedClasses(tsPath);
-    const componentDir = dirname19(tsPath);
+    const componentDir = dirname20(tsPath);
     for (const cls of classes) {
       const entity = {
         className: cls.className,
@@ -20079,7 +20504,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
       };
       if (cls.kind === "component") {
         for (const url of [...cls.templateUrls, ...cls.styleUrls]) {
-          const abs = safeNormalize(resolve33(componentDir, url));
+          const abs = safeNormalize(resolve34(componentDir, url));
           const existing = resource.get(abs);
           if (existing)
             existing.push(entity);
@@ -20106,7 +20531,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
   const norm = safeNormalize(params.changedFilePath);
   let rootStat;
   try {
-    rootStat = statSync4(params.userAngularRoot);
+    rootStat = statSync5(params.userAngularRoot);
   } catch {
     return [];
   }
@@ -20264,7 +20689,7 @@ __export(exports_loadConfig, {
   isWorkspaceConfig: () => isWorkspaceConfig,
   getWorkspaceServices: () => getWorkspaceServices
 });
-import { resolve as resolve34 } from "path";
+import { resolve as resolve35 } from "path";
 var RESERVED_TOP_LEVEL_KEYS, isObject2 = (value) => typeof value === "object" && value !== null, isCommandService = (service) => service.kind === "command" || Array.isArray(service.command), isServiceCandidate = (value) => isObject2(value) && (typeof value.entry === "string" || Array.isArray(value.command)), isWorkspaceConfig = (config) => {
   if (!isObject2(config)) {
     return false;
@@ -20315,7 +20740,7 @@ var RESERVED_TOP_LEVEL_KEYS, isObject2 = (value) => typeof value === "object" &&
   }
   return config;
 }, loadRawConfig = async (configPath2) => {
-  const resolved = resolve34(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+  const resolved = resolve35(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
   const mod = await import(resolved);
   const config = mod.default ?? mod.config;
   if (!config) {
@@ -20375,8 +20800,8 @@ __export(exports_moduleServer, {
   createModuleServer: () => createModuleServer,
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
-import { existsSync as existsSync25, readFileSync as readFileSync19, statSync as statSync5 } from "fs";
-import { basename as basename10, dirname as dirname20, extname as extname10, join as join29, resolve as resolve35, relative as relative14 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync20, statSync as statSync6 } from "fs";
+import { basename as basename11, dirname as dirname21, extname as extname10, join as join30, resolve as resolve36, relative as relative14 } 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 = [];
@@ -20396,7 +20821,7 @@ var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPIL
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const found = extensions.find((ext) => existsSync25(resolve35(projectRoot, srcPath + ext)));
+  const found = extensions.find((ext) => existsSync26(resolve36(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);
@@ -20411,24 +20836,24 @@ ${stubs}
   return invalidationVersion > 0 ? `${mtime}.${invalidationVersion}` : `${mtime}`;
 }, srcUrl = (relPath, projectRoot) => {
   const base = `${SRC_PREFIX}${relPath.replace(/\\/g, "/")}`;
-  const absPath = resolve35(projectRoot, relPath);
+  const absPath = resolve36(projectRoot, relPath);
   const cached = mtimeCache.get(absPath);
   if (cached !== undefined)
     return `${base}?v=${buildVersion(cached, absPath)}`;
   try {
-    const mtime = Math.round(statSync5(absPath).mtimeMs);
+    const mtime = Math.round(statSync6(absPath).mtimeMs);
     mtimeCache.set(absPath, mtime);
     return `${base}?v=${buildVersion(mtime, absPath)}`;
   } catch {
     return base;
   }
 }, resolveRelativeImport = (relPath, fileDir, projectRoot, extensions) => {
-  const absPath = resolve35(fileDir, relPath);
+  const absPath = resolve36(fileDir, relPath);
   const rel = relative14(projectRoot, absPath);
   const extension = extname10(rel);
   let srcPath = RESOLVED_MODULE_EXTENSIONS.has(extension) ? rel : resolveRelativeExtension(rel, projectRoot, extensions);
   if (extname10(srcPath) === ".svelte") {
-    srcPath = relative14(projectRoot, resolveSvelteModulePath(resolve35(projectRoot, srcPath)));
+    srcPath = relative14(projectRoot, resolveSvelteModulePath(resolve36(projectRoot, srcPath)));
   }
   return srcUrl(srcPath, projectRoot);
 }, NODE_BUILTIN_RE, resolveAbsoluteSpecifier = (specifier, projectRoot) => {
@@ -20447,14 +20872,14 @@ ${stubs}
       const packageName = isScoped ? `${parts[0]}/${parts[1]}` : parts[0];
       const subpath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
       if (!subpath) {
-        const pkgDir = resolve35(projectRoot, "node_modules", packageName ?? "");
-        const pkgJsonPath = join29(pkgDir, "package.json");
-        if (existsSync25(pkgJsonPath)) {
-          const pkg = JSON.parse(readFileSync19(pkgJsonPath, "utf-8"));
+        const pkgDir = resolve36(projectRoot, "node_modules", packageName ?? "");
+        const pkgJsonPath = join30(pkgDir, "package.json");
+        if (existsSync26(pkgJsonPath)) {
+          const pkg = JSON.parse(readFileSync20(pkgJsonPath, "utf-8"));
           const esmEntry = typeof pkg.module === "string" && pkg.module || typeof pkg.browser === "string" && pkg.browser;
           if (esmEntry) {
-            const resolved = resolve35(pkgDir, esmEntry);
-            if (existsSync25(resolved))
+            const resolved = resolve36(pkgDir, esmEntry);
+            if (existsSync26(resolved))
               return relative14(projectRoot, resolved);
           }
         }
@@ -20485,7 +20910,7 @@ ${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 = dirname20(filePath);
+  const fileDir = dirname21(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}`);
@@ -20500,12 +20925,12 @@ ${stubs}
   result = result.replace(/((?:from|import)\s*["'])(\/[^"']+\.(tsx?|jsx?|ts))(["'])/g, rewriteAbsoluteToSrc);
   result = result.replace(/(import\s*\(\s*["'])(\/[^"']+\.(tsx?|jsx?|ts))(["']\s*\))/g, rewriteAbsoluteToSrc);
   result = result.replace(/new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g, (_match, relPath) => {
-    const absPath = resolve35(fileDir, relPath);
+    const absPath = resolve36(fileDir, relPath);
     const rel = relative14(projectRoot, absPath);
     return `new URL('${srcUrl(rel, projectRoot)}', import.meta.url)`;
   });
   result = result.replace(/import\.meta\.resolve\(\s*["'](\.\.?\/[^"']+)["']\s*\)/g, (_match, relPath) => {
-    const absPath = resolve35(fileDir, relPath);
+    const absPath = resolve36(fileDir, relPath);
     const rel = relative14(projectRoot, absPath);
     return `'${srcUrl(rel, projectRoot)}'`;
   });
@@ -20551,7 +20976,7 @@ ${code}`;
   reactFastRefreshWarningEmitted = true;
   logWarn("React HMR is blocked: this Bun build ignores " + "`reactFastRefresh` on Bun.Transpiler, so component state " + "cannot be preserved across edits. Tracking " + "https://github.com/oven-sh/bun/pull/28312 \u2014 if it still has " + "not merged, leave a \uD83D\uDC4D on the PR so the Bun team knows it " + "is blocking you. Until then, React edits trigger a full " + "reload instead of a fast refresh.");
 }, transformReactFile = (filePath, projectRoot, rewriter) => {
-  const raw = readFileSync19(filePath, "utf-8");
+  const raw = readFileSync20(filePath, "utf-8");
   const valueExports = tsxTranspiler.scan(raw).exports;
   let transpiled = reactTranspiler.transformSync(raw);
   transpiled = preserveTypeExports(raw, transpiled, valueExports);
@@ -20567,7 +20992,7 @@ ${transpiled}`;
   transpiled += buildIslandMetadataExports(raw);
   return rewriteImports(transpiled, filePath, projectRoot, rewriter);
 }, transformPlainFile = (filePath, projectRoot, rewriter, vueDir) => {
-  const raw = readFileSync19(filePath, "utf-8");
+  const raw = readFileSync20(filePath, "utf-8");
   const ext = extname10(filePath);
   const isTS = ext === ".ts" || ext === ".tsx";
   const isTSX = ext === ".tsx" || ext === ".jsx";
@@ -20733,7 +21158,7 @@ ${code}`;
 ` + `  var __hmr_accept = function(cb) { window.__SVELTE_HMR_ACCEPT__[${JSON.stringify(moduleUrl)}] = cb; };`);
   return code.replace(/import\.meta\.hot\.accept\(/g, "__hmr_accept(");
 }, transformSvelteFile = async (filePath, projectRoot, rewriter, stylePreprocessors) => {
-  const raw = readFileSync19(filePath, "utf-8");
+  const raw = readFileSync20(filePath, "utf-8");
   if (!svelteCompiler) {
     svelteCompiler = await import("svelte/compiler");
   }
@@ -20795,12 +21220,12 @@ export default __script__;`;
   return `${cssInjection}
 ${code}`;
 }, transformVueFile = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
-  const rawSource = readFileSync19(filePath, "utf-8");
+  const rawSource = readFileSync20(filePath, "utf-8");
   const raw = addAutoRouterSetupApp(rawSource);
   if (!vueCompiler) {
     vueCompiler = await import("@vue/compiler-sfc");
   }
-  const fileName = basename10(filePath, ".vue");
+  const fileName = basename11(filePath, ".vue");
   const componentId = fileName.toLowerCase();
   const { descriptor } = vueCompiler.parse(raw, { filename: filePath });
   const hasScript = descriptor.script || descriptor.scriptSetup;
@@ -20818,7 +21243,7 @@ ${code}`;
   code = injectVueHmr(code, filePath, projectRoot, vueDir);
   return rewriteImports(code, filePath, projectRoot, rewriter);
 }, injectVueHmr = (code, filePath, projectRoot, vueDir) => {
-  const hmrBase = vueDir ? resolve35(vueDir) : projectRoot;
+  const hmrBase = vueDir ? resolve36(vueDir) : projectRoot;
   const hmrId = relative14(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
   let result = code.replace(/export\s+default\s+/, "var __hmr_comp__ = ");
   result += [
@@ -20833,11 +21258,11 @@ ${code}`;
 `);
   return result;
 }, resolveSvelteModulePath = (path) => {
-  if (existsSync25(path))
+  if (existsSync26(path))
     return path;
-  if (existsSync25(`${path}.ts`))
+  if (existsSync26(`${path}.ts`))
     return `${path}.ts`;
-  if (existsSync25(`${path}.js`))
+  if (existsSync26(`${path}.js`))
     return `${path}.js`;
   return path;
 }, jsResponse = (body) => {
@@ -20850,7 +21275,7 @@ ${code}`;
     }
   });
 }, handleCssRequest = (filePath) => {
-  const raw = readFileSync19(filePath, "utf-8");
+  const raw = readFileSync20(filePath, "utf-8");
   const escaped = raw.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return [
     `const style = document.createElement('style');`,
@@ -20982,13 +21407,13 @@ 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 = resolve35(projectRoot, relPath);
+  const filePath = resolve36(projectRoot, relPath);
   const ext = extname10(filePath);
   if (ext === ".svelte")
     return { ext, filePath: resolveSvelteModulePath(filePath) };
   if (ext)
     return { ext, filePath };
-  const found = MODULE_EXTENSIONS.find((candidate) => existsSync25(filePath + candidate));
+  const found = MODULE_EXTENSIONS.find((candidate) => existsSync26(filePath + candidate));
   if (!found)
     return { ext, filePath };
   const resolved = filePath + found;
@@ -21019,14 +21444,14 @@ export default {};
           const absoluteCandidate = "/" + tail.replace(/^\/+/, "");
           const candidates = [
             absoluteCandidate,
-            resolve35(projectRoot, tail)
+            resolve36(projectRoot, tail)
           ];
           try {
             const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_loadConfig(), exports_loadConfig));
             const cfg = await loadConfig2();
-            const angularDir = cfg.angularDirectory && resolve35(projectRoot, cfg.angularDirectory);
+            const angularDir = cfg.angularDirectory && resolve36(projectRoot, cfg.angularDirectory);
             if (angularDir)
-              candidates.push(resolve35(angularDir, tail));
+              candidates.push(resolve36(angularDir, tail));
           } catch {}
           for (const candidate of candidates) {
             if (await fileExists(candidate)) {
@@ -21056,8 +21481,8 @@ export default {};
     return transformAndCacheVue(filePath, projectRoot, rewriter, vueDir, stylePreprocessors);
   if (!TRANSPILABLE.has(ext))
     return;
-  const stat3 = statSync5(filePath);
-  const resolvedVueDir = vueDir ? resolve35(vueDir) : undefined;
+  const stat3 = statSync6(filePath);
+  const resolvedVueDir = vueDir ? resolve36(vueDir) : undefined;
   let content = REACT_EXTENSIONS.has(ext) ? transformReactFile(filePath, projectRoot, rewriter) : transformPlainFile(filePath, projectRoot, rewriter, resolvedVueDir);
   const isAngularGeneratedJs = ext === ".js" && filePath.replace(/\\/g, "/").includes("/.absolutejs/generated/angular/");
   if (isAngularGeneratedJs) {
@@ -21084,12 +21509,12 @@ export default {};
   cachedAngularUserRoot = configuredAngularUserRoot ?? null;
   return cachedAngularUserRoot;
 }, configuredAngularUserRoot, transformAndCacheSvelte = async (filePath, projectRoot, rewriter, stylePreprocessors) => {
-  const stat3 = statSync5(filePath);
+  const stat3 = statSync6(filePath);
   const content = await transformSvelteFile(filePath, projectRoot, rewriter, stylePreprocessors);
   setTransformed(filePath, content, stat3.mtimeMs, extractImportedFiles(content, projectRoot));
   return jsResponse(content);
 }, transformAndCacheVue = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
-  const stat3 = statSync5(filePath);
+  const stat3 = statSync6(filePath);
   const content = await transformVueFile(filePath, projectRoot, rewriter, vueDir, stylePreprocessors);
   setTransformed(filePath, content, stat3.mtimeMs, extractImportedFiles(content, projectRoot));
   return jsResponse(content);
@@ -21116,7 +21541,7 @@ export default {};
     const relPath = pathname.slice(SRC_PREFIX.length);
     if (relPath === "bun:wrap" || relPath.startsWith("bun:wrap?"))
       return handleBunWrapRequest();
-    const virtualCssResponse = handleVirtualSvelteCss(resolve35(projectRoot, relPath));
+    const virtualCssResponse = handleVirtualSvelteCss(resolve36(projectRoot, relPath));
     if (virtualCssResponse)
       return virtualCssResponse;
     const { filePath, ext } = resolveSourcePath(relPath, projectRoot);
@@ -21132,11 +21557,11 @@ export default {};
   SRC_IMPORT_RE.lastIndex = 0;
   while ((match = SRC_IMPORT_RE.exec(content)) !== null) {
     if (match[1])
-      files.push(resolve35(projectRoot, match[1]));
+      files.push(resolve36(projectRoot, match[1]));
   }
   return files;
 }, invalidateModule = (filePath) => {
-  const resolved = resolve35(filePath);
+  const resolved = resolve36(filePath);
   invalidate(filePath);
   if (resolved !== filePath)
     invalidate(resolved);
@@ -21281,7 +21706,7 @@ __export(exports_hmrCompiler, {
   getApplyMetadataModule: () => getApplyMetadataModule,
   encodeHmrComponentId: () => encodeHmrComponentId
 });
-import { dirname as dirname21, relative as relative15, resolve as resolve36 } from "path";
+import { dirname as dirname22, relative as relative15, resolve as resolve37 } from "path";
 import { performance as performance2 } from "perf_hooks";
 var getApplyMetadataModule = async (encodedId) => {
   const decoded = decodeURIComponent(encodedId);
@@ -21290,7 +21715,7 @@ var getApplyMetadataModule = async (encodedId) => {
     return null;
   const filePathRel = decoded.slice(0, at2);
   const className = decoded.slice(at2 + 1);
-  const componentFilePath = resolve36(process.cwd(), filePathRel);
+  const componentFilePath = resolve37(process.cwd(), filePathRel);
   const projectRelPath = relative15(process.cwd(), componentFilePath).replace(/\\/g, "/");
   const cacheKey2 = encodeURIComponent(`${projectRelPath}@${className}`);
   const { takePendingModule: takePendingModule2 } = await Promise.resolve().then(() => (init_fastHmrCompiler(), exports_fastHmrCompiler));
@@ -21301,7 +21726,7 @@ var getApplyMetadataModule = async (encodedId) => {
   const { resolveOwningComponents: resolveOwningComponents2 } = await Promise.resolve().then(() => (init_resolveOwningComponents(), exports_resolveOwningComponents));
   const owners = resolveOwningComponents2({
     changedFilePath: componentFilePath,
-    userAngularRoot: dirname21(componentFilePath)
+    userAngularRoot: dirname22(componentFilePath)
   });
   const owner = owners.find((o3) => o3.className === className);
   const kind = owner?.kind ?? "component";
@@ -21322,6 +21747,10 @@ var init_hmrCompiler = __esm(() => {
 });
 
 // src/utils/ssrErrorPage.ts
+var exports_ssrErrorPage = {};
+__export(exports_ssrErrorPage, {
+  ssrErrorPage: () => ssrErrorPage
+});
 var ssrErrorPage = (framework, error) => {
   const frameworkColors2 = {
     angular: "#dd0031",
@@ -21374,7 +21803,7 @@ body{min-height:100vh;background:linear-gradient(135deg,rgba(15,23,42,0.98) 0%,r
 };
 
 // src/ember/pageHandler.ts
-import { pathToFileURL } from "url";
+import { pathToFileURL as pathToFileURL2 } from "url";
 var resolveRequestPathname = (request) => {
   if (!request)
     return;
@@ -21397,7 +21826,7 @@ var resolveRequestPathname = (request) => {
 }, emberCacheBuster = 0, buildRuntimeModuleSpecifier = (modulePath) => {
   if (emberCacheBuster === 0)
     return modulePath;
-  const moduleUrl = new URL(pathToFileURL(modulePath).href);
+  const moduleUrl = new URL(pathToFileURL2(modulePath).href);
   moduleUrl.searchParams.set("t", String(emberCacheBuster));
   return moduleUrl.href;
 }, invalidateEmberSsrCache = () => {
@@ -21448,11 +21877,11 @@ var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { resolve as resolve37 } from "path";
+import { resolve as resolve38 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve37(htmlFilePath);
+    const resolvedPath = resolve38(htmlFilePath);
     const file4 = Bun.file(resolvedPath);
     if (!await file4.exists()) {
       return null;
@@ -21478,11 +21907,11 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { resolve as resolve38 } from "path";
+import { resolve as resolve39 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve38(htmxFilePath);
+    const resolvedPath = resolve39(htmxFilePath);
     const file4 = Bun.file(resolvedPath);
     if (!await file4.exists()) {
       return null;
@@ -21504,8 +21933,8 @@ var handleHTMXUpdate = async (htmxFilePath) => {
 var init_simpleHTMXHMR = () => {};
 
 // src/dev/rebuildTrigger.ts
-import { existsSync as existsSync26, rmSync as rmSync3 } from "fs";
-import { basename as basename11, dirname as dirname22, join as join30, relative as relative16, resolve as resolve39, sep as sep4 } from "path";
+import { existsSync as existsSync27, rmSync as rmSync3 } from "fs";
+import { basename as basename12, dirname as dirname23, join as join31, relative as relative16, resolve as resolve40, sep as sep4 } 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;
@@ -21517,13 +21946,17 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     if (!cssChanged)
       return;
     try {
-      const outputPath = resolve39(state.resolvedPaths.buildDir, config.tailwind.output);
+      const outputPath = resolve40(state.resolvedPaths.buildDir, config.tailwind.output);
       const bytes = await Bun.file(outputPath).bytes();
       const webPath = `/${config.tailwind.output.replace(/^\/+/, "")}`;
       state.assetStore.set(webPath, bytes);
     } catch {}
     broadcastToClients(state, {
-      data: { framework: "tailwind", manifest: state.manifest },
+      data: {
+        cause: files.filter(isTailwindCandidate),
+        framework: "tailwind",
+        manifest: state.manifest
+      },
       message: "Tailwind utilities recompiled",
       type: "style-update"
     });
@@ -21600,15 +22033,15 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     detectedFw = detected !== "ignored" ? detected : affectedFrameworks[0];
   }
   return { ...parsed, framework: detectedFw };
-}, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync26(affectedFile), FRAMEWORK_DIR_KEYS_FOR_CLEANUP, removeStaleGenerated = (state, deletedFile) => {
+}, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync27(affectedFile), FRAMEWORK_DIR_KEYS_FOR_CLEANUP, removeStaleGenerated = (state, deletedFile) => {
   const config = state.config;
   const cwd2 = process.cwd();
-  const absDeleted = resolve39(deletedFile).replace(/\\/g, "/");
+  const absDeleted = resolve40(deletedFile).replace(/\\/g, "/");
   for (const { configKey, framework } of FRAMEWORK_DIR_KEYS_FOR_CLEANUP) {
     const dir = config[configKey];
     if (!dir)
       continue;
-    const absDir = resolve39(cwd2, dir).replace(/\\/g, "/");
+    const absDir = resolve40(cwd2, dir).replace(/\\/g, "/");
     if (!absDeleted.startsWith(`${absDir}/`))
       continue;
     const rel = absDeleted.slice(absDir.length + 1);
@@ -21618,8 +22051,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const relJs = `${rel.slice(0, -ext[0].length)}.js`;
     const generatedDir = getFrameworkGeneratedDir(framework, cwd2);
     for (const candidate of [
-      join30(generatedDir, relJs),
-      `${join30(generatedDir, relJs)}.map`
+      join31(generatedDir, relJs),
+      `${join31(generatedDir, relJs)}.map`
     ]) {
       try {
         rmSync3(candidate, { force: true });
@@ -21632,7 +22065,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   removeStaleGenerated(state, filePathInSet);
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, filePathInSet);
-    const deletedPathResolved = resolve39(filePathInSet);
+    const deletedPathResolved = resolve40(filePathInSet);
     affectedFiles.forEach((affectedFile) => {
       if (isValidDeletedAffectedFile(affectedFile, deletedPathResolved, processedFiles)) {
         validFiles.push(affectedFile);
@@ -21646,7 +22079,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     if (!dependents || dependents.size === 0) {
       return;
     }
-    const dependentFiles = Array.from(dependents).filter((file4) => existsSync26(file4));
+    const dependentFiles = Array.from(dependents).filter((file4) => existsSync27(file4));
     if (dependentFiles.length === 0) {
       return;
     }
@@ -21662,7 +22095,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, normalizedFilePath);
     affectedFiles.forEach((affectedFile) => {
-      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync26(affectedFile)) {
+      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync27(affectedFile)) {
         validFiles.push(affectedFile);
         processedFiles.add(affectedFile);
       }
@@ -21676,7 +22109,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (storedHash !== undefined && storedHash === fileHash) {
     return;
   }
-  const normalizedFilePath = resolve39(filePathInSet);
+  const normalizedFilePath = resolve40(filePathInSet);
   if (!processedFiles.has(normalizedFilePath)) {
     validFiles.push(normalizedFilePath);
     processedFiles.add(normalizedFilePath);
@@ -21687,7 +22120,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   collectChangedFileAffected(state, normalizedFilePath, processedFiles, validFiles);
 }, processFilePathSet = (state, filePathSet, processedFiles, validFiles) => {
   filePathSet.forEach((filePathInSet) => {
-    if (!existsSync26(filePathInSet)) {
+    if (!existsSync27(filePathInSet)) {
       collectDeletedFileAffected(state, filePathInSet, processedFiles, validFiles);
       return;
     }
@@ -21814,7 +22247,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const publicDir = state.resolvedPaths.publicDir;
   const assetsDir = state.resolvedPaths.assetsDir;
   const handleStaticMirror = async (sourceDir, urlPrefix) => {
-    const absSource = resolve39(filePath);
+    const absSource = resolve40(filePath);
     const normalizedSource = absSource.replace(/\\/g, "/");
     const normalizedDir = sourceDir.replace(/\\/g, "/");
     if (!normalizedSource.startsWith(normalizedDir + "/"))
@@ -21822,10 +22255,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     try {
       const relFromDir = normalizedSource.slice(normalizedDir.length + 1);
       const buildDir = state.resolvedPaths.buildDir;
-      const destPath = resolve39(buildDir, urlPrefix ? `${urlPrefix}/${relFromDir}` : relFromDir);
+      const destPath = resolve40(buildDir, urlPrefix ? `${urlPrefix}/${relFromDir}` : relFromDir);
       const { mkdir: mkdir7, copyFile, readFile: readFile6 } = await import("fs/promises");
-      const { dirname: dirname23 } = await import("path");
-      await mkdir7(dirname23(destPath), { recursive: true });
+      const { dirname: dirname24 } = await import("path");
+      await mkdir7(dirname24(destPath), { recursive: true });
       await copyFile(absSource, destPath);
       const bytes = await readFile6(destPath);
       const webPath = urlPrefix ? `/${urlPrefix}/${relFromDir}` : `/${relFromDir}`;
@@ -21848,7 +22281,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (assetsDir && await handleStaticMirror(assetsDir, "assets"))
     return;
   if (framework === "unknown") {
-    invalidate(resolve39(filePath));
+    invalidate(resolve40(filePath));
     const relPath = relative16(process.cwd(), filePath);
     logHmrUpdate(relPath);
     const angularDir = state.resolvedPaths.angularDir;
@@ -21856,10 +22289,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     if (angularDir && state.dependencyGraph) {
       try {
         const { addFileToGraph: addFileToGraph2 } = await Promise.resolve().then(() => (init_dependencyGraph(), exports_dependencyGraph));
-        addFileToGraph2(state.dependencyGraph, resolve39(filePath));
-        const affected = getAffectedFiles(state.dependencyGraph, resolve39(filePath));
+        addFileToGraph2(state.dependencyGraph, resolve40(filePath));
+        const affected = getAffectedFiles(state.dependencyGraph, resolve40(filePath));
         for (const dependent of affected) {
-          if (dependent === resolve39(filePath))
+          if (dependent === resolve40(filePath))
             continue;
           const dependentFramework = detectFramework(dependent, state.resolvedPaths);
           if (dependentFramework !== "angular")
@@ -21876,14 +22309,14 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
       } catch {}
     }
     if (!hasAngularDependent) {
-      console.log(`[abs:restart] ${resolve39(filePath)}`);
+      console.log(`[abs:restart] ${resolve40(filePath)}`);
       return;
     }
     try {
       const { getFrameworkGeneratedDir: getFrameworkGeneratedDir2 } = await Promise.resolve().then(() => (init_generatedDir(), exports_generatedDir));
       const { invalidateModule: invalidateModuleServer } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
       const generatedAngularRoot = getFrameworkGeneratedDir2("angular");
-      const sourceAbs = resolve39(filePath).replace(/\\/g, "/");
+      const sourceAbs = resolve40(filePath).replace(/\\/g, "/");
       const generatedTwin = `${generatedAngularRoot.replace(/\\/g, "/")}${sourceAbs.replace(/\.ts$/, ".js")}`;
       invalidateModuleServer(generatedTwin);
     } catch {}
@@ -21917,7 +22350,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const userEditedFiles = new Set;
     state.fileChangeQueue.forEach((filePaths) => {
       for (const filePath2 of filePaths) {
-        userEditedFiles.add(resolve39(filePath2));
+        userEditedFiles.add(resolve40(filePath2));
       }
     });
     state.lastUserEditedFiles = userEditedFiles;
@@ -21941,12 +22374,12 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return componentFile;
   }
   const tsCounterpart = componentFile.replace(/\.html$/, ".ts");
-  if (existsSync26(tsCounterpart)) {
+  if (existsSync27(tsCounterpart)) {
     return tsCounterpart;
   }
   if (!graph)
     return componentFile;
-  const dependents = graph.dependents.get(resolve39(componentFile));
+  const dependents = graph.dependents.get(resolve40(componentFile));
   if (!dependents)
     return componentFile;
   for (const dep of dependents) {
@@ -21955,7 +22388,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   return componentFile;
 }, resolveAngularPageEntries = (state, angularFiles, angularPagesPath) => {
-  const pageEntries = angularFiles.filter((file4) => file4.endsWith(".ts") && resolve39(file4).startsWith(angularPagesPath));
+  const pageEntries = angularFiles.filter((file4) => file4.endsWith(".ts") && resolve40(file4).startsWith(angularPagesPath));
   if (pageEntries.length > 0 || !state.dependencyGraph) {
     return pageEntries;
   }
@@ -21964,7 +22397,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") && resolve39(file4).startsWith(angularPagesPath)) {
+      if (file4.endsWith(".ts") && resolve40(file4).startsWith(angularPagesPath)) {
         resolvedPages.add(file4);
       }
     });
@@ -22005,8 +22438,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (serverDirs.length <= 1) {
     const dir = getFrameworkGeneratedDir2(framework, projectRoot);
     return {
-      serverOutDir: resolve39(resolvedPaths.buildDir, basename11(dir)),
-      serverRoot: resolve39(dir, "server")
+      serverOutDir: resolve40(resolvedPaths.buildDir, basename12(dir)),
+      serverRoot: resolve40(dir, "server")
     };
   }
   return {
@@ -22014,7 +22447,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     serverRoot: commonAncestor2(serverDirs.map((entry) => entry.dir), projectRoot)
   };
 }, updateServerManifestEntry = (state, artifact) => {
-  const fileWithHash = basename11(artifact.path);
+  const fileWithHash = basename12(artifact.path);
   const [baseName] = fileWithHash.split(`.${artifact.hash}.`);
   if (!baseName) {
     return;
@@ -22027,8 +22460,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const keepByDir = new Map;
   const prefixByDir = new Map;
   for (const artifact of freshOutputs) {
-    const dir = dirname22(artifact.path);
-    const name = basename11(artifact.path);
+    const dir = dirname23(artifact.path);
+    const name = basename12(artifact.path);
     const [prefix] = name.split(".");
     if (!prefix)
       continue;
@@ -22099,6 +22532,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
       })
     ],
     root: clientRoot,
+    sourcemap: "inline",
     target: "browser",
     throw: false
   });
@@ -22112,6 +22546,11 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
       ...depVendorPaths
     });
   }
+  const { chainBundleInlineSourcemap: chainBundleInlineSourcemap2 } = await Promise.resolve().then(() => (init_chainInlineSourcemaps(), exports_chainInlineSourcemaps));
+  for (const out of clientResult.outputs) {
+    if (out.path.endsWith(".js"))
+      chainBundleInlineSourcemap2(out.path);
+  }
   const clientManifest = generateManifest2(clientResult.outputs, buildDir);
   Object.assign(state.manifest, clientManifest);
   await populateAssetStore(state.assetStore, clientManifest, buildDir);
@@ -22133,7 +22572,11 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
 }, decideAngularTier = async (state, angularDir) => {
   const userEdited = state.lastUserEditedFiles ?? new Set;
   if (userEdited.size === 0)
-    return { queue: [], tier: 0 };
+    return {
+      breakdown: { compileMs: 0, importsMs: 0, resolveMs: 0 },
+      queue: [],
+      tier: 0
+    };
   const importsStart = performance.now();
   const {
     resolveOwningComponents: resolveOwningComponents2,
@@ -22157,8 +22600,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     if (detected !== "unknown")
       continue;
     try {
-      const affected = getAffectedFiles(state.dependencyGraph, resolve39(editedFile));
-      const hasAngularConsumer = affected.some((dep) => dep !== resolve39(editedFile) && detectFramework(dep, state.resolvedPaths) === "angular");
+      const affected = getAffectedFiles(state.dependencyGraph, resolve40(editedFile));
+      const hasAngularConsumer = affected.some((dep) => dep !== resolve40(editedFile) && detectFramework(dep, state.resolvedPaths) === "angular");
       if (hasAngularConsumer) {
         return {
           kind: "rebootstrap",
@@ -22205,7 +22648,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     }
     if (owners.length === 0 && (editedFile.endsWith(".ts") || editedFile.endsWith(".json")) && !editedFile.endsWith(".d.ts")) {
       const normalized = editedFile.replace(/\\/g, "/");
-      const angularDirAbs = resolve39(angularDir).replace(/\\/g, "/");
+      const angularDirAbs = resolve40(angularDir).replace(/\\/g, "/");
       if (normalized.startsWith(angularDirAbs + "/")) {
         return {
           kind: "rebootstrap",
@@ -22348,16 +22791,16 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   };
   const fire = () => {
     ctx.debounceTimer = null;
-    const resolve40 = ctx.debouncedResolve;
+    const resolve41 = ctx.debouncedResolve;
     ctx.debouncedResolve = null;
     ctx.debouncedPromise = null;
     if (ctx.inFlight) {
       ctx.pending = true;
-      ctx.inFlight.finally(() => resolve40?.());
+      ctx.inFlight.finally(() => resolve41?.());
       return;
     }
     ctx.inFlight = drive();
-    ctx.inFlight.finally(() => resolve40?.());
+    ctx.inFlight.finally(() => resolve41?.());
   };
   return ({ immediate = false } = {}) => {
     if (!ctx.debouncedPromise) {
@@ -22384,9 +22827,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const diskRefreshPromise = (async () => {
     if (!angularDir || editedFiles.size === 0)
       return;
-    const angularDirAbs = resolve39(angularDir);
+    const angularDirAbs = resolve40(angularDir);
     const filesUnderAngular = Array.from(editedFiles).filter((file4) => {
-      const abs = resolve39(file4);
+      const abs = resolve40(file4);
       return abs === angularDirAbs || abs.startsWith(angularDirAbs + sep4);
     });
     if (filesUnderAngular.length === 0)
@@ -22408,7 +22851,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
         if (!ext)
           continue;
         if (ext === ".ts" || ext === ".tsx") {
-          tsFilesToRefresh.add(resolve39(file4));
+          tsFilesToRefresh.add(resolve40(file4));
           continue;
         }
         const owners = resolveOwningComponents2({
@@ -22416,7 +22859,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
           userAngularRoot: angularDirAbs
         });
         for (const owner of owners) {
-          tsFilesToRefresh.add(resolve39(owner.componentFilePath));
+          tsFilesToRefresh.add(resolve40(owner.componentFilePath));
         }
       }
       if (tsFilesToRefresh.size === 0)
@@ -22431,7 +22874,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
         const { invalidateModule: invalidateModule2 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
         for (const tsFile of tsFilesToRefresh) {
           const rel = relative16(angularDirAbs, tsFile).replace(/\\/g, "/").replace(/\.[tj]sx?$/, ".js");
-          const compiledFile = resolve39(compiledRoot, rel);
+          const compiledFile = resolve40(compiledRoot, rel);
           invalidateModule2(compiledFile);
         }
       } catch {}
@@ -22447,12 +22890,12 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     try {
       const { primeComponentFingerprint: primeComponentFingerprint2 } = await Promise.resolve().then(() => (init_fastHmrCompiler(), exports_fastHmrCompiler));
       const { readdir: readdir5 } = await import("fs/promises");
-      const { join: join31 } = await import("path");
+      const { join: join32 } = await import("path");
       const walk = async (dir) => {
         const entries = await readdir5(dir, { withFileTypes: true });
         const files = [];
         for (const entry of entries) {
-          const full = join31(dir, entry.name);
+          const full = join32(dir, entry.name);
           if (entry.isDirectory()) {
             files.push(...await walk(full));
           } else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
@@ -22480,9 +22923,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     await rewriteImports3(ssrPaths, angServerVendorPaths);
   }
   serverPaths.forEach((serverPath, idx) => {
-    const fileBase = basename11(serverPath, ".js");
+    const fileBase = basename12(serverPath, ".js");
     const ssrPath = ssrPaths[idx] ?? serverPath;
-    state.manifest[toPascal(fileBase)] = resolve39(ssrPath);
+    state.manifest[toPascal(fileBase)] = resolve40(ssrPath);
   });
   if (clientPaths.length > 0) {
     await bundleAngularClient(state, clientPaths, state.resolvedPaths.buildDir, angularDir);
@@ -22495,9 +22938,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const angularDir = config.angularDirectory ?? "";
   const angularFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "angular");
   for (const file4 of angularFiles) {
-    state.fileHashes.set(resolve39(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve40(file4), computeFileHash(file4));
   }
-  const angularPagesPath = resolve39(angularDir, "pages");
+  const angularPagesPath = resolve40(angularDir, "pages");
   const pageEntries = resolveAngularPageEntries(state, angularFiles, angularPagesPath);
   const tierStart = performance.now();
   const verdict = await decideAngularTier(state, angularDir);
@@ -22515,6 +22958,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     broadcastRemount(state, verdict.queue);
     const b2 = verdict.breakdown;
     logInfo(`[ng-hmr] tier-1a remount ${queueDescription(verdict.queue)} (server ${tierMs}ms: imports ${b2.importsMs}/resolve ${b2.resolveMs}/compile ${b2.compileMs}; awaiting client apply)`);
+    runBundle();
   } else if (verdict.tier === 1 && verdict.kind === "rebootstrap") {
     await runBundle({ immediate: true });
     await broadcastRebootstrap(state, verdict.reason);
@@ -22537,11 +22981,11 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (isComponentFile2)
     return primaryFile;
   const { findNearestComponent: findNearestComponent2 } = await Promise.resolve().then(() => (init_transformCache(), exports_transformCache));
-  const nearest = findNearestComponent2(resolve39(primaryFile));
+  const nearest = findNearestComponent2(resolve40(primaryFile));
   return nearest ?? primaryFile;
 }, handleReactModuleServerPath = async (state, reactFiles, startTime, onRebuildComplete) => {
   for (const file4 of reactFiles) {
-    state.fileHashes.set(resolve39(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve40(file4), computeFileHash(file4));
   }
   const primaryFile = reactFiles.find((file4) => !file4.replace(/\\/g, "/").includes("/pages/")) ?? reactFiles[0];
   if (!primaryFile) {
@@ -22622,7 +23066,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, handleSvelteModuleServerPath = async (state, svelteFiles, config, startTime, onRebuildComplete) => {
   for (const file4 of svelteFiles) {
-    state.fileHashes.set(resolve39(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve40(file4), computeFileHash(file4));
   }
   const serverDuration = Date.now() - startTime;
   await runSequentially(svelteFiles, (changedFile) => broadcastSvelteModuleUpdate(state, changedFile, svelteFiles, serverDuration));
@@ -22678,6 +23122,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
         createStylePreprocessorPlugin(getStyleTransformConfig(state.config))
       ],
       root: serverRoot,
+      sourcemap: "inline",
       target: "bun",
       throw: false
     }) : undefined,
@@ -22690,6 +23135,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
         createStylePreprocessorPlugin(getStyleTransformConfig(state.config))
       ],
       root: clientRoot,
+      sourcemap: "inline",
       target: "browser",
       throw: false
     }) : undefined
@@ -22697,6 +23143,17 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   handleServerManifestUpdate(state, serverResult);
   await handleClientManifestUpdate(state, clientResult, buildDir);
   await pruneStaleHashedSiblings(serverResult?.outputs);
+  if (serverResult?.success || clientResult?.success) {
+    const { chainBundleInlineSourcemap: chainBundleInlineSourcemap2 } = await Promise.resolve().then(() => (init_chainInlineSourcemaps(), exports_chainInlineSourcemaps));
+    for (const out of serverResult?.outputs ?? []) {
+      if (out.path.endsWith(".js"))
+        chainBundleInlineSourcemap2(out.path);
+    }
+    for (const out of clientResult?.outputs ?? []) {
+      if (out.path.endsWith(".js"))
+        chainBundleInlineSourcemap2(out.path);
+    }
+  }
   broadcastToClients(state, {
     data: { manifest: state.manifest },
     type: "svelte-tier-zero-ssr-rebuild-complete"
@@ -22801,7 +23258,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const duration = Date.now() - startTime;
   const broadcastFiles = svelteFiles.length > 0 ? svelteFiles : filesToRebuild;
   broadcastFiles.forEach((sveltePagePath) => {
-    const fileName = basename11(sveltePagePath);
+    const fileName = basename12(sveltePagePath);
     const baseName = fileName.replace(/\.svelte$/, "");
     const pascalName = toPascal(baseName);
     const cssKey = `${pascalName}CSS`;
@@ -22856,7 +23313,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, handleVueModuleServerPath = async (state, vueFiles, nonVueFiles, config, startTime, onRebuildComplete) => {
   for (const file4 of [...vueFiles, ...nonVueFiles]) {
-    state.fileHashes.set(resolve39(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve40(file4), computeFileHash(file4));
   }
   await invalidateNonVueModules(nonVueFiles);
   const serverDuration = Date.now() - startTime;
@@ -22881,7 +23338,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const { vueServerPaths, vueIndexPaths, vueClientPaths, vueCssPaths } = await compileVue2(vueFiles, vueDir, true, getStyleTransformConfig(state.config));
   const serverEntries = [...vueServerPaths];
   const clientEntries = [...vueIndexPaths, ...vueClientPaths];
-  const cssOutDir = join30(buildDir, state.resolvedPaths.assetsDir ? basename11(state.resolvedPaths.assetsDir) : "assets", "css");
+  const cssOutDir = join31(buildDir, state.resolvedPaths.assetsDir ? basename12(state.resolvedPaths.assetsDir) : "assets", "css");
   const { serverRoot, serverOutDir } = await computeServerOutPaths(state.resolvedPaths, "vue");
   const [serverResult, clientResult, cssResult] = await Promise.all([
     serverEntries.length > 0 ? bunBuild9({
@@ -22894,6 +23351,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
         createStylePreprocessorPlugin(getStyleTransformConfig(state.config))
       ],
       root: serverRoot,
+      sourcemap: "inline",
       target: "bun",
       throw: false
     }) : undefined,
@@ -22906,6 +23364,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
         createStylePreprocessorPlugin(getStyleTransformConfig(state.config))
       ],
       root: clientRoot,
+      sourcemap: "inline",
       target: "browser",
       throw: false
     }) : undefined,
@@ -22925,6 +23384,20 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   await handleClientManifestUpdate(state, cssResult, buildDir);
   await pruneStaleHashedSiblings(serverResult?.outputs);
   await pruneStaleHashedSiblings(cssResult?.outputs);
+  if (serverResult?.success) {
+    const { chainBundleInlineSourcemap: chainBundleInlineSourcemap2 } = await Promise.resolve().then(() => (init_chainInlineSourcemaps(), exports_chainInlineSourcemaps));
+    for (const out of serverResult.outputs) {
+      if (out.path.endsWith(".js"))
+        chainBundleInlineSourcemap2(out.path);
+    }
+  }
+  if (clientResult?.success) {
+    const { chainBundleInlineSourcemap: chainBundleInlineSourcemap2 } = await Promise.resolve().then(() => (init_chainInlineSourcemaps(), exports_chainInlineSourcemaps));
+    for (const out of clientResult.outputs) {
+      if (out.path.endsWith(".js"))
+        chainBundleInlineSourcemap2(out.path);
+    }
+  }
   broadcastToClients(state, {
     data: { manifest: state.manifest },
     type: "vue-tier-zero-ssr-rebuild-complete"
@@ -22989,7 +23462,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) => resolve39(emberPagesPath, entry.name));
+    return entries.filter((entry) => entry.isFile() && EMBER_PAGE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))).map((entry) => resolve40(emberPagesPath, entry.name));
   } catch {
     return [];
   }
@@ -23001,10 +23474,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return state.manifest;
   }
   for (const file4 of emberFiles) {
-    state.fileHashes.set(resolve39(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve40(file4), computeFileHash(file4));
   }
-  const emberPagesPath = resolve39(emberDir, "pages");
-  const directPageEntries = emberFiles.filter((file4) => resolve39(file4).startsWith(emberPagesPath));
+  const emberPagesPath = resolve40(emberDir, "pages");
+  const directPageEntries = emberFiles.filter((file4) => resolve40(file4).startsWith(emberPagesPath));
   const allPageEntries = directPageEntries.length > 0 ? directPageEntries : await collectAllEmberPages(emberPagesPath);
   if (allPageEntries.length === 0) {
     onRebuildComplete({ hmrState: state, manifest: state.manifest });
@@ -23013,8 +23486,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const { compileEmber: compileEmber2 } = await Promise.resolve().then(() => (init_compileEmber(), exports_compileEmber));
   const { serverPaths } = await compileEmber2(allPageEntries, emberDir, process.cwd(), true);
   for (const serverPath of serverPaths) {
-    const fileBase = basename11(serverPath, ".js");
-    state.manifest[toPascal(fileBase)] = resolve39(serverPath);
+    const fileBase = basename12(serverPath, ".js");
+    state.manifest[toPascal(fileBase)] = resolve40(serverPath);
   }
   const { invalidateEmberSsrCache: invalidateEmberSsrCache2 } = await Promise.resolve().then(() => (init_ember(), exports_ember));
   invalidateEmberSsrCache2();
@@ -23084,7 +23557,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     });
   }
 }, handleScriptUpdate = (state, scriptFile, manifest, framework, duration) => {
-  const scriptBaseName = basename11(scriptFile).replace(/\.(ts|js|tsx|jsx)$/, "");
+  const scriptBaseName = basename12(scriptFile).replace(/\.(ts|js|tsx|jsx)$/, "");
   const pascalName = toPascal(scriptBaseName);
   const scriptPath = manifest[pascalName] || null;
   if (!scriptPath) {
@@ -23106,8 +23579,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!buildReference?.source) {
     return;
   }
-  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve39(dirname22(buildInfo.resolvedRegistryPath), buildReference.source);
-  islandFiles.add(resolve39(sourcePath));
+  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve40(dirname23(buildInfo.resolvedRegistryPath), buildReference.source);
+  islandFiles.add(resolve40(sourcePath));
 }, resolveIslandSourceFiles = async (config) => {
   const registryPath = config.islands?.registry;
   if (!registryPath) {
@@ -23115,7 +23588,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   const buildInfo = await loadIslandRegistryBuildInfo(registryPath);
   const islandFiles = new Set([
-    resolve39(buildInfo.resolvedRegistryPath)
+    resolve40(buildInfo.resolvedRegistryPath)
   ]);
   for (const definition of buildInfo.definitions) {
     resolveIslandDefinitionSource(definition, buildInfo, islandFiles);
@@ -23126,7 +23599,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (islandFiles.size === 0) {
     return false;
   }
-  return filesToRebuild.some((file4) => islandFiles.has(resolve39(file4)));
+  return filesToRebuild.some((file4) => islandFiles.has(resolve40(file4)));
 }, handleIslandSourceReload = async (state, config, filesToRebuild, manifest) => {
   const shouldReload = await didStaticPagesNeedIslandRefresh(config, filesToRebuild);
   if (!shouldReload) {
@@ -23161,10 +23634,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 resolve39(state.resolvedPaths.buildDir, "pages");
+    return resolve40(state.resolvedPaths.buildDir, "pages");
   }
-  const dirName = framework === "html" ? basename11(config.htmlDirectory ?? "html") : basename11(config.htmxDirectory ?? "htmx");
-  return resolve39(state.resolvedPaths.buildDir, dirName, "pages");
+  const dirName = framework === "html" ? basename12(config.htmlDirectory ?? "html") : basename12(config.htmxDirectory ?? "htmx");
+  return resolve40(state.resolvedPaths.buildDir, dirName, "pages");
 }, processHtmlPageUpdate = async (state, pageFile, builtHtmlPagePath, manifest, duration) => {
   try {
     const { handleHTMLUpdate: handleHTMLUpdate2 } = await Promise.resolve().then(() => (init_simpleHTMLHMR(), exports_simpleHTMLHMR));
@@ -23202,8 +23675,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const shouldRefreshAllPages = htmlPageFiles.length === 0 && shouldRefreshFromIslandChange;
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmlPages, "*.html") : htmlPageFiles;
   await runSequentially(pageFilesToUpdate, async (pageFile) => {
-    const htmlPageName = basename11(pageFile);
-    const builtHtmlPagePath = resolve39(outputHtmlPages, htmlPageName);
+    const htmlPageName = basename12(pageFile);
+    const builtHtmlPagePath = resolve40(outputHtmlPages, htmlPageName);
     await processHtmlPageUpdate(state, pageFile, builtHtmlPagePath, manifest, duration);
   });
 }, handleVueCssOnlyUpdate = (state, vueCssFiles, manifest, duration) => {
@@ -23211,7 +23684,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!cssFile) {
     return;
   }
-  const cssBaseName = basename11(getStyleBaseName(cssFile));
+  const cssBaseName = basename12(getStyleBaseName(cssFile));
   const cssPascalName = toPascal(cssBaseName);
   const cssKey = `${cssPascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
@@ -23260,7 +23733,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     type: "vue-update"
   });
 }, broadcastVuePageChange = async (state, config, vuePagePath, manifest, duration) => {
-  const fileName = basename11(vuePagePath);
+  const fileName = basename12(vuePagePath);
   const baseName = fileName.replace(/\.vue$/, "");
   const pascalName = toPascal(baseName);
   const vueRoot = config.vueDirectory;
@@ -23268,7 +23741,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const cssKey = `${pascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
   const { vueHmrMetadata: vueHmrMetadata2 } = await Promise.resolve().then(() => (init_compileVue(), exports_compileVue));
-  const hmrMeta = vueHmrMetadata2.get(resolve39(vuePagePath));
+  const hmrMeta = vueHmrMetadata2.get(resolve40(vuePagePath));
   const changeType = hmrMeta?.changeType ?? "full";
   if (changeType === "style-only") {
     broadcastVueStyleOnly(state, vuePagePath, baseName, cssUrl, hmrId, manifest, duration);
@@ -23306,7 +23779,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!cssFile) {
     return;
   }
-  const cssBaseName = basename11(getStyleBaseName(cssFile));
+  const cssBaseName = basename12(getStyleBaseName(cssFile));
   const cssPascalName = toPascal(cssBaseName);
   const cssKey = `${cssPascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
@@ -23324,7 +23797,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, broadcastSveltePageUpdate = (state, sveltePagePath, manifest, duration) => {
   try {
-    const fileName = basename11(sveltePagePath);
+    const fileName = basename12(sveltePagePath);
     const baseName = fileName.replace(/\.svelte$/, "");
     const pascalName = toPascal(baseName);
     const cssKey = `${pascalName}CSS`;
@@ -23372,7 +23845,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!cssFile) {
     return;
   }
-  const cssBaseName = basename11(getStyleBaseName(cssFile));
+  const cssBaseName = basename12(getStyleBaseName(cssFile));
   const cssPascalName = toPascal(cssBaseName);
   const cssKey = `${cssPascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
@@ -23452,8 +23925,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const shouldRefreshAllPages = htmxPageFiles.length === 0 && shouldRefreshFromIslandChange;
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmxPages, "*.html") : htmxPageFiles;
   await runSequentially(pageFilesToUpdate, async (htmxPageFile) => {
-    const htmxPageName = basename11(htmxPageFile);
-    const builtHtmxPagePath = resolve39(outputHtmxPages, htmxPageName);
+    const htmxPageName = basename12(htmxPageFile);
+    const builtHtmxPagePath = resolve40(outputHtmxPages, htmxPageName);
     await processHtmxPageUpdate(state, htmxPageFile, builtHtmxPagePath, manifest, duration);
   });
 }, collectUpdatedModulePaths = (allModuleUpdates) => {
@@ -23562,7 +24035,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 = resolve39(outputDir, basename11(sourceFile));
+  const destPath = resolve40(outputDir, basename12(sourceFile));
   const hmrScript = extractHmrScript(destPath, readFs);
   const source = await Bun.file(sourceFile).text();
   await Bun.write(destPath, source);
@@ -23704,13 +24177,17 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
   if (config.tailwind && filesToRebuild && filesToRebuild.some(isTailwindCandidate)) {
     try {
-      const outputPath = resolve39(state.resolvedPaths.buildDir, config.tailwind.output);
+      const outputPath = resolve40(state.resolvedPaths.buildDir, config.tailwind.output);
       const bytes = await Bun.file(outputPath).bytes();
       const webPath = `/${config.tailwind.output.replace(/^\/+/, "")}`;
       state.assetStore.set(webPath, bytes);
     } catch {}
     broadcastToClients(state, {
-      data: { framework: "tailwind", manifest },
+      data: {
+        cause: filesToRebuild?.filter(isTailwindCandidate) ?? [],
+        framework: "tailwind",
+        manifest
+      },
       message: "Tailwind utilities recompiled",
       type: "style-update"
     });
@@ -23875,8 +24352,8 @@ __export(exports_buildDepVendor, {
   computeDepVendorPaths: () => computeDepVendorPaths,
   buildDepVendor: () => buildDepVendor
 });
-import { mkdirSync as mkdirSync13 } from "fs";
-import { join as join31 } from "path";
+import { mkdirSync as mkdirSync14 } from "fs";
+import { join as join32 } from "path";
 import { rm as rm10 } from "fs/promises";
 var {build: bunBuild9, Glob: Glob10 } = globalThis.Bun;
 var toSafeFileName6 = (specifier) => {
@@ -23930,7 +24407,7 @@ var toSafeFileName6 = (specifier) => {
     framework: Array.from(framework).filter(isResolvable4)
   };
 }, collectTransitiveImports = async (specs, alreadyVendored, alreadyScanned) => {
-  const { readFileSync: readFileSync20 } = await import("fs");
+  const { readFileSync: readFileSync21 } = await import("fs");
   const transpiler6 = new Bun.Transpiler({ loader: "js" });
   const newSpecs = new Set;
   for (const spec of specs) {
@@ -23945,7 +24422,7 @@ var toSafeFileName6 = (specifier) => {
     }
     let content;
     try {
-      content = readFileSync20(resolved, "utf-8");
+      content = readFileSync21(resolved, "utf-8");
     } catch {
       continue;
     }
@@ -23977,7 +24454,7 @@ var toSafeFileName6 = (specifier) => {
     bld.onLoad({ filter: /\.(?:m?js|cjs)$/ }, async (args) => {
       const source = await Bun.file(args.path).text();
       if (!source.includes("@__PURE__"))
-        return null;
+        return;
       return {
         contents: source.replace(PURE_ANNOTATION, ""),
         loader: args.path.endsWith(".cjs") ? "js" : "js"
@@ -23987,7 +24464,7 @@ var toSafeFileName6 = (specifier) => {
 }), buildDepVendorPass = async (specifiers, vendorDir, tmpDir) => {
   const entries = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName6(specifier);
-    const entryPath = join31(tmpDir, `${safeName}.ts`);
+    const entryPath = join32(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return { entryPath, specifier };
   }));
@@ -24048,10 +24525,10 @@ var toSafeFileName6 = (specifier) => {
   const { dep: initialSpecs, framework: frameworkRoots } = await scanBareImports(directories);
   if (initialSpecs.length === 0 && frameworkRoots.length === 0)
     return {};
-  const vendorDir = join31(buildDir, "vendor");
-  mkdirSync13(vendorDir, { recursive: true });
-  const tmpDir = join31(buildDir, "_dep_vendor_tmp");
-  mkdirSync13(tmpDir, { recursive: true });
+  const vendorDir = join32(buildDir, "vendor");
+  mkdirSync14(vendorDir, { recursive: true });
+  const tmpDir = join32(buildDir, "_dep_vendor_tmp");
+  mkdirSync14(tmpDir, { recursive: true });
   const allSpecs = new Set(initialSpecs);
   const alreadyScanned = new Set;
   let frontier = [...allSpecs, ...frameworkRoots];
@@ -24133,8 +24610,8 @@ __export(exports_devBuild, {
   applyConfigChanges: () => applyConfigChanges
 });
 import { readdir as readdir5 } from "fs/promises";
-import { statSync as statSync6 } from "fs";
-import { resolve as resolve40 } from "path";
+import { statSync as statSync7 } from "fs";
+import { resolve as resolve41 } from "path";
 var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const configuredDirs = [
     config.reactDirectory,
@@ -24157,7 +24634,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return Object.keys(config).length > 0 ? config : null;
 }, reloadConfig = async () => {
   try {
-    const configPath2 = resolve40(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+    const configPath2 = resolve41(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
     const source = await Bun.file(configPath2).text();
     return parseDirectoryConfig(source);
   } catch {
@@ -24264,7 +24741,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     state.fileChangeQueue.clear();
   }
 }, handleCachedReload = async () => {
-  const serverMtime = statSync6(resolve40(Bun.main)).mtimeMs;
+  const serverMtime = statSync7(resolve41(Bun.main)).mtimeMs;
   const lastMtime = globalThis.__hmrServerMtime;
   globalThis.__hmrServerMtime = serverMtime;
   const cached = globalThis.__hmrDevResult;
@@ -24301,8 +24778,8 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return true;
 }, resolveAbsoluteVersion2 = async () => {
   const candidates = [
-    resolve40(import.meta.dir, "..", "..", "package.json"),
-    resolve40(import.meta.dir, "..", "package.json")
+    resolve41(import.meta.dir, "..", "..", "package.json"),
+    resolve41(import.meta.dir, "..", "package.json")
   ];
   const [candidate, ...remaining] = candidates;
   if (!candidate) {
@@ -24328,7 +24805,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(resolve40(vendorDir, entry)).bytes();
+    const bytes = await Bun.file(resolve41(vendorDir, entry)).bytes();
     assetStore.set(webPath, bytes);
   }));
 }, devBuild = async (config) => {
@@ -24377,16 +24854,27 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   await resolveAbsoluteVersion2();
   recordStep("resolve version", stepStartedAt);
   const buildStart = performance.now();
-  const buildResult = await build({
-    ...config,
-    mode: "development",
-    options: {
-      ...config.options,
-      injectHMR: true
+  let buildResult = null;
+  try {
+    buildResult = await build({
+      ...config,
+      mode: "development",
+      options: {
+        ...config.options,
+        injectHMR: true,
+        throwOnError: true
+      }
+    });
+  } catch (err) {
+    console.error(`[hmr] initial build failed \u2014 starting dev server with an empty manifest.
+` + "      Fix the error above and save the file to trigger a recovery rebuild.");
+    if (err instanceof Error && err.stack) {
+      console.error(err.stack);
     }
-  });
-  const manifest = buildResult.manifest ?? {};
-  const conventions = buildResult.conventions ?? {};
+    state.initialBuildFailed = true;
+  }
+  const manifest = buildResult?.manifest ?? {};
+  const conventions = buildResult?.conventions ?? {};
   recordStep("initial build", buildStart);
   if (Object.keys(manifest).length === 0) {
     console.log("\u26A0\uFE0F Manifest is empty - this is OK for HTML/HTMX-only projects");
@@ -24396,11 +24884,11 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   cleanStaleAssets(state.assetStore, manifest, state.resolvedPaths.buildDir);
   recordStep("populate asset store", stepStartedAt);
   stepStartedAt = performance.now();
-  const reactVendorDir = resolve40(state.resolvedPaths.buildDir, "react", "vendor");
-  const angularVendorDir = resolve40(state.resolvedPaths.buildDir, "angular", "vendor");
-  const svelteVendorDir = resolve40(state.resolvedPaths.buildDir, "svelte", "vendor");
-  const vueVendorDir = resolve40(state.resolvedPaths.buildDir, "vue", "vendor");
-  const depVendorDir = resolve40(state.resolvedPaths.buildDir, "vendor");
+  const reactVendorDir = resolve41(state.resolvedPaths.buildDir, "react", "vendor");
+  const angularVendorDir = resolve41(state.resolvedPaths.buildDir, "angular", "vendor");
+  const svelteVendorDir = resolve41(state.resolvedPaths.buildDir, "svelte", "vendor");
+  const vueVendorDir = resolve41(state.resolvedPaths.buildDir, "vue", "vendor");
+  const depVendorDir = resolve41(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),
@@ -24466,7 +24954,37 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   }
   state.manifest = manifest;
   stepStartedAt = performance.now();
+  const recoverFromColdStartFailure = async () => {
+    await waitForRebuild(state);
+    state.isRebuilding = true;
+    try {
+      const recoveryResult = await build({
+        ...config,
+        mode: "development",
+        options: {
+          ...config.options,
+          injectHMR: true,
+          throwOnError: true
+        }
+      });
+      if (recoveryResult?.manifest) {
+        Object.assign(manifest, recoveryResult.manifest);
+        state.manifest = manifest;
+        await populateAssetStore(state.assetStore, manifest, state.resolvedPaths.buildDir);
+        state.initialBuildFailed = false;
+        console.log("[hmr] cold-start recovery rebuild succeeded \u2014 manifest populated.");
+      }
+    } catch {} finally {
+      state.rebuildCount++;
+      state.isRebuilding = false;
+      state.fileChangeQueue.clear();
+    }
+  };
   startFileWatching(state, config, (filePath) => {
+    if (state.initialBuildFailed) {
+      recoverFromColdStartFailure();
+      return;
+    }
     queueFileChange(state, filePath, config, (newBuildResult) => {
       Object.assign(manifest, newBuildResult.manifest);
       state.manifest = manifest;
@@ -24481,7 +24999,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     manifest
   };
   globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync6(resolve40(Bun.main)).mtimeMs;
+  globalThis.__hmrServerMtime = statSync7(resolve41(Bun.main)).mtimeMs;
   return result;
 };
 var init_devBuild = __esm(() => {
@@ -24521,5 +25039,5 @@ export {
   build
 };
 
-//# debugId=B8826CA959AD016E64756E2164756E21
+//# debugId=5DF1E4572046015A64756E2164756E21
 //# sourceMappingURL=build.js.map