@absolutejs/absolute 0.20.0-beta.66 → 0.20.0-beta.67

package/dist/index.js

@@ -9949,7 +9949,7 @@ var init_getDurationString = __esm(() => {
 });
 
 // src/utils/startupTimings.ts
-var startupTimingsEnabled, formatStartupTimingBlock = (title, steps) => {
+var isTruthyFlag = (value) => value === "1" || value === "true", devProfileEnabled, startupTimingsEnabled, formatStartupTimingBlock = (title, steps) => {
   const totalDuration = steps.reduce((sum, step) => sum + step.durationMs, 0);
   return [
     title,
@@ -9961,11 +9961,12 @@ var startupTimingsEnabled, formatStartupTimingBlock = (title, steps) => {
   if (!startupTimingsEnabled || steps.length === 0) {
     return;
   }
-  console.log(formatStartupTimingBlock(title, steps));
+  console.error(formatStartupTimingBlock(title, steps));
 };
 var init_startupTimings = __esm(() => {
   init_getDurationString();
-  startupTimingsEnabled = process.env.ABSOLUTE_STARTUP_TIMINGS === "1" || process.env.ABSOLUTE_STARTUP_TIMINGS === "true";
+  devProfileEnabled = isTruthyFlag(process.env.ABSOLUTE_DEV_PROFILE);
+  startupTimingsEnabled = devProfileEnabled || isTruthyFlag(process.env.ABSOLUTE_STARTUP_TIMINGS);
 });
 
 // src/utils/startupBanner.ts
@@ -10113,6 +10114,37 @@ var init_logger = __esm(() => {
   };
 });
 
+// src/dev/bootLifecycle.ts
+var DEFERRED_TASK_FALLBACK_SECONDS = 15, setBootPhase = (phase) => {
+  globalThis.__absoluteBootPhase = phase;
+}, runTask = async (task) => {
+  try {
+    await task();
+  } catch (error) {
+    console.error(`[dev] deferred boot task failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}, deferUntilServing = (task) => {
+  if (globalThis.__absoluteDeferredBootTasksRan) {
+    runTask(task);
+    return;
+  }
+  const queue = globalThis.__absoluteDeferredBootTasks ?? [];
+  globalThis.__absoluteDeferredBootTasks = queue;
+  queue.push(task);
+  const timer = setTimeout(runDeferredBootTasks, DEFERRED_TASK_FALLBACK_SECONDS * MILLISECONDS_IN_A_SECOND);
+  if (typeof timer === "object" && "unref" in timer)
+    timer.unref();
+}, runDeferredBootTasks = () => {
+  const tasks = globalThis.__absoluteDeferredBootTasks ?? [];
+  globalThis.__absoluteDeferredBootTasks = [];
+  globalThis.__absoluteDeferredBootTasksRan = true;
+  for (const task of tasks)
+    runTask(task);
+};
+var init_bootLifecycle = __esm(() => {
+  init_constants();
+});
+
 // src/core/devRouteRegistrationCallsite.ts
 var exports_devRouteRegistrationCallsite = {};
 __export(exports_devRouteRegistrationCallsite, {
@@ -15429,6 +15461,7 @@ var exports_chainInlineSourcemaps = {};
 __export(exports_chainInlineSourcemaps, {
   buildLineRemap: () => buildLineRemap,
   chainBundleInlineSourcemap: () => chainBundleInlineSourcemap,
+  chainBundleInlineSourcemaps: () => chainBundleInlineSourcemaps,
   chainExternalSourcemap: () => chainExternalSourcemap,
   chainSourcemap: () => chainSourcemap,
   inlineLineMapComment: () => inlineLineMapComment,
@@ -15742,6 +15775,10 @@ var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567
   const inline = `
 //# sourceMappingURL=data:application/json;base64,` + Buffer.from(JSON.stringify(chained)).toString("base64");
   writeFileSync8(bundleFilePath, stripped + inline);
+}, chainBundleInlineSourcemaps = async (bundlePaths) => {
+  for (const bundlePath of bundlePaths) {
+    chainBundleInlineSourcemap(bundlePath);
+  }
 }, chainExternalSourcemap = (mapFilePath) => {
   let outerMap;
   try {
@@ -15835,6 +15872,98 @@ var init_vueAutoRouterTransform = __esm(() => {
   SETUP_APP_FUNCTION_REGEX = /\bexport\s+(async\s+function|function)\s+setupApp\b/;
 });
 
+// src/build/vueCompileCache.ts
+import { createHash as createHash9 } from "crypto";
+import {
+  existsSync as existsSync26,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync25,
+  renameSync,
+  writeFileSync as writeFileSync9
+} from "fs";
+import { join as join37, resolve as resolve28 } from "path";
+var CACHE_DIR_NAME = "compile-cache", ABSOLUTE_CACHE_DIR_NAME2 = ".absolutejs", CACHE_FORMAT_VERSION = 1, FILE_NAME_HASH_LENGTH = 32, vueCompileCacheEnabled = () => process.env.ABSOLUTE_COMPILE_CACHE !== "0", hashContent = (content) => createHash9("sha256").update(content).digest("hex"), hashParts = (parts) => {
+  const hash = createHash9("sha256");
+  for (const part of parts) {
+    hash.update(part);
+    hash.update("\x00");
+  }
+  return hash.digest("hex");
+}, readOwnPackageVersion = () => {
+  const candidates = [
+    resolve28(import.meta.dir, "..", "..", "package.json"),
+    resolve28(import.meta.dir, "..", "package.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const pkg = JSON.parse(readFileSync25(candidate, "utf-8"));
+      if (pkg.name === "@absolutejs/absolute" && pkg.version) {
+        return pkg.version;
+      }
+    } catch {}
+  }
+  return globalThis.__absoluteVersion ?? null;
+}, cachedFrameworkVersion, frameworkVersionForCache = () => {
+  cachedFrameworkVersion ??= readOwnPackageVersion();
+  return cachedFrameworkVersion;
+}, vueCompileCacheDir = (projectRoot = process.cwd()) => join37(projectRoot, ABSOLUTE_CACHE_DIR_NAME2, CACHE_DIR_NAME, "vue"), entryFileFor = (sourceFilePath, projectRoot) => join37(vueCompileCacheDir(projectRoot), `${hashContent(sourceFilePath).slice(0, FILE_NAME_HASH_LENGTH)}.json`), vueCompileCacheFingerprint = (parts) => {
+  const frameworkVersion = frameworkVersionForCache();
+  if (!frameworkVersion)
+    return null;
+  return hashParts([
+    String(CACHE_FORMAT_VERSION),
+    frameworkVersion,
+    parts.compilerVersion ?? "unknown-vue-compiler",
+    JSON.stringify(parts.stylePreprocessors ?? null),
+    parts.vueRootDir,
+    parts.outputDirs.client,
+    parts.outputDirs.server,
+    parts.outputDirs.css
+  ]);
+}, typeDepsUnchanged = (typeDeps) => {
+  for (const [path, hash] of Object.entries(typeDeps)) {
+    try {
+      if (hashContent(readFileSync25(path, "utf-8")) !== hash)
+        return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}, isEntryShape = (value) => {
+  if (!value || typeof value !== "object")
+    return false;
+  const entry = value;
+  return typeof entry.key === "string" && typeof entry.clientCode === "string" && typeof entry.serverCode === "string" && typeof entry.result === "object" && entry.result !== null && typeof entry.typeDeps === "object" && entry.typeDeps !== null;
+}, readVueCompileCacheEntry = (sourceFilePath, key, projectRoot) => {
+  if (!vueCompileCacheEnabled())
+    return null;
+  const entryFile = entryFileFor(sourceFilePath, projectRoot);
+  if (!existsSync26(entryFile))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync25(entryFile, "utf-8"));
+    if (!isEntryShape(parsed) || parsed.key !== key)
+      return null;
+    if (!typeDepsUnchanged(parsed.typeDeps))
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}, writeVueCompileCacheEntry = (sourceFilePath, entry, projectRoot) => {
+  if (!vueCompileCacheEnabled())
+    return;
+  const entryFile = entryFileFor(sourceFilePath, projectRoot);
+  try {
+    mkdirSync8(vueCompileCacheDir(projectRoot), { recursive: true });
+    const tempFile = `${entryFile}.${process.pid}.tmp`;
+    writeFileSync9(tempFile, JSON.stringify(entry));
+    renameSync(tempFile, entryFile);
+  } catch {}
+};
+var init_vueCompileCache = () => {};
+
 // src/build/compileVue.ts
 var exports_compileVue = {};
 __export(exports_compileVue, {
@@ -15844,27 +15973,27 @@ __export(exports_compileVue, {
   generateVueHmrId: () => generateVueHmrId,
   vueHmrMetadata: () => vueHmrMetadata
 });
-import { existsSync as existsSync26, readFileSync as readFileSync25, realpathSync as realpathSync2 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync26, realpathSync as realpathSync2 } from "fs";
 import { mkdir as mkdir10 } from "fs/promises";
 import {
   basename as basename11,
   dirname as dirname20,
   isAbsolute as isAbsolute4,
-  join as join37,
+  join as join38,
   relative as relative13,
-  resolve as resolve28
+  resolve as resolve29
 } from "path";
 var {file: file3, write: write3, Transpiler: Transpiler3 } = globalThis.Bun;
 var resolveDevClientDir3 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve28(import.meta.dir, "../dev/client");
-  if (existsSync26(fromSource) && fromSource.startsWith(projectRoot)) {
+  const fromSource = resolve29(import.meta.dir, "../dev/client");
+  if (existsSync27(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve28(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync26(fromNodeModules))
+  const fromNodeModules = resolve29(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  if (existsSync27(fromNodeModules))
     return fromNodeModules;
-  return resolve28(import.meta.dir, "./dev/client");
+  return resolve29(import.meta.dir, "./dev/client");
 }, devClientDir3, hmrClientPath4, transpiler4, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, clearVueHmrCaches = () => {
   scriptCache.clear();
   scriptSetupCache.clear();
@@ -15914,20 +16043,20 @@ var resolveDevClientDir3 = () => {
   visited.add(resolved);
   const importRegex = /@import\s+(?:url\(\s*)?(['"])(\.{1,2}\/[^'"]+)\1\s*\)?\s*;?/g;
   return cssContent.replace(importRegex, (match, _quote, relPath) => {
-    const importedPath = resolve28(dirname20(cssFilePath), relPath);
-    if (!existsSync26(importedPath))
+    const importedPath = resolve29(dirname20(cssFilePath), relPath);
+    if (!existsSync27(importedPath))
       return match;
-    const importedContent = readFileSync25(importedPath, "utf-8");
+    const importedContent = readFileSync26(importedPath, "utf-8");
     return inlineCssImports(importedContent, importedPath, visited);
   });
 }, resolveHelperTsPath = (sourceDir, helper) => {
   if (helper.endsWith(".ts"))
-    return resolve28(sourceDir, helper);
-  const direct = resolve28(sourceDir, `${helper}.ts`);
-  if (existsSync26(direct))
+    return resolve29(sourceDir, helper);
+  const direct = resolve29(sourceDir, `${helper}.ts`);
+  if (existsSync27(direct))
     return direct;
-  const indexed = resolve28(sourceDir, helper, "index.ts");
-  if (existsSync26(indexed))
+  const indexed = resolve29(sourceDir, helper, "index.ts");
+  if (existsSync27(indexed))
     return indexed;
   return direct;
 }, toJs = (filePath, sourceDir) => {
@@ -15937,16 +16066,16 @@ var resolveDevClientDir3 = () => {
     return filePath.replace(/\.ts$/, ".js");
   if (isStylePath(filePath)) {
     if (sourceDir && (filePath.startsWith("./") || filePath.startsWith("../"))) {
-      return resolve28(sourceDir, filePath);
+      return resolve29(sourceDir, filePath);
     }
     return filePath;
   }
   if (sourceDir && (filePath.startsWith("./") || filePath.startsWith("../"))) {
-    const directTs = resolve28(sourceDir, `${filePath}.ts`);
-    if (existsSync26(directTs))
+    const directTs = resolve29(sourceDir, `${filePath}.ts`);
+    if (existsSync27(directTs))
       return `${filePath}.js`;
-    const indexedTs = resolve28(sourceDir, filePath, "index.ts");
-    if (existsSync26(indexedTs))
+    const indexedTs = resolve29(sourceDir, filePath, "index.ts");
+    if (existsSync27(indexedTs))
       return `${filePath}/index.js`;
   }
   return `${filePath}.js`;
@@ -15993,6 +16122,50 @@ const ${localName} = (source) => ${importedName}(
     : { ...source, loader: () => __absoluteResolveAsyncVueComponent(source.loader) },
 );`;
   return code.replace(vueImportRegex, `import { ${specifiers.join(", ")} } from 'vue';${wrapper}`);
+}, EXTERNAL_STYLE_DEPENDENCY, hasExternalStyleDependency = (descriptor) => descriptor.styles.some((styleBlock) => Boolean(styleBlock.lang) || EXTERNAL_STYLE_DEPENDENCY.test(styleBlock.content)), fingerprintCache, currentVueCompileFingerprint = (compiler, outputDirs, vueRootDir, stylePreprocessors) => {
+  const memoKey = JSON.stringify([outputDirs, vueRootDir, stylePreprocessors]);
+  const memoised = fingerprintCache.get(memoKey);
+  if (memoised !== undefined)
+    return memoised;
+  const fingerprint = vueCompileCacheFingerprint({
+    compilerVersion: compiler.version,
+    outputDirs,
+    stylePreprocessors,
+    vueRootDir
+  });
+  fingerprintCache.set(memoKey, fingerprint);
+  return fingerprint;
+}, computeVueCompileCacheKey = (parts) => {
+  if (!parts.fingerprint || !vueCompileCacheEnabled())
+    return;
+  if (hasExternalStyleDependency(parts.descriptor))
+    return;
+  const childKeys = [];
+  for (const child of parts.childResults) {
+    if (!child.cacheKey)
+      return;
+    childKeys.push(child.cacheKey);
+  }
+  return hashParts([
+    parts.fingerprint,
+    parts.relativeWithoutExtension,
+    parts.isEntryPoint ? "entry" : "child",
+    parts.contentHash,
+    ...childKeys
+  ]);
+}, materialiseVueCompileCacheEntry = async (entry, cacheKey2, isEntryPoint, outputDirs, fileBaseName) => {
+  const { result } = entry;
+  await mkdir10(dirname20(result.clientPath), { recursive: true });
+  await mkdir10(dirname20(result.serverPath), { recursive: true });
+  await write3(result.clientPath, entry.clientCode);
+  await write3(result.serverPath, entry.serverCode);
+  if (isEntryPoint && result.cssCodes.length > 0) {
+    const cssOutputFile = join38(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
+    await mkdir10(dirname20(cssOutputFile), { recursive: true });
+    await write3(cssOutputFile, result.cssCodes.join(`
+`));
+  }
+  return { ...result, cacheKey: cacheKey2 };
 }, compileVueFile = async (sourceFilePath, outputDirs, cacheMap, isEntryPoint, vueRootDir, compiler, stylePreprocessors) => {
   const cachedResult = cacheMap.get(sourceFilePath);
   if (cachedResult)
@@ -16007,7 +16180,7 @@ const ${localName} = (source) => ${importedName}(
   const contentHash = Bun.hash(sourceContent).toString(BASE_36_RADIX);
   const prevHash = vueSourceHashCache.get(sourceFilePath);
   const persistent = persistentBuildCache.get(sourceFilePath);
-  if (prevHash === contentHash && persistent && existsSync26(persistent.clientPath) && existsSync26(persistent.serverPath)) {
+  if (prevHash === contentHash && persistent && existsSync27(persistent.clientPath) && existsSync27(persistent.serverPath)) {
     cacheMap.set(sourceFilePath, persistent);
     return persistent;
   }
@@ -16036,25 +16209,55 @@ const ${localName} = (source) => ${importedName}(
   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(".") || isAbsolute4(path)) && isStylePath(path)).map((path) => isAbsolute4(path) ? path : resolve28(dirname20(sourceFilePath), path));
+  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute4(path)) && isStylePath(path)).map((path) => isAbsolute4(path) ? path : resolve29(dirname20(sourceFilePath), path));
   for (const stylePath of stylePathsImported) {
     addStyleImporter(sourceFilePath, stylePath);
   }
   const childBuildResults = await Promise.all([
-    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve28(dirname20(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
+    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve29(dirname20(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
     ...packageComponentPaths.map(([, absolutePath]) => compileVueFile(absolutePath, outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors))
   ]);
+  const cacheKey2 = computeVueCompileCacheKey({
+    childResults: childBuildResults,
+    contentHash,
+    descriptor,
+    fingerprint: currentVueCompileFingerprint(compiler, outputDirs, vueRootDir, stylePreprocessors),
+    isEntryPoint,
+    relativeWithoutExtension
+  });
+  const typeDepHashes = {};
+  if (cacheKey2) {
+    const restored = readVueCompileCacheEntry(sourceFilePath, cacheKey2);
+    if (restored) {
+      const result2 = await materialiseVueCompileCacheEntry(restored, cacheKey2, isEntryPoint, outputDirs, fileBaseName);
+      cacheMap.set(sourceFilePath, result2);
+      persistentBuildCache.set(sourceFilePath, result2);
+      return result2;
+    }
+  }
   const hasScript = descriptor.script || descriptor.scriptSetup;
   const compiledScript = hasScript ? compiler.compileScript(descriptor, {
     fs: {
-      fileExists: existsSync26,
-      readFile: (file4) => existsSync26(file4) ? readFileSync25(file4, "utf-8") : undefined,
+      fileExists: existsSync27,
+      readFile: (file4) => {
+        if (!existsSync27(file4))
+          return;
+        const content = readFileSync26(file4, "utf-8");
+        typeDepHashes[file4] = hashContent(content);
+        return content;
+      },
       realpath: realpathSync2
     },
     id: componentId,
     inlineTemplate: false,
     sourceMap: true
   }) : { bindings: {}, content: "export default {};", map: undefined };
+  const typeDependencies = "deps" in compiledScript ? compiledScript.deps ?? [] : [];
+  for (const dep of typeDependencies) {
+    if (dep in typeDepHashes || !existsSync27(dep))
+      continue;
+    typeDepHashes[dep] = hashContent(readFileSync26(dep, "utf-8"));
+  }
   const strippedScript = stripExports2(compiledScript.content);
   const sourceDir = dirname20(sourceFilePath);
   const transpiledScript = transpiler4.transformSync(strippedScript).replace(/(['"])(\.{1,2}\/[^'"]+)(['"])/g, (_2, quoteStart, relativeImport, quoteEnd) => `${quoteStart}${toJs(relativeImport, sourceDir)}${quoteEnd}`);
@@ -16101,7 +16304,7 @@ const ${localName} = (source) => ${importedName}(
   ];
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
-    const cssOutputFile = join37(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
+    const cssOutputFile = join38(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
     await mkdir10(dirname20(cssOutputFile), { recursive: true });
     await write3(cssOutputFile, allCss.join(`
 `));
@@ -16132,8 +16335,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
   const clientCode = assembleModule(generateRenderFunction(false), "render", true) + islandMetadataExports;
   const serverCode = wrapServerAsyncComponentLoader(assembleModule(generateRenderFunction(true), "ssrRender", false)) + islandMetadataExports;
-  const clientOutputPath = join37(outputDirs.client, `${relativeWithoutExtension}.js`);
-  const serverOutputPath = join37(outputDirs.server, `${relativeWithoutExtension}.js`);
+  const clientOutputPath = join38(outputDirs.client, `${relativeWithoutExtension}.js`);
+  const serverOutputPath = join38(outputDirs.server, `${relativeWithoutExtension}.js`);
   const rewritePackageImports = (code, outputPath, mode) => {
     let result2 = code;
     for (const [bareImport, paths] of packageImportRewrites) {
@@ -16159,9 +16362,11 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
 //# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(map)).toString("base64")}
 `;
   };
-  await write3(clientOutputPath, clientFinal + inlineSourceMapFor(clientFinal));
-  await write3(serverOutputPath, serverFinal + inlineSourceMapFor(serverFinal));
-  const result = {
+  const clientOutput = clientFinal + inlineSourceMapFor(clientFinal);
+  const serverOutput = serverFinal + inlineSourceMapFor(serverFinal);
+  await write3(clientOutputPath, clientOutput);
+  await write3(serverOutputPath, serverOutput);
+  const cacheableResult = {
     clientPath: clientOutputPath,
     cssCodes: allCss,
     cssPaths: cssOutputPaths,
@@ -16173,16 +16378,26 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
       ...childBuildResults.flatMap((child) => child.tsHelperPaths)
     ]
   };
+  const result = { ...cacheableResult, cacheKey: cacheKey2 };
   cacheMap.set(sourceFilePath, result);
   persistentBuildCache.set(sourceFilePath, result);
+  if (cacheKey2) {
+    writeVueCompileCacheEntry(sourceFilePath, {
+      clientCode: clientOutput,
+      key: cacheKey2,
+      result: cacheableResult,
+      serverCode: serverOutput,
+      typeDeps: typeDepHashes
+    });
+  }
   return result;
 }, compileVue = async (entryPoints, vueRootDir, isDev2 = false, stylePreprocessors, ssrOnlyEntries) => {
   const compiler = await loadVueCompiler();
   const generatedDir = getFrameworkGeneratedDir("vue");
-  const clientOutputDir = join37(generatedDir, "client");
-  const indexOutputDir = join37(generatedDir, "indexes");
-  const serverOutputDir = join37(generatedDir, "server");
-  const cssOutputDir = join37(generatedDir, "compiled");
+  const clientOutputDir = join38(generatedDir, "client");
+  const indexOutputDir = join38(generatedDir, "indexes");
+  const serverOutputDir = join38(generatedDir, "server");
+  const cssOutputDir = join38(generatedDir, "compiled");
   await Promise.all([
     mkdir10(clientOutputDir, { recursive: true }),
     mkdir10(indexOutputDir, { recursive: true }),
@@ -16192,7 +16407,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   const buildCache = new Map;
   const allTsHelperPaths = new Set;
   const expandSpaRouteChildren = async (entries) => {
-    const expanded = new Set(entries.map((entry) => resolve28(entry)));
+    const expanded = new Set(entries.map((entry) => resolve29(entry)));
     const queue2 = [...expanded];
     while (queue2.length > 0) {
       const entryPath = queue2.pop();
@@ -16209,8 +16424,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
       });
       const routes = parseVueSpaRoutes(descriptor.script?.content ?? "");
       for (const { importPath } of routes) {
-        const childPath = resolve28(dirname20(entryPath), importPath);
-        if (expanded.has(childPath) || !existsSync26(childPath)) {
+        const childPath = resolve29(dirname20(entryPath), importPath);
+        if (expanded.has(childPath) || !existsSync27(childPath)) {
           continue;
         }
         expanded.add(childPath);
@@ -16221,7 +16436,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
   const expandedEntryPoints = await expandSpaRouteChildren(entryPoints);
   const compiledPages = await Promise.all(expandedEntryPoints.map(async (entryPath) => {
-    const resolvedEntryPath = resolve28(entryPath);
+    const resolvedEntryPath = resolve29(entryPath);
     const result = await compileVueFile(resolvedEntryPath, {
       client: clientOutputDir,
       css: cssOutputDir,
@@ -16239,8 +16454,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
       };
     }
     const entryBaseName = basename11(entryPath, ".vue");
-    const indexOutputFile = join37(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join37(clientOutputDir, relative13(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    const indexOutputFile = join38(indexOutputDir, `${entryBaseName}.js`);
+    const clientOutputFile = join38(clientOutputDir, relative13(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
     await mkdir10(dirname20(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev2 ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
@@ -16424,7 +16639,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
         continue;
       }
       const resolved = resolveHelperTsPath(helperDir, dep);
-      if (!existsSync26(resolved))
+      if (!existsSync27(resolved))
         continue;
       if (allTsHelperPaths.has(resolved))
         continue;
@@ -16437,8 +16652,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     const transpiledCode = transpiler4.transformSync(sourceCode);
     const withMap = transpiledCode + inlineLineMapComment(tsPath, sourceCode, transpiledCode);
     const relativeJsPath = relative13(vueRootDir, tsPath).replace(/\.ts$/, ".js");
-    const outClientPath = join37(clientOutputDir, relativeJsPath);
-    const outServerPath = join37(serverOutputDir, relativeJsPath);
+    const outClientPath = join38(clientOutputDir, relativeJsPath);
+    const outServerPath = join38(serverOutputDir, relativeJsPath);
     await mkdir10(dirname20(outClientPath), { recursive: true });
     await mkdir10(dirname20(outServerPath), { recursive: true });
     await write3(outClientPath, withMap);
@@ -16469,8 +16684,9 @@ var init_compileVue = __esm(() => {
   init_chainInlineSourcemaps();
   init_vueAutoRouterTransform();
   init_stylePreprocessor();
+  init_vueCompileCache();
   devClientDir3 = resolveDevClientDir3();
-  hmrClientPath4 = join37(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath4 = join38(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
   transpiler4 = new Transpiler3({ loader: "ts", target: "browser" });
   scriptCache = new Map;
   scriptSetupCache = new Map;
@@ -16479,6 +16695,8 @@ var init_compileVue = __esm(() => {
   persistentBuildCache = new Map;
   vueSourceHashCache = new Map;
   vueHmrMetadata = new Map;
+  EXTERNAL_STYLE_DEPENDENCY = /@(?:import|use|forward)\b/;
+  fingerprintCache = new Map;
 });
 
 // src/angular/lowerDeferSyntax.ts
@@ -16951,8 +17169,8 @@ __export(exports_compileAngular, {
   compileAngularFiles: () => compileAngularFiles,
   invalidateAngularJitCache: () => invalidateAngularJitCache
 });
-import { existsSync as existsSync27, readFileSync as readFileSync26, promises as fs5 } from "fs";
-import { join as join38, basename as basename12, sep as sep3, dirname as dirname21, resolve as resolve29, relative as relative14 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync27, promises as fs5 } from "fs";
+import { join as join39, basename as basename12, sep as sep3, dirname as dirname21, resolve as resolve30, relative as relative14 } from "path";
 var {Glob: Glob6 } = globalThis.Bun;
 import ts14 from "typescript";
 var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) => {
@@ -16968,10 +17186,10 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
   return tracePhase ? tracePhase(`compile/angular/${name}`, fn2, metadata2) : await fn2();
 }, readTsconfigPathAliases = () => {
   try {
-    const configPath2 = resolve29(process.cwd(), "tsconfig.json");
+    const configPath2 = resolve30(process.cwd(), "tsconfig.json");
     const config = ts14.readConfigFile(configPath2, ts14.sys.readFile).config;
     const compilerOptions = config?.compilerOptions ?? {};
-    const baseUrl = resolve29(process.cwd(), compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve30(process.cwd(), compilerOptions.baseUrl ?? ".");
     const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
     return { aliases, baseUrl };
   } catch {
@@ -16991,7 +17209,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
     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(resolve29(baseUrl, candidate));
+      const resolved = resolveSourceFile(resolve30(baseUrl, candidate));
       if (resolved)
         return resolved;
     }
@@ -17003,20 +17221,20 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
     `${candidate}.tsx`,
     `${candidate}.js`,
     `${candidate}.jsx`,
-    join38(candidate, "index.ts"),
-    join38(candidate, "index.tsx"),
-    join38(candidate, "index.js"),
-    join38(candidate, "index.jsx")
+    join39(candidate, "index.ts"),
+    join39(candidate, "index.tsx"),
+    join39(candidate, "index.js"),
+    join39(candidate, "index.jsx")
   ];
-  return candidates.find((file4) => existsSync27(file4));
+  return candidates.find((file4) => existsSync28(file4));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
-  const baseDir = resolve29(rootDir);
+  const baseDir = resolve30(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(resolve29(fromDir, specifier));
+      return resolveSourceFile(resolve30(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile);
     if (aliased)
@@ -17025,7 +17243,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve29(resolved);
+      const absolute = resolve30(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile(absolute);
@@ -17041,7 +17259,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
         usesLegacyAnimations: false
       });
     }
-    const resolved = resolve29(actualPath);
+    const resolved = resolve30(actualPath);
     const cached = scanCache.get(resolved);
     if (cached)
       return cached;
@@ -17070,7 +17288,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
     const actualPath = resolveSourceFile(filePath);
     if (!actualPath)
       return false;
-    const resolved = resolve29(actualPath);
+    const resolved = resolve30(actualPath);
     if (visited.has(resolved))
       return false;
     visited.add(resolved);
@@ -17088,14 +17306,14 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
   return (entryPath) => visit(entryPath);
 }, resolveDevClientDir4 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve29(import.meta.dir, "../dev/client");
-  if (existsSync27(fromSource) && fromSource.startsWith(projectRoot)) {
+  const fromSource = resolve30(import.meta.dir, "../dev/client");
+  if (existsSync28(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve29(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync27(fromNodeModules))
+  const fromNodeModules = resolve30(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  if (existsSync28(fromNodeModules))
     return fromNodeModules;
-  return resolve29(import.meta.dir, "./dev/client");
+  return resolve30(import.meta.dir, "./dev/client");
 }, devClientDir4, hmrClientPath5, formatDiagnosticMessage = (diagnostic) => {
   try {
     return ts14.flattenDiagnosticMessageText(diagnostic.messageText, `
@@ -17138,12 +17356,12 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
   if (hasJsLikeExtension(path))
     return `${path}${query}`;
   const importerDir = dirname21(importerOutputPath);
-  const fileCandidate = resolve29(importerDir, `${path}.js`);
-  if (outputFiles?.has(fileCandidate) || existsSync27(fileCandidate)) {
+  const fileCandidate = resolve30(importerDir, `${path}.js`);
+  if (outputFiles?.has(fileCandidate) || existsSync28(fileCandidate)) {
     return `${path}.js${query}`;
   }
-  const indexCandidate = resolve29(importerDir, path, "index.js");
-  if (outputFiles?.has(indexCandidate) || existsSync27(indexCandidate)) {
+  const indexCandidate = resolve30(importerDir, path, "index.js");
+  if (outputFiles?.has(indexCandidate) || existsSync28(indexCandidate)) {
     return `${path}/index.js${query}`;
   }
   return `${path}.js${query}`;
@@ -17170,18 +17388,18 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve29(dirname21(fromFile), specifier);
+  const basePath = resolve30(dirname21(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join38(basePath, "index.ts"),
-    join38(basePath, "index.tsx"),
-    join38(basePath, "index.mts"),
-    join38(basePath, "index.cts")
+    join39(basePath, "index.ts"),
+    join39(basePath, "index.tsx"),
+    join39(basePath, "index.mts"),
+    join39(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve29(candidate)).find((candidate) => existsSync27(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+  return candidates.map((candidate) => resolve30(candidate)).find((candidate) => existsSync28(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile9) => {
   const hostSource = readFile9?.(fileName);
   if (typeof hostSource === "string")
@@ -17205,18 +17423,18 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
   const paths = [];
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1])
-    paths.push(join38(fileDir, templateUrlMatch[1]));
+    paths.push(join39(fileDir, templateUrlMatch[1]));
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (styleUrlMatch?.[1])
-    paths.push(join38(fileDir, styleUrlMatch[1]));
+    paths.push(join39(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(join38(fileDir, urlMatch.replace(/['"]/g, "")));
+      paths.push(join39(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
-  return paths.map((path) => resolve29(path));
+  return paths.map((path) => resolve30(path));
 }, readResourceCacheFile = async (cachePath) => {
   try {
     const entry = JSON.parse(await fs5.readFile(cachePath, "utf-8"));
@@ -17247,7 +17465,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
     safeStableStringify(stylePreprocessors ?? null)
   ].join("\x00");
   const cacheKey2 = Bun.hash(cacheInput).toString(BASE_36_RADIX);
-  return join38(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
+  return join39(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
 }, precomputeAotResourceTransforms = async (inputPaths, readFile9, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
@@ -17258,11 +17476,11 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
     transformedFiles: 0
   };
   const transformFile = async (filePath) => {
-    const resolvedPath = resolve29(filePath);
+    const resolvedPath = resolve30(filePath);
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
-    if (!existsSync27(resolvedPath) || resolvedPath.endsWith(".d.ts"))
+    if (!existsSync28(resolvedPath) || resolvedPath.endsWith(".d.ts"))
       return;
     stats.filesVisited += 1;
     const source = await readFileForAotTransform(resolvedPath, readFile9);
@@ -17293,10 +17511,10 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
   return { stats, transformedSources };
 }, compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
   const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
-    const outputPath = resolve29(join38(outDir, relative14(process.cwd(), resolve29(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve30(join39(outDir, relative14(process.cwd(), resolve30(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
-      buildIslandMetadataExports(readFileSync26(inputPath, "utf-8"))
+      buildIslandMetadataExports(readFileSync27(inputPath, "utf-8"))
     ];
   })), { entries: inputPaths.length });
   await traceAngularPhase("aot/preload-compiler", () => import("@angular/compiler"));
@@ -17304,7 +17522,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
   const tsLibDir = await traceAngularPhase("aot/resolve-typescript-lib", () => {
     const tsPath = __require.resolve("typescript");
     const tsRootDir = dirname21(tsPath);
-    return tsRootDir.endsWith("lib") ? tsRootDir : resolve29(tsRootDir, "lib");
+    return tsRootDir.endsWith("lib") ? tsRootDir : resolve30(tsRootDir, "lib");
   });
   const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
   const options = {
@@ -17340,13 +17558,13 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
   const originalGetSourceFile = host2.getSourceFile;
   host2.getSourceFile = (fileName, languageVersion, onError) => {
     if (fileName.startsWith("lib.") && fileName.endsWith(".d.ts") && tsLibDir) {
-      const resolvedPath = join38(tsLibDir, fileName);
+      const resolvedPath = join39(tsLibDir, fileName);
       return originalGetSourceFile?.call(host2, resolvedPath, languageVersion, onError);
     }
     return originalGetSourceFile?.call(host2, fileName, languageVersion, onError);
   };
   const emitted = {};
-  const resolvedOutDir = resolve29(outDir);
+  const resolvedOutDir = resolve30(outDir);
   host2.writeFile = (fileName, text2) => {
     const relativePath = resolveRelativePath(fileName, resolvedOutDir, outDir);
     emitted[relativePath] = text2;
@@ -17368,12 +17586,12 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
     if (!fileName.endsWith(".ts") || fileName.endsWith(".d.ts")) {
       return source;
     }
-    const resolvedPath = resolve29(fileName);
+    const resolvedPath = resolve30(fileName);
     return transformedSources.get(resolvedPath) ?? source;
   };
   const originalGetSourceFileForCompile = host2.getSourceFile;
   host2.getSourceFile = (fileName, languageVersion, onError) => {
-    const source = transformedSources.get(resolve29(fileName));
+    const source = transformedSources.get(resolve30(fileName));
     if (source) {
       return ts14.createSourceFile(fileName, source, languageVersion, true);
     }
@@ -17395,9 +17613,9 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
   const entries = await traceAngularPhase("aot/postprocess-emitted-js", () => {
     const rawEntries = Object.entries(emitted).filter(([fileName]) => fileName.endsWith(".js")).map(([fileName, content]) => ({
       content,
-      target: join38(outDir, fileName)
+      target: join39(outDir, fileName)
     }));
-    const outputFiles = new Set(rawEntries.map(({ target }) => resolve29(target)));
+    const outputFiles = new Set(rawEntries.map(({ target }) => resolve30(target)));
     return rawEntries.map(({ content, target }) => {
       let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
         const rewritten = rewriteRelativeJsSpecifier(target, path, outputFiles);
@@ -17412,7 +17630,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
         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(resolve29(target)) ?? "";
+      processedContent += islandMetadataByOutputPath.get(resolve30(target)) ?? "";
       return { content: processedContent, target };
     });
   });
@@ -17422,7 +17640,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
   })), { 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(resolve29(filePath));
+  jitContentCache.delete(resolve30(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;
@@ -17435,8 +17653,8 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
   }
   return null;
 }, resolveAngularDeferImportSpecifier = () => {
-  const sourceEntry = resolve29(import.meta.dir, "../angular/components/index.ts");
-  if (existsSync27(sourceEntry)) {
+  const sourceEntry = resolve30(import.meta.dir, "../angular/components/index.ts");
+  if (existsSync28(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
   return "@absolutejs/absolute/angular/components";
@@ -17564,7 +17782,7 @@ ${slot.resolvedBindings.map((binding) => `		"${binding.key}": this.__absoluteDef
 ${fields}
 `);
 }, readAndEscapeFile = async (filePath, stylePreprocessors) => {
-  if (!existsSync27(filePath)) {
+  if (!existsSync28(filePath)) {
     throw new Error(`Unable to inline Angular style resource: file not found at ${filePath}`);
   }
   const content = await compileStyleFileIfNeeded(filePath, stylePreprocessors);
@@ -17572,8 +17790,8 @@ ${fields}
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join38(fileDir, templateUrlMatch[1]);
-    if (!existsSync27(templatePath)) {
+    const templatePath = join39(fileDir, templateUrlMatch[1]);
+    if (!existsSync28(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
     const templateRaw2 = await fs5.readFile(templatePath, "utf-8");
@@ -17603,11 +17821,11 @@ ${fields}
 }, inlineTemplateAndLowerDeferSync = (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join38(fileDir, templateUrlMatch[1]);
-    if (!existsSync27(templatePath)) {
+    const templatePath = join39(fileDir, templateUrlMatch[1]);
+    if (!existsSync28(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
-    const templateRaw2 = readFileSync26(templatePath, "utf-8");
+    const templateRaw2 = readFileSync27(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);
@@ -17640,7 +17858,7 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join38(fileDir, styleUrl), stylePreprocessors);
+    return readAndEscapeFile(join39(fileDir, styleUrl), stylePreprocessors);
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -17651,7 +17869,7 @@ ${fields}
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join38(fileDir, styleUrlMatch[1]), stylePreprocessors);
+  const escaped = await readAndEscapeFile(join39(fileDir, styleUrlMatch[1]), stylePreprocessors);
   if (!escaped)
     return source;
   return source.slice(0, styleUrlMatch.index) + `styles: [\`${escaped}\`]` + source.slice(styleUrlMatch.index + styleUrlMatch[0].length);
@@ -17725,10 +17943,10 @@ ${fields}
     return "";
   }
 }, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors, cacheBuster) => {
-  const entryPath = resolve29(inputPath);
+  const entryPath = resolve30(inputPath);
   const allOutputs = [];
   const visited = new Set;
-  const baseDir = resolve29(rootDir ?? process.cwd());
+  const baseDir = resolve30(rootDir ?? process.cwd());
   let usesLegacyAnimations = false;
   const angularTranspiler = new Bun.Transpiler({
     loader: "ts",
@@ -17747,16 +17965,16 @@ ${fields}
       `${candidate}.js`,
       `${candidate}.jsx`,
       `${candidate}.json`,
-      join38(candidate, "index.ts"),
-      join38(candidate, "index.tsx"),
-      join38(candidate, "index.js"),
-      join38(candidate, "index.jsx")
+      join39(candidate, "index.ts"),
+      join39(candidate, "index.tsx"),
+      join39(candidate, "index.js"),
+      join39(candidate, "index.jsx")
     ];
-    return candidates.find((file4) => existsSync27(file4));
+    return candidates.find((file4) => existsSync28(file4));
   };
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile2(resolve29(fromDir, specifier));
+      return resolveSourceFile2(resolve30(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile2);
     if (aliased)
@@ -17765,7 +17983,7 @@ ${fields}
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve29(resolved);
+      const absolute = resolve30(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile2(absolute);
@@ -17777,10 +17995,10 @@ ${fields}
     const inputDir = dirname21(sourcePath);
     const fileBase = basename12(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
     if (inputDir === outDir || inputDir.startsWith(`${outDir}${sep3}`)) {
-      return join38(inputDir, fileBase);
+      return join39(inputDir, fileBase);
     }
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
-    return join38(outDir, relativeDir, fileBase);
+    return join39(outDir, relativeDir, fileBase);
   };
   const withCacheBuster = (specifier) => {
     if (!cacheBuster)
@@ -17817,21 +18035,21 @@ ${fields}
         return `${prefix}${dots}`;
       return `${prefix}../${dots}`;
     });
-    if (resolve29(actualPath) === entryPath) {
+    if (resolve30(actualPath) === entryPath) {
       processedContent += buildIslandMetadataExports(sourceCode);
     }
     return processedContent;
   };
   const transpileFile = async (filePath) => {
-    const resolved = resolve29(filePath);
+    const resolved = resolve30(filePath);
     if (visited.has(resolved))
       return;
     visited.add(resolved);
-    if (resolved.endsWith(".json") && existsSync27(resolved)) {
+    if (resolved.endsWith(".json") && existsSync28(resolved)) {
       const inputDir2 = dirname21(resolved);
       const relativeDir2 = inputDir2.startsWith(baseDir) ? inputDir2.substring(baseDir.length + 1) : inputDir2;
-      const targetDir2 = join38(outDir, relativeDir2);
-      const targetPath2 = join38(targetDir2, basename12(resolved));
+      const targetDir2 = join39(outDir, relativeDir2);
+      const targetPath2 = join39(targetDir2, basename12(resolved));
       await fs5.mkdir(targetDir2, { recursive: true });
       await fs5.copyFile(resolved, targetPath2);
       allOutputs.push(targetPath2);
@@ -17840,7 +18058,7 @@ ${fields}
     let actualPath = resolved;
     if (!actualPath.endsWith(".ts"))
       actualPath += ".ts";
-    if (!existsSync27(actualPath))
+    if (!existsSync28(actualPath))
       return;
     let sourceCode = await fs5.readFile(actualPath, "utf-8");
     const inlined = await inlineResources(sourceCode, dirname21(actualPath), stylePreprocessors);
@@ -17875,10 +18093,10 @@ ${fields}
       importRewrites.set(specifier, relativeRewrite);
       return resolved2;
     }).filter((path) => Boolean(path));
-    const isEntry = resolve29(actualPath) === resolve29(entryPath);
+    const isEntry = resolve30(actualPath) === resolve30(entryPath);
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey2 = actualPath;
-    const shouldWriteFile = cacheBuster && isEntry ? true : jitContentCache.get(cacheKey2) !== contentHash || !existsSync27(targetPath);
+    const shouldWriteFile = cacheBuster && isEntry ? true : jitContentCache.get(cacheKey2) !== contentHash || !existsSync28(targetPath);
     if (shouldWriteFile) {
       const processedContent = transpileAndRewrite(sourceCode, relativeDir, actualPath, importRewrites);
       const preservedInjection = await readPreservedInjection(targetPath);
@@ -17891,7 +18109,7 @@ ${fields}
   };
   await transpileFile(inputPath);
   const entryOutputPath = toOutputPath(entryPath);
-  if (existsSync27(entryOutputPath)) {
+  if (existsSync28(entryOutputPath)) {
     const entryOutput = await fs5.readFile(entryOutputPath, "utf-8");
     const withoutLegacyFlag = entryOutput.replace(/\nexport const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;\n?/g, `
 `);
@@ -17910,23 +18128,23 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join38(compiledParent, "indexes");
+  const indexesDir = join39(compiledParent, "indexes");
   await traceAngularPhase("setup/create-indexes-dir", () => fs5.mkdir(indexesDir, { recursive: true }));
-  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve29(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
+  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve30(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   if (!hmr) {
     await traceAngularPhase("aot/copy-json-resources", async () => {
       const cwd = process.cwd();
-      const angularSrcDir = resolve29(outRoot);
-      if (!existsSync27(angularSrcDir))
+      const angularSrcDir = resolve30(outRoot);
+      if (!existsSync28(angularSrcDir))
         return;
       const jsonGlob = new Glob6("**/*.json");
       for (const rel of jsonGlob.scanSync({
         absolute: false,
         cwd: angularSrcDir
       })) {
-        const sourcePath = join38(angularSrcDir, rel);
+        const sourcePath = join39(angularSrcDir, rel);
         const cwdRel = relative14(cwd, sourcePath);
-        const targetPath = join38(compiledRoot, cwdRel);
+        const targetPath = join39(compiledRoot, cwdRel);
         await fs5.mkdir(dirname21(targetPath), { recursive: true });
         await fs5.copyFile(sourcePath, targetPath);
       }
@@ -17934,7 +18152,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
   }
   const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
   const compileTasks = entryPoints.map(async (entry) => {
-    const resolvedEntry = resolve29(entry);
+    const resolvedEntry = resolve30(entry);
     const relativeEntry = relative14(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
     const compileEntry = () => compileAngularFileJIT(resolvedEntry, compiledRoot, outRoot, stylePreprocessors);
     let outputs = hmr ? await traceAngularPhase("jit/compile-entry", compileEntry, {
@@ -17943,24 +18161,24 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const fileBase = basename12(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
     const compiledFallbackPaths = [
-      join38(compiledRoot, relativeEntry),
-      join38(compiledRoot, "pages", jsName),
-      join38(compiledRoot, jsName)
-    ].map((file4) => resolve29(file4));
+      join39(compiledRoot, relativeEntry),
+      join39(compiledRoot, "pages", jsName),
+      join39(compiledRoot, jsName)
+    ].map((file4) => resolve30(file4));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
-        ...candidatePaths.map((file4) => resolve29(file4)),
+        ...candidatePaths.map((file4) => resolve30(file4)),
         ...compiledFallbackPaths
       ];
-      let candidate = normalizedCandidates.find((file4) => existsSync27(file4) && file4.endsWith(`${sep3}${relativeEntry}`));
+      let candidate = normalizedCandidates.find((file4) => existsSync28(file4) && file4.endsWith(`${sep3}${relativeEntry}`));
       if (!candidate) {
-        candidate = normalizedCandidates.find((file4) => existsSync27(file4) && file4.endsWith(`${sep3}pages${sep3}${jsName}`));
+        candidate = normalizedCandidates.find((file4) => existsSync28(file4) && file4.endsWith(`${sep3}pages${sep3}${jsName}`));
       }
       if (!candidate) {
-        candidate = normalizedCandidates.find((file4) => existsSync27(file4) && file4.endsWith(`${sep3}${jsName}`));
+        candidate = normalizedCandidates.find((file4) => existsSync28(file4) && file4.endsWith(`${sep3}${jsName}`));
       }
       if (!candidate) {
-        candidate = normalizedCandidates.find((file4) => existsSync27(file4));
+        candidate = normalizedCandidates.find((file4) => existsSync28(file4));
       }
       return candidate;
     };
@@ -17968,11 +18186,11 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     if (!rawServerFile) {
       rawServerFile = await traceAngularPhase("wrapper/resolve-server-output-fallback", () => resolveRawServerFile([]), { entry: resolvedEntry });
     }
-    if (rawServerFile && !existsSync27(rawServerFile)) {
+    if (rawServerFile && !existsSync28(rawServerFile)) {
       outputs = hmr ? await compileEntry() : aotOutputs;
       rawServerFile = await traceAngularPhase("wrapper/resolve-server-output-retry", () => resolveRawServerFile(outputs), { entry: resolvedEntry });
     }
-    if (!rawServerFile || !existsSync27(rawServerFile)) {
+    if (!rawServerFile || !existsSync28(rawServerFile)) {
       throw new Error(`Compiled output not found for ${entry}. Looking for: ${jsName}. Available: ${[
         ...outputs,
         ...compiledFallbackPaths
@@ -17996,7 +18214,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
       let providersSourceContent = "";
       if (providersInjection.appProvidersSource) {
         try {
-          providersSourceContent = readFileSync26(providersInjection.appProvidersSource, "utf-8");
+          providersSourceContent = readFileSync27(providersInjection.appProvidersSource, "utf-8");
         } catch {}
       }
       return JSON.stringify({
@@ -18007,8 +18225,8 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     })() : "no-providers";
     const serverContentHash = `${Bun.hash(original).toString(BASE_36_RADIX)}.${Bun.hash(providersHashInput).toString(BASE_36_RADIX)}`;
     const cachedWrapper = wrapperOutputCache.get(resolvedEntry);
-    const clientFile = join38(indexesDir, jsName);
-    if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync27(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
+    const clientFile = join39(indexesDir, jsName);
+    if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync28(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
       return {
         clientPath: clientFile,
         indexUnchanged: true,
@@ -18039,10 +18257,10 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
       const fragments = [];
       if (providersInjection.appProvidersSource) {
         const compiledAppProvidersPath = (() => {
-          const angularDirAbs = resolve29(outRoot);
-          const appSourceAbs = resolve29(providersInjection.appProvidersSource);
+          const angularDirAbs = resolve30(outRoot);
+          const appSourceAbs = resolve30(providersInjection.appProvidersSource);
           const rel = relative14(angularDirAbs, appSourceAbs).replace(/\\/g, "/");
-          return join38(compiledParent, rel).replace(/\.[cm]?[tj]sx?$/, ".js");
+          return join39(compiledParent, rel).replace(/\.[cm]?[tj]sx?$/, ".js");
         })();
         const appProvidersSpec = (() => {
           const rel = relative14(dirname21(rawServerFile), compiledAppProvidersPath).replace(/\\/g, "/");
@@ -18303,7 +18521,7 @@ var init_compileAngular = __esm(() => {
   init_stylePreprocessor();
   init_generatedDir();
   devClientDir4 = resolveDevClientDir4();
-  hmrClientPath5 = join38(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath5 = join39(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
   PROVIDERS_INJECTION_BLOCK_RE = /\n\/\* __ABS_PROVIDERS_INJECTION_START \*\/[\s\S]*?\/\* __ABS_PROVIDERS_INJECTION_END \*\/\n?/;
@@ -19019,15 +19237,15 @@ __export(exports_fastHmrCompiler, {
   takePendingModule: () => takePendingModule,
   tryFastHmr: () => tryFastHmr
 });
-import { existsSync as existsSync28, readFileSync as readFileSync27, statSync as statSync2 } from "fs";
-import { dirname as dirname22, extname as extname9, relative as relative15, resolve as resolve30 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync28, statSync as statSync2 } from "fs";
+import { dirname as dirname22, extname as extname9, relative as relative15, resolve as resolve31 } from "path";
 import ts18 from "typescript";
 var fail = (reason, detail, location) => ({
   detail,
   ok: false,
   reason,
   ...location ?? {}
-}), fingerprintCache, pendingModuleCache, ANGULAR_DECORATOR_NAMES, findAngularDecoratorName = (decorators) => {
+}), fingerprintCache2, pendingModuleCache, ANGULAR_DECORATOR_NAMES, findAngularDecoratorName = (decorators) => {
   for (const decorator of decorators) {
     if (!ts18.isCallExpression(decorator.expression))
       continue;
@@ -19107,7 +19325,7 @@ var fail = (reason, detail, location) => ({
     return false;
   return true;
 }, invalidateFingerprintCache = () => {
-  fingerprintCache.clear();
+  fingerprintCache2.clear();
   entityFingerprintCache.clear();
 }, primeComponentFingerprint = async (componentFilePath) => {
   let source;
@@ -19152,7 +19370,7 @@ var fail = (reason, detail, location) => ({
       const { inputs, outputs } = extractInputsAndOutputs(stmt, null);
       const componentDir = dirname22(componentFilePath);
       const fingerprint = extractFingerprint(stmt, className, decoratorMeta, inputs, outputs, sourceFile, componentDir);
-      fingerprintCache.set(id, fingerprint);
+      fingerprintCache2.set(id, fingerprint);
     } else {
       try {
         const entityFingerprint = extractEntityFingerprint(stmt, className, sourceFile);
@@ -19161,7 +19379,7 @@ var fail = (reason, detail, location) => ({
     }
   }
 }, recordFingerprint = (id, fingerprint) => {
-  fingerprintCache.set(id, fingerprint);
+  fingerprintCache2.set(id, fingerprint);
 }, entityFingerprintCache, entityFingerprintsEqual = (leftValue, rightValue) => {
   if (leftValue.className !== rightValue.className)
     return false;
@@ -19335,7 +19553,7 @@ var fail = (reason, detail, location) => ({
     if (!spec.startsWith(".") && !spec.startsWith("/")) {
       return true;
     }
-    const base = resolve30(componentDir, spec);
+    const base = resolve31(componentDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -19343,11 +19561,11 @@ var fail = (reason, detail, location) => ({
       `${base}/index.tsx`
     ];
     for (const candidate of candidates) {
-      if (!existsSync28(candidate))
+      if (!existsSync29(candidate))
         continue;
       let content;
       try {
-        content = readFileSync27(candidate, "utf-8");
+        content = readFileSync28(candidate, "utf-8");
       } catch {
         continue;
       }
@@ -19935,7 +20153,7 @@ var fail = (reason, detail, location) => ({
     return cached.info;
   let source;
   try {
-    source = readFileSync27(filePath, "utf-8");
+    source = readFileSync28(filePath, "utf-8");
   } catch {
     childComponentInfoCache.set(cacheKey2, {
       info: null,
@@ -19989,7 +20207,7 @@ var fail = (reason, detail, location) => ({
     return cached.info;
   let content;
   try {
-    content = readFileSync27(dtsPath, "utf-8");
+    content = readFileSync28(dtsPath, "utf-8");
   } catch {
     childComponentInfoCache.set(cacheKey2, {
       info: null,
@@ -20108,11 +20326,11 @@ var fail = (reason, detail, location) => ({
   if (visited.has(startDtsPath))
     return null;
   visited.add(startDtsPath);
-  if (!existsSync28(startDtsPath))
+  if (!existsSync29(startDtsPath))
     return null;
   let content;
   try {
-    content = readFileSync27(startDtsPath, "utf-8");
+    content = readFileSync28(startDtsPath, "utf-8");
   } catch {
     return null;
   }
@@ -20151,7 +20369,7 @@ var fail = (reason, detail, location) => ({
   return null;
 }, resolveDtsFromSpec = (spec, fromDir) => {
   const stripped = spec.replace(/\.[mc]?js$/, "");
-  const base = resolve30(fromDir, stripped);
+  const base = resolve31(fromDir, stripped);
   const candidates = [
     `${base}.d.ts`,
     `${base}.d.mts`,
@@ -20161,21 +20379,21 @@ var fail = (reason, detail, location) => ({
     `${base}/index.d.cts`
   ];
   for (const c of candidates) {
-    if (existsSync28(c))
+    if (existsSync29(c))
       return c;
   }
   return null;
 }, findPackageDtsForJs = (jsPath) => {
   const sibling = jsPath.replace(/\.[mc]?js$/, ".d.ts");
-  if (existsSync28(sibling))
+  if (existsSync29(sibling))
     return sibling;
   const mirror = jsPath.replace(/\/dist\//, "/dist/src/").replace(/\.[mc]?js$/, ".d.ts");
-  if (existsSync28(mirror))
+  if (existsSync29(mirror))
     return mirror;
   return null;
 }, resolveChildComponentInfo = (className, spec, componentDir, projectRoot) => {
   if (spec.startsWith(".") || spec.startsWith("/")) {
-    const base = resolve30(componentDir, spec);
+    const base = resolve31(componentDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -20183,7 +20401,7 @@ var fail = (reason, detail, location) => ({
       `${base}/index.tsx`
     ];
     for (const candidate of candidates) {
-      if (!existsSync28(candidate))
+      if (!existsSync29(candidate))
         continue;
       const info = getChildComponentInfoFromTsSource(candidate, className);
       if (info)
@@ -20330,7 +20548,7 @@ var fail = (reason, detail, location) => ({
     return cached.hasProviders;
   let source;
   try {
-    source = readFileSync27(filePath, "utf8");
+    source = readFileSync28(filePath, "utf8");
   } catch {
     return true;
   }
@@ -20394,14 +20612,14 @@ var fail = (reason, detail, location) => ({
     }
     if (!matches)
       continue;
-    const resolved = resolve30(componentDir, spec);
+    const resolved = resolve31(componentDir, spec);
     for (const ext of TS_EXTENSIONS) {
       const candidate = resolved + ext;
-      if (existsSync28(candidate))
+      if (existsSync29(candidate))
         return candidate;
     }
-    const indexCandidate = resolve30(resolved, "index.ts");
-    if (existsSync28(indexCandidate))
+    const indexCandidate = resolve31(resolved, "index.ts");
+    if (existsSync29(indexCandidate))
       return indexCandidate;
   }
   return null;
@@ -20638,12 +20856,12 @@ ${transpiled}
     }
 }${staticPatch}`;
 }, STYLE_PREPROCESSED_EXT, resolveAndReadStyleResource = (componentDir, url) => {
-  const abs = resolve30(componentDir, url);
-  if (!existsSync28(abs))
+  const abs = resolve31(componentDir, url);
+  if (!existsSync29(abs))
     return null;
   const ext = extname9(abs).toLowerCase();
   if (!STYLE_PREPROCESSED_EXT.has(ext) || ext === ".css") {
-    return readFileSync27(abs, "utf8");
+    return readFileSync28(abs, "utf8");
   }
   try {
     return compileStyleFileIfNeededSync(abs);
@@ -20677,11 +20895,11 @@ ${block}
   const cached = projectOptionsCache.get(projectRoot);
   if (cached !== undefined)
     return cached;
-  const tsconfigPath = resolve30(projectRoot, "tsconfig.json");
+  const tsconfigPath = resolve31(projectRoot, "tsconfig.json");
   const opts = {};
-  if (existsSync28(tsconfigPath)) {
+  if (existsSync29(tsconfigPath)) {
     try {
-      const text2 = readFileSync27(tsconfigPath, "utf8");
+      const text2 = readFileSync28(tsconfigPath, "utf8");
       const parsed = ts18.parseConfigFileTextToJson(tsconfigPath, text2);
       if (!parsed.error && parsed.config) {
         const cfg = parsed.config;
@@ -20706,7 +20924,7 @@ ${block}
 }, tryFastHmr = async (params) => {
   const { componentFilePath, className } = params;
   const projectRoot = params.projectRoot ?? process.cwd();
-  if (!existsSync28(componentFilePath)) {
+  if (!existsSync29(componentFilePath)) {
     return fail("file-not-found", componentFilePath);
   }
   let compiler;
@@ -20715,7 +20933,7 @@ ${block}
   } catch (err) {
     return fail("unexpected-error", `import @angular/compiler: ${err}`);
   }
-  const tsSource = readFileSync27(componentFilePath, "utf8");
+  const tsSource = readFileSync28(componentFilePath, "utf8");
   const sourceFile = ts18.createSourceFile(componentFilePath, tsSource, ts18.ScriptTarget.ES2022, true, ts18.ScriptKind.TS);
   const classNode = findClassDeclaration(sourceFile, className);
   if (!classNode) {
@@ -20761,11 +20979,11 @@ ${block}
     templateText = decoratorMeta.template;
     templatePath = componentFilePath;
   } else if (decoratorMeta.templateUrl) {
-    const tplAbs = resolve30(componentDir, decoratorMeta.templateUrl);
-    if (!existsSync28(tplAbs)) {
+    const tplAbs = resolve31(componentDir, decoratorMeta.templateUrl);
+    if (!existsSync29(tplAbs)) {
       return fail("template-resource-not-found", `Template file not found: ${tplAbs}`, { file: componentFilePath });
     }
-    templateText = readFileSync27(tplAbs, "utf8");
+    templateText = readFileSync28(tplAbs, "utf8");
     templatePath = tplAbs;
   } else {
     return fail("unsupported-decorator-args", "missing template/templateUrl");
@@ -20810,7 +21028,7 @@ ${block}
   const projectRelPath = relative15(projectRoot, componentFilePath).replace(/\\/g, "/");
   const fingerprintId = encodeURIComponent(`${projectRelPath}@${className}`);
   const currentFingerprint = extractFingerprint(classNode, className, decoratorMeta, inputs, outputs, sourceFile, componentDir);
-  const cachedFingerprint = fingerprintCache.get(fingerprintId);
+  const cachedFingerprint = fingerprintCache2.get(fingerprintId);
   const fingerprintChanged = cachedFingerprint !== undefined && !fingerprintsEqual(cachedFingerprint, currentFingerprint);
   const rebootstrapRequired = !currentFingerprint.standalone || cachedFingerprint !== undefined && (cachedFingerprint.importsArraySig !== currentFingerprint.importsArraySig || cachedFingerprint.hostDirectivesSig !== currentFingerprint.hostDirectivesSig || cachedFingerprint.providersArraySig !== currentFingerprint.providersArraySig || cachedFingerprint.viewProvidersArraySig !== currentFingerprint.viewProvidersArraySig || cachedFingerprint.selector !== currentFingerprint.selector || cachedFingerprint.pageExportsSig !== currentFingerprint.pageExportsSig || cachedFingerprint.standalone !== currentFingerprint.standalone);
   const sourceFileObj = new compiler.ParseSourceFile(tsSource, componentFilePath);
@@ -21017,7 +21235,7 @@ ${methodsBlock}
         moduleText = moduleText.slice(0, lastBrace) + tail + moduleText.slice(lastBrace);
       }
     }
-    fingerprintCache.set(fingerprintId, currentFingerprint);
+    fingerprintCache2.set(fingerprintId, currentFingerprint);
     setPendingModule(fingerprintId, moduleText);
     return {
       componentSource: sourceFile,
@@ -21034,7 +21252,7 @@ var init_fastHmrCompiler = __esm(() => {
   init_stylePreprocessor();
   init_hmrImportGenerator();
   init_typescript_translator();
-  fingerprintCache = new Map;
+  fingerprintCache2 = new Map;
   pendingModuleCache = new Map;
   ANGULAR_DECORATOR_NAMES = new Set([
     "Component",
@@ -21531,9 +21749,9 @@ __export(exports_compileEmber, {
   getEmberCompiledRoot: () => getEmberCompiledRoot,
   getEmberServerCompiledDir: () => getEmberServerCompiledDir
 });
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 import { mkdir as mkdir11, rm as rm8 } from "fs/promises";
-import { basename as basename13, dirname as dirname23, extname as extname10, join as join39, resolve as resolve31 } from "path";
+import { basename as basename13, dirname as dirname23, extname as extname10, join as join40, resolve as resolve32 } from "path";
 var {build: bunBuild2, Transpiler: Transpiler4, write: write4, file: file4 } = globalThis.Bun;
 var cachedPreprocessor = null, getPreprocessor = async () => {
   if (cachedPreprocessor)
@@ -21629,11 +21847,11 @@ export const importSync = (specifier) => {
         const originalImporter = stagedSourceMap.get(args.importer);
         if (!originalImporter)
           return;
-        const candidateBase = resolve31(dirname23(originalImporter), args.path);
+        const candidateBase = resolve32(dirname23(originalImporter), args.path);
         const extensionsToTry = ["", ".gts", ".gjs", ".ts", ".js"];
         for (const ext of extensionsToTry) {
           const candidate = candidateBase + ext;
-          if (existsSync29(candidate))
+          if (existsSync30(candidate))
             return { path: candidate };
         }
         return;
@@ -21652,8 +21870,8 @@ export const importSync = (specifier) => {
     build2.onResolve({ filter: /^@(?:ember|glimmer|simple-dom)\// }, (args) => {
       if (standalonePackages.has(args.path))
         return;
-      const internal = join39(cwd, "node_modules/ember-source/dist/packages", args.path, "index.js");
-      if (existsSync29(internal))
+      const internal = join40(cwd, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      if (existsSync30(internal))
         return { path: internal };
       return;
     });
@@ -21688,7 +21906,7 @@ export const renderToHTML = (props = {}) => {
 export { PageComponent };
 export default PageComponent;
 `, compileEmberFile = async (entry, compiledRoot, cwd = process.cwd()) => {
-  const resolvedEntry = resolve31(entry);
+  const resolvedEntry = resolve32(entry);
   const source = await file4(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -21700,16 +21918,16 @@ export default PageComponent;
   }
   const transpiled = transpiler5.transformSync(preprocessed);
   const baseName = basename13(resolvedEntry).replace(/\.(gjs|gts|ts|js)$/, "");
-  const tmpDir = join39(compiledRoot, "_tmp");
-  const serverDir = join39(compiledRoot, "server");
-  const clientDir = join39(compiledRoot, "client");
+  const tmpDir = join40(compiledRoot, "_tmp");
+  const serverDir = join40(compiledRoot, "server");
+  const clientDir = join40(compiledRoot, "client");
   await Promise.all([
     mkdir11(tmpDir, { recursive: true }),
     mkdir11(serverDir, { recursive: true }),
     mkdir11(clientDir, { recursive: true })
   ]);
-  const tmpPagePath = resolve31(join39(tmpDir, `${baseName}.module.js`));
-  const tmpHarnessPath = resolve31(join39(tmpDir, `${baseName}.harness.js`));
+  const tmpPagePath = resolve32(join40(tmpDir, `${baseName}.module.js`));
+  const tmpHarnessPath = resolve32(join40(tmpDir, `${baseName}.harness.js`));
   await Promise.all([
     write4(tmpPagePath, transpiled),
     write4(tmpHarnessPath, generateServerHarness(tmpPagePath))
@@ -21717,7 +21935,7 @@ export default PageComponent;
   const stagedSourceMap = new Map([
     [tmpPagePath, resolvedEntry]
   ]);
-  const serverPath = join39(serverDir, `${baseName}.js`);
+  const serverPath = join40(serverDir, `${baseName}.js`);
   const buildResult = await bunBuild2({
     entrypoints: [tmpHarnessPath],
     format: "esm",
@@ -21734,7 +21952,7 @@ export default PageComponent;
     console.warn(`\u26A0\uFE0F Ember server build for ${baseName} had errors:`, buildResult.logs);
   }
   await rm8(tmpDir, { force: true, recursive: true });
-  const clientPath = join39(clientDir, `${baseName}.js`);
+  const clientPath = join40(clientDir, `${baseName}.js`);
   await write4(clientPath, transpiled);
   return { clientPath, serverPath };
 }, compileEmber = async (entries, emberDir, cwd = process.cwd(), _hmr = false) => {
@@ -21751,7 +21969,7 @@ export default PageComponent;
     serverPaths: outputs.map((o3) => o3.serverPath)
   };
 }, compileEmberFileSource = async (entry) => {
-  const resolvedEntry = resolve31(entry);
+  const resolvedEntry = resolve32(entry);
   const source = await file4(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -21762,7 +21980,7 @@ export default PageComponent;
     preprocessed = rewriteTemplateEvalToScope(result.code);
   }
   return transpiler5.transformSync(preprocessed);
-}, clearEmberCompilerCache = () => {}, getEmberCompiledRoot = (_emberDir) => getFrameworkGeneratedDir("ember"), getEmberServerCompiledDir = (emberDir) => join39(getEmberCompiledRoot(emberDir), "server"), getEmberClientCompiledDir = (emberDir) => join39(getEmberCompiledRoot(emberDir), "client");
+}, clearEmberCompilerCache = () => {}, getEmberCompiledRoot = (_emberDir) => getFrameworkGeneratedDir("ember"), getEmberServerCompiledDir = (emberDir) => join40(getEmberCompiledRoot(emberDir), "server"), getEmberClientCompiledDir = (emberDir) => join40(getEmberCompiledRoot(emberDir), "client");
 var init_compileEmber = __esm(() => {
   init_generatedDir();
   transpiler5 = new Transpiler4({
@@ -21783,25 +22001,25 @@ __export(exports_buildReactVendor, {
   buildReactVendor: () => buildReactVendor,
   computeVendorPaths: () => computeVendorPaths
 });
-import { existsSync as existsSync30, mkdirSync as mkdirSync8 } from "fs";
-import { join as join40, resolve as resolve32 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync9 } from "fs";
+import { join as join41, resolve as resolve33 } from "path";
 import { rm as rm9 } from "fs/promises";
 var {build: bunBuild3 } = globalThis.Bun;
 var resolveJsxDevRuntimeCompatPath = () => {
   const candidates = [
-    resolve32(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
-    resolve32(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve32(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve32(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve32(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve32(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve33(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
+    resolve33(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve33(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve33(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve33(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve33(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
-    if (existsSync30(candidate)) {
+    if (existsSync31(candidate)) {
       return candidate.replace(/\\/g, "/");
     }
   }
-  return (candidates[0] ?? resolve32(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
+  return (candidates[0] ?? resolve33(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
 }, jsxDevRuntimeCompatPath, jsxRuntimeCompatPath, reactSpecifiers, toSafeFileName = (specifier) => specifier.replace(/\//g, "_"), computeVendorPaths = () => {
   const paths = {};
   for (const specifier of reactSpecifiers) {
@@ -21834,14 +22052,14 @@ var resolveJsxDevRuntimeCompatPath = () => {
 `)}
 `;
 }, buildReactVendor = async (buildDir) => {
-  const vendorDir = join40(buildDir, "react", "vendor");
-  mkdirSync8(vendorDir, { recursive: true });
-  const tmpDir = join40(buildDir, "_vendor_tmp");
-  mkdirSync8(tmpDir, { recursive: true });
+  const vendorDir = join41(buildDir, "react", "vendor");
+  mkdirSync9(vendorDir, { recursive: true });
+  const tmpDir = join41(buildDir, "_vendor_tmp");
+  mkdirSync9(tmpDir, { recursive: true });
   const specifiers = reactSpecifiers;
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName(specifier);
-    const entryPath = join40(tmpDir, `${safeName}.ts`);
+    const entryPath = join41(tmpDir, `${safeName}.ts`);
     const source = await generateEntrySource(specifier);
     await Bun.write(entryPath, source);
     return entryPath;
@@ -21908,8 +22126,8 @@ __export(exports_buildAngularVendor, {
   computeAngularVendorPaths: () => computeAngularVendorPaths,
   computeAngularVendorPathsAsync: () => computeAngularVendorPathsAsync
 });
-import { mkdirSync as mkdirSync9 } from "fs";
-import { join as join41 } from "path";
+import { mkdirSync as mkdirSync10 } from "fs";
+import { join as join42 } from "path";
 import { rm as rm10 } 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, isResolvable = (specifier) => {
@@ -21946,7 +22164,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: readFileSync28 } = await import("fs");
+  const { readFileSync: readFileSync29 } = await import("fs");
   const transpiler6 = new Bun.Transpiler({ loader: "js" });
   const visited = new Set;
   const frontier = [];
@@ -21967,7 +22185,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
       }
       let content;
       try {
-        content = readFileSync28(resolved, "utf-8");
+        content = readFileSync29(resolved, "utf-8");
       } catch {
         continue;
       }
@@ -22006,14 +22224,14 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   await collectTransitiveAngularSpecs([...angular, ...transitiveRoots], angular);
   return Array.from(angular).filter(isResolvable);
 }, buildAngularVendor = async (buildDir, directories = [], linkerJitMode = false, depVendorSpecifiers = []) => {
-  const vendorDir = join41(buildDir, "angular", "vendor");
-  mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join41(buildDir, "_angular_vendor_tmp");
-  mkdirSync9(tmpDir, { recursive: true });
+  const vendorDir = join42(buildDir, "angular", "vendor");
+  mkdirSync10(vendorDir, { recursive: true });
+  const tmpDir = join42(buildDir, "_angular_vendor_tmp");
+  mkdirSync10(tmpDir, { recursive: true });
   const specifiers = await resolveAngularSpecifiers(directories, linkerJitMode);
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
-    const entryPath = join41(tmpDir, `${safeName}.ts`);
+    const entryPath = join42(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -22044,10 +22262,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 = join41(buildDir, "angular", "vendor", "server");
-  mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join41(buildDir, "_angular_server_vendor_tmp");
-  mkdirSync9(tmpDir, { recursive: true });
+  const vendorDir = join42(buildDir, "angular", "vendor", "server");
+  mkdirSync10(vendorDir, { recursive: true });
+  const tmpDir = join42(buildDir, "_angular_server_vendor_tmp");
+  mkdirSync10(tmpDir, { recursive: true });
   const browserSpecs = await resolveAngularSpecifiers(directories, linkerJitMode);
   const allSpecs = new Set(browserSpecs);
   for (const spec of SERVER_ONLY_ANGULAR_SPECIFIERS) {
@@ -22057,7 +22275,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 = join41(tmpDir, `${safeName}.ts`);
+    const entryPath = join42(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -22079,9 +22297,9 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   return specifiers;
 }, computeAngularServerVendorPaths = (buildDir, specifiers) => {
   const paths = {};
-  const vendorDir = join41(buildDir, "angular", "vendor", "server");
+  const vendorDir = join42(buildDir, "angular", "vendor", "server");
   for (const specifier of specifiers) {
-    paths[specifier] = join41(vendorDir, `${toSafeFileName2(specifier)}.js`);
+    paths[specifier] = join42(vendorDir, `${toSafeFileName2(specifier)}.js`);
   }
   return paths;
 }, computeAngularServerVendorPathsAsync = async (buildDir, directories = [], linkerJitMode = true) => {
@@ -22136,18 +22354,18 @@ __export(exports_buildVueVendor, {
   buildVueVendor: () => buildVueVendor,
   computeVueVendorPaths: () => computeVueVendorPaths
 });
-import { mkdirSync as mkdirSync10 } from "fs";
-import { join as join42 } from "path";
+import { mkdirSync as mkdirSync11 } from "fs";
+import { join as join43 } from "path";
 import { rm as rm11 } from "fs/promises";
 var {build: bunBuild5 } = globalThis.Bun;
 var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"), buildVueVendor = async (buildDir) => {
-  const vendorDir = join42(buildDir, "vue", "vendor");
-  mkdirSync10(vendorDir, { recursive: true });
-  const tmpDir = join42(buildDir, "_vue_vendor_tmp");
-  mkdirSync10(tmpDir, { recursive: true });
+  const vendorDir = join43(buildDir, "vue", "vendor");
+  mkdirSync11(vendorDir, { recursive: true });
+  const tmpDir = join43(buildDir, "_vue_vendor_tmp");
+  mkdirSync11(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(vueSpecifiers.map(async (specifier) => {
     const safeName = toSafeFileName3(specifier);
-    const entryPath = join42(tmpDir, `${safeName}.ts`);
+    const entryPath = join43(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -22172,17 +22390,17 @@ var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"
     console.warn("\u26A0\uFE0F Vue vendor build had errors:", result.logs);
     return;
   }
-  const { readFileSync: readFileSync28, writeFileSync: writeFileSync9, readdirSync: readdirSync5 } = await import("fs");
+  const { readFileSync: readFileSync29, writeFileSync: writeFileSync10, readdirSync: readdirSync5 } = await import("fs");
   const files = readdirSync5(vendorDir).filter((f2) => f2.endsWith(".js"));
   for (const file5 of files) {
-    const filePath = join42(vendorDir, file5);
-    const content = readFileSync28(filePath, "utf-8");
+    const filePath = join43(vendorDir, file5);
+    const content = readFileSync29(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;
-    writeFileSync9(filePath, patched);
+    writeFileSync10(filePath, patched);
   }
 }, computeVueVendorPaths = () => {
   const paths = {};
@@ -22201,8 +22419,8 @@ __export(exports_buildSvelteVendor, {
   buildSvelteVendor: () => buildSvelteVendor,
   computeSvelteVendorPaths: () => computeSvelteVendorPaths
 });
-import { mkdirSync as mkdirSync11 } from "fs";
-import { join as join43 } from "path";
+import { mkdirSync as mkdirSync12 } from "fs";
+import { join as join44 } from "path";
 import { rm as rm12 } from "fs/promises";
 var {build: bunBuild6 } = globalThis.Bun;
 var svelteSpecifiers, isResolvable2 = (specifier) => {
@@ -22216,13 +22434,13 @@ var svelteSpecifiers, isResolvable2 = (specifier) => {
   const specifiers = resolveVendorSpecifiers();
   if (specifiers.length === 0)
     return;
-  const vendorDir = join43(buildDir, "svelte", "vendor");
-  mkdirSync11(vendorDir, { recursive: true });
-  const tmpDir = join43(buildDir, "_svelte_vendor_tmp");
-  mkdirSync11(tmpDir, { recursive: true });
+  const vendorDir = join44(buildDir, "svelte", "vendor");
+  mkdirSync12(vendorDir, { recursive: true });
+  const tmpDir = join44(buildDir, "_svelte_vendor_tmp");
+  mkdirSync12(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName4(specifier);
-    const entryPath = join43(tmpDir, `${safeName}.ts`);
+    const entryPath = join44(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -22264,21 +22482,21 @@ var init_buildSvelteVendor = __esm(() => {
 import {
   copyFileSync as copyFileSync2,
   cpSync,
-  existsSync as existsSync31,
-  mkdirSync as mkdirSync12,
+  existsSync as existsSync32,
+  mkdirSync as mkdirSync13,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync28,
-  renameSync,
+  readFileSync as readFileSync29,
+  renameSync as renameSync2,
   rmSync as rmSync2,
   statSync as statSync3,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "fs";
-import { basename as basename14, dirname as dirname24, extname as extname11, join as join44, relative as relative16, resolve as resolve33 } from "path";
+import { basename as basename14, dirname as dirname24, extname as extname11, join as join45, relative as relative16, resolve as resolve34 } from "path";
 import { cwd, env as env3, exit } from "process";
 var {build: bunBuild7, Glob: Glob8 } = globalThis.Bun;
 var isBuildTraceEnabled = () => {
   const value = env3.ABSOLUTE_BUILD_TRACE?.toLowerCase();
-  return value === "1" || value === "true" || value === "yes";
+  return devProfileEnabled || value === "1" || value === "true" || value === "yes";
 }, collectConventionSourceFiles = (entry) => {
   if (!entry)
     return [];
@@ -22356,7 +22574,7 @@ var isBuildTraceEnabled = () => {
 }, REACT_VENDOR_SPECIFIERS, findBareReactImports = (path, importRegex) => {
   let content;
   try {
-    content = readFileSync28(path, "utf-8");
+    content = readFileSync29(path, "utf-8");
   } catch {
     return [];
   }
@@ -22404,11 +22622,11 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   }
   exit(1);
 }, copyHtmxVendor = (htmxDir, htmxDestDir) => {
-  mkdirSync12(htmxDestDir, { recursive: true });
+  mkdirSync13(htmxDestDir, { recursive: true });
   const glob = new Glob8("htmx*.min.js");
   for (const relPath of glob.scanSync({ cwd: htmxDir })) {
-    const src = join44(htmxDir, relPath);
-    const dest = join44(htmxDestDir, "htmx.min.js");
+    const src = join45(htmxDir, relPath);
+    const dest = join45(htmxDestDir, "htmx.min.js");
     copyFileSync2(src, dest);
     return;
   }
@@ -22420,8 +22638,8 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   }
 }, resolveAbsoluteVersion = async () => {
   const candidates = [
-    resolve33(import.meta.dir, "..", "..", "package.json"),
-    resolve33(import.meta.dir, "..", "package.json")
+    resolve34(import.meta.dir, "..", "..", "package.json"),
+    resolve34(import.meta.dir, "..", "package.json")
   ];
   const resolveCandidate = async (remaining) => {
     const [candidate, ...rest] = remaining;
@@ -22437,7 +22655,7 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   };
   await resolveCandidate(candidates);
 }, SKIP_DIRS5, addWorkerPathIfExists = (file5, relPath, workerPaths) => {
-  const absPath = resolve33(file5, "..", relPath);
+  const absPath = resolve34(file5, "..", relPath);
   try {
     statSync3(absPath);
     workerPaths.add(absPath);
@@ -22452,7 +22670,7 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
     addWorkerPathIfExists(file5, relPath, workerPaths);
   }
 }, collectWorkerPathsFromFile = (file5, patterns, workerPaths) => {
-  const content = readFileSync28(file5, "utf-8");
+  const content = readFileSync29(file5, "utf-8");
   for (const pattern of patterns) {
     collectWorkerPathsFromContent(content, pattern, file5, workerPaths);
   }
@@ -22485,8 +22703,8 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   vuePagesPath
 }) => {
   const { readdirSync: readDir } = await import("fs");
-  const devIndexDir = join44(buildPath, "_src_indexes");
-  mkdirSync12(devIndexDir, { recursive: true });
+  const devIndexDir = join45(buildPath, "_src_indexes");
+  mkdirSync13(devIndexDir, { recursive: true });
   if (reactIndexesPath && reactPagesPath) {
     copyReactDevIndexes(reactIndexesPath, reactPagesPath, devIndexDir, readDir);
   }
@@ -22497,41 +22715,41 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
     copyVueDevIndexes(vueDir, vuePagesPath, vueEntries, devIndexDir);
   }
 }, copyReactDevIndexes = (reactIndexesPath, reactPagesPath, devIndexDir, readDir) => {
-  if (!existsSync31(reactIndexesPath)) {
+  if (!existsSync32(reactIndexesPath)) {
     return;
   }
   const indexFiles = readDir(reactIndexesPath).filter((file5) => file5.endsWith(".tsx"));
-  const pagesRel = relative16(process.cwd(), resolve33(reactPagesPath)).replace(/\\/g, "/");
+  const pagesRel = relative16(process.cwd(), resolve34(reactPagesPath)).replace(/\\/g, "/");
   for (const file5 of indexFiles) {
-    let content = readFileSync28(join44(reactIndexesPath, file5), "utf-8");
+    let content = readFileSync29(join45(reactIndexesPath, file5), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
-    writeFileSync9(join44(devIndexDir, file5), content);
+    writeFileSync10(join45(devIndexDir, file5), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
-  const svelteIndexDir = join44(getFrameworkGeneratedDir("svelte"), "indexes");
-  const sveltePageEntries = svelteEntries.filter((file5) => resolve33(file5).startsWith(resolve33(sveltePagesPath)));
+  const svelteIndexDir = join45(getFrameworkGeneratedDir("svelte"), "indexes");
+  const sveltePageEntries = svelteEntries.filter((file5) => resolve34(file5).startsWith(resolve34(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename14(entry).replace(/\.svelte(\.(ts|js))?$/, "");
-    const indexFile = join44(svelteIndexDir, "pages", `${name}.js`);
-    if (!existsSync31(indexFile))
+    const indexFile = join45(svelteIndexDir, "pages", `${name}.js`);
+    if (!existsSync32(indexFile))
       continue;
-    let content = readFileSync28(indexFile, "utf-8");
-    const srcRel = relative16(process.cwd(), resolve33(entry)).replace(/\\/g, "/");
+    let content = readFileSync29(indexFile, "utf-8");
+    const srcRel = relative16(process.cwd(), resolve34(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
-    writeFileSync9(join44(devIndexDir, `${name}.svelte.js`), content);
+    writeFileSync10(join45(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
-  const vueIndexDir = join44(getFrameworkGeneratedDir("vue"), "indexes");
-  const vuePageEntries = vueEntries.filter((file5) => resolve33(file5).startsWith(resolve33(vuePagesPath)));
+  const vueIndexDir = join45(getFrameworkGeneratedDir("vue"), "indexes");
+  const vuePageEntries = vueEntries.filter((file5) => resolve34(file5).startsWith(resolve34(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename14(entry, ".vue");
-    const indexFile = join44(vueIndexDir, `${name}.js`);
-    if (!existsSync31(indexFile))
+    const indexFile = join45(vueIndexDir, `${name}.js`);
+    if (!existsSync32(indexFile))
       continue;
-    let content = readFileSync28(indexFile, "utf-8");
-    const srcRel = relative16(process.cwd(), resolve33(entry)).replace(/\\/g, "/");
+    let content = readFileSync29(indexFile, "utf-8");
+    const srcRel = relative16(process.cwd(), resolve34(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}"`));
-    writeFileSync9(join44(devIndexDir, `${name}.vue.js`), content);
+    writeFileSync10(join45(devIndexDir, `${name}.vue.js`), content);
   }
 }, resolveVueRuntimeId = (content, firstUseName, outputPath, projectRoot) => {
   const varIdx = content.indexOf(`var ${firstUseName} =`);
@@ -22542,7 +22760,7 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   const last = allComments[allComments.length - 1];
   if (!last?.[1])
     return JSON.stringify(outputPath);
-  const srcPath = resolve33(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
+  const srcPath = resolve34(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
   return JSON.stringify(srcPath);
 }, QUOTE_CHARS, OPEN_BRACES, CLOSE_BRACES, findFunctionExpressionEnd = (content, startPos) => {
   let depth = 0;
@@ -22579,7 +22797,7 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   }
   return result;
 }, VUE_HMR_RUNTIME, injectVueComposableTracking = (outputPath, projectRoot) => {
-  let content = readFileSync28(outputPath, "utf-8");
+  let content = readFileSync29(outputPath, "utf-8");
   const usePattern = /^var\s+(use[A-Z]\w*)\s*=/gm;
   const useNames = [];
   let match;
@@ -22600,7 +22818,7 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   content = `${content.slice(0, firstUseIdx) + runtime}
 ${content.slice(firstUseIdx)}`;
   content = wrapUseFunctions(content, useNames);
-  writeFileSync9(outputPath, content);
+  writeFileSync10(outputPath, content);
 }, buildDevUrlFileMap = (urlReferencedFiles, projectRoot) => {
   const urlFileMap = new Map;
   for (const srcPath of urlReferencedFiles) {
@@ -22629,7 +22847,7 @@ ${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 = readFileSync28(outputPath, "utf-8");
+    let content = readFileSync29(outputPath, "utf-8");
     let changed = false;
     content = content.replace(urlPattern, (_match, relPath) => {
       const targetName = basename14(relPath);
@@ -22640,7 +22858,7 @@ ${content.slice(firstUseIdx)}`;
       return `new URL('${resolvedPath}', import.meta.url)`;
     });
     if (changed)
-      writeFileSync9(outputPath, content);
+      writeFileSync10(outputPath, content);
   }
 }, bunBuildPassKeys, bunBuildPassKeySet, reservedBunBuildConfigKeys, passLockedKeys, isObject2 = (value) => typeof value === "object" && value !== null, isBunBuildPassConfig = (config) => isObject2(config) && Object.keys(config).some((key) => bunBuildPassKeySet.has(key)), sanitizeBunBuildOverride = (override, extraReservedKeys = new Set) => {
   if (!override)
@@ -22769,10 +22987,10 @@ ${content.slice(firstUseIdx)}`;
       restoreTracePhase();
       return;
     }
-    const traceDir = join44(buildPath2, ".absolute-trace");
+    const traceDir = join45(buildPath2, ".absolute-trace");
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    mkdirSync12(traceDir, { recursive: true });
-    writeFileSync9(join44(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
+    mkdirSync13(traceDir, { recursive: true });
+    writeFileSync10(join45(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
       events: traceEvents,
       frameworks: traceFrameworkNames,
       generatedAt: new Date().toISOString(),
@@ -22803,16 +23021,16 @@ ${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 && join44(getFrameworkGeneratedDir("react"), "indexes");
-  const reactPagesPath = reactDir && join44(reactDir, "pages");
-  const htmlPagesPath = htmlDir && join44(htmlDir, "pages");
-  const htmlScriptsPath = htmlDir && join44(htmlDir, "scripts");
-  const sveltePagesPath = svelteDir && join44(svelteDir, "pages");
-  const vuePagesPath = vueDir && join44(vueDir, "pages");
-  const htmxPagesPath = htmxDir && join44(htmxDir, "pages");
-  const htmxScriptsPath = htmxDir && join44(htmxDir, "scripts");
-  const angularPagesPath = angularDir && join44(angularDir, "pages");
-  const emberPagesPath = emberDir && join44(emberDir, "pages");
+  const reactIndexesPath = reactDir && join45(getFrameworkGeneratedDir("react"), "indexes");
+  const reactPagesPath = reactDir && join45(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join45(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join45(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join45(svelteDir, "pages");
+  const vuePagesPath = vueDir && join45(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join45(htmxDir, "pages");
+  const htmxScriptsPath = htmxDir && join45(htmxDir, "scripts");
+  const angularPagesPath = angularDir && join45(angularDir, "pages");
+  const emberPagesPath = emberDir && join45(emberDir, "pages");
   const frontends = [
     reactDir,
     htmlDir,
@@ -22873,14 +23091,14 @@ ${content.slice(firstUseIdx)}`;
     const [firstEntry] = serverDirMap;
     if (!firstEntry)
       throw new Error("Expected at least one server directory entry");
-    serverRoot = join44(firstEntry.dir, firstEntry.subdir);
-    serverOutDir = join44(buildPath, basename14(firstEntry.dir));
+    serverRoot = join45(firstEntry.dir, firstEntry.subdir);
+    serverOutDir = join45(buildPath, basename14(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", () => mkdirSync12(buildPath, { recursive: true }));
+  await tracePhase("build-dir/create", () => mkdirSync13(buildPath, { recursive: true }));
   if (publicPath)
     await tracePhase("public/copy", () => cpSync(publicPath, buildPath, { force: true, recursive: true }));
   const pwaArtifacts = pwa ? await tracePhase("pwa/materialize", () => materializeAbsolutePwa({
@@ -22893,13 +23111,13 @@ ${content.slice(firstUseIdx)}`;
   const filterToIncrementalEntries = (entryPoints, mapToSource) => {
     if (!isIncremental || !incrementalFiles)
       return entryPoints;
-    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve33(f2)));
+    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve34(f2)));
     const matchingEntries = [];
     for (const entry of entryPoints) {
       const sourceFile = mapToSource(entry);
       if (!sourceFile)
         continue;
-      if (!normalizedIncremental.has(resolve33(sourceFile)))
+      if (!normalizedIncremental.has(resolve34(sourceFile)))
         continue;
       matchingEntries.push(entry);
     }
@@ -22909,7 +23127,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, join44(buildPath, "assets"), {
+    await tracePhase("assets/copy", () => cpSync(assetsPath, join45(buildPath, "assets"), {
       force: true,
       recursive: true
     }));
@@ -23023,11 +23241,11 @@ ${content.slice(firstUseIdx)}`;
     }
   }
   if (htmlDefaults.error || htmlDefaults.notFound || htmlDefaults.loading || Object.keys(htmlPages).length > 0) {
-    const htmlConventionsOutDir = join44(buildPath, "conventions", "html");
-    mkdirSync12(htmlConventionsOutDir, { recursive: true });
+    const htmlConventionsOutDir = join45(buildPath, "conventions", "html");
+    mkdirSync13(htmlConventionsOutDir, { recursive: true });
     const htmlPathRemap = new Map;
     for (const sourcePath of htmlConventionSources) {
-      const dest = join44(htmlConventionsOutDir, basename14(sourcePath));
+      const dest = join45(htmlConventionsOutDir, basename14(sourcePath));
       cpSync(sourcePath, dest, { force: true });
       htmlPathRemap.set(sourcePath, dest);
     }
@@ -23068,9 +23286,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(resolve33(reactIndexesPath))) {
+    if (entry.startsWith(resolve34(reactIndexesPath))) {
       const pageName = basename14(entry, ".tsx");
-      return join44(reactPagesPath, `${pageName}.tsx`);
+      return join45(reactPagesPath, `${pageName}.tsx`);
     }
     return null;
   }) : allReactEntries;
@@ -23102,7 +23320,7 @@ ${content.slice(firstUseIdx)}`;
     for (const entry of vueEntries) {
       const name = basename14(entry, ".vue");
       if (ssrOnlyPageNames.has(name)) {
-        resolved.add(resolve33(entry));
+        resolved.add(resolve34(entry));
       }
     }
     return resolved;
@@ -23239,7 +23457,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandSvelteClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandSvelteClientPathMap.set(resolve33(sourcePath), clientPath);
+    islandSvelteClientPathMap.set(resolve34(sourcePath), clientPath);
   }
   const islandVueClientPathMap = new Map;
   for (let idx = 0;idx < islandVueSources.length; idx++) {
@@ -23247,7 +23465,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandVueClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandVueClientPathMap.set(resolve33(sourcePath), clientPath);
+    islandVueClientPathMap.set(resolve34(sourcePath), clientPath);
   }
   const islandAngularClientPathMap = new Map;
   for (let idx = 0;idx < islandAngularSources.length; idx++) {
@@ -23255,7 +23473,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandAngularClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandAngularClientPathMap.set(resolve33(sourcePath), clientPath);
+    islandAngularClientPathMap.set(resolve34(sourcePath), clientPath);
   }
   const reactConventionSources = collectConventionSourceFiles(conventionsMap.react);
   const svelteConventionSources = collectConventionSourceFiles(conventionsMap.svelte);
@@ -23266,9 +23484,9 @@ ${content.slice(firstUseIdx)}`;
     const compileReactConventions = async () => {
       if (reactConventionSources.length === 0)
         return emptyStringArray;
-      const destDir = join44(buildPath, "conventions", "react");
+      const destDir = join45(buildPath, "conventions", "react");
       rmSync2(destDir, { force: true, recursive: true });
-      mkdirSync12(destDir, { recursive: true });
+      mkdirSync13(destDir, { recursive: true });
       const destPaths = await Promise.all(reactConventionSources.map(async (source, idx) => {
         const result = await bunBuild7({
           entrypoints: [source],
@@ -23309,9 +23527,9 @@ ${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 = join44(buildPath, "conventions", framework);
+      const destDir = join45(buildPath, "conventions", framework);
       rmSync2(destDir, { force: true, recursive: true });
-      mkdirSync12(destDir, { recursive: true });
+      mkdirSync13(destDir, { recursive: true });
       const destPaths = await Promise.all(compiledPaths.map(async (compiledPath, idx) => {
         const name = basename14(compiledPath).replace(/\.[^.]+$/, "");
         const result = await bunBuild7({
@@ -23381,7 +23599,7 @@ ${content.slice(firstUseIdx)}`;
     }
   })) : {
     entries: [],
-    generatedRoot: join44(buildPath, "_island_entries")
+    generatedRoot: join45(buildPath, "_island_entries")
   };
   const islandClientEntryPoints = islandEntryResult.entries.map((entry) => entry.entryPath);
   if (serverEntryPoints.length === 0 && reactClientEntryPoints.length === 0 && nonReactClientEntryPoints.length === 0 && urlReferencedFiles.length === 0 && islandClientEntryPoints.length === 0 && htmxDir === undefined && htmlDir === undefined) {
@@ -23417,7 +23635,7 @@ ${content.slice(firstUseIdx)}`;
     return {};
   }
   if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
-    const refreshEntry = join44(reactIndexesPath, "_refresh.tsx");
+    const refreshEntry = join45(reactIndexesPath, "_refresh.tsx");
     if (!reactClientEntryPoints.includes(refreshEntry))
       reactClientEntryPoints.push(refreshEntry);
   }
@@ -23534,19 +23752,19 @@ ${content.slice(firstUseIdx)}`;
     throw: false
   }, resolveBunBuildOverride(bunBuildConfig, "reactClient")) : undefined;
   if (reactDir && reactClientEntryPoints.length > 0) {
-    rmSync2(join44(buildPath, "react", "generated", "indexes"), {
+    rmSync2(join45(buildPath, "react", "generated", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (angularDir && angularClientPaths.length > 0) {
-    rmSync2(join44(buildPath, "angular", "indexes"), {
+    rmSync2(join45(buildPath, "angular", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (islandClientEntryPoints.length > 0) {
-    rmSync2(join44(buildPath, "islands"), {
+    rmSync2(join45(buildPath, "islands"), {
       force: true,
       recursive: true
     });
@@ -23660,7 +23878,7 @@ ${content.slice(firstUseIdx)}`;
     globalCssEntries.length > 0 ? tracePhase("bun/global-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: globalCssEntries,
       naming: `[dir]/[name].[hash].[ext]`,
-      outdir: stylesDir ? join44(buildPath, basename14(stylesDir)) : buildPath,
+      outdir: stylesDir ? join45(buildPath, basename14(stylesDir)) : buildPath,
       plugins: [stylePreprocessorPlugin2],
       root: stylesDir || clientRoot,
       target: "browser",
@@ -23669,7 +23887,7 @@ ${content.slice(firstUseIdx)}`;
     vueCssPaths.length > 0 ? tracePhase("bun/vue-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: vueCssPaths,
       naming: `[name].[hash].[ext]`,
-      outdir: join44(buildPath, assetsPath ? basename14(assetsPath) : "assets", "css"),
+      outdir: join45(buildPath, assetsPath ? basename14(assetsPath) : "assets", "css"),
       target: "browser",
       throw: false
     }, resolveBunBuildOverride(bunBuildConfig, "vueCss")))) : undefined
@@ -23685,28 +23903,26 @@ ${content.slice(firstUseIdx)}`;
     extractBuildError(logs, pass, label, frameworkNames, isIncremental, throwOnError);
   };
   if (isDev2 && 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);
-    }
+    const { chainBundleInlineSourcemaps: chainBundleInlineSourcemaps2 } = await Promise.resolve().then(() => (init_chainInlineSourcemaps(), exports_chainInlineSourcemaps));
+    const serverBundlePaths = serverOutputs.map((out) => out.path).filter((path) => path.endsWith(".js"));
+    await tracePhase("postprocess/server-sourcemap-chain", () => chainBundleInlineSourcemaps2(serverBundlePaths), { bundles: serverBundlePaths.length });
   }
   if (!isDev2 && resolveClientSourcemap(sourcemaps, isDev2) === "external") {
     const { chainExternalSourcemap: chainExternalSourcemap2 } = await Promise.resolve().then(() => (init_chainInlineSourcemaps(), exports_chainInlineSourcemaps));
-    const sourcemapDir = join44(projectRoot, "sourcemaps");
-    mkdirSync12(sourcemapDir, { recursive: true });
+    const sourcemapDir = join45(projectRoot, "sourcemaps");
+    mkdirSync13(sourcemapDir, { recursive: true });
     const mapFiles = readdirSync5(buildPath, {
       encoding: "utf8",
       recursive: true
-    }).filter((entry) => entry.endsWith(".js.map") && !entry.includes("node_modules")).map((entry) => join44(buildPath, entry));
+    }).filter((entry) => entry.endsWith(".js.map") && !entry.includes("node_modules")).map((entry) => join45(buildPath, entry));
     for (const mapPath of mapFiles) {
       chainExternalSourcemap2(mapPath);
-      renameSync(mapPath, join44(sourcemapDir, basename14(mapPath)));
+      renameSync2(mapPath, join45(sourcemapDir, basename14(mapPath)));
       const jsPath = mapPath.slice(0, -4);
       try {
-        const javascript = readFileSync28(jsPath, "utf-8").replace(/\n?\/\/# sourceMappingURL=[^\n]*\s*$/, `
+        const javascript = readFileSync29(jsPath, "utf-8").replace(/\n?\/\/# sourceMappingURL=[^\n]*\s*$/, `
 `);
-        writeFileSync9(jsPath, javascript);
+        writeFileSync10(jsPath, javascript);
       } catch {}
     }
     console.info(`[absolute] sourcemaps: chained + privatized ${mapFiles.length} client maps \u2192 ${relative16(projectRoot, sourcemapDir)}/`);
@@ -23775,8 +23991,8 @@ ${content.slice(firstUseIdx)}`;
     await tracePhase("postprocess/island-vendor-imports", () => rewriteBuildOutputs2(islandClientOutputs, allIslandVendorPaths));
   }
   if (!hmr) {
-    const reactVendorDir = join44(buildPath, "react", "vendor");
-    const vendorChunkPaths = existsSync31(reactVendorDir) ? [
+    const reactVendorDir = join45(buildPath, "react", "vendor");
+    const vendorChunkPaths = existsSync32(reactVendorDir) ? [
       ...new Glob8("**/*.js").scanSync({
         absolute: true,
         cwd: reactVendorDir
@@ -23920,19 +24136,19 @@ ${content.slice(firstUseIdx)}`;
   const injectHMRIntoHTMLFile = (filePath, framework) => {
     if (!hmrClientBundle)
       return;
-    let html = readFileSync28(filePath, "utf-8");
+    let html = readFileSync29(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;
-    writeFileSync9(filePath, html);
+    writeFileSync10(filePath, html);
   };
   const processHtmlPages = async () => {
     if (!(htmlDir && htmlPagesPath))
       return;
-    const outputHtmlPages = isSingle ? join44(buildPath, "pages") : join44(buildPath, basename14(htmlDir), "pages");
-    mkdirSync12(outputHtmlPages, { recursive: true });
+    const outputHtmlPages = isSingle ? join45(buildPath, "pages") : join45(buildPath, basename14(htmlDir), "pages");
+    mkdirSync13(outputHtmlPages, { recursive: true });
     cpSync(htmlPagesPath, outputHtmlPages, {
       force: true,
       recursive: true
@@ -23947,8 +24163,8 @@ ${content.slice(firstUseIdx)}`;
       if (hmr)
         injectHMRIntoHTMLFile(htmlFile, "html");
       if (pwaArtifacts) {
-        const source = readFileSync28(htmlFile, "utf8");
-        writeFileSync9(htmlFile, injectPwaBootstrapHtml(source));
+        const source = readFileSync29(htmlFile, "utf8");
+        writeFileSync10(htmlFile, injectPwaBootstrapHtml(source));
       }
       const fileName = basename14(htmlFile, ".html");
       if (manifest[fileName] && manifest[fileName] !== htmlFile) {
@@ -23960,14 +24176,14 @@ ${content.slice(firstUseIdx)}`;
   const processHtmxPages = async () => {
     if (!(htmxDir && htmxPagesPath))
       return;
-    const outputHtmxPages = isSingle ? join44(buildPath, "pages") : join44(buildPath, basename14(htmxDir), "pages");
-    mkdirSync12(outputHtmxPages, { recursive: true });
+    const outputHtmxPages = isSingle ? join45(buildPath, "pages") : join45(buildPath, basename14(htmxDir), "pages");
+    mkdirSync13(outputHtmxPages, { recursive: true });
     cpSync(htmxPagesPath, outputHtmxPages, {
       force: true,
       recursive: true
     });
     if (shouldCopyHtmx) {
-      const htmxDestDir = isSingle ? buildPath : join44(buildPath, basename14(htmxDir));
+      const htmxDestDir = isSingle ? buildPath : join45(buildPath, basename14(htmxDir));
       copyHtmxVendor(htmxDir, htmxDestDir);
     }
     if (shouldUpdateHtmxAssetPaths) {
@@ -23980,8 +24196,8 @@ ${content.slice(firstUseIdx)}`;
       if (hmr)
         injectHMRIntoHTMLFile(htmxFile, "htmx");
       if (pwaArtifacts) {
-        const source = readFileSync28(htmxFile, "utf8");
-        writeFileSync9(htmxFile, injectPwaBootstrapHtml(source));
+        const source = readFileSync29(htmxFile, "utf8");
+        writeFileSync10(htmxFile, injectPwaBootstrapHtml(source));
       }
       const fileName = basename14(htmxFile, ".html");
       if (manifest[fileName] && manifest[fileName] !== htmxFile) {
@@ -24058,7 +24274,7 @@ ${content.slice(firstUseIdx)}`;
     }))
   ];
   setSpaRouteManifest(spaRouteHosts);
-  writeFileSync9(join44(buildPath, "spa-routes.json"), JSON.stringify(spaRouteHosts, null, "\t"));
+  writeFileSync10(join45(buildPath, "spa-routes.json"), JSON.stringify(spaRouteHosts, null, "\t"));
   if (isIncremental) {
     writeBuildTrace(buildPath);
     return {
@@ -24067,9 +24283,9 @@ ${content.slice(firstUseIdx)}`;
       manifest
     };
   }
-  writeFileSync9(join44(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
+  writeFileSync10(join45(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
   if (Object.keys(conventionsMap).length > 0) {
-    writeFileSync9(join44(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
+    writeFileSync10(join45(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
   }
   writeBuildTrace(buildPath);
   if (mode === "production") {
@@ -24134,6 +24350,7 @@ var init_build = __esm(() => {
   init_hmrInjectionPlugin();
   init_cleanStaleOutputs();
   init_cleanup();
+  init_startupTimings();
   init_commonAncestor();
   init_generatedDir();
   init_buildDirectoryLock();
@@ -24202,8 +24419,8 @@ var init_build = __esm(() => {
 });
 
 // src/build/buildEmberVendor.ts
-import { mkdirSync as mkdirSync13, existsSync as existsSync32 } from "fs";
-import { join as join45 } from "path";
+import { mkdirSync as mkdirSync14, existsSync as existsSync33 } from "fs";
+import { join as join46 } from "path";
 import { rm as rm13 } 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
@@ -24255,8 +24472,8 @@ export const importSync = (specifier) => {
   if (standaloneSpecifiers.has(specifier)) {
     return { resolveTo: specifier, specifier };
   }
-  const emberInternalPath = join45(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
-  if (!existsSync32(emberInternalPath)) {
+  const emberInternalPath = join46(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
+  if (!existsSync33(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 };
@@ -24287,24 +24504,24 @@ export const importSync = (specifier) => {
       if (standalonePackages.has(args.path)) {
         return;
       }
-      const internal = join45(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
-      if (existsSync32(internal)) {
+      const internal = join46(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      if (existsSync33(internal)) {
         return { path: internal };
       }
       return;
     });
   }
 }), buildEmberVendor = async (buildDir, cwd2 = process.cwd()) => {
-  const vendorDir = join45(buildDir, "ember", "vendor");
-  mkdirSync13(vendorDir, { recursive: true });
-  const tmpDir = join45(buildDir, "_ember_vendor_tmp");
-  mkdirSync13(tmpDir, { recursive: true });
-  const macrosShimPath = join45(tmpDir, "embroider_macros_shim.js");
+  const vendorDir = join46(buildDir, "ember", "vendor");
+  mkdirSync14(vendorDir, { recursive: true });
+  const tmpDir = join46(buildDir, "_ember_vendor_tmp");
+  mkdirSync14(tmpDir, { recursive: true });
+  const macrosShimPath = join46(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 = join45(tmpDir, `${safeName}.js`);
+    const entryPath = join46(tmpDir, `${safeName}.js`);
     const source = resolution.specifier === "@embroider/macros" ? `export * from ${JSON.stringify(macrosShimPath)};
 ` : generateVendorEntrySource2(resolution);
     await Bun.write(entryPath, source);
@@ -24460,9 +24677,9 @@ __export(exports_dependencyGraph, {
   getAffectedFiles: () => getAffectedFiles,
   removeFileFromGraph: () => removeFileFromGraph
 });
-import { existsSync as existsSync33, readFileSync as readFileSync29 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync30 } from "fs";
 var {Glob: Glob9 } = globalThis.Bun;
-import { resolve as resolve34 } from "path";
+import { resolve as resolve35 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
   const lower = filePath.toLowerCase();
   if (lower.endsWith(".ts") || lower.endsWith(".tsx") || lower.endsWith(".jsx"))
@@ -24476,8 +24693,8 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
     return null;
   }
-  const fromDir = resolve34(fromFile, "..");
-  const normalized = resolve34(fromDir, importPath);
+  const fromDir = resolve35(fromFile, "..");
+  const normalized = resolve35(fromDir, importPath);
   const extensions = [
     ".ts",
     ".tsx",
@@ -24490,10 +24707,10 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   ];
   for (const ext of extensions) {
     const withExt = normalized + ext;
-    if (existsSync33(withExt))
+    if (existsSync34(withExt))
       return withExt;
   }
-  if (existsSync33(normalized))
+  if (existsSync34(normalized))
     return normalized;
   return null;
 }, clearExistingDependents = (graph, normalizedPath) => {
@@ -24507,8 +24724,8 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     dependents.delete(normalizedPath);
   }
 }, addFileToGraph = (graph, filePath) => {
-  const normalizedPath = resolve34(filePath);
-  if (!existsSync33(normalizedPath))
+  const normalizedPath = resolve35(filePath);
+  if (!existsSync34(normalizedPath))
     return;
   const dependencies = extractDependencies(normalizedPath);
   clearExistingDependents(graph, normalizedPath);
@@ -24534,10 +24751,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) => resolve34(dir)).filter((dir) => existsSync33(dir));
+  const resolvedDirs = directories.map((dir) => resolve35(dir)).filter((dir) => existsSync34(dir));
   const allFiles = resolvedDirs.flatMap((dir) => Array.from(glob.scanSync({ absolute: true, cwd: dir })));
   for (const file5 of allFiles) {
-    const fullPath = resolve34(file5);
+    const fullPath = resolve35(file5);
     if (IGNORED_SEGMENTS.some((seg) => fullPath.includes(seg)))
       continue;
     if (processedFiles.has(fullPath))
@@ -24631,15 +24848,15 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   const lowerPath = filePath.toLowerCase();
   const isSvelteOrVue = lowerPath.endsWith(".svelte") || lowerPath.endsWith(".vue");
   if (loader === "html") {
-    const content = readFileSync29(filePath, "utf-8");
+    const content = readFileSync30(filePath, "utf-8");
     return extractHtmlDependencies(filePath, content);
   }
   if (loader === "tsx" || loader === "js") {
-    const content = readFileSync29(filePath, "utf-8");
+    const content = readFileSync30(filePath, "utf-8");
     return extractJsDependencies(filePath, content, loader);
   }
   if (isSvelteOrVue) {
-    const content = readFileSync29(filePath, "utf-8");
+    const content = readFileSync30(filePath, "utf-8");
     return extractSvelteVueDependencies(filePath, content);
   }
   return [];
@@ -24650,7 +24867,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     return [];
   }
 }, getAffectedFiles = (graph, changedFile) => {
-  const normalizedPath = resolve34(changedFile);
+  const normalizedPath = resolve35(changedFile);
   const affected = new Set;
   const toProcess = [normalizedPath];
   const processNode = (current) => {
@@ -24681,7 +24898,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
 }, removeDependentsForFile = (graph, normalizedPath) => {
   graph.dependents.delete(normalizedPath);
 }, removeFileFromGraph = (graph, filePath) => {
-  const normalizedPath = resolve34(filePath);
+  const normalizedPath = resolve35(filePath);
   removeDepsForFile(graph, normalizedPath);
   removeDependentsForFile(graph, normalizedPath);
 };
@@ -24724,12 +24941,12 @@ var globalVersionCounter = 0, createModuleVersionTracker = () => new Map, getNex
 };
 
 // src/dev/configResolver.ts
-import { resolve as resolve35 } from "path";
+import { resolve as resolve36 } from "path";
 var resolveBuildPaths = (config) => {
   const cwd2 = process.cwd();
   const normalize = (path) => path.replace(/\\/g, "/");
-  const withDefault = (value, fallback) => normalize(resolve35(cwd2, value ?? fallback));
-  const optional = (value) => value ? normalize(resolve35(cwd2, value)) : undefined;
+  const withDefault = (value, fallback) => normalize(resolve36(cwd2, value ?? fallback));
+  const optional = (value) => value ? normalize(resolve36(cwd2, value)) : undefined;
   return {
     angularDir: optional(config.angularDirectory),
     assetsDir: optional(config.assetsDirectory),
@@ -24788,8 +25005,8 @@ var init_clientManager = __esm(() => {
 });
 
 // src/dev/pathUtils.ts
-import { existsSync as existsSync34, readdirSync as readdirSync6, readFileSync as readFileSync30 } from "fs";
-import { dirname as dirname25, resolve as resolve36 } from "path";
+import { existsSync as existsSync35, readdirSync as readdirSync6, readFileSync as readFileSync31 } from "fs";
+import { dirname as dirname25, resolve as resolve37 } from "path";
 var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   if (shouldIgnorePath(filePath, resolved)) {
     return "ignored";
@@ -24865,7 +25082,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   return "unknown";
 }, collectAngularResourceDirs = (angularDir) => {
   const out = new Set;
-  const angularRoot = resolve36(angularDir);
+  const angularRoot = resolve37(angularDir);
   const angularRootNormalized = normalizePath2(angularRoot);
   const walk = (dir) => {
     let entries;
@@ -24878,7 +25095,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const full = resolve36(dir, entry.name);
+      const full = resolve37(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
         continue;
@@ -24888,7 +25105,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
       }
       let source;
       try {
-        source = readFileSync30(full, "utf8");
+        source = readFileSync31(full, "utf8");
       } catch {
         continue;
       }
@@ -24919,7 +25136,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
       }
       const componentDir = dirname25(full);
       for (const ref of refs) {
-        const refAbs = normalizePath2(resolve36(componentDir, ref));
+        const refAbs = normalizePath2(resolve37(componentDir, ref));
         const refDir = normalizePath2(dirname25(refAbs));
         if (refDir === angularRootNormalized || refDir.startsWith(`${angularRootNormalized}/`)) {
           continue;
@@ -24936,7 +25153,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   const push = (path) => {
     if (!path)
       return;
-    const abs = normalizePath2(resolve36(cwd2, path));
+    const abs = normalizePath2(resolve37(cwd2, path));
     if (!roots.includes(abs))
       roots.push(abs);
   };
@@ -24961,8 +25178,8 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   push(cfg.assetsDir);
   push(cfg.stylesDir);
   for (const candidate of ["src", "db", "assets", "styles"]) {
-    const abs = normalizePath2(resolve36(cwd2, candidate));
-    if (existsSync34(abs) && !roots.includes(abs))
+    const abs = normalizePath2(resolve37(cwd2, candidate));
+    if (existsSync35(abs) && !roots.includes(abs))
       roots.push(abs);
   }
   try {
@@ -24972,7 +25189,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
         continue;
       if (entry.name.startsWith("."))
         continue;
-      const abs = normalizePath2(resolve36(cwd2, entry.name));
+      const abs = normalizePath2(resolve37(cwd2, entry.name));
       if (roots.includes(abs))
         continue;
       if (shouldIgnorePath(abs, resolved))
@@ -25055,8 +25272,8 @@ var init_pathUtils = __esm(() => {
 
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
-import { existsSync as existsSync35, readdirSync as readdirSync7, statSync as statSync4 } from "fs";
-import { dirname as dirname26, join as join46, resolve as resolve37 } from "path";
+import { existsSync as existsSync36, readdirSync as readdirSync7, statSync as statSync4 } from "fs";
+import { dirname as dirname26, join as join47, resolve as resolve38 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -25088,7 +25305,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
     for (const name of entries) {
       if (shouldSkipFilename(name, isStylesDir))
         continue;
-      const child = join46(eventDir, name).replace(/\\/g, "/");
+      const child = join47(eventDir, name).replace(/\\/g, "/");
       let st2;
       try {
         st2 = statSync4(child);
@@ -25109,7 +25326,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
       return;
     if (shouldSkipFilename(filename, isStylesDir)) {
       if (event === "rename") {
-        const eventDir = dirname26(join46(absolutePath, filename)).replace(/\\/g, "/");
+        const eventDir = dirname26(join47(absolutePath, filename)).replace(/\\/g, "/");
         atomicRecoveryScan(eventDir);
         for (const delay of [25, 100]) {
           const timer = setTimeout(() => atomicRecoveryScan(eventDir), delay);
@@ -25118,16 +25335,16 @@ var safeRemoveFromGraph = (graph, fullPath) => {
       }
       return;
     }
-    const fullPath = join46(absolutePath, filename).replace(/\\/g, "/");
+    const fullPath = join47(absolutePath, filename).replace(/\\/g, "/");
     if (shouldIgnorePath(fullPath, state.resolvedPaths)) {
       return;
     }
-    if (event === "rename" && !existsSync35(fullPath)) {
+    if (event === "rename" && !existsSync36(fullPath)) {
       safeRemoveFromGraph(state.dependencyGraph, fullPath);
       onFileChange(fullPath);
       return;
     }
-    if (existsSync35(fullPath)) {
+    if (existsSync36(fullPath)) {
       onFileChange(fullPath);
       safeAddToGraph(state.dependencyGraph, fullPath);
     }
@@ -25136,8 +25353,8 @@ var safeRemoveFromGraph = (graph, fullPath) => {
 }, addFileWatchers = (state, paths, onFileChange) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
-    const absolutePath = resolve37(path).replace(/\\/g, "/");
-    if (!existsSync35(absolutePath)) {
+    const absolutePath = resolve38(path).replace(/\\/g, "/");
+    if (!existsSync36(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -25147,8 +25364,8 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const watchPaths = getWatchPaths(config, state.resolvedPaths);
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
-    const absolutePath = resolve37(path).replace(/\\/g, "/");
-    if (!existsSync35(absolutePath)) {
+    const absolutePath = resolve38(path).replace(/\\/g, "/");
+    if (!existsSync36(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -25166,13 +25383,13 @@ var init_fileWatcher = __esm(() => {
 });
 
 // src/dev/assetStore.ts
-import { resolve as resolve38 } from "path";
+import { resolve as resolve39 } from "path";
 import { readdir as readdir5, 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 = resolve38(dir, entry.name);
+  const fullPath = resolve39(dir, entry.name);
   if (entry.isDirectory()) {
     return walkAndClean(fullPath);
   }
@@ -25188,10 +25405,10 @@ var mimeTypes, getMimeType = (filePath) => {
 }, cleanStaleAssets = async (store, manifest, buildDir) => {
   const liveByIdentity = new Map;
   for (const webPath of store.keys()) {
-    const diskPath = resolve38(buildDir, webPath.slice(1));
+    const diskPath = resolve39(buildDir, webPath.slice(1));
     liveByIdentity.set(stripHash(diskPath), diskPath);
   }
-  const absBuildDir = resolve38(buildDir);
+  const absBuildDir = resolve39(buildDir);
   Object.values(manifest).forEach((val) => {
     if (!HASHED_FILE_RE.test(val))
       return;
@@ -25209,7 +25426,7 @@ var mimeTypes, getMimeType = (filePath) => {
   } catch {}
 }, lookupAsset = (store, path) => store.get(path), processScanEntry = (entry, dir, prefix, store, scanDir) => {
   if (entry.isDirectory()) {
-    return scanDir(resolve38(dir, entry.name), `${prefix}${entry.name}/`);
+    return scanDir(resolve39(dir, entry.name), `${prefix}${entry.name}/`);
   }
   if (!entry.name.startsWith("chunk-")) {
     return null;
@@ -25218,7 +25435,7 @@ var mimeTypes, getMimeType = (filePath) => {
   if (store.has(webPath)) {
     return null;
   }
-  return Bun.file(resolve38(dir, entry.name)).bytes().then((bytes) => {
+  return Bun.file(resolve39(dir, entry.name)).bytes().then((bytes) => {
     store.set(webPath, bytes);
     return;
   }).catch(() => {});
@@ -25240,7 +25457,7 @@ var mimeTypes, getMimeType = (filePath) => {
   for (const webPath of newIdentities.values()) {
     if (store.has(webPath))
       continue;
-    loadPromises.push(Bun.file(resolve38(buildDir, webPath.slice(1))).bytes().then((bytes) => {
+    loadPromises.push(Bun.file(resolve39(buildDir, webPath.slice(1))).bytes().then((bytes) => {
       store.set(webPath, bytes);
       return;
     }).catch(() => {}));
@@ -25285,10 +25502,10 @@ var init_assetStore = __esm(() => {
 });
 
 // src/dev/fileHashTracker.ts
-import { readFileSync as readFileSync31 } from "fs";
+import { readFileSync as readFileSync32 } from "fs";
 var computeFileHash = (filePath) => {
   try {
-    const fileContent = readFileSync31(filePath);
+    const fileContent = readFileSync32(filePath);
     return Number(Bun.hash(fileContent));
   } catch {
     return UNFOUND_INDEX;
@@ -25381,9 +25598,9 @@ var init_transformCache = __esm(() => {
 });
 
 // src/dev/reactComponentClassifier.ts
-import { resolve as resolve39 } from "path";
+import { resolve as resolve40 } from "path";
 var classifyComponent = (filePath) => {
-  const normalizedPath = resolve39(filePath);
+  const normalizedPath = resolve40(filePath);
   if (normalizedPath.includes("/react/pages/")) {
     return "server";
   }
@@ -25395,7 +25612,7 @@ var classifyComponent = (filePath) => {
 var init_reactComponentClassifier = () => {};
 
 // src/dev/moduleMapper.ts
-import { basename as basename15, resolve as resolve40 } from "path";
+import { basename as basename15, resolve as resolve41 } from "path";
 var buildModulePaths = (moduleKeys, manifest) => {
   const modulePaths = {};
   moduleKeys.forEach((key) => {
@@ -25405,7 +25622,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return modulePaths;
 }, processChangedFile = (sourceFile, framework, manifest, resolvedPaths, processedFiles) => {
-  const normalizedFile = resolve40(sourceFile);
+  const normalizedFile = resolve41(sourceFile);
   const normalizedPath = normalizedFile.replace(/\\/g, "/");
   if (processedFiles.has(normalizedFile)) {
     return null;
@@ -25441,7 +25658,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return grouped;
 }, mapSourceFileToManifestKeys = (sourceFile, framework, resolvedPaths) => {
-  const normalizedFile = resolve40(sourceFile);
+  const normalizedFile = resolve41(sourceFile);
   const fileName = basename15(normalizedFile);
   const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|css|html)$/, "");
   const pascalName = toPascal(baseName);
@@ -25497,7 +25714,7 @@ var init_moduleMapper = __esm(() => {
 
 // src/utils/spaRouteCss.ts
 import { readFile as readFile9 } from "fs/promises";
-import { dirname as dirname27, isAbsolute as isAbsolute5, resolve as resolve41 } from "path";
+import { dirname as dirname27, isAbsolute as isAbsolute5, resolve as resolve42 } from "path";
 var sideManifestCache, readSideManifest = async (sideManifestPath) => {
   const cached = sideManifestCache.get(sideManifestPath);
   if (cached !== undefined)
@@ -25535,7 +25752,7 @@ var sideManifestCache, readSideManifest = async (sideManifestPath) => {
 }, readChildCss = async (cssPath, sideManifestPath) => {
   if (!cssPath)
     return "";
-  const resolvedCssPath = isAbsolute5(cssPath) ? cssPath : resolve41(dirname27(sideManifestPath), cssPath);
+  const resolvedCssPath = isAbsolute5(cssPath) ? cssPath : resolve42(dirname27(sideManifestPath), cssPath);
   const cached = childCssCache.get(resolvedCssPath);
   if (cached !== undefined)
     return cached;
@@ -25618,8 +25835,8 @@ __export(exports_resolveOwningComponents, {
   resolveDescendantsOfParent: () => resolveDescendantsOfParent,
   resolveOwningComponents: () => resolveOwningComponents
 });
-import { readdirSync as readdirSync8, readFileSync as readFileSync32, statSync as statSync5 } from "fs";
-import { dirname as dirname28, extname as extname12, join as join47, resolve as resolve42 } from "path";
+import { readdirSync as readdirSync8, readFileSync as readFileSync33, statSync as statSync5 } from "fs";
+import { dirname as dirname28, extname as extname12, join as join48, resolve as resolve43 } from "path";
 import ts19 from "typescript";
 var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") || file5.endsWith(".tsx"), walkAngularSourceFiles = (root) => {
   const out = [];
@@ -25634,7 +25851,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const full = join47(dir, entry.name);
+      const full = join48(dir, entry.name);
       if (entry.isDirectory()) {
         visit(full);
       } else if (entry.isFile() && isAngularSourceFile(entry.name)) {
@@ -25678,7 +25895,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
 }, parseDecoratedClasses = (filePath) => {
   let source;
   try {
-    source = readFileSync32(filePath, "utf8");
+    source = readFileSync33(filePath, "utf8");
   } catch {
     return [];
   }
@@ -25732,7 +25949,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
   };
   visit(sourceFile);
   return out;
-}, safeNormalize = (path) => resolve42(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
+}, safeNormalize = (path) => resolve43(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
   const { changedFilePath, userAngularRoot } = params;
   const changedAbs = safeNormalize(changedFilePath);
   const out = [];
@@ -25768,7 +25985,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
 }, indexByRoot, resolveParentClassFile = (parentName, childFilePath, angularRoot) => {
   let source;
   try {
-    source = readFileSync32(childFilePath, "utf8");
+    source = readFileSync33(childFilePath, "utf8");
   } catch {
     return null;
   }
@@ -25801,7 +26018,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
     if (!spec.startsWith(".") && !spec.startsWith("/")) {
       return null;
     }
-    const base = resolve42(childDir, spec);
+    const base = resolve43(childDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -25839,7 +26056,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
       };
       if (cls.kind === "component") {
         for (const url of [...cls.templateUrls, ...cls.styleUrls]) {
-          const abs = safeNormalize(resolve42(componentDir, url));
+          const abs = safeNormalize(resolve43(componentDir, url));
           const existing = resource.get(abs);
           if (existing)
             existing.push(entity);
@@ -26087,8 +26304,8 @@ __export(exports_moduleServer, {
   warmCompilers: () => warmCompilers,
   warnIfReactFastRefreshUnsupported: () => warnIfReactFastRefreshUnsupported
 });
-import { existsSync as existsSync36, readFileSync as readFileSync33, realpathSync as realpathSync3, statSync as statSync6 } from "fs";
-import { basename as basename16, dirname as dirname29, extname as extname13, join as join48, resolve as resolve43, relative as relative17 } from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync34, realpathSync as realpathSync3, statSync as statSync6 } from "fs";
+import { basename as basename16, dirname as dirname29, extname as extname13, join as join49, resolve as resolve44, relative as relative17 } from "path";
 var SRC_PREFIX = "/@src/", BROWSER_DEFINE, jsTranspiler2, legacyDecoratorTsconfig, tsTranspiler2, tsxTranspiler, TRANSPILABLE, ALL_EXPORTS_RE, STRING_CONTENTS_RE, preserveTypeExports = (originalSource, transpiled, valueExports) => {
   const codeOnly = originalSource.replace(STRING_CONTENTS_RE, '""');
   const allExports = [];
@@ -26108,10 +26325,10 @@ var SRC_PREFIX = "/@src/", BROWSER_DEFINE, jsTranspiler2, legacyDecoratorTsconfi
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const directHit = extensions.find((ext) => existsSync36(resolve43(projectRoot, srcPath + ext)));
+  const directHit = extensions.find((ext) => existsSync37(resolve44(projectRoot, srcPath + ext)));
   if (directHit)
     return srcPath + directHit;
-  const indexHit = extensions.find((ext) => existsSync36(resolve43(projectRoot, srcPath, `index${ext}`)));
+  const indexHit = extensions.find((ext) => existsSync37(resolve44(projectRoot, srcPath, `index${ext}`)));
   if (indexHit)
     return `${srcPath}/index${indexHit}`;
   return srcPath;
@@ -26134,7 +26351,7 @@ ${stubs}
   return invalidationVersion > 0 ? `${mtime}.${invalidationVersion}` : `${mtime}`;
 }, srcUrl = (relPath, projectRoot) => {
   const base = `${SRC_PREFIX}${relPath.replace(/\\/g, "/")}`;
-  const absPath = resolve43(projectRoot, relPath);
+  const absPath = resolve44(projectRoot, relPath);
   const cached = mtimeCache.get(absPath);
   if (cached !== undefined)
     return `${base}?v=${buildVersion(cached, absPath)}`;
@@ -26146,12 +26363,12 @@ ${stubs}
     return base;
   }
 }, resolveRelativeImport = (relPath, fileDir, projectRoot, extensions) => {
-  const absPath = resolve43(fileDir, relPath);
+  const absPath = resolve44(fileDir, relPath);
   const rel = relative17(projectRoot, absPath);
   const extension = extname13(rel);
   let srcPath = RESOLVED_MODULE_EXTENSIONS.has(extension) ? rel : resolveRelativeExtension(rel, projectRoot, extensions);
   if (extname13(srcPath) === ".svelte") {
-    srcPath = relative17(projectRoot, resolveSvelteModulePath(resolve43(projectRoot, srcPath)));
+    srcPath = relative17(projectRoot, resolveSvelteModulePath(resolve44(projectRoot, srcPath)));
   }
   return srcUrl(srcPath, projectRoot);
 }, NODE_BUILTIN_RE, resolveAbsoluteSpecifier = (specifier, projectRoot) => {
@@ -26170,14 +26387,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 = resolve43(projectRoot, "node_modules", packageName ?? "");
-        const pkgJsonPath = join48(pkgDir, "package.json");
-        if (existsSync36(pkgJsonPath)) {
-          const pkg = JSON.parse(readFileSync33(pkgJsonPath, "utf-8"));
+        const pkgDir = resolve44(projectRoot, "node_modules", packageName ?? "");
+        const pkgJsonPath = join49(pkgDir, "package.json");
+        if (existsSync37(pkgJsonPath)) {
+          const pkg = JSON.parse(readFileSync34(pkgJsonPath, "utf-8"));
           const esmEntry = typeof pkg.module === "string" && pkg.module || typeof pkg.browser === "string" && pkg.browser;
           if (esmEntry) {
-            const resolved = resolve43(pkgDir, esmEntry);
-            if (existsSync36(resolved))
+            const resolved = resolve44(pkgDir, esmEntry);
+            if (existsSync37(resolved))
               return relative17(projectRoot, resolved);
           }
         }
@@ -26229,12 +26446,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 = resolve43(fileDir, relPath);
+    const absPath = resolve44(fileDir, relPath);
     const rel = relative17(projectRoot, absPath);
     return `new URL('${srcUrl(rel, projectRoot)}', import.meta.url)`;
   });
   result = result.replace(/import\.meta\.resolve\(\s*["'](\.\.?\/[^"']+)["']\s*\)/g, (_match, relPath) => {
-    const absPath = resolve43(fileDir, relPath);
+    const absPath = resolve44(fileDir, relPath);
     const rel = relative17(projectRoot, absPath);
     return `'${srcUrl(rel, projectRoot)}'`;
   });
@@ -26280,7 +26497,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 targeted " + "page remount instead of a state-preserving fast refresh.");
 }, transformReactFile = (filePath, projectRoot, rewriter) => {
-  const raw = readFileSync33(filePath, "utf-8");
+  const raw = readFileSync34(filePath, "utf-8");
   const valueExports = tsxTranspiler.scan(raw).exports;
   let transpiled = reactTranspiler.transformSync(raw);
   transpiled = preserveTypeExports(raw, transpiled, valueExports);
@@ -26296,7 +26513,7 @@ ${transpiled}`;
   transpiled += buildIslandMetadataExports(raw);
   return rewriteImports(transpiled, filePath, projectRoot, rewriter);
 }, transformPlainFile = (filePath, projectRoot, rewriter, vueDir) => {
-  const raw = readFileSync33(filePath, "utf-8");
+  const raw = readFileSync34(filePath, "utf-8");
   const ext = extname13(filePath);
   const isTS = ext === ".ts" || ext === ".tsx";
   const isTSX = ext === ".tsx" || ext === ".jsx";
@@ -26462,7 +26679,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 = readFileSync33(filePath, "utf-8");
+  const raw = readFileSync34(filePath, "utf-8");
   if (!svelteCompiler) {
     svelteCompiler = await import("svelte/compiler");
   }
@@ -26528,7 +26745,7 @@ export default __script__;`;
   return `${cssInjection}
 ${code}`;
 }, transformVueFile = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
-  const rawSource = readFileSync33(filePath, "utf-8");
+  const rawSource = readFileSync34(filePath, "utf-8");
   const raw = addAutoRouterSetupApp(rawSource);
   if (!vueCompiler) {
     vueCompiler = await loadVueCompiler();
@@ -26539,9 +26756,9 @@ ${code}`;
   const hasScript = descriptor.script || descriptor.scriptSetup;
   const compiledScript = hasScript ? vueCompiler.compileScript(descriptor, {
     fs: {
-      fileExists: existsSync36,
+      fileExists: existsSync37,
       realpath: realpathSync3,
-      readFile: (file5) => existsSync36(file5) ? readFileSync33(file5, "utf-8") : undefined
+      readFile: (file5) => existsSync37(file5) ? readFileSync34(file5, "utf-8") : undefined
     },
     id: componentId,
     inlineTemplate: false
@@ -26556,7 +26773,7 @@ ${code}`;
   code = injectVueHmr(code, filePath, projectRoot, vueDir);
   return rewriteImports(code, filePath, projectRoot, rewriter);
 }, injectVueHmr = (code, filePath, projectRoot, vueDir) => {
-  const hmrBase = vueDir ? resolve43(vueDir) : projectRoot;
+  const hmrBase = vueDir ? resolve44(vueDir) : projectRoot;
   const hmrId = relative17(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
   let result = code.replace(/export\s+default\s+/, "var __hmr_comp__ = ");
   result += [
@@ -26571,11 +26788,11 @@ ${code}`;
 `);
   return result;
 }, resolveSvelteModulePath = (path) => {
-  if (existsSync36(path))
+  if (existsSync37(path))
     return path;
-  if (existsSync36(`${path}.ts`))
+  if (existsSync37(`${path}.ts`))
     return `${path}.ts`;
-  if (existsSync36(`${path}.js`))
+  if (existsSync37(`${path}.js`))
     return `${path}.js`;
   return path;
 }, jsResponse = (body) => {
@@ -26588,7 +26805,7 @@ ${code}`;
     }
   });
 }, handleCssRequest = (filePath) => {
-  const raw = readFileSync33(filePath, "utf-8");
+  const raw = readFileSync34(filePath, "utf-8");
   const escaped = raw.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return [
     `const style = document.createElement('style');`,
@@ -26720,13 +26937,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 = resolve43(projectRoot, relPath);
+  const filePath = resolve44(projectRoot, relPath);
   const ext = extname13(filePath);
   if (ext === ".svelte")
     return { ext, filePath: resolveSvelteModulePath(filePath) };
   if (ext)
     return { ext, filePath };
-  const found = MODULE_EXTENSIONS.find((candidate) => existsSync36(filePath + candidate));
+  const found = MODULE_EXTENSIONS.find((candidate) => existsSync37(filePath + candidate));
   if (!found)
     return { ext, filePath };
   const resolved = filePath + found;
@@ -26757,14 +26974,14 @@ export default {};
           const absoluteCandidate = `/${tail.replace(/^\/+/, "")}`;
           const candidates = [
             absoluteCandidate,
-            resolve43(projectRoot, tail)
+            resolve44(projectRoot, tail)
           ];
           try {
             const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_loadConfig(), exports_loadConfig));
             const cfg = await loadConfig2();
-            const angularDir = cfg.angularDirectory && resolve43(projectRoot, cfg.angularDirectory);
+            const angularDir = cfg.angularDirectory && resolve44(projectRoot, cfg.angularDirectory);
             if (angularDir)
-              candidates.push(resolve43(angularDir, tail));
+              candidates.push(resolve44(angularDir, tail));
           } catch {}
           for (const candidate of candidates) {
             if (await fileExists(candidate)) {
@@ -26795,7 +27012,7 @@ export default {};
   if (!TRANSPILABLE.has(ext))
     return;
   const stat3 = statSync6(filePath);
-  const resolvedVueDir = vueDir ? resolve43(vueDir) : undefined;
+  const resolvedVueDir = vueDir ? resolve44(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) {
@@ -26854,7 +27071,7 @@ export default {};
     const relPath = pathname.slice(SRC_PREFIX.length);
     if (relPath === "bun:wrap" || relPath.startsWith("bun:wrap?"))
       return handleBunWrapRequest();
-    const virtualCssResponse = handleVirtualSvelteCss(resolve43(projectRoot, relPath));
+    const virtualCssResponse = handleVirtualSvelteCss(resolve44(projectRoot, relPath));
     if (virtualCssResponse)
       return virtualCssResponse;
     const { filePath, ext } = resolveSourcePath(relPath, projectRoot);
@@ -26870,11 +27087,11 @@ export default {};
   SRC_IMPORT_RE.lastIndex = 0;
   while ((match = SRC_IMPORT_RE.exec(content)) !== null) {
     if (match[1])
-      files.push(resolve43(projectRoot, match[1]));
+      files.push(resolve44(projectRoot, match[1]));
   }
   return files;
 }, invalidateModule = (filePath) => {
-  const resolved = resolve43(filePath);
+  const resolved = resolve44(filePath);
   invalidate(filePath);
   if (resolved !== filePath)
     invalidate(resolved);
@@ -27037,7 +27254,7 @@ __export(exports_hmrCompiler, {
   encodeHmrComponentId: () => encodeHmrComponentId,
   getApplyMetadataModule: () => getApplyMetadataModule
 });
-import { dirname as dirname30, relative as relative18, resolve as resolve44 } from "path";
+import { dirname as dirname30, relative as relative18, resolve as resolve45 } from "path";
 import { performance as performance2 } from "perf_hooks";
 var encodeHmrComponentId = (absoluteFilePath, className) => {
   const projectRel = relative18(process.cwd(), absoluteFilePath).replace(/\\/g, "/");
@@ -27049,7 +27266,7 @@ var encodeHmrComponentId = (absoluteFilePath, className) => {
     return null;
   const filePathRel = decoded.slice(0, separatorIndex);
   const className = decoded.slice(separatorIndex + 1);
-  const componentFilePath = resolve44(process.cwd(), filePathRel);
+  const componentFilePath = resolve45(process.cwd(), filePathRel);
   const projectRelPath = relative18(process.cwd(), componentFilePath).replace(/\\/g, "/");
   const cacheKey2 = encodeURIComponent(`${projectRelPath}@${className}`);
   const { takePendingModule: takePendingModule2 } = await Promise.resolve().then(() => (init_fastHmrCompiler(), exports_fastHmrCompiler));
@@ -27219,11 +27436,11 @@ var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { resolve as resolve45 } from "path";
+import { resolve as resolve46 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve45(htmlFilePath);
+    const resolvedPath = resolve46(htmlFilePath);
     const file5 = Bun.file(resolvedPath);
     if (!await file5.exists()) {
       return null;
@@ -27249,11 +27466,11 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { resolve as resolve46 } from "path";
+import { resolve as resolve47 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve46(htmxFilePath);
+    const resolvedPath = resolve47(htmxFilePath);
     const file5 = Bun.file(resolvedPath);
     if (!await file5.exists()) {
       return null;
@@ -27275,12 +27492,12 @@ var handleHTMXUpdate = async (htmxFilePath) => {
 var init_simpleHTMXHMR = () => {};
 
 // src/dev/rebuildTrigger.ts
-import { existsSync as existsSync37, readdirSync as readdirSync9, rmSync as rmSync3 } from "fs";
+import { existsSync as existsSync38, readdirSync as readdirSync9, rmSync as rmSync3 } from "fs";
 import {
   basename as basename17,
   dirname as dirname31,
   isAbsolute as isAbsolute6,
-  join as join49,
+  join as join50,
   relative as relative19,
   resolve as resolvePath3,
   sep as sep4
@@ -27389,7 +27606,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
     detectedFw = detected !== "ignored" ? detected : affectedFrameworks[0];
   }
   return { ...parsed, framework: detectedFw };
-}, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync37(affectedFile), FRAMEWORK_DIR_KEYS_FOR_CLEANUP, removeStaleGenerated = (state, deletedFile) => {
+}, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync38(affectedFile), FRAMEWORK_DIR_KEYS_FOR_CLEANUP, removeStaleGenerated = (state, deletedFile) => {
   const { config } = state;
   const cwd2 = process.cwd();
   const absDeleted = resolvePath3(deletedFile).replace(/\\/g, "/");
@@ -27407,8 +27624,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
     const relJs = `${rel.slice(0, -ext[0].length)}.js`;
     const generatedDir = getFrameworkGeneratedDir(framework, cwd2);
     for (const candidate of [
-      join49(generatedDir, relJs),
-      `${join49(generatedDir, relJs)}.map`
+      join50(generatedDir, relJs),
+      `${join50(generatedDir, relJs)}.map`
     ]) {
       try {
         rmSync3(candidate, { force: true });
@@ -27435,7 +27652,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
     if (!dependents || dependents.size === 0) {
       return;
     }
-    const dependentFiles = Array.from(dependents).filter((file5) => existsSync37(file5));
+    const dependentFiles = Array.from(dependents).filter((file5) => existsSync38(file5));
     if (dependentFiles.length === 0) {
       return;
     }
@@ -27451,7 +27668,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, normalizedFilePath);
     affectedFiles.forEach((affectedFile) => {
-      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync37(affectedFile)) {
+      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync38(affectedFile)) {
         validFiles.push(affectedFile);
         processedFiles.add(affectedFile);
       }
@@ -27476,7 +27693,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   collectChangedFileAffected(state, normalizedFilePath, processedFiles, validFiles);
 }, processFilePathSet = (state, filePathSet, processedFiles, validFiles) => {
   filePathSet.forEach((filePathInSet) => {
-    if (!existsSync37(filePathInSet)) {
+    if (!existsSync38(filePathInSet)) {
       collectDeletedFileAffected(state, filePathInSet, processedFiles, validFiles);
       return;
     }
@@ -27741,7 +27958,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
     return componentFile;
   }
   const tsCounterpart = componentFile.replace(/\.html$/, ".ts");
-  if (existsSync37(tsCounterpart)) {
+  if (existsSync38(tsCounterpart)) {
     return tsCounterpart;
   }
   if (!graph)
@@ -28191,8 +28408,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   };
   return ({ immediate = false } = {}) => {
     if (!ctx.debouncedPromise) {
-      ctx.debouncedPromise = new Promise((resolve47) => {
-        ctx.debouncedResolve = resolve47;
+      ctx.debouncedPromise = new Promise((resolve48) => {
+        ctx.debouncedResolve = resolve48;
       });
     }
     const scheduled = ctx.debouncedPromise;
@@ -28314,7 +28531,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
         const entries = await readdir6(dir, { withFileTypes: true });
         const files = [];
         for (const entry of entries) {
-          const full = join49(dir, entry.name);
+          const full = join50(dir, entry.name);
           if (entry.isDirectory()) {
             files.push(...await walk(full));
           } else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
@@ -28611,7 +28828,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   }
   return ctx;
 }, runSvelteBundleRebuild = async (state, svelteFiles, config) => {
-  const existingSvelteFiles = svelteFiles.filter((file5) => existsSync37(file5));
+  const existingSvelteFiles = svelteFiles.filter((file5) => existsSync38(file5));
   if (existingSvelteFiles.length === 0)
     return;
   const svelteDir = config.svelteDirectory ?? "";
@@ -28727,8 +28944,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   };
   return () => {
     if (!ctx.debouncedPromise) {
-      ctx.debouncedPromise = new Promise((resolve47) => {
-        ctx.debouncedResolve = resolve47;
+      ctx.debouncedPromise = new Promise((resolve48) => {
+        ctx.debouncedResolve = resolve48;
       });
     }
     if (ctx.debounceTimer)
@@ -28877,7 +29094,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   } = await compileVue2(vueFiles, vueDir, true, getStyleTransformConfig(state.config));
   const serverEntries = [...vueServerPaths];
   const clientEntries = [...vueIndexPaths, ...vueClientPaths];
-  const cssOutDir = join49(buildDir, state.resolvedPaths.assetsDir ? basename17(state.resolvedPaths.assetsDir) : "assets", "css");
+  const cssOutDir = join50(buildDir, state.resolvedPaths.assetsDir ? basename17(state.resolvedPaths.assetsDir) : "assets", "css");
   const { serverRoot, serverOutDir } = await computeServerOutPaths(state.resolvedPaths, "vue");
   const serverExternals = await getServerBundleExternals();
   const clientVendorPaths = await getClientVendorPaths();
@@ -29005,8 +29222,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   };
   return () => {
     if (!ctx.debouncedPromise) {
-      ctx.debouncedPromise = new Promise((resolve47) => {
-        ctx.debouncedResolve = resolve47;
+      ctx.debouncedPromise = new Promise((resolve48) => {
+        ctx.debouncedResolve = resolve48;
       });
     }
     if (ctx.debounceTimer)
@@ -29968,9 +30185,9 @@ __export(exports_buildDepVendor, {
   buildDepVendor: () => buildDepVendor,
   computeDepVendorPaths: () => computeDepVendorPaths
 });
-import { mkdirSync as mkdirSync14 } from "fs";
+import { mkdirSync as mkdirSync15 } from "fs";
 import { isBuiltin } from "module";
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 import { rm as rm14 } from "fs/promises";
 var {build: bunBuild9, Glob: Glob10 } = globalThis.Bun;
 var toSafeFileName6 = (specifier) => {
@@ -30029,7 +30246,7 @@ var toSafeFileName6 = (specifier) => {
     framework: Array.from(framework).filter(isResolvable3)
   };
 }, collectBareImportsFromFile = async (entryPath, transpiler6, maxDepth = 8) => {
-  const { readFileSync: readFileSync34 } = await import("fs");
+  const { readFileSync: readFileSync35 } = await import("fs");
   const { dirname: dirname32 } = await import("path");
   const seenFiles = new Set;
   const bareOut = new Set;
@@ -30045,7 +30262,7 @@ var toSafeFileName6 = (specifier) => {
       continue;
     let content;
     try {
-      content = readFileSync34(path, "utf-8");
+      content = readFileSync35(path, "utf-8");
     } catch {
       continue;
     }
@@ -30119,7 +30336,7 @@ var toSafeFileName6 = (specifier) => {
 }), buildDepVendorPass = async (specifiers, vendorDir, tmpDir) => {
   const entries = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName6(specifier);
-    const entryPath = join50(tmpDir, `${safeName}.ts`);
+    const entryPath = join51(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return { entryPath, specifier };
   }));
@@ -30210,10 +30427,10 @@ var toSafeFileName6 = (specifier) => {
   const { dep: initialSpecs, framework: frameworkRoots } = await scanBareImports(directories);
   if (initialSpecs.length === 0 && frameworkRoots.length === 0)
     return {};
-  const vendorDir = join50(buildDir, "vendor");
-  mkdirSync14(vendorDir, { recursive: true });
-  const tmpDir = join50(buildDir, "_dep_vendor_tmp");
-  mkdirSync14(tmpDir, { recursive: true });
+  const vendorDir = join51(buildDir, "vendor");
+  mkdirSync15(vendorDir, { recursive: true });
+  const tmpDir = join51(buildDir, "_dep_vendor_tmp");
+  mkdirSync15(tmpDir, { recursive: true });
   const allSpecs = new Set(initialSpecs);
   const alreadyScanned = new Set;
   let frontier = [...allSpecs, ...frameworkRoots];
@@ -30296,7 +30513,7 @@ __export(exports_devBuild, {
 });
 import { readdir as readdir6 } from "fs/promises";
 import { statSync as statSync7 } from "fs";
-import { resolve as resolve47 } from "path";
+import { resolve as resolve48 } from "path";
 var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const configuredDirs = [
     config.reactDirectory,
@@ -30305,7 +30522,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     config.angularDirectory,
     config.htmlDirectory,
     config.htmxDirectory,
-    resolve47(import.meta.dir, "../dev/client")
+    resolve48(import.meta.dir, "../dev/client")
   ].filter((dir) => Boolean(dir));
   return Array.from(new Set(configuredDirs));
 }, parseDirectoryConfig = (source) => {
@@ -30320,7 +30537,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return Object.keys(config).length > 0 ? config : null;
 }, reloadConfig = async () => {
   try {
-    const configPath2 = resolve47(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+    const configPath2 = resolve48(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
     const source = await Bun.file(configPath2).text();
     return parseDirectoryConfig(source);
   } catch {
@@ -30432,7 +30649,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     });
   }
 }, handleCachedReload = async () => {
-  const serverMtime = statSync7(resolve47(Bun.main)).mtimeMs;
+  const serverMtime = statSync7(resolve48(Bun.main)).mtimeMs;
   const lastMtime = globalThis.__hmrServerMtime;
   globalThis.__hmrServerMtime = serverMtime;
   const cached = globalThis.__hmrDevResult;
@@ -30469,8 +30686,8 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return true;
 }, resolveAbsoluteVersion2 = async () => {
   const candidates = [
-    resolve47(import.meta.dir, "..", "..", "package.json"),
-    resolve47(import.meta.dir, "..", "package.json")
+    resolve48(import.meta.dir, "..", "..", "package.json"),
+    resolve48(import.meta.dir, "..", "package.json")
   ];
   const [candidate, ...remaining] = candidates;
   if (!candidate) {
@@ -30496,7 +30713,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const entries = await readdir6(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(resolve47(vendorDir, entry)).bytes();
+    const bytes = await Bun.file(resolve48(vendorDir, entry)).bytes();
     assetStore.set(webPath, bytes);
   }));
 }, devBuild = async (config) => {
@@ -30521,6 +30738,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   process.env.ABSOLUTE_BUILD_DIR ??= state.resolvedPaths.buildDir;
   recordStep("create HMR state", stepStartedAt);
   stepStartedAt = performance.now();
+  setBootPhase("scan source tree");
   const watchPaths = getWatchPaths(config, state.resolvedPaths);
   buildInitialDependencyGraph(state.dependencyGraph, watchPaths);
   recordStep("initialize dependency graph", stepStartedAt);
@@ -30599,6 +30817,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   recordStep("start file watching", stepStartedAt);
   const buildStart = performance.now();
   let buildResult = null;
+  setBootPhase("initial build");
   try {
     buildResult = await build2({
       ...config,
@@ -30631,15 +30850,17 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     console.log("\u26A0\uFE0F Manifest is empty - this is OK for HTML/HTMX-only projects");
   }
   stepStartedAt = performance.now();
+  setBootPhase("populate asset store");
   await populateAssetStore(state.assetStore, manifest, state.resolvedPaths.buildDir);
   cleanStaleAssets(state.assetStore, manifest, state.resolvedPaths.buildDir);
   recordStep("populate asset store", stepStartedAt);
   stepStartedAt = performance.now();
-  const reactVendorDir = resolve47(state.resolvedPaths.buildDir, "react", "vendor");
-  const angularVendorDir = resolve47(state.resolvedPaths.buildDir, "angular", "vendor");
-  const svelteVendorDir = resolve47(state.resolvedPaths.buildDir, "svelte", "vendor");
-  const vueVendorDir = resolve47(state.resolvedPaths.buildDir, "vue", "vendor");
-  const depVendorDir = resolve47(state.resolvedPaths.buildDir, "vendor");
+  setBootPhase("build vendor bundles");
+  const reactVendorDir = resolve48(state.resolvedPaths.buildDir, "react", "vendor");
+  const angularVendorDir = resolve48(state.resolvedPaths.buildDir, "angular", "vendor");
+  const svelteVendorDir = resolve48(state.resolvedPaths.buildDir, "svelte", "vendor");
+  const vueVendorDir = resolve48(state.resolvedPaths.buildDir, "vue", "vendor");
+  const depVendorDir = resolve48(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),
@@ -30658,6 +30879,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   globalThis.__depVendorPaths = depPaths;
   recordStep("build vendor bundles", stepStartedAt);
   stepStartedAt = performance.now();
+  setBootPhase("rewrite vendor cross-references");
   const combinedVendorPaths = {
     ...getDevVendorPaths() ?? {},
     ...getAngularVendorPaths() ?? {},
@@ -30685,6 +30907,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   ]);
   recordStep("load vendor files", stepStartedAt);
   stepStartedAt = performance.now();
+  setBootPhase("warm compilers");
   const { warmCompilers: warmCompilers2 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
   await warmCompilers2({
     svelte: Boolean(config.svelteDirectory),
@@ -30717,7 +30940,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     manifest
   };
   globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync7(resolve47(Bun.main)).mtimeMs;
+  globalThis.__hmrServerMtime = statSync7(resolve48(Bun.main)).mtimeMs;
   return result;
 };
 var init_devBuild = __esm(() => {
@@ -30736,6 +30959,7 @@ var init_devBuild = __esm(() => {
   init_rebuildTrigger();
   init_logger();
   init_startupTimings();
+  init_bootLifecycle();
   FRAMEWORK_DIR_KEYS = [
     "reactDirectory",
     "svelteDirectory",
@@ -30866,8 +31090,8 @@ var STORE_KEY = "__elysiaStore", restoredStores, getGlobalValue = (key) => Refle
     return null;
   if (!pathname.startsWith("/"))
     return null;
-  const { resolve: resolve48, normalize } = await import("path");
-  const candidate = resolve48(buildDir, pathname.slice(1));
+  const { resolve: resolve49, normalize } = await import("path");
+  const candidate = resolve49(buildDir, pathname.slice(1));
   const normalizedBuild = normalize(buildDir);
   if (!candidate.startsWith(normalizedBuild))
     return null;
@@ -30966,17 +31190,17 @@ __export(exports_devtoolsJson, {
   normalizeDevtoolsWorkspaceRoot: () => normalizeDevtoolsWorkspaceRoot,
   resolveDevtoolsUuidCachePath: () => resolveDevtoolsUuidCachePath
 });
-import { existsSync as existsSync38, mkdirSync as mkdirSync15, readFileSync as readFileSync34, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname32, join as join51, resolve as resolve48 } from "path";
+import { existsSync as existsSync39, mkdirSync as mkdirSync16, readFileSync as readFileSync35, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname32, join as join52, resolve as resolve49 } from "path";
 import { Elysia as Elysia7 } from "elysia";
 var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_KEY = "__absoluteDevtoolsWorkspaceUuid", getGlobalUuid = () => Reflect.get(globalThis, UUID_CACHE_KEY), setGlobalUuid = (uuid) => {
   Reflect.set(globalThis, UUID_CACHE_KEY, uuid);
   return uuid;
-}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve48(uuidCachePath ?? join51(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
-  if (!existsSync38(cachePath))
+}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve49(uuidCachePath ?? join52(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
+  if (!existsSync39(cachePath))
     return null;
   try {
-    const value = readFileSync34(cachePath, "utf-8").trim();
+    const value = readFileSync35(cachePath, "utf-8").trim();
     return isUuidV4(value) ? value : null;
   } catch {
     return null;
@@ -30994,11 +31218,11 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   if (cachedUuid)
     return setGlobalUuid(cachedUuid);
   const uuid = crypto.randomUUID();
-  mkdirSync15(dirname32(cachePath), { recursive: true });
-  writeFileSync10(cachePath, uuid, "utf-8");
+  mkdirSync16(dirname32(cachePath), { recursive: true });
+  writeFileSync11(cachePath, uuid, "utf-8");
   return setGlobalUuid(uuid);
 }, devtoolsJson = (buildDir, options = {}) => {
-  const rootPath = resolve48(options.projectRoot ?? process.cwd());
+  const rootPath = resolve49(options.projectRoot ?? process.cwd());
   const root = options.normalizeForWindowsContainer === false ? rootPath : normalizeDevtoolsWorkspaceRoot(rootPath);
   const uuid = getOrCreateUuid(buildDir, options);
   return new Elysia7({ name: "absolute-devtools-json" }).get(ENDPOINT, () => ({
@@ -31011,11 +31235,11 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   if (process.env.WSL_DISTRO_NAME) {
     const distro = process.env.WSL_DISTRO_NAME;
     const withoutLeadingSlash = root.replace(/^\//, "");
-    return join51("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
+    return join52("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
   }
   if (process.env.DOCKER_DESKTOP && !root.startsWith("\\\\")) {
     const withoutLeadingSlash = root.replace(/^\//, "");
-    return join51("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
+    return join52("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
   }
   return root;
 };
@@ -31026,13 +31250,13 @@ var exports_imageOptimizer = {};
 __export(exports_imageOptimizer, {
   imageOptimizer: () => imageOptimizer
 });
-import { existsSync as existsSync39 } from "fs";
-import { resolve as resolve49 } from "path";
+import { existsSync as existsSync40 } from "fs";
+import { resolve as resolve50 } from "path";
 import { Elysia as Elysia8 } from "elysia";
 var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avifInProgress, safeResolve = (path, baseDir) => {
   try {
     const resolved = validateSafePath(path, baseDir);
-    if (existsSync39(resolved))
+    if (existsSync40(resolved))
       return resolved;
     return null;
   } catch {
@@ -31040,7 +31264,7 @@ var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avi
   }
 }, resolveLocalImage = (url, buildDir) => {
   const cleanPath = url.startsWith("/") ? url.slice(1) : url;
-  return safeResolve(cleanPath, buildDir) ?? safeResolve(cleanPath, resolve49(process.cwd()));
+  return safeResolve(cleanPath, buildDir) ?? safeResolve(cleanPath, resolve50(process.cwd()));
 }, parseQueryParams = (query, allowedSizes, defaultQuality) => {
   const url = typeof query["url"] === "string" ? query["url"] : undefined;
   const wParam = typeof query["w"] === "string" ? query["w"] : undefined;
@@ -31309,11 +31533,11 @@ var init_requestInspector = __esm(() => {
 });
 
 // src/mobile/nativeAuth.ts
-import { readFileSync as readFileSync35 } from "fs";
-import { join as join52 } from "path";
+import { readFileSync as readFileSync36 } from "fs";
+import { join as join53 } from "path";
 var ABSOLUTE_AUTH_PACKAGE = "@absolutejs/auth", ABSOLUTE_EXPO_AUTH_CORE_VERSION = "0.75.6", ABSOLUTE_EXPO_AUTH_PACKAGE = "@absolutejs/auth-expo", ABSOLUTE_EXPO_AUTH_VERSION = "0.0.2", ABSOLUTE_EXPO_SYNC_CORE_VERSION = "2.31.0", ABSOLUTE_EXPO_SYNC_PACKAGE = "@absolutejs/sync-expo", ABSOLUTE_EXPO_SYNC_VERSION = "0.0.2", ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV = "ABSOLUTE_AUTH_NATIVE_CLIENTS", ABSOLUTE_NATIVE_AUTH_SCOPES, ABSOLUTE_SYNC_PACKAGE = "@absolutejs/sync", readPackageManifest = (projectRoot) => {
   try {
-    return JSON.parse(readFileSync35(join52(projectRoot, "package.json"), "utf8"));
+    return JSON.parse(readFileSync36(join53(projectRoot, "package.json"), "utf8"));
   } catch {
     return;
   }
@@ -31359,7 +31583,7 @@ __export(exports_devDeviceAdapter, {
   buildAbsoluteNativeDevAdapter: () => buildAbsoluteNativeDevAdapter
 });
 import { access as access3, mkdtemp as mkdtemp3, rm as rm15, writeFile as writeFile9 } from "fs/promises";
-import { join as join53 } from "path";
+import { join as join54 } from "path";
 import { tmpdir } from "os";
 var absoluteNativeDevAdapterSource = (projectRoot, mobile, resolveModule = (specifier) => specifier, expoAdapterModule = "@absolutejs/absolute/mobile/expo-devices", expoAuthModule = "@absolutejs/absolute/mobile/expo-auth", expoSyncModule = "@absolutejs/absolute/mobile/expo-sync") => {
   if ((mobile.engine ?? "capacitor") === "expo") {
@@ -31397,7 +31621,7 @@ ${auth ? `void createAbsoluteExpoShellAuth(${JSON.stringify(auth)}).then(auth =>
 `);
 }, expoAdapterPath = async () => {
   const candidates = await Promise.all(["ts", "js"].map(async (extension) => {
-    const path2 = join53(import.meta.dir, `shellExpoDevices.${extension}`);
+    const path2 = join54(import.meta.dir, `shellExpoDevices.${extension}`);
     try {
       await access3(path2);
       return path2;
@@ -31411,7 +31635,7 @@ ${auth ? `void createAbsoluteExpoShellAuth(${JSON.stringify(auth)}).then(auth =>
   throw new TypeError("The AbsoluteJS Expo development adapter is missing.");
 }, expoAuthPath = async () => {
   const candidates = await Promise.all(["ts", "js"].map(async (extension) => {
-    const path2 = join53(import.meta.dir, `shellExpoAuth.${extension}`);
+    const path2 = join54(import.meta.dir, `shellExpoAuth.${extension}`);
     try {
       await access3(path2);
       return path2;
@@ -31425,7 +31649,7 @@ ${auth ? `void createAbsoluteExpoShellAuth(${JSON.stringify(auth)}).then(auth =>
   throw new TypeError("The AbsoluteJS Expo Auth development adapter is missing.");
 }, expoSyncPath = async () => {
   const candidates = await Promise.all(["ts", "js"].map(async (extension) => {
-    const path2 = join53(import.meta.dir, `shellExpoSync.${extension}`);
+    const path2 = join54(import.meta.dir, `shellExpoSync.${extension}`);
     try {
       await access3(path2);
       return path2;
@@ -31438,8 +31662,8 @@ ${auth ? `void createAbsoluteExpoShellAuth(${JSON.stringify(auth)}).then(auth =>
     return path;
   throw new TypeError("The AbsoluteJS Expo Sync development adapter is missing.");
 }, buildAbsoluteNativeDevAdapter = async (projectRoot, mobile) => {
-  const temporaryDirectory = await mkdtemp3(join53(tmpdir(), "absolutejs-native-dev-adapter-"));
-  const entry = join53(temporaryDirectory, "entry.ts");
+  const temporaryDirectory = await mkdtemp3(join54(tmpdir(), "absolutejs-native-dev-adapter-"));
+  const entry = join54(temporaryDirectory, "entry.ts");
   try {
     await writeFile9(entry, absoluteNativeDevAdapterSource(projectRoot, mobile, (specifier) => Bun.resolveSync(specifier, projectRoot), await expoAdapterPath(), await expoAuthPath(), await expoSyncPath()));
     const result = await Bun.build({
@@ -31473,15 +31697,15 @@ __export(exports_prerender, {
   rerenderRoute: () => rerenderRoute,
   routeToFilename: () => routeToFilename
 });
-import { mkdirSync as mkdirSync16, readFileSync as readFileSync36 } from "fs";
-import { join as join54 } from "path";
+import { mkdirSync as mkdirSync17, readFileSync as readFileSync37 } from "fs";
+import { join as join55 } from "path";
 var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_TIMEOUT_MS = 30000, DEFAULT_FETCH_TIMEOUT_MS = 1e4, PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass", routeToFilename = (route) => route === "/" ? "index.html" : `${route.slice(1).replace(/\//g, "-")}.html`, writeTimestamp = async (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   await Bun.write(metaPath, String(Date.now()));
 }, readTimestamp = (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   try {
-    const content = readFileSync36(metaPath, "utf-8");
+    const content = readFileSync37(metaPath, "utf-8");
     return Number(content) || 0;
   } catch {
     return 0;
@@ -31544,7 +31768,7 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
     if (!isCompleteHtml(html))
       return false;
     const fileName = routeToFilename(route);
-    const filePath = join54(prerenderDir, fileName);
+    const filePath = join55(prerenderDir, fileName);
     await Bun.write(filePath, html);
     await writeTimestamp(filePath);
     return true;
@@ -31574,14 +31798,14 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
     return;
   }
   const fileName = routeToFilename(route);
-  const filePath = join54(prerenderDir, fileName);
+  const filePath = join55(prerenderDir, fileName);
   await Bun.write(filePath, html);
   await writeTimestamp(filePath);
   result.routes.set(route, filePath);
   log2?.(`  Pre-rendered ${route} \u2192 ${fileName} (${html.length} bytes)`);
 }, prerender = async (port, outDir, staticConfig, log2) => {
-  const prerenderDir = join54(outDir, "_prerendered");
-  mkdirSync16(prerenderDir, { recursive: true });
+  const prerenderDir = join55(outDir, "_prerendered");
+  mkdirSync17(prerenderDir, { recursive: true });
   const baseUrl = `http://localhost:${port}`;
   let routes;
   if (staticConfig.routes === "all") {
@@ -31699,17 +31923,17 @@ __export(exports_serverEntryWatcher, {
 });
 import {
   copyFileSync as copyFileSync4,
-  existsSync as existsSync42,
+  existsSync as existsSync43,
   readdirSync as readdirSync12,
-  readFileSync as readFileSync40,
+  readFileSync as readFileSync41,
   statSync as statSync8,
   watch as watch2
 } from "fs";
-import { createHash as createHash10 } from "crypto";
-import { dirname as dirname33, join as join58, resolve as resolve50 } from "path";
+import { createHash as createHash11 } from "crypto";
+import { dirname as dirname33, join as join59, resolve as resolve51 } from "path";
 var ATOMIC_RECOVERY_WINDOW_MS = 1000, RELOAD_DEBOUNCE_MS = 80, ENTRY_IMPORT_RETRY_DELAY_MS = 250, MAX_ENTRY_IMPORT_ATTEMPTS = 3, WATCH_FALLBACK_INTERVAL_MS = 250, ATOMIC_WRITE_TEMP_PATTERNS2, isAtomicWriteTemp = (filename) => filename.endsWith(".tmp") || filename.includes(".tmp.") || filename.endsWith("~") || filename.startsWith(".#") || filename.startsWith(".absolutejs-hmr-") || ATOMIC_WRITE_TEMP_PATTERNS2.some((pattern) => pattern.test(filename)), fileHash = (path) => {
   try {
-    return createHash10("sha256").update(readFileSync40(path)).digest("hex");
+    return createHash11("sha256").update(readFileSync41(path)).digest("hex");
   } catch {
     return null;
   }
@@ -31730,14 +31954,14 @@ var ATOMIC_RECOVERY_WINDOW_MS = 1000, RELOAD_DEBOUNCE_MS = 80, ENTRY_IMPORT_RETR
   if (globalThis.__absoluteEntryWatcherStarted)
     return;
   const originalEntry = process.env.ABSOLUTE_SERVER_ENTRY ?? Bun.main;
-  if (!originalEntry || !existsSync42(originalEntry))
+  if (!originalEntry || !existsSync43(originalEntry))
     return;
   globalThis.__absoluteEntryWatcherStarted = true;
   globalThis.__absoluteEntryWatcherReady = false;
-  const entryPath = resolve50(originalEntry);
+  const entryPath = resolve51(originalEntry);
   const entryDir = dirname33(entryPath);
   const entryBase = entryPath.slice(entryDir.length + 1);
-  const configPath2 = resolve50(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+  const configPath2 = resolve51(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
   const configDir2 = dirname33(configPath2);
   const configBase = configPath2.slice(configDir2.length + 1);
   const recentlyHandled = new Map;
@@ -31748,7 +31972,7 @@ var ATOMIC_RECOVERY_WINDOW_MS = 1000, RELOAD_DEBOUNCE_MS = 80, ENTRY_IMPORT_RETR
   let pendingEntryCause = null;
   let siblingSequence = 0;
   const importFreshEntry = async (attempt = 1) => {
-    const siblingPath = join58(entryDir, `.absolutejs-hmr-${process.pid}-${siblingSequence++}.ts`);
+    const siblingPath = join59(entryDir, `.absolutejs-hmr-${process.pid}-${siblingSequence++}.ts`);
     let failure;
     try {
       copyFileSync4(entryPath, siblingPath);
@@ -31861,7 +32085,7 @@ var ATOMIC_RECOVERY_WINDOW_MS = 1000, RELOAD_DEBOUNCE_MS = 80, ENTRY_IMPORT_RETR
         continue;
       let st2;
       try {
-        st2 = statSync8(join58(dir, entry.name));
+        st2 = statSync8(join59(dir, entry.name));
       } catch {
         continue;
       }
@@ -32763,9 +32987,9 @@ var handleHTMXPageRequest = async (pagePath, options = {}) => {
   });
 };
 // src/core/prepare.ts
-import { createHash as createHash9 } from "crypto";
-import { existsSync as existsSync40, readdirSync as readdirSync10, readFileSync as readFileSync37 } from "fs";
-import { basename as basename18, join as join55, relative as relative20, resolve as resolvePath4 } from "path";
+import { createHash as createHash10 } from "crypto";
+import { existsSync as existsSync41, readdirSync as readdirSync10, readFileSync as readFileSync38 } from "fs";
+import { basename as basename18, join as join56, relative as relative20, resolve as resolvePath4 } from "path";
 import { Elysia as Elysia10, NotFound } from "elysia";
 
 // src/plugins/openApiPlugin.ts
@@ -34025,12 +34249,13 @@ init_resolveConvention();
 init_spaRouteManifest();
 init_startupTimings();
 init_logger();
+init_bootLifecycle();
 var MS_PER_SECOND2 = 1000;
 var DEFAULT_PORT2 = 3000;
 var MAX_STATIC_ROUTE_COUNT = Number.MAX_SAFE_INTEGER;
 var STATIC_PLUGIN_RETRY_DELAY_MS = 50;
-var waitForStaticPluginRetry = () => new Promise((resolve50) => {
-  setTimeout(resolve50, STATIC_PLUGIN_RETRY_DELAY_MS);
+var waitForStaticPluginRetry = () => new Promise((resolve51) => {
+  setTimeout(resolve51, STATIC_PLUGIN_RETRY_DELAY_MS);
 });
 var retryStaticPlugin = async (createStaticPlugin, options) => {
   try {
@@ -34110,7 +34335,7 @@ var patchManifestIndexes = (manifest, devIndexDir, SRC_URL_PREFIX2) => {
     if (!fileName)
       continue;
     const srcPath = resolvePath4(devIndexDir, fileName);
-    if (!existsSync40(srcPath))
+    if (!existsSync41(srcPath))
       continue;
     const rel = relative20(process.cwd(), srcPath).replace(/\\/g, "/");
     manifest[key] = `${SRC_URL_PREFIX2}${rel}`;
@@ -34126,10 +34351,10 @@ var registerIconVersioning = (buildDir) => {
     if (cached !== undefined)
       return cached;
     const path = href.split("?")[0] ?? href;
-    const filePath = join55(buildDir, path);
+    const filePath = join56(buildDir, path);
     let versioned = href;
-    if (existsSync40(filePath)) {
-      const hash = createHash9("sha256").update(readFileSync37(filePath)).digest("hex").slice(0, ICON_HASH_LENGTH);
+    if (existsSync41(filePath)) {
+      const hash = createHash10("sha256").update(readFileSync38(filePath)).digest("hex").slice(0, ICON_HASH_LENGTH);
       versioned = href.includes("?") ? `${href}&v=${hash}` : `${href}?v=${hash}`;
     }
     cache2.set(href, versioned);
@@ -34146,14 +34371,17 @@ var prepareDev = async (config, buildDir) => {
     });
   };
   let stepStartedAt = performance.now();
+  setBootPhase("patch route registration");
   const { patchElysiaRouteRegistrationCallsites: patchElysiaRouteRegistrationCallsites2 } = await Promise.resolve().then(() => (init_devRouteRegistrationCallsite(), exports_devRouteRegistrationCallsite));
   patchElysiaRouteRegistrationCallsites2();
   recordStep("patch route registration", stepStartedAt);
   stepStartedAt = performance.now();
+  setBootPhase("build");
   const { devBuild: devBuild2 } = await Promise.resolve().then(() => (init_devBuild(), exports_devBuild));
   const result = await devBuild2(config);
   recordStep("devBuild", stepStartedAt);
   stepStartedAt = performance.now();
+  setBootPhase("load dev runtime");
   const { hmr: hmr2 } = await Promise.resolve().then(() => (init_hmr(), exports_hmr));
   const { staticPlugin } = await import("@elysia/static");
   const { createModuleServer: createModuleServer2 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
@@ -34191,8 +34419,17 @@ var prepareDev = async (config, buildDir) => {
   const { warmCache: warmCache2, SRC_URL_PREFIX: SRC_URL_PREFIX2 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
   const prewarmDirs = buildPrewarmDirs(config);
   stepStartedAt = performance.now();
-  await warmPrewarmDirs(prewarmDirs, warmCache2, SRC_URL_PREFIX2);
-  recordStep("prewarm source modules", stepStartedAt);
+  deferUntilServing(async () => {
+    const prewarmStartedAt = performance.now();
+    await warmPrewarmDirs(prewarmDirs, warmCache2, SRC_URL_PREFIX2);
+    logStartupTimingBlock("AbsoluteJS deferred boot timing", [
+      {
+        durationMs: performance.now() - prewarmStartedAt,
+        label: "prewarm source modules (after listen)"
+      }
+    ]);
+  });
+  recordStep("schedule source module prewarm", stepStartedAt);
   if (config.dev?.https) {
     globalThis.__http2Config = {
       hmrState: result.hmrState,
@@ -34200,12 +34437,14 @@ var prepareDev = async (config, buildDir) => {
     };
   }
   stepStartedAt = performance.now();
+  setBootPhase("configure dev plugins");
   const hmrPlugin = hmr2(result.hmrState, result.manifest, moduleHandler);
   const { devtoolsJson: devtoolsJson2 } = await Promise.resolve().then(() => (init_devtoolsJson(), exports_devtoolsJson));
   const devIndexDir = resolvePath4(buildDir, "_src_indexes");
   patchManifestIndexes(result.manifest, devIndexDir, SRC_URL_PREFIX2);
   recordStep("configure dev plugins", stepStartedAt);
   stepStartedAt = performance.now();
+  setBootPhase("load runtime metadata");
   if (result.conventions)
     setConventions(result.conventions);
   setCurrentIslandManifest(result.manifest);
@@ -34215,6 +34454,7 @@ var prepareDev = async (config, buildDir) => {
   setCurrentPageIslandMetadata(await loadPageIslandMetadata(config));
   recordStep("load runtime metadata", stepStartedAt);
   stepStartedAt = performance.now();
+  setBootPhase("assemble dev runtime");
   const { imageOptimizer: imageOptimizer2 } = await Promise.resolve().then(() => (init_imageOptimizer(), exports_imageOptimizer));
   const { requestInspector: requestInspector2 } = await Promise.resolve().then(() => (init_requestInspector(), exports_requestInspector));
   const { serverTiming } = await import("@elysia/server-timing");
@@ -34244,6 +34484,7 @@ var prepareDev = async (config, buildDir) => {
   await withOpenApi(absolutejs, config, process.cwd(), true);
   await withTelemetry(absolutejs, config, process.cwd());
   recordStep("assemble dev runtime", stepStartedAt);
+  setBootPhase("starting server");
   logStartupTimingBlock("AbsoluteJS prepareDev timing", startupSteps);
   return {
     absolutejs,
@@ -34252,7 +34493,7 @@ var prepareDev = async (config, buildDir) => {
 };
 var loadPrerenderMap = (prerenderDir) => {
   const map = new Map;
-  if (!existsSync40(prerenderDir))
+  if (!existsSync41(prerenderDir))
     return map;
   let entries;
   try {
@@ -34265,13 +34506,13 @@ var loadPrerenderMap = (prerenderDir) => {
       continue;
     const name = basename18(entry, ".html");
     const route = name === "index" ? "/" : `/${name}`;
-    map.set(route, join55(prerenderDir, entry));
+    map.set(route, join56(prerenderDir, entry));
   }
   return map;
 };
 var loadMobileCompatibilityPlugin = async (buildDir) => {
-  const root = join55(buildDir, ".absolutejs", "mobile-compatibility");
-  if (!existsSync40(join55(root, "current.json"))) {
+  const root = join56(buildDir, ".absolutejs", "mobile-compatibility");
+  if (!existsSync41(join56(root, "current.json"))) {
     return new Elysia10({ name: "absolutejs-mobile-compatibility-empty" });
   }
   const options = await loadAbsoluteMobileMaterializedBundle(root);
@@ -34324,7 +34565,7 @@ var prepare = async (configOrPath) => {
     return result;
   }
   stepStartedAt = performance.now();
-  const manifest = JSON.parse(readFileSync37(`${buildDir}/manifest.json`, "utf-8"));
+  const manifest = JSON.parse(readFileSync38(`${buildDir}/manifest.json`, "utf-8"));
   setCurrentIslandManifest(manifest);
   if (config.islands?.registry) {
     setCurrentIslandRegistry(await loadIslandRegistry(config.islands.registry));
@@ -34332,14 +34573,14 @@ var prepare = async (configOrPath) => {
   setCurrentPageIslandMetadata(await loadPageIslandMetadata(config));
   recordStep("load production manifest and island metadata", stepStartedAt);
   stepStartedAt = performance.now();
-  const conventionsPath = join55(buildDir, "conventions.json");
-  if (existsSync40(conventionsPath)) {
-    const conventions2 = JSON.parse(readFileSync37(conventionsPath, "utf-8"));
+  const conventionsPath = join56(buildDir, "conventions.json");
+  if (existsSync41(conventionsPath)) {
+    const conventions2 = JSON.parse(readFileSync38(conventionsPath, "utf-8"));
     setConventions(conventions2);
   }
-  const spaRoutesPath = join55(buildDir, "spa-routes.json");
-  if (existsSync40(spaRoutesPath)) {
-    setSpaRouteManifest(JSON.parse(readFileSync37(spaRoutesPath, "utf-8")));
+  const spaRoutesPath = join56(buildDir, "spa-routes.json");
+  if (existsSync41(spaRoutesPath)) {
+    setSpaRouteManifest(JSON.parse(readFileSync38(spaRoutesPath, "utf-8")));
   }
   recordStep("load production conventions", stepStartedAt);
   stepStartedAt = performance.now();
@@ -34350,7 +34591,7 @@ var prepare = async (configOrPath) => {
     prefix: "",
     staticLimit: MAX_STATIC_ROUTE_COUNT
   });
-  const generatedAssetsRoot = join55(buildDir, ".absolutejs");
+  const generatedAssetsRoot = join56(buildDir, ".absolutejs");
   const generatedAssetsPlugin = new Elysia10({
     name: "absolutejs-generated-assets"
   }).get("/.absolutejs/*", async ({ params, set }) => {
@@ -34388,7 +34629,7 @@ var prepare = async (configOrPath) => {
     responseValue.headers.set("cache-control", isFingerprintedAsset(pathname) ? "public, max-age=31536000, immutable" : "public, max-age=0, must-revalidate");
   });
   stepStartedAt = performance.now();
-  const prerenderDir = join55(buildDir, "_prerendered");
+  const prerenderDir = join56(buildDir, "_prerendered");
   const prerenderMap = loadPrerenderMap(prerenderDir);
   const mobileCompatibilityPlugin = await loadMobileCompatibilityPlugin(buildDir);
   const mobileAssociationPlugin = createAbsoluteMobileAssociationPlugin(config.mobile, process.cwd(), { requireAll: true });
@@ -34448,6 +34689,7 @@ var wrapPageHandlerWithStreamingSlots = (handler, options) => {
 };
 // src/plugins/networking.ts
 init_constants();
+init_bootLifecycle();
 import { argv } from "process";
 var {env: env4 } = globalThis.Bun;
 import { websocket as websocket3 } from "elysia/websocket";
@@ -34456,23 +34698,23 @@ import { buildGlobalWSHandler } from "elysia/ws";
 // src/dev/devCert.ts
 import {
   copyFileSync as copyFileSync3,
-  existsSync as existsSync41,
-  mkdirSync as mkdirSync17,
-  readFileSync as readFileSync38,
+  existsSync as existsSync42,
+  mkdirSync as mkdirSync18,
+  readFileSync as readFileSync39,
   rmSync as rmSync4
 } from "fs";
 import { X509Certificate as X509Certificate2 } from "crypto";
 import { isIP } from "net";
-import { join as join56 } from "path";
-var CERT_DIR = join56(process.cwd(), ".absolutejs");
-var CERT_PATH = join56(CERT_DIR, "cert.pem");
-var KEY_PATH = join56(CERT_DIR, "key.pem");
+import { join as join57 } from "path";
+var CERT_DIR = join57(process.cwd(), ".absolutejs");
+var CERT_PATH = join57(CERT_DIR, "cert.pem");
+var KEY_PATH = join57(CERT_DIR, "key.pem");
 var CERT_VALIDITY_DAYS = 365;
 var DEFAULT_CERTIFICATE_HOSTS = ["localhost", "127.0.0.1", "::1"];
 var CERTIFICATE_HOSTNAME_PATTERN = /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\.(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?))*$/u;
 var devLog = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[36m[dev]\x1B[0m ${msg}`);
 var devWarn = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[33m[dev]\x1B[0m \x1B[33m${msg}\x1B[0m`);
-var certFilesExist = () => existsSync41(CERT_PATH) && existsSync41(KEY_PATH);
+var certFilesExist = () => existsSync42(CERT_PATH) && existsSync42(KEY_PATH);
 var normalizeDevCertificateHosts = (hosts = []) => {
   const normalized = new Set(DEFAULT_CERTIFICATE_HOSTS);
   for (const host2 of hosts) {
@@ -34488,7 +34730,7 @@ var normalizeDevCertificateHosts = (hosts = []) => {
 };
 var certificateIsUsable = (hosts) => {
   try {
-    const certPem = readFileSync38(CERT_PATH, "utf-8");
+    const certPem = readFileSync39(CERT_PATH, "utf-8");
     const certificate = new X509Certificate2(certPem);
     if (new Date(certificate.validTo).getTime() <= Date.now())
       return false;
@@ -34558,7 +34800,7 @@ var generateCert = (hosts = []) => {
   }
 };
 var ensureDevCert = (hosts = []) => {
-  mkdirSync17(CERT_DIR, { recursive: true });
+  mkdirSync18(CERT_DIR, { recursive: true });
   if (hasCert(hosts)) {
     return { cert: CERT_PATH, key: KEY_PATH };
   }
@@ -34580,29 +34822,44 @@ var loadDevCert = (hosts = []) => {
     return null;
   try {
     return {
-      cert: readFileSync38(paths.cert, "utf-8"),
-      key: readFileSync38(paths.key, "utf-8")
+      cert: readFileSync39(paths.cert, "utf-8"),
+      key: readFileSync39(paths.key, "utf-8")
     };
   } catch {
     return null;
   }
 };
 
+// src/dev/earlyListener.ts
+init_constants();
+init_bootLifecycle();
+var RETRY_AFTER_SECONDS = 2;
+var POLL_INTERVAL_MS = RETRY_AFTER_SECONDS * MILLISECONDS_IN_A_SECOND;
+var releaseEarlyListener = () => {
+  const listener = globalThis.__absoluteEarlyListener;
+  if (!listener)
+    return false;
+  const hadServer = listener.server !== null;
+  listener.release();
+  globalThis.__absoluteEarlyListener = undefined;
+  return hadServer;
+};
+
 // src/utils/instanceRegistry.ts
 import {
-  mkdirSync as mkdirSync18,
-  readFileSync as readFileSync39,
+  mkdirSync as mkdirSync19,
+  readFileSync as readFileSync40,
   readdirSync as readdirSync11,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync12
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename as basename19, join as join57 } from "path";
+import { basename as basename19, join as join58 } from "path";
 var registeredPids = new Set;
 var exitHandlerRegistered = false;
-var instanceFilePath = (pid) => join57(instanceRegistryDir(), `${pid}.json`);
-var instanceLogPath = (pid) => join57(instanceRegistryDir(), `${pid}.log`);
-var instanceRegistryDir = () => join57(homedir2(), ".absolutejs", "instances");
+var instanceFilePath = (pid) => join58(instanceRegistryDir(), `${pid}.json`);
+var instanceLogPath = (pid) => join58(instanceRegistryDir(), `${pid}.log`);
+var instanceRegistryDir = () => join58(homedir2(), ".absolutejs", "instances");
 var removeInstanceFilesSync = (pid) => {
   try {
     unlinkSync2(instanceFilePath(pid));
@@ -34624,20 +34881,20 @@ var registerExitHandlerOnce = () => {
 };
 var readJsonFile = (path) => {
   try {
-    return JSON.parse(readFileSync39(path, "utf-8"));
+    return JSON.parse(readFileSync40(path, "utf-8"));
   } catch {
     return null;
   }
 };
 var registerInstance = (record) => {
-  mkdirSync18(instanceRegistryDir(), { recursive: true });
-  writeFileSync11(instanceFilePath(record.pid), JSON.stringify(record, null, 2));
+  mkdirSync19(instanceRegistryDir(), { recursive: true });
+  writeFileSync12(instanceFilePath(record.pid), JSON.stringify(record, null, 2));
   registeredPids.add(record.pid);
   registerExitHandlerOnce();
   return record;
 };
 var resolveProjectName = (cwd2) => {
-  const parsed = readJsonFile(join57(cwd2, "package.json"));
+  const parsed = readJsonFile(join58(cwd2, "package.json"));
   if (parsed !== null && typeof parsed === "object" && typeof parsed.name === "string" && parsed.name.trim().length > 0) {
     return parsed.name;
   }
@@ -34751,8 +35008,10 @@ var networking = (app) => {
       },
       fetch: (request) => app.fetch(request)
     });
+    runDeferredBootTasks();
     return app;
   }
+  releaseEarlyListener();
   const listened = app.listen({
     hostname: host2,
     idleTimeout: httpIdleTimeout,
@@ -34765,6 +35024,7 @@ var networking = (app) => {
     } : {}
   }, () => {
     selfRegisterInstance();
+    runDeferredBootTasks();
     if (visibility === "internal" || managedByWorkspace) {
       return;
     }
@@ -34949,8 +35209,8 @@ var generateHeadElement = ({
 };
 // src/utils/defineEnv.ts
 var {env: bunEnv } = globalThis.Bun;
-import { existsSync as existsSync43, readFileSync as readFileSync41 } from "fs";
-import { resolve as resolve51 } from "path";
+import { existsSync as existsSync44, readFileSync as readFileSync42 } from "fs";
+import { resolve as resolve52 } from "path";
 
 // node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
 var exports_value = {};
@@ -40985,19 +41245,19 @@ ${lines.join(`
 };
 var checkEnvFileSecurity = (properties) => {
   const cwd2 = process.cwd();
-  const envPath = resolve51(cwd2, ".env");
-  if (!existsSync43(envPath))
+  const envPath = resolve52(cwd2, ".env");
+  if (!existsSync44(envPath))
     return;
   const sensitiveKeys = Object.keys(properties).filter(isSensitive);
   if (sensitiveKeys.length === 0)
     return;
-  const envContent = readFileSync41(envPath, "utf-8");
+  const envContent = readFileSync42(envPath, "utf-8");
   const presentKeys = sensitiveKeys.filter((key) => envContent.includes(`${key}=`));
   if (presentKeys.length === 0)
     return;
-  const gitignorePath = resolve51(cwd2, ".gitignore");
-  if (existsSync43(gitignorePath)) {
-    const gitignore = readFileSync41(gitignorePath, "utf-8");
+  const gitignorePath = resolve52(cwd2, ".gitignore");
+  if (existsSync44(gitignorePath)) {
+    const gitignore = readFileSync42(gitignorePath, "utf-8");
     if (gitignore.split(`
 `).some((line) => line.trim() === ".env"))
       return;
@@ -41029,8 +41289,8 @@ var getEnv = (key) => {
   return environmentVariable;
 };
 // src/utils/projectRoot.ts
-import { existsSync as existsSync44 } from "fs";
-import { dirname as dirname34, resolve as resolve52 } from "path";
+import { existsSync as existsSync45 } from "fs";
+import { dirname as dirname34, resolve as resolve53 } from "path";
 var CONFIG_CANDIDATES = [
   "absolute.config.ts",
   "absolute.config.js",
@@ -41039,7 +41299,7 @@ var CONFIG_CANDIDATES = [
   "absolute.config.mts",
   "absolute.config.cts"
 ];
-var hasAbsoluteConfig = (directory) => CONFIG_CANDIDATES.some((name) => existsSync44(resolve52(directory, name)));
+var hasAbsoluteConfig = (directory) => CONFIG_CANDIDATES.some((name) => existsSync45(resolve53(directory, name)));
 var findProjectRoot = () => {
   const start = process.cwd();
   let packageRoot = null;
@@ -41048,7 +41308,7 @@ var findProjectRoot = () => {
     if (hasAbsoluteConfig(directory)) {
       return directory;
     }
-    if (packageRoot === null && existsSync44(resolve52(directory, "package.json"))) {
+    if (packageRoot === null && existsSync45(resolve53(directory, "package.json"))) {
       packageRoot = directory;
     }
     const parent = dirname34(directory);
@@ -41297,5 +41557,5 @@ export {
   wrapPageHandlerWithStreamingSlots
 };
 
-//# debugId=5413308C072D0B1164756E2164756E21
+//# debugId=C2C6E94A66DDD23764756E2164756E21
 //# sourceMappingURL=index.js.map