@absolutejs/absolute 0.20.0-beta.148 → 0.20.0-beta.149

package/dist/build.js

@@ -18667,11 +18667,10 @@ var init_emitTsHelpers = __esm(() => {
   transpiler4 = new Transpiler3({ loader: "ts", target: "browser" });
 });
 
-// src/build/compileVueSfc.ts
-import { existsSync as existsSync28, readFileSync as readFileSync24, realpathSync as realpathSync2 } from "fs";
-import { dirname as dirname20, relative as relative17, resolve as resolve28 } from "path";
-var {Transpiler: Transpiler4 } = globalThis.Bun;
-var transpiler5, inlineCssImports = (cssContent, cssFilePath, visited = new Set) => {
+// src/build/inlineCssImports.ts
+import { readFileSync as readFileSync24, realpathSync as realpathSync2 } from "fs";
+import { dirname as dirname20, resolve as resolve28 } from "path";
+var inlineCssImports = (cssContent, cssFilePath, visited = new Set) => {
   const resolved = realpathSync2(cssFilePath);
   if (visited.has(resolved))
     return "";
@@ -18684,22 +18683,31 @@ var transpiler5, inlineCssImports = (cssContent, cssFilePath, visited = new Set)
     const importedContent = readFileSync24(importedPath, "utf-8");
     return inlineCssImports(importedContent, importedPath, visited);
   });
-}, toJs = (filePath, sourceDir) => {
+};
+var init_inlineCssImports = __esm(() => {
+  init_isFile();
+});
+
+// src/build/compileVueSfc.ts
+import { existsSync as existsSync28, readFileSync as readFileSync25, realpathSync as realpathSync3 } from "fs";
+import { dirname as dirname21, relative as relative17, resolve as resolve29 } from "path";
+var {Transpiler: Transpiler4 } = globalThis.Bun;
+var transpiler5, toJs = (filePath, sourceDir) => {
   if (filePath.endsWith(".vue"))
     return filePath.replace(/\.vue$/, ".js");
   if (filePath.endsWith(".ts"))
     return filePath.replace(/\.ts$/, ".js");
   if (isStylePath(filePath)) {
     if (sourceDir && (filePath.startsWith("./") || filePath.startsWith("../"))) {
-      return resolve28(sourceDir, filePath);
+      return resolve29(sourceDir, filePath);
     }
     return filePath;
   }
   if (sourceDir && (filePath.startsWith("./") || filePath.startsWith("../"))) {
-    const directTs = resolve28(sourceDir, `${filePath}.ts`);
+    const directTs = resolve29(sourceDir, `${filePath}.ts`);
     if (existsSync28(directTs))
       return `${filePath}.js`;
-    const indexedTs = resolve28(sourceDir, filePath, "index.ts");
+    const indexedTs = resolve29(sourceDir, filePath, "index.ts");
     if (existsSync28(indexedTs))
       return `${filePath}/index.js`;
   }
@@ -18767,11 +18775,11 @@ const ${localName} = (source) => ${importedName}(
   const compiledScript = hasScript ? compiler.compileScript(descriptor, {
     fs: {
       fileExists: isFile,
-      realpath: realpathSync2,
+      realpath: realpathSync3,
       readFile: (file) => {
         if (!isFile(file))
           return;
-        const content = readFileSync24(file, "utf-8");
+        const content = readFileSync25(file, "utf-8");
         typeDepHashes[file] = hashContent(content);
         return content;
       }
@@ -18784,10 +18792,10 @@ const ${localName} = (source) => ${importedName}(
   for (const dep of typeDependencies) {
     if (dep in typeDepHashes || !existsSync28(dep))
       continue;
-    typeDepHashes[dep] = hashContent(readFileSync24(dep, "utf-8"));
+    typeDepHashes[dep] = hashContent(readFileSync25(dep, "utf-8"));
   }
   const strippedScript = stripExports2(compiledScript.content);
-  const sourceDir = dirname20(sourceFilePath);
+  const sourceDir = dirname21(sourceFilePath);
   const transpiledScript = rewriteRelativeImports(transpiler5.transformSync(strippedScript), sourceDir);
   const generateRenderFunction = (ssr) => {
     const rendered = compiler.compileTemplate({
@@ -18842,7 +18850,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     let result = code;
     for (const [bareImport, paths] of packageImportRewrites) {
       const targetPath = mode === "server" ? paths.server : paths.client;
-      let rel = relative17(dirname20(outputPath), targetPath).replace(/\\/g, "/");
+      let rel = relative17(dirname21(outputPath), targetPath).replace(/\\/g, "/");
       if (!rel.startsWith("."))
         rel = `./${rel}`;
       result = result.replaceAll(bareImport, rel);
@@ -18877,6 +18885,7 @@ var init_compileVueSfc = __esm(() => {
   init_isFile();
   init_chainInlineSourcemaps();
   init_stylePreprocessor();
+  init_inlineCssImports();
   init_vueCompileCache();
   transpiler5 = new Transpiler4({ loader: "ts", target: "browser" });
 });
@@ -18939,9 +18948,9 @@ var init_workerJobs = __esm(() => {
 });
 
 // src/build/workerPool.ts
-import { existsSync as existsSync29, readFileSync as readFileSync25 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync26 } from "fs";
 import { availableParallelism, freemem } from "os";
-import { dirname as dirname21, join as join38 } from "path";
+import { dirname as dirname22, join as join38 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 var MIN_WORKERS = 2, MAX_DEFAULT_WORKERS = 8, MAX_OVERRIDE_WORKERS = 64, WORKER_MEMORY_BUDGET_BYTES, DEFAULT_IDLE_TIMEOUT_MS = 2000, DEFAULT_MIN_BATCH = 4, PACKAGE_WALK_DEPTH = 6, PERCENT = 100, OWN_PACKAGE_NAME = "@absolutejs/absolute", parseWorkerOverride = (raw) => {
   if (raw === undefined || raw.trim() === "")
@@ -18962,7 +18971,7 @@ var MIN_WORKERS = 2, MAX_DEFAULT_WORKERS = 8, MAX_OVERRIDE_WORKERS = 64, WORKER_
   if (!existsSync29(packageFile))
     return false;
   try {
-    const pkg = JSON.parse(readFileSync25(packageFile, "utf-8"));
+    const pkg = JSON.parse(readFileSync26(packageFile, "utf-8"));
     return typeof pkg === "object" && pkg !== null && "name" in pkg && pkg.name === OWN_PACKAGE_NAME;
   } catch {
     return false;
@@ -18972,7 +18981,7 @@ var MIN_WORKERS = 2, MAX_DEFAULT_WORKERS = 8, MAX_OVERRIDE_WORKERS = 64, WORKER_
   for (let depth = 0;depth < PACKAGE_WALK_DEPTH; depth++) {
     if (isOwnPackageRoot(dir))
       return dir;
-    const parent = dirname21(dir);
+    const parent = dirname22(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -19268,23 +19277,23 @@ import { existsSync as existsSync30 } from "fs";
 import { mkdir as mkdir9 } from "fs/promises";
 import {
   basename as basename14,
-  dirname as dirname22,
+  dirname as dirname23,
   isAbsolute as isAbsolute7,
   join as join39,
   relative as relative18,
-  resolve as resolve29
+  resolve as resolve30
 } from "path";
 var {file: file3, write: write4 } = globalThis.Bun;
 var resolveDevClientDir3 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve29(import.meta.dir, "../dev/client");
+  const fromSource = resolve30(import.meta.dir, "../dev/client");
   if (existsSync30(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve29(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve30(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync30(fromNodeModules))
     return fromNodeModules;
-  return resolve29(import.meta.dir, "./dev/client");
+  return resolve30(import.meta.dir, "./dev/client");
 }, devClientDir3, hmrClientPath4, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, detectVueChangeType = (filePath, descriptor) => {
   const prevScript = scriptCache.get(filePath);
   const prevScriptSetup = scriptSetupCache.get(filePath);
@@ -19325,11 +19334,11 @@ var resolveDevClientDir3 = () => {
   return Array.from(new Set(found));
 }, resolveHelperTsPath = (sourceDir, helper) => {
   if (helper.endsWith(".ts"))
-    return resolve29(sourceDir, helper);
-  const direct = resolve29(sourceDir, `${helper}.ts`);
+    return resolve30(sourceDir, helper);
+  const direct = resolve30(sourceDir, `${helper}.ts`);
   if (existsSync30(direct))
     return direct;
-  const indexed = resolve29(sourceDir, helper, "index.ts");
+  const indexed = resolve30(sourceDir, helper, "index.ts");
   if (existsSync30(indexed))
     return indexed;
   return direct;
@@ -19356,7 +19365,7 @@ var resolveDevClientDir3 = () => {
   if (!inline)
     pool.warm("vue-sfc");
   const runSfc = (input) => pool.run("vue-sfc", input, {
-    affinity: dirname22(input.sourceFilePath),
+    affinity: dirname23(input.sourceFilePath),
     inline
   });
   return runSfc;
@@ -19418,9 +19427,9 @@ var resolveDevClientDir3 = () => {
   serverPath
 }) => {
   await Promise.all([
-    mkdir9(dirname22(clientPath), { recursive: true }),
-    mkdir9(dirname22(serverPath), { recursive: true }),
-    ...css ? [mkdir9(dirname22(css.path), { recursive: true })] : []
+    mkdir9(dirname23(clientPath), { recursive: true }),
+    mkdir9(dirname23(serverPath), { recursive: true }),
+    ...css ? [mkdir9(dirname23(css.path), { recursive: true })] : []
   ]);
   await Promise.all([
     write4(clientPath, clientCode),
@@ -19489,12 +19498,12 @@ var resolveDevClientDir3 = () => {
   const childComponentPaths = importPaths.filter((path) => path.startsWith(".") && path.endsWith(".vue"));
   const packageComponentPaths = Array.from(resolvedPackageVueImports.entries());
   const helperModulePaths = importPaths.filter((path) => path.startsWith(".") && !path.endsWith(".vue") && !isStylePath(path));
-  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute7(path)) && isStylePath(path)).map((path) => isAbsolute7(path) ? path : resolve29(dirname22(sourceFilePath), path));
+  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute7(path)) && isStylePath(path)).map((path) => isAbsolute7(path) ? path : resolve30(dirname23(sourceFilePath), path));
   for (const stylePath of stylePathsImported) {
     addStyleImporter(sourceFilePath, stylePath);
   }
   const childBuildResults = await Promise.all([
-    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve29(dirname22(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, runSfc, stylePreprocessors)),
+    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve30(dirname23(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, runSfc, stylePreprocessors)),
     ...packageComponentPaths.map(([, absolutePath]) => compileVueFile(absolutePath, outputDirs, cacheMap, false, vueRootDir, compiler, runSfc, stylePreprocessors))
   ]);
   const cacheKeyStartedAt = performance.now();
@@ -19563,7 +19572,7 @@ var resolveDevClientDir3 = () => {
     serverPath: serverOutputPath,
     spaRoutes: spaRoutes.length > 0 ? spaRoutes : undefined,
     tsHelperPaths: [
-      ...helperModulePaths.map((helper) => resolveHelperTsPath(dirname22(sourceFilePath), helper)),
+      ...helperModulePaths.map((helper) => resolveHelperTsPath(dirname23(sourceFilePath), helper)),
       ...childBuildResults.flatMap((child) => child.tsHelperPaths)
     ]
   };
@@ -19602,7 +19611,7 @@ var resolveDevClientDir3 = () => {
   const buildCache = new Map;
   const allTsHelperPaths = new Set;
   const expandSpaRouteChildren = async (entries) => {
-    const expanded = new Set(entries.map((entry) => resolve29(entry)));
+    const expanded = new Set(entries.map((entry) => resolve30(entry)));
     const queue = [...expanded];
     while (queue.length > 0) {
       const entryPath = queue.pop();
@@ -19619,7 +19628,7 @@ var resolveDevClientDir3 = () => {
       });
       const routes = parseVueSpaRoutes(descriptor.script?.content ?? "");
       for (const { importPath } of routes) {
-        const childPath = resolve29(dirname22(entryPath), importPath);
+        const childPath = resolve30(dirname23(entryPath), importPath);
         if (expanded.has(childPath) || !existsSync30(childPath)) {
           continue;
         }
@@ -19634,7 +19643,7 @@ var resolveDevClientDir3 = () => {
   vueCompileProfile.stageExpandMs = performance.now() - stageStartedAt;
   stageStartedAt = performance.now();
   const compiledPages = await Promise.all(expandedEntryPoints.map(async (entryPath) => {
-    const resolvedEntryPath = resolve29(entryPath);
+    const resolvedEntryPath = resolve30(entryPath);
     const result = await compileVueFile(resolvedEntryPath, {
       client: clientOutputDir,
       css: cssOutputDir,
@@ -19654,14 +19663,14 @@ var resolveDevClientDir3 = () => {
     const entryBaseName = basename14(entryPath, ".vue");
     const indexOutputFile = join39(indexOutputDir, `${entryBaseName}.js`);
     const clientOutputFile = result.clientPath;
-    await mkdir9(dirname22(indexOutputFile), { recursive: true });
+    await mkdir9(dirname23(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
       `import "${hmrClientPath4}";`
     ] : [];
     await write4(indexOutputFile, [
       ...vueHmrImports,
-      `import Comp, * as PageModule from "${relative18(dirname22(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
+      `import Comp, * as PageModule from "${relative18(dirname23(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
       'import { createSSRApp, createApp } from "vue";',
       'import { prepareBrowserTranslationHydration } from "@absolutejs/absolute/vue";',
       "",
@@ -19827,7 +19836,7 @@ var resolveDevClientDir3 = () => {
   }));
   vueCompileProfile.stagePagesMs = performance.now() - stageStartedAt;
   stageStartedAt = performance.now();
-  const helperDependencies = (tsPath, sourceCode) => extractImports(sourceCode).filter((dep) => dep.startsWith(".") && !isStylePath(dep) && !dep.endsWith(".vue")).map((dep) => resolveHelperTsPath(dirname22(tsPath), dep)).filter((resolved) => existsSync30(resolved) && !allTsHelperPaths.has(resolved));
+  const helperDependencies = (tsPath, sourceCode) => extractImports(sourceCode).filter((dep) => dep.startsWith(".") && !isStylePath(dep) && !dep.endsWith(".vue")).map((dep) => resolveHelperTsPath(dirname23(tsPath), dep)).filter((resolved) => existsSync30(resolved) && !allTsHelperPaths.has(resolved));
   const readHelperWave = (paths) => Promise.all(paths.map((tsPath) => file3(tsPath).text().then((sourceCode) => helperDependencies(tsPath, sourceCode)).catch(() => [])));
   const expandHelpers = async (frontier) => {
     if (frontier.length === 0)
@@ -20397,8 +20406,8 @@ __export(exports_compileAngular, {
   compileAngularFileJIT: () => compileAngularFileJIT,
   invalidateAngularJitCache: () => invalidateAngularJitCache
 });
-import { existsSync as existsSync31, readFileSync as readFileSync26, promises as fs5 } from "fs";
-import { join as join40, basename as basename15, sep as sep5, dirname as dirname23, resolve as resolve30, relative as relative19 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync27, promises as fs5 } from "fs";
+import { join as join40, basename as basename15, sep as sep5, dirname as dirname24, resolve as resolve31, relative as relative19 } from "path";
 var {Glob: Glob6 } = globalThis.Bun;
 import ts18 from "typescript";
 var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) => {
@@ -20414,10 +20423,10 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
   return tracePhase ? tracePhase(`compile/angular/${name}`, fn, metadata) : await fn();
 }, readTsconfigPathAliases = () => {
   try {
-    const configPath = resolve30(process.cwd(), "tsconfig.json");
+    const configPath = resolve31(process.cwd(), "tsconfig.json");
     const config = ts18.readConfigFile(configPath, ts18.sys.readFile).config;
     const compilerOptions = config?.compilerOptions ?? {};
-    const baseUrl = resolve30(process.cwd(), compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve31(process.cwd(), compilerOptions.baseUrl ?? ".");
     const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
     return { aliases, baseUrl };
   } catch {
@@ -20437,7 +20446,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(resolve30(baseUrl, candidate));
+      const resolved = resolveSourceFile(resolve31(baseUrl, candidate));
       if (resolved)
         return resolved;
     }
@@ -20456,13 +20465,13 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
   ];
   return candidates.find((file) => existsSync31(file));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
-  const baseDir = resolve30(rootDir);
+  const baseDir = resolve31(rootDir);
   const tsconfigAliases = readTsconfigPathAliases();
   const transpiler = new Bun.Transpiler({ loader: "tsx" });
   const scanCache = new Map;
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile(resolve30(fromDir, specifier));
+      return resolveSourceFile(resolve31(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile);
     if (aliased)
@@ -20471,7 +20480,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve30(resolved);
+      const absolute = resolve31(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile(absolute);
@@ -20487,7 +20496,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
         usesLegacyAnimations: false
       });
     }
-    const resolved = resolve30(actualPath);
+    const resolved = resolve31(actualPath);
     const cached = scanCache.get(resolved);
     if (cached)
       return cached;
@@ -20516,7 +20525,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
     const actualPath = resolveSourceFile(filePath);
     if (!actualPath)
       return false;
-    const resolved = resolve30(actualPath);
+    const resolved = resolve31(actualPath);
     if (visited.has(resolved))
       return false;
     visited.add(resolved);
@@ -20524,7 +20533,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
     if (scan.usesLegacyAnimations)
       return true;
     for (const specifier of scan.imports) {
-      const importedPath = resolveLocalImport(specifier, dirname23(resolved));
+      const importedPath = resolveLocalImport(specifier, dirname24(resolved));
       if (importedPath && await visit(importedPath, visited)) {
         return true;
       }
@@ -20534,14 +20543,14 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
   return (entryPath) => visit(entryPath);
 }, resolveDevClientDir4 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve30(import.meta.dir, "../dev/client");
+  const fromSource = resolve31(import.meta.dir, "../dev/client");
   if (existsSync31(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve30(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve31(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync31(fromNodeModules))
     return fromNodeModules;
-  return resolve30(import.meta.dir, "./dev/client");
+  return resolve31(import.meta.dir, "./dev/client");
 }, devClientDir4, hmrClientPath5, formatDiagnosticMessage = (diagnostic) => {
   try {
     return ts18.flattenDiagnosticMessageText(diagnostic.messageText, `
@@ -20583,12 +20592,12 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
     return `${path.replace(/\.ts$/, ".js")}${query}`;
   if (hasJsLikeExtension(path))
     return `${path}${query}`;
-  const importerDir = dirname23(importerOutputPath);
-  const fileCandidate = resolve30(importerDir, `${path}.js`);
+  const importerDir = dirname24(importerOutputPath);
+  const fileCandidate = resolve31(importerDir, `${path}.js`);
   if (outputFiles?.has(fileCandidate) || existsSync31(fileCandidate)) {
     return `${path}.js${query}`;
   }
-  const indexCandidate = resolve30(importerDir, path, "index.js");
+  const indexCandidate = resolve31(importerDir, path, "index.js");
   if (outputFiles?.has(indexCandidate) || existsSync31(indexCandidate)) {
     return `${path}/index.js${query}`;
   }
@@ -20616,7 +20625,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve30(dirname23(fromFile), specifier);
+  const basePath = resolve31(dirname24(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
@@ -20627,7 +20636,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
     join40(basePath, "index.mts"),
     join40(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve30(candidate)).find((candidate) => existsSync31(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+  return candidates.map((candidate) => resolve31(candidate)).find((candidate) => existsSync31(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile) => {
   const hostSource = readFile?.(fileName);
   if (typeof hostSource === "string")
@@ -20662,7 +20671,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
       paths.push(join40(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
-  return paths.map((path) => resolve30(path));
+  return paths.map((path) => resolve31(path));
 }, readResourceCacheFile = async (cachePath) => {
   try {
     const entry = JSON.parse(await fs5.readFile(cachePath, "utf-8"));
@@ -20674,13 +20683,13 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
     return null;
   }
 }, writeResourceCacheFile = async (cachePath, source) => {
-  await fs5.mkdir(dirname23(cachePath), { recursive: true });
+  await fs5.mkdir(dirname24(cachePath), { recursive: true });
   await writeTextFileAtomically(cachePath, JSON.stringify({
     source,
     version: 1
   }));
 }, resolveResourceTransformCachePath = async (filePath, source, stylePreprocessors) => {
-  const resourcePaths = collectAngularResourcePaths(source, dirname23(filePath));
+  const resourcePaths = collectAngularResourcePaths(source, dirname24(filePath));
   const resourceContents = await Promise.all(resourcePaths.map(async (resourcePath) => {
     const content = await fs5.readFile(resourcePath, "utf-8");
     return `${resourcePath}\x00${content}`;
@@ -20704,7 +20713,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
     transformedFiles: 0
   };
   const transformFile = async (filePath) => {
-    const resolvedPath = resolve30(filePath);
+    const resolvedPath = resolve31(filePath);
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
@@ -20720,7 +20729,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
       transformedSource = cached.source;
     } else {
       stats.cacheMisses += 1;
-      const transformed = await inlineResources(source, dirname23(resolvedPath), stylePreprocessors);
+      const transformed = await inlineResources(source, dirname24(resolvedPath), stylePreprocessors);
       transformedSource = transformed.source;
       await writeResourceCacheFile(cachePath, transformedSource);
     }
@@ -20739,18 +20748,18 @@ 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 = resolve30(join40(outDir, relative19(process.cwd(), resolve30(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve31(join40(outDir, relative19(process.cwd(), resolve31(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"));
   const { readConfiguration, performCompilation, EmitFlags } = await traceAngularPhase("aot/import-compiler-cli", () => import("@angular/compiler-cli"));
   const tsLibDir = await traceAngularPhase("aot/resolve-typescript-lib", () => {
     const tsPath = __require.resolve("typescript");
-    const tsRootDir = dirname23(tsPath);
-    return tsRootDir.endsWith("lib") ? tsRootDir : resolve30(tsRootDir, "lib");
+    const tsRootDir = dirname24(tsPath);
+    return tsRootDir.endsWith("lib") ? tsRootDir : resolve31(tsRootDir, "lib");
   });
   const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
   const options = {
@@ -20792,7 +20801,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
     return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
   };
   const emitted = {};
-  const resolvedOutDir = resolve30(outDir);
+  const resolvedOutDir = resolve31(outDir);
   host.writeFile = (fileName, text) => {
     const relativePath = resolveRelativePath(fileName, resolvedOutDir, outDir);
     emitted[relativePath] = text;
@@ -20814,12 +20823,12 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
     if (!fileName.endsWith(".ts") || fileName.endsWith(".d.ts")) {
       return source;
     }
-    const resolvedPath = resolve30(fileName);
+    const resolvedPath = resolve31(fileName);
     return transformedSources.get(resolvedPath) ?? source;
   };
   const originalGetSourceFileForCompile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
-    const source = transformedSources.get(resolve30(fileName));
+    const source = transformedSources.get(resolve31(fileName));
     if (source) {
       return ts18.createSourceFile(fileName, source, languageVersion, true);
     }
@@ -20843,7 +20852,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
       content,
       target: join40(outDir, fileName)
     }));
-    const outputFiles = new Set(rawEntries.map(({ target }) => resolve30(target)));
+    const outputFiles = new Set(rawEntries.map(({ target }) => resolve31(target)));
     return rawEntries.map(({ content, target }) => {
       let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
         const rewritten = rewriteRelativeJsSpecifier(target, path, outputFiles);
@@ -20858,17 +20867,17 @@ 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(resolve30(target)) ?? "";
+      processedContent += islandMetadataByOutputPath.get(resolve31(target)) ?? "";
       return { content: processedContent, target };
     });
   });
   await traceAngularPhase("aot/write-output", () => Promise.all(entries.map(async ({ target, content }) => {
-    await fs5.mkdir(dirname23(target), { recursive: true });
+    await fs5.mkdir(dirname24(target), { recursive: true });
     await writeTextFileAtomically(target, content);
   })), { outputs: entries.length });
   return await traceAngularPhase("aot/collect-output-paths", () => entries.map(({ target }) => target), { outputs: entries.length });
 }, jitContentCache, invalidateAngularJitCache = (filePath) => {
-  jitContentCache.delete(resolve30(filePath));
+  jitContentCache.delete(resolve31(filePath));
 }, wrapperOutputCache, escapeTemplateContent = (content) => content.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${"), findUncommentedMatch = (source, pattern) => {
   const re = new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g");
   let match;
@@ -20881,7 +20890,7 @@ var atomicWriteSequence = 0, writeTextFileAtomically = async (path, content) =>
   }
   return null;
 }, resolveAngularDeferImportSpecifier = () => {
-  const sourceEntry = resolve30(import.meta.dir, "../angular/components/index.ts");
+  const sourceEntry = resolve31(import.meta.dir, "../angular/components/index.ts");
   if (existsSync31(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
@@ -21053,7 +21062,7 @@ ${fields}
     if (!existsSync31(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
-    const templateRaw = readFileSync26(templatePath, "utf-8");
+    const templateRaw = readFileSync27(templatePath, "utf-8");
     const lowered = lowerAngularDeferSyntax(templateRaw);
     const escaped = escapeTemplateContent(lowered.template);
     const replacedSource = source.slice(0, templateUrlMatch.index) + `template: \`${escaped}\`` + source.slice(templateUrlMatch.index + templateUrlMatch[0].length);
@@ -21171,10 +21180,10 @@ ${fields}
     return "";
   }
 }, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors, cacheBuster) => {
-  const entryPath = resolve30(inputPath);
+  const entryPath = resolve31(inputPath);
   const allOutputs = [];
   const visited = new Set;
-  const baseDir = resolve30(rootDir ?? process.cwd());
+  const baseDir = resolve31(rootDir ?? process.cwd());
   let usesLegacyAnimations = false;
   const angularTranspiler = new Bun.Transpiler({
     loader: "ts",
@@ -21202,7 +21211,7 @@ ${fields}
   };
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile(resolve30(fromDir, specifier));
+      return resolveSourceFile(resolve31(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile);
     if (aliased)
@@ -21211,7 +21220,7 @@ ${fields}
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve30(resolved);
+      const absolute = resolve31(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile(absolute);
@@ -21220,7 +21229,7 @@ ${fields}
     }
   };
   const toOutputPath = (sourcePath) => {
-    const inputDir = dirname23(sourcePath);
+    const inputDir = dirname24(sourcePath);
     const fileBase = basename15(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
     if (inputDir === outDir || inputDir.startsWith(`${outDir}${sep5}`)) {
       return join40(inputDir, fileBase);
@@ -21263,18 +21272,18 @@ ${fields}
         return `${prefix}${dots}`;
       return `${prefix}../${dots}`;
     });
-    if (resolve30(actualPath) === entryPath) {
+    if (resolve31(actualPath) === entryPath) {
       processedContent += buildIslandMetadataExports(sourceCode);
     }
     return processedContent;
   };
   const transpileFile = async (filePath) => {
-    const resolved = resolve30(filePath);
+    const resolved = resolve31(filePath);
     if (visited.has(resolved))
       return;
     visited.add(resolved);
     if (resolved.endsWith(".json") && existsSync31(resolved)) {
-      const inputDir = dirname23(resolved);
+      const inputDir = dirname24(resolved);
       const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
       const targetDir = join40(outDir, relativeDir);
       const targetPath = join40(targetDir, basename15(resolved));
@@ -21289,12 +21298,12 @@ ${fields}
     if (!existsSync31(actualPath))
       return;
     let sourceCode = await fs5.readFile(actualPath, "utf-8");
-    const inlined = await inlineResources(sourceCode, dirname23(actualPath), stylePreprocessors);
-    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname23(actualPath)).source;
-    const inputDir = dirname23(actualPath);
+    const inlined = await inlineResources(sourceCode, dirname24(actualPath), stylePreprocessors);
+    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname24(actualPath)).source;
+    const inputDir = dirname24(actualPath);
     const fileBase = basename15(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
     const targetPath = toOutputPath(actualPath);
-    const targetDir = dirname23(targetPath);
+    const targetDir = dirname24(targetPath);
     const relativeDir = relative19(outDir, targetDir).replace(/\\/g, "/");
     const localImports = [];
     const importRewrites = new Map;
@@ -21321,7 +21330,7 @@ ${fields}
       importRewrites.set(specifier, relativeRewrite);
       return resolved;
     }).filter((path) => Boolean(path));
-    const isEntry = resolve30(actualPath) === resolve30(entryPath);
+    const isEntry = resolve31(actualPath) === resolve31(entryPath);
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey = actualPath;
     const shouldWriteFile = cacheBuster && isEntry ? true : jitContentCache.get(cacheKey) !== contentHash || !existsSync31(targetPath);
@@ -21358,11 +21367,11 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
   const compiledRoot = compiledParent;
   const indexesDir = join40(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) => resolve30(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
+  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve31(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   if (!hmr) {
     await traceAngularPhase("aot/copy-json-resources", async () => {
       const cwd = process.cwd();
-      const angularSrcDir = resolve30(outRoot);
+      const angularSrcDir = resolve31(outRoot);
       if (!existsSync31(angularSrcDir))
         return;
       const jsonGlob = new Glob6("**/*.json");
@@ -21373,14 +21382,14 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
         const sourcePath = join40(angularSrcDir, rel);
         const cwdRel = relative19(cwd, sourcePath);
         const targetPath = join40(compiledRoot, cwdRel);
-        await fs5.mkdir(dirname23(targetPath), { recursive: true });
+        await fs5.mkdir(dirname24(targetPath), { recursive: true });
         await fs5.copyFile(sourcePath, targetPath);
       }
     });
   }
   const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
   const compileTasks = entryPoints.map(async (entry) => {
-    const resolvedEntry = resolve30(entry);
+    const resolvedEntry = resolve31(entry);
     const relativeEntry = relative19(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
     const compileEntry = () => compileAngularFileJIT(resolvedEntry, compiledRoot, outRoot, stylePreprocessors);
     let outputs = hmr ? await traceAngularPhase("jit/compile-entry", compileEntry, {
@@ -21392,10 +21401,10 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
       join40(compiledRoot, relativeEntry),
       join40(compiledRoot, "pages", jsName),
       join40(compiledRoot, jsName)
-    ].map((file) => resolve30(file));
+    ].map((file) => resolve31(file));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
-        ...candidatePaths.map((file) => resolve30(file)),
+        ...candidatePaths.map((file) => resolve31(file)),
         ...compiledFallbackPaths
       ];
       let candidate = normalizedCandidates.find((file) => existsSync31(file) && file.endsWith(`${sep5}${relativeEntry}`));
@@ -21442,7 +21451,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({
@@ -21485,13 +21494,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
       const fragments = [];
       if (providersInjection.appProvidersSource) {
         const compiledAppProvidersPath = (() => {
-          const angularDirAbs = resolve30(outRoot);
-          const appSourceAbs = resolve30(providersInjection.appProvidersSource);
+          const angularDirAbs = resolve31(outRoot);
+          const appSourceAbs = resolve31(providersInjection.appProvidersSource);
           const rel = relative19(angularDirAbs, appSourceAbs).replace(/\\/g, "/");
           return join40(compiledParent, rel).replace(/\.[cm]?[tj]sx?$/, ".js");
         })();
         const appProvidersSpec = (() => {
-          const rel = relative19(dirname23(rawServerFile), compiledAppProvidersPath).replace(/\\/g, "/");
+          const rel = relative19(dirname24(rawServerFile), compiledAppProvidersPath).replace(/\\/g, "/");
           return rel.startsWith(".") ? rel : `./${rel}`;
         })();
         importLines.push(`import { appProviders as __abs_globalProviders } from "${appProvidersSpec}";`);
@@ -22192,7 +22201,7 @@ var require_node = __commonJS(function(exports, module) {
 // src/build/compileEmber.ts
 import { existsSync as existsSync32 } from "fs";
 import { mkdir as mkdir10, rm as rm5 } from "fs/promises";
-import { basename as basename16, dirname as dirname24, extname as extname13, join as join41, resolve as resolve31 } from "path";
+import { basename as basename16, dirname as dirname25, extname as extname13, join as join41, resolve as resolve32 } from "path";
 var {build: bunBuild2, Transpiler: Transpiler5, write: write5, file: file4 } = globalThis.Bun;
 var cachedPreprocessor = null, getPreprocessor = async () => {
   if (cachedPreprocessor)
@@ -22288,7 +22297,7 @@ export const importSync = (specifier) => {
         const originalImporter = stagedSourceMap.get(args.importer);
         if (!originalImporter)
           return;
-        const candidateBase = resolve31(dirname24(originalImporter), args.path);
+        const candidateBase = resolve32(dirname25(originalImporter), args.path);
         const extensionsToTry = ["", ".gts", ".gjs", ".ts", ".js"];
         for (const ext of extensionsToTry) {
           const candidate = candidateBase + ext;
@@ -22347,7 +22356,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)) {
@@ -22367,8 +22376,8 @@ export default PageComponent;
     mkdir10(serverDir, { recursive: true }),
     mkdir10(clientDir, { recursive: true })
   ]);
-  const tmpPagePath = resolve31(join41(tmpDir, `${baseName}.module.js`));
-  const tmpHarnessPath = resolve31(join41(tmpDir, `${baseName}.harness.js`));
+  const tmpPagePath = resolve32(join41(tmpDir, `${baseName}.module.js`));
+  const tmpHarnessPath = resolve32(join41(tmpDir, `${baseName}.harness.js`));
   await Promise.all([
     write5(tmpPagePath, transpiled),
     write5(tmpHarnessPath, generateServerHarness(tmpPagePath))
@@ -22433,24 +22442,24 @@ var importFromProject = (specifier, projectRoot = process.cwd()) => {
 
 // src/build/buildReactVendor.ts
 import { existsSync as existsSync33, mkdirSync as mkdirSync8 } from "fs";
-import { join as join42, resolve as resolve32 } from "path";
+import { join as join42, resolve as resolve33 } from "path";
 import { rm as rm6 } 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 (existsSync33(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) {
@@ -22898,13 +22907,13 @@ import {
   existsSync as existsSync34,
   mkdirSync as mkdirSync12,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync27,
+  readFileSync as readFileSync28,
   renameSync,
   rmSync as rmSync2,
   statSync as statSync5,
   writeFileSync as writeFileSync9
 } from "fs";
-import { basename as basename17, dirname as dirname25, extname as extname14, join as join46, relative as relative20, resolve as resolve33 } from "path";
+import { basename as basename17, dirname as dirname26, extname as extname14, join as join46, relative as relative20, resolve as resolve34 } from "path";
 import { cwd, env as env2, exit } from "process";
 var {build: bunBuild7, Glob: Glob8 } = globalThis.Bun;
 var isBuildTraceEnabled = () => {
@@ -22987,7 +22996,7 @@ var isBuildTraceEnabled = () => {
 }, REACT_VENDOR_SPECIFIERS, findBareReactImports = (path, importRegex) => {
   let content;
   try {
-    content = readFileSync27(path, "utf-8");
+    content = readFileSync28(path, "utf-8");
   } catch {
     return [];
   }
@@ -23053,8 +23062,8 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
   if (globalThis.__absoluteVersion)
     return;
   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;
@@ -23070,13 +23079,13 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
   };
   await resolveCandidate(candidates);
 }, SKIP_DIRS5, addWorkerPathIfExists = (file, relPath, workerPaths) => {
-  const absPath = resolve33(file, "..", relPath);
+  const absPath = resolve34(file, "..", relPath);
   try {
     statSync5(absPath);
     workerPaths.add(absPath);
   } catch {}
 }, extractWorkerSpecifiers = (file, patterns) => {
-  const content = readFileSync27(file, "utf-8");
+  const content = readFileSync28(file, "utf-8");
   const specifiers = [];
   for (const pattern of patterns) {
     pattern.lastIndex = 0;
@@ -23165,35 +23174,35 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
     return;
   }
   const indexFiles = readDir(reactIndexesPath).filter((file) => file.endsWith(".tsx"));
-  const pagesRel = relative20(process.cwd(), resolve33(reactPagesPath)).replace(/\\/g, "/");
+  const pagesRel = relative20(process.cwd(), resolve34(reactPagesPath)).replace(/\\/g, "/");
   for (const file of indexFiles) {
-    let content = readFileSync27(join46(reactIndexesPath, file), "utf-8");
+    let content = readFileSync28(join46(reactIndexesPath, file), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
     writeFileSync9(join46(devIndexDir, file), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
   const svelteIndexDir = join46(getFrameworkGeneratedDir("svelte"), "indexes");
-  const sveltePageEntries = svelteEntries.filter((file) => resolve33(file).startsWith(resolve33(sveltePagesPath)));
+  const sveltePageEntries = svelteEntries.filter((file) => resolve34(file).startsWith(resolve34(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename17(entry).replace(/\.svelte(\.(ts|js))?$/, "");
     const indexFile = join46(svelteIndexDir, "pages", `${name}.js`);
     if (!existsSync34(indexFile))
       continue;
-    let content = readFileSync27(indexFile, "utf-8");
-    const srcRel = relative20(process.cwd(), resolve33(entry)).replace(/\\/g, "/");
+    let content = readFileSync28(indexFile, "utf-8");
+    const srcRel = relative20(process.cwd(), resolve34(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
     writeFileSync9(join46(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
   const vueIndexDir = join46(getFrameworkGeneratedDir("vue"), "indexes");
-  const vuePageEntries = vueEntries.filter((file) => resolve33(file).startsWith(resolve33(vuePagesPath)));
+  const vuePageEntries = vueEntries.filter((file) => resolve34(file).startsWith(resolve34(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename17(entry, ".vue");
     const indexFile = join46(vueIndexDir, `${name}.js`);
     if (!existsSync34(indexFile))
       continue;
-    let content = readFileSync27(indexFile, "utf-8");
-    const srcRel = relative20(process.cwd(), resolve33(entry)).replace(/\\/g, "/");
+    let content = readFileSync28(indexFile, "utf-8");
+    const srcRel = relative20(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(join46(devIndexDir, `${name}.vue.js`), content);
   }
@@ -23432,7 +23441,7 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
   const sourceClientRoots = [
     htmlDir,
     htmxDir,
-    islandBootstrapPath && dirname25(islandBootstrapPath)
+    islandBootstrapPath && dirname26(islandBootstrapPath)
   ].filter((dir) => Boolean(dir));
   const usesGenerated = Boolean(reactDir) || Boolean(svelteDir) || Boolean(vueDir) || Boolean(angularDir);
   if (usesGenerated)
@@ -23480,13 +23489,13 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
   const filterToIncrementalEntries = (entryPoints, mapToSource) => {
     if (!isIncremental || !incrementalFiles)
       return entryPoints;
-    const normalizedIncremental = new Set(incrementalFiles.map((f) => resolve33(f)));
+    const normalizedIncremental = new Set(incrementalFiles.map((f) => resolve34(f)));
     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);
     }
@@ -23662,11 +23671,11 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
       return scoped;
     return scoped.filter((entry) => {
       const source = mapToSource(entry);
-      return source !== null && deferPageEntries.except.has(resolve33(source));
+      return source !== null && deferPageEntries.except.has(resolve34(source));
     });
   };
   const mapReactIndexToPage = (entry) => {
-    if (reactIndexesPath && reactPagesPath && entry.startsWith(resolve33(reactIndexesPath))) {
+    if (reactIndexesPath && reactPagesPath && entry.startsWith(resolve34(reactIndexesPath))) {
       const pageName = basename17(entry, ".tsx");
       return join46(reactPagesPath, `${pageName}.tsx`);
     }
@@ -23708,7 +23717,7 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
     for (const entry of vueEntries) {
       const name = basename17(entry, ".vue");
       if (ssrOnlyPageNames.has(name)) {
-        resolved.add(resolve33(entry));
+        resolved.add(resolve34(entry));
       }
     }
     return resolved;
@@ -23821,7 +23830,7 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
     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++) {
@@ -23829,7 +23838,7 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
     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++) {
@@ -23837,7 +23846,7 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
     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);
@@ -23864,7 +23873,7 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
             stylePreprocessorPlugin,
             createBunStringRawUnicodePlugin()
           ],
-          root: dirname25(source),
+          root: dirname26(source),
           target: "bun",
           throw: false,
           ...projectTsconfig()
@@ -23956,7 +23965,7 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
     ...islandBootstrapPath ? [islandBootstrapPath] : []
   ];
   const [onlyWorkerClientEntry] = urlReferencedFiles;
-  const workerClientRoot = urlReferencedFiles.length === 1 && onlyWorkerClientEntry ? dirname25(onlyWorkerClientEntry) : commonAncestor(urlReferencedFiles.map((file) => dirname25(file)), projectRoot);
+  const workerClientRoot = urlReferencedFiles.length === 1 && onlyWorkerClientEntry ? dirname26(onlyWorkerClientEntry) : commonAncestor(urlReferencedFiles.map((file) => dirname26(file)), projectRoot);
   const islandEntryResult = islandBuildInfo ? await tracePhase("islands/client-entry-generation", () => generateIslandEntryPoints({
     buildInfo: islandBuildInfo,
     buildPath,
@@ -24284,7 +24293,7 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
       renameSync(mapPath, join46(sourcemapDir, basename17(mapPath)));
       const jsPath = mapPath.slice(0, -4);
       try {
-        const javascript = readFileSync27(jsPath, "utf-8").replace(/\n?\/\/# sourceMappingURL=[^\n]*\s*$/, `
+        const javascript = readFileSync28(jsPath, "utf-8").replace(/\n?\/\/# sourceMappingURL=[^\n]*\s*$/, `
 `);
         writeFileSync9(jsPath, javascript);
       } catch {}
@@ -24363,7 +24372,7 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
   if (serverOutputs.length > 0 && angularServerVendorPaths && Object.keys(angularServerVendorPaths).length > 0) {
     await Promise.resolve().then(() => init_rewriteImportsPlugin());
     await tracePhase("postprocess/server-angular-vendor-imports", () => rewriteBuildOutputsWith(serverOutputs, (artifact) => {
-      const fileDir = dirname25(artifact.path);
+      const fileDir = dirname26(artifact.path);
       const relativePaths = {};
       for (const [specifier, absolute] of Object.entries(angularServerVendorPaths)) {
         const rel = relative20(fileDir, absolute);
@@ -24491,7 +24500,7 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
   const injectHMRIntoHTMLFile = (filePath, framework) => {
     if (!hmrClientBundle)
       return;
-    let html = readFileSync27(filePath, "utf-8");
+    let html = readFileSync28(filePath, "utf-8");
     if (html.includes("data-hmr-client"))
       return;
     const tag = `<script>window.__HMR_FRAMEWORK__="${framework}";</script><script data-hmr-client>${hmrClientBundle}</script>`;
@@ -24516,7 +24525,7 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
       if (hmr)
         injectHMRIntoHTMLFile(htmlFile, "html");
       if (pwaArtifacts) {
-        const source = readFileSync27(htmlFile, "utf8");
+        const source = readFileSync28(htmlFile, "utf8");
         writeFileSync9(htmlFile, injectPwaBootstrapHtml(source));
       }
       const fileName = basename17(htmlFile, ".html");
@@ -24547,7 +24556,7 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
       if (hmr)
         injectHMRIntoHTMLFile(htmxFile, "htmx");
       if (pwaArtifacts) {
-        const source = readFileSync27(htmxFile, "utf8");
+        const source = readFileSync28(htmxFile, "utf8");
         writeFileSync9(htmxFile, injectPwaBootstrapHtml(source));
       }
       const fileName = basename17(htmxFile, ".html");
@@ -24672,7 +24681,7 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
     pageEntries,
     tailwindChanged: tailwindResult?.cssChanged ?? false
   };
-}, projectTsconfig = () => existsSync34(resolve33("tsconfig.json")) ? { tsconfig: "./tsconfig.json" } : {}, build = async (config) => {
+}, projectTsconfig = () => existsSync34(resolve34("tsconfig.json")) ? { tsconfig: "./tsconfig.json" } : {}, build = async (config) => {
   const projectRoot = cwd();
   const buildPath = validateSafePath(config.buildDirectory ?? "build", projectRoot);
   return withBuildDirectoryLock(buildPath, () => buildUnlocked(config));
@@ -24762,14 +24771,14 @@ var init_build = __esm(() => {
 
 // src/dev/runtimePaths.ts
 import { existsSync as existsSync35 } from "fs";
-import { resolve as resolve34 } from "path";
+import { resolve as resolve35 } from "path";
 var resolveDevClientDirectory = () => {
   const candidates = [
-    resolve34(import.meta.dir, "client"),
-    resolve34(import.meta.dir, "dev/client"),
-    resolve34(import.meta.dir, "../dev/client")
+    resolve35(import.meta.dir, "client"),
+    resolve35(import.meta.dir, "dev/client"),
+    resolve35(import.meta.dir, "../dev/client")
   ];
-  const directory = candidates.find((candidate) => existsSync35(resolve34(candidate, "hmrClient.ts")));
+  const directory = candidates.find((candidate) => existsSync35(resolve35(candidate, "hmrClient.ts")));
   if (!directory) {
     throw new Error("AbsoluteJS browser HMR sources are missing from the installed package.");
   }
@@ -24926,7 +24935,7 @@ var init_buildEmberVendor = __esm(() => {
 });
 
 // src/build/workspacePackages.ts
-import { readFileSync as readFileSync28, realpathSync as realpathSync3 } from "fs";
+import { readFileSync as readFileSync29, realpathSync as realpathSync4 } from "fs";
 import { join as join48, sep as sep6 } from "path";
 var NODE_MODULES_SEGMENT, verdicts, isWorkspacePackageSpecifier = (specifier, projectRoot = process.cwd()) => {
   const key = `${projectRoot}\x00${specifier}`;
@@ -24935,7 +24944,7 @@ var NODE_MODULES_SEGMENT, verdicts, isWorkspacePackageSpecifier = (specifier, pr
     return known;
   let verdict = false;
   try {
-    const resolved = realpathSync3(Bun.resolveSync(specifier, projectRoot));
+    const resolved = realpathSync4(Bun.resolveSync(specifier, projectRoot));
     verdict = !resolved.includes(NODE_MODULES_SEGMENT);
   } catch {
     verdict = false;
@@ -24945,7 +24954,7 @@ var NODE_MODULES_SEGMENT, verdicts, isWorkspacePackageSpecifier = (specifier, pr
 }, workspacePackageDirs = (projectRoot = process.cwd()) => {
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync28(join48(projectRoot, "package.json"), "utf-8"));
+    manifest = JSON.parse(readFileSync29(join48(projectRoot, "package.json"), "utf-8"));
   } catch {
     return [];
   }
@@ -24960,7 +24969,7 @@ var NODE_MODULES_SEGMENT, verdicts, isWorkspacePackageSpecifier = (specifier, pr
   const dirs = new Set;
   for (const name of names) {
     try {
-      const linked = realpathSync3(join48(projectRoot, "node_modules", name));
+      const linked = realpathSync4(join48(projectRoot, "node_modules", name));
       if (!`${linked}${sep6}`.includes(NODE_MODULES_SEGMENT))
         dirs.add(linked);
     } catch {}
@@ -25076,9 +25085,9 @@ var stripStringsAndComments = (source) => {
 };
 
 // src/dev/dependencyGraph.ts
-import { existsSync as existsSync37, readFileSync as readFileSync29, realpathSync as realpathSync4 } from "fs";
+import { existsSync as existsSync37, readFileSync as readFileSync30, realpathSync as realpathSync5 } from "fs";
 var {Glob: Glob9 } = globalThis.Bun;
-import { resolve as resolve35 } from "path";
+import { resolve as resolve36 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
   const lower = filePath.toLowerCase();
   if (lower.endsWith(".ts") || lower.endsWith(".tsx") || lower.endsWith(".jsx"))
@@ -25089,17 +25098,17 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     return "html";
   return null;
 }, resolveImportPath2 = (importPath, fromFile) => {
-  const fromDir = resolve35(fromFile, "..");
+  const fromDir = resolve36(fromFile, "..");
   if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
     if (!isWorkspacePackageSpecifier(importPath, fromDir))
       return null;
     try {
-      return realpathSync4(Bun.resolveSync(importPath, fromDir));
+      return realpathSync5(Bun.resolveSync(importPath, fromDir));
     } catch {
       return null;
     }
   }
-  const normalized = resolve35(fromDir, importPath);
+  const normalized = resolve36(fromDir, importPath);
   const extensions = [
     ".ts",
     ".tsx",
@@ -25129,7 +25138,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     dependents.delete(normalizedPath);
   }
 }, addFileToGraph = (graph, filePath) => {
-  const normalizedPath = resolve35(filePath);
+  const normalizedPath = resolve36(filePath);
   if (!existsSync37(normalizedPath))
     return;
   const dependencies = extractDependencies(normalizedPath);
@@ -25156,10 +25165,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) => resolve35(dir)).filter((dir) => existsSync37(dir));
+  const resolvedDirs = directories.map((dir) => resolve36(dir)).filter((dir) => existsSync37(dir));
   const allFiles = resolvedDirs.flatMap((dir) => Array.from(glob.scanSync({ absolute: true, cwd: dir })));
   for (const file of allFiles) {
-    const fullPath = resolve35(file);
+    const fullPath = resolve36(file);
     if (IGNORED_SEGMENTS.some((seg) => fullPath.includes(seg)))
       continue;
     if (processedFiles.has(fullPath))
@@ -25253,15 +25262,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 [];
@@ -25272,7 +25281,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     return [];
   }
 }, getAffectedFiles = (graph, changedFile) => {
-  const normalizedPath = resolve35(changedFile);
+  const normalizedPath = resolve36(changedFile);
   const affected = new Set;
   const toProcess = [normalizedPath];
   const processNode = (current) => {
@@ -25303,7 +25312,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
 }, removeDependentsForFile = (graph, normalizedPath) => {
   graph.dependents.delete(normalizedPath);
 }, removeFileFromGraph = (graph, filePath) => {
-  const normalizedPath = resolve35(filePath);
+  const normalizedPath = resolve36(filePath);
   removeDepsForFile(graph, normalizedPath);
   removeDependentsForFile(graph, normalizedPath);
 };
@@ -25347,12 +25356,12 @@ var globalVersionCounter = 0, createModuleVersionTracker = () => new Map, getNex
 };
 
 // src/dev/configResolver.ts
-import { resolve as resolve36 } from "path";
+import { resolve as resolve37 } from "path";
 var resolveBuildPaths = (config) => {
   const cwd = process.cwd();
   const normalize = (path) => path.replace(/\\/g, "/");
-  const withDefault = (value, fallback) => normalize(resolve36(cwd, value ?? fallback));
-  const optional = (value) => value ? normalize(resolve36(cwd, value)) : undefined;
+  const withDefault = (value, fallback) => normalize(resolve37(cwd, value ?? fallback));
+  const optional = (value) => value ? normalize(resolve37(cwd, value)) : undefined;
   return {
     angularDir: optional(config.angularDirectory),
     assetsDir: optional(config.assetsDirectory),
@@ -25411,8 +25420,8 @@ var init_clientManager = __esm(() => {
 });
 
 // src/dev/pathUtils.ts
-import { existsSync as existsSync38, readdirSync as readdirSync8, readFileSync as readFileSync30 } from "fs";
-import { dirname as dirname26, resolve as resolve37 } from "path";
+import { existsSync as existsSync38, readdirSync as readdirSync8, readFileSync as readFileSync31 } from "fs";
+import { dirname as dirname27, resolve as resolve38 } from "path";
 var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   if (shouldIgnorePath(filePath, resolved)) {
     return "ignored";
@@ -25488,7 +25497,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   return "unknown";
 }, collectAngularResourceDirs = (angularDir) => {
   const out = new Set;
-  const angularRoot = resolve37(angularDir);
+  const angularRoot = resolve38(angularDir);
   const angularRootNormalized = normalizePath(angularRoot);
   const walk = (dir) => {
     let entries;
@@ -25501,7 +25510,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const full = resolve37(dir, entry.name);
+      const full = resolve38(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
         continue;
@@ -25511,7 +25520,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
       }
       let source;
       try {
-        source = readFileSync30(full, "utf8");
+        source = readFileSync31(full, "utf8");
       } catch {
         continue;
       }
@@ -25540,10 +25549,10 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
             refs.push(strMatch[1]);
         }
       }
-      const componentDir = dirname26(full);
+      const componentDir = dirname27(full);
       for (const ref of refs) {
-        const refAbs = normalizePath(resolve37(componentDir, ref));
-        const refDir = normalizePath(dirname26(refAbs));
+        const refAbs = normalizePath(resolve38(componentDir, ref));
+        const refDir = normalizePath(dirname27(refAbs));
         if (refDir === angularRootNormalized || refDir.startsWith(`${angularRootNormalized}/`)) {
           continue;
         }
@@ -25559,7 +25568,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   const push = (path) => {
     if (!path)
       return;
-    const abs = normalizePath(resolve37(cwd, path));
+    const abs = normalizePath(resolve38(cwd, path));
     if (!roots.includes(abs))
       roots.push(abs);
   };
@@ -25584,7 +25593,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   push(cfg.assetsDir);
   push(cfg.stylesDir);
   for (const candidate of ["src", "db", "assets", "styles"]) {
-    const abs = normalizePath(resolve37(cwd, candidate));
+    const abs = normalizePath(resolve38(cwd, candidate));
     if (existsSync38(abs) && !roots.includes(abs))
       roots.push(abs);
   }
@@ -25595,7 +25604,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
         continue;
       if (entry.name.startsWith("."))
         continue;
-      const abs = normalizePath(resolve37(cwd, entry.name));
+      const abs = normalizePath(resolve38(cwd, entry.name));
       if (roots.includes(abs))
         continue;
       if (shouldIgnorePath(abs, resolved))
@@ -25753,7 +25762,7 @@ var init_serverEntryCopies = () => {};
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
 import { existsSync as existsSync40, readdirSync as readdirSync10, statSync as statSync6 } from "fs";
-import { dirname as dirname27, join as join50, resolve as resolve38 } from "path";
+import { dirname as dirname28, join as join50, resolve as resolve39 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -25808,7 +25817,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
       return;
     if (shouldSkipFilename(filename, isStylesDir)) {
       if (event === "rename") {
-        const eventDir = dirname27(join50(absolutePath, filename)).replace(/\\/g, "/");
+        const eventDir = dirname28(join50(absolutePath, filename)).replace(/\\/g, "/");
         atomicRecoveryScan(eventDir);
         for (const delay of [25, 100]) {
           const timer = setTimeout(() => atomicRecoveryScan(eventDir), delay);
@@ -25835,7 +25844,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
 }, addFileWatchers = (state, paths, onFileChange) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
-    const absolutePath = resolve38(path).replace(/\\/g, "/");
+    const absolutePath = resolve39(path).replace(/\\/g, "/");
     if (!existsSync40(absolutePath)) {
       return;
     }
@@ -25846,7 +25855,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const watchPaths = getWatchPaths(config, state.resolvedPaths);
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
-    const absolutePath = resolve38(path).replace(/\\/g, "/");
+    const absolutePath = resolve39(path).replace(/\\/g, "/");
     if (!existsSync40(absolutePath)) {
       return;
     }
@@ -25866,13 +25875,13 @@ var init_fileWatcher = __esm(() => {
 });
 
 // src/dev/assetStore.ts
-import { resolve as resolve39 } from "path";
+import { resolve as resolve40 } 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 = resolve39(dir, entry.name);
+  const fullPath = resolve40(dir, entry.name);
   if (entry.isDirectory()) {
     return walkAndClean(fullPath);
   }
@@ -25888,10 +25897,10 @@ var mimeTypes, getMimeType = (filePath) => {
 }, cleanStaleAssets = async (store, manifest, buildDir) => {
   const liveByIdentity = new Map;
   for (const webPath of store.keys()) {
-    const diskPath = resolve39(buildDir, webPath.slice(1));
+    const diskPath = resolve40(buildDir, webPath.slice(1));
     liveByIdentity.set(stripHash(diskPath), diskPath);
   }
-  const absBuildDir = resolve39(buildDir);
+  const absBuildDir = resolve40(buildDir);
   Object.values(manifest).forEach((val) => {
     if (!HASHED_FILE_RE.test(val))
       return;
@@ -25911,13 +25920,13 @@ var mimeTypes, getMimeType = (filePath) => {
 }, evictMissingChunks = async (store, buildDir) => {
   const chunkKeys = [...store.keys()].filter((webPath) => webPath.includes("/chunk-"));
   await Promise.all(chunkKeys.map(async (webPath) => {
-    const onDisk = await Bun.file(resolve39(buildDir, webPath.slice(1))).exists().catch(() => false);
+    const onDisk = await Bun.file(resolve40(buildDir, webPath.slice(1))).exists().catch(() => false);
     if (!onDisk)
       store.delete(webPath);
   }));
 }, lookupAsset = (store, path) => store.get(path), processScanEntry = (entry, dir, prefix, store, scanDir) => {
   if (entry.isDirectory()) {
-    return scanDir(resolve39(dir, entry.name), `${prefix}${entry.name}/`);
+    return scanDir(resolve40(dir, entry.name), `${prefix}${entry.name}/`);
   }
   if (!entry.name.startsWith("chunk-")) {
     return null;
@@ -25926,7 +25935,7 @@ var mimeTypes, getMimeType = (filePath) => {
   if (store.has(webPath)) {
     return null;
   }
-  return Bun.file(resolve39(dir, entry.name)).bytes().then((bytes) => {
+  return Bun.file(resolve40(dir, entry.name)).bytes().then((bytes) => {
     store.set(webPath, bytes);
     return;
   }).catch(() => {});
@@ -25948,7 +25957,7 @@ var mimeTypes, getMimeType = (filePath) => {
   for (const webPath of newIdentities.values()) {
     if (store.has(webPath))
       continue;
-    loadPromises.push(Bun.file(resolve39(buildDir, webPath.slice(1))).bytes().then((bytes) => {
+    loadPromises.push(Bun.file(resolve40(buildDir, webPath.slice(1))).bytes().then((bytes) => {
       store.set(webPath, bytes);
       return;
     }).catch(() => {}));
@@ -25994,10 +26003,10 @@ var init_assetStore = __esm(() => {
 });
 
 // src/dev/restartScope.ts
-import { realpathSync as realpathSync5 } from "fs";
+import { realpathSync as realpathSync6 } from "fs";
 var MODULE_FILE, DOCUMENT_FILE, realPath = (path) => {
   try {
-    return realpathSync5(path);
+    return realpathSync6(path);
   } catch {
     return path;
   }
@@ -26014,8 +26023,8 @@ var init_restartScope = __esm(() => {
 });
 
 // src/islands/pageMetadata.ts
-import { readFileSync as readFileSync31 } from "fs";
-import { dirname as dirname28, resolve as resolve40 } from "path";
+import { readFileSync as readFileSync32 } from "fs";
+import { dirname as dirname29, resolve as resolve41 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
   { dir: config.emberDirectory, framework: "ember" },
@@ -26035,15 +26044,15 @@ var pagePatterns, getPageDirs = (config) => [
     const source = definition.buildReference?.source;
     if (!source)
       continue;
-    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve40(dirname28(buildInfo.resolvedRegistryPath), source);
-    lookup.set(`${definition.framework}:${definition.component}`, resolve40(resolvedSource));
+    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve41(dirname29(buildInfo.resolvedRegistryPath), source);
+    lookup.set(`${definition.framework}:${definition.component}`, resolve41(resolvedSource));
   }
   return lookup;
 }, getCurrentPageIslandMetadata = () => globalThis.__absolutePageIslandMetadata ?? new Map, metadataUsesSource = (metadata, target) => metadata.islands.some((usage) => {
   const candidate = usage.source;
-  return candidate ? resolve40(candidate) === target : false;
+  return candidate ? resolve41(candidate) === target : false;
 }), getPagesUsingIslandSource = (sourcePath) => {
-  const target = resolve40(sourcePath);
+  const target = resolve41(sourcePath);
   return [...getCurrentPageIslandMetadata().values()].filter((metadata) => metadataUsesSource(metadata, target)).map((metadata) => metadata.pagePath);
 }, resolveIslandUsages = (islands, islandSourceLookup) => islands.map((usage) => {
   const sourcePath = islandSourceLookup.get(`${usage.framework}:${usage.component}`);
@@ -26055,13 +26064,13 @@ var pagePatterns, getPageDirs = (config) => [
   const pattern = pagePatterns[entry.framework];
   if (!pattern)
     return;
-  const files = await scanEntryPoints(resolve40(entry.dir), pattern);
+  const files = await scanEntryPoints(resolve41(entry.dir), pattern);
   for (const filePath of files) {
-    const source = readFileSync31(filePath, "utf-8");
+    const source = readFileSync32(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
-    pageMetadata.set(resolve40(filePath), {
+    pageMetadata.set(resolve41(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
-      pagePath: resolve40(filePath)
+      pagePath: resolve41(filePath)
     });
   }
 }, loadPageIslandMetadata = async (config) => {
@@ -26088,10 +26097,10 @@ var init_pageMetadata = __esm(() => {
 });
 
 // src/dev/fileHashTracker.ts
-import { readFileSync as readFileSync32, statSync as statSync7 } from "fs";
+import { readFileSync as readFileSync33, statSync as statSync7 } from "fs";
 var computeFileHash = (filePath) => {
   try {
-    const fileContent = readFileSync32(filePath);
+    const fileContent = readFileSync33(filePath);
     return Number(Bun.hash(fileContent));
   } catch {
     return UNFOUND_INDEX;
@@ -26179,9 +26188,9 @@ var init_transformCache = __esm(() => {
 });
 
 // src/dev/reactComponentClassifier.ts
-import { resolve as resolve41 } from "path";
+import { resolve as resolve42 } from "path";
 var classifyComponent = (filePath) => {
-  const normalizedPath = resolve41(filePath);
+  const normalizedPath = resolve42(filePath);
   if (normalizedPath.includes("/react/pages/")) {
     return "server";
   }
@@ -26193,7 +26202,7 @@ var classifyComponent = (filePath) => {
 var init_reactComponentClassifier = () => {};
 
 // src/dev/moduleMapper.ts
-import { basename as basename18, resolve as resolve42 } from "path";
+import { basename as basename18, resolve as resolve43 } from "path";
 var buildModulePaths = (moduleKeys, manifest) => {
   const modulePaths = {};
   moduleKeys.forEach((key) => {
@@ -26203,7 +26212,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return modulePaths;
 }, processChangedFile = (sourceFile, framework, manifest, resolvedPaths, processedFiles) => {
-  const normalizedFile = resolve42(sourceFile);
+  const normalizedFile = resolve43(sourceFile);
   const normalizedPath = normalizedFile.replace(/\\/g, "/");
   if (processedFiles.has(normalizedFile)) {
     return null;
@@ -26239,7 +26248,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return grouped;
 }, mapSourceFileToManifestKeys = (sourceFile, framework, resolvedPaths) => {
-  const normalizedFile = resolve42(sourceFile);
+  const normalizedFile = resolve43(sourceFile);
   const fileName = basename18(normalizedFile);
   const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|css|html)$/, "");
   const pascalName = toPascal(baseName);
@@ -26295,7 +26304,7 @@ var init_moduleMapper = __esm(() => {
 
 // src/utils/spaRouteCss.ts
 import { readFile as readFile8 } from "fs/promises";
-import { dirname as dirname29, isAbsolute as isAbsolute8, resolve as resolve43 } from "path";
+import { dirname as dirname30, isAbsolute as isAbsolute8, resolve as resolve44 } from "path";
 var sideManifestCache, readSideManifest = async (sideManifestPath) => {
   const cached = sideManifestCache.get(sideManifestPath);
   if (cached !== undefined)
@@ -26333,7 +26342,7 @@ var sideManifestCache, readSideManifest = async (sideManifestPath) => {
 }, readChildCss = async (cssPath, sideManifestPath) => {
   if (!cssPath)
     return "";
-  const resolvedCssPath = isAbsolute8(cssPath) ? cssPath : resolve43(dirname29(sideManifestPath), cssPath);
+  const resolvedCssPath = isAbsolute8(cssPath) ? cssPath : resolve44(dirname30(sideManifestPath), cssPath);
   const cached = childCssCache.get(resolvedCssPath);
   if (cached !== undefined)
     return cached;
@@ -26416,8 +26425,8 @@ __export(exports_resolveOwningComponents, {
   resolveDescendantsOfParent: () => resolveDescendantsOfParent,
   resolveOwningComponents: () => resolveOwningComponents
 });
-import { readdirSync as readdirSync11, readFileSync as readFileSync33, statSync as statSync8 } from "fs";
-import { dirname as dirname30, extname as extname15, join as join51, resolve as resolve44 } from "path";
+import { readdirSync as readdirSync11, readFileSync as readFileSync34, statSync as statSync8 } from "fs";
+import { dirname as dirname31, extname as extname15, join as join51, resolve as resolve45 } from "path";
 import ts19 from "typescript";
 var ENTITY_DECORATORS, isAngularSourceFile = (file) => file.endsWith(".ts") || file.endsWith(".tsx"), walkAngularSourceFiles = (root) => {
   const out = [];
@@ -26476,7 +26485,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file) => file.endsWith(".ts") || f
 }, parseDecoratedClasses = (filePath) => {
   let source;
   try {
-    source = readFileSync33(filePath, "utf8");
+    source = readFileSync34(filePath, "utf8");
   } catch {
     return [];
   }
@@ -26530,7 +26539,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file) => file.endsWith(".ts") || f
   };
   visit(sourceFile);
   return out;
-}, safeNormalize = (path) => resolve44(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
+}, safeNormalize = (path) => resolve45(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
   const { changedFilePath, userAngularRoot } = params;
   const changedAbs = safeNormalize(changedFilePath);
   const out = [];
@@ -26566,12 +26575,12 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file) => file.endsWith(".ts") || f
 }, indexByRoot, resolveParentClassFile = (parentName, childFilePath, angularRoot) => {
   let source;
   try {
-    source = readFileSync33(childFilePath, "utf8");
+    source = readFileSync34(childFilePath, "utf8");
   } catch {
     return null;
   }
   const sourceFile = ts19.createSourceFile(childFilePath, source, ts19.ScriptTarget.ES2022, true, ts19.ScriptKind.TS);
-  const childDir = dirname30(childFilePath);
+  const childDir = dirname31(childFilePath);
   for (const stmt of sourceFile.statements) {
     if (!ts19.isImportDeclaration(stmt))
       continue;
@@ -26599,7 +26608,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file) => file.endsWith(".ts") || f
     if (!spec.startsWith(".") && !spec.startsWith("/")) {
       return null;
     }
-    const base = resolve44(childDir, spec);
+    const base = resolve45(childDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -26628,7 +26637,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file) => file.endsWith(".ts") || f
   const parentFile = new Map;
   for (const tsPath of walkAngularSourceFiles(userAngularRoot)) {
     const classes = parseDecoratedClasses(tsPath);
-    const componentDir = dirname30(tsPath);
+    const componentDir = dirname31(tsPath);
     for (const cls of classes) {
       const entity = {
         className: cls.className,
@@ -26637,7 +26646,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file) => file.endsWith(".ts") || f
       };
       if (cls.kind === "component") {
         for (const url of [...cls.templateUrls, ...cls.styleUrls]) {
-          const abs = safeNormalize(resolve44(componentDir, url));
+          const abs = safeNormalize(resolve45(componentDir, url));
           const existing = resource.get(abs);
           if (existing)
             existing.push(entity);
@@ -26905,7 +26914,7 @@ var init_webSocket = __esm(() => {
 });
 
 // src/utils/loadConfig.ts
-import { resolve as resolve45 } from "path";
+import { resolve as resolve46 } from "path";
 var RESERVED_TOP_LEVEL_KEYS, isObject2 = (value) => typeof value === "object" && value !== null, isCommandService = (service) => service.kind === "command" || Array.isArray(service.command), isServiceCandidate = (value) => isObject2(value) && (typeof value.entry === "string" || Array.isArray(value.command)), isWorkspaceConfig = (config) => {
   if (!isObject2(config)) {
     return false;
@@ -26956,7 +26965,7 @@ var RESERVED_TOP_LEVEL_KEYS, isObject2 = (value) => typeof value === "object" &&
   }
   return config;
 }, loadRawConfig = async (configPath) => {
-  const resolved = resolve45(configPath ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+  const resolved = resolve46(configPath ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
   const mod = await import(resolved);
   const config = mod.default ?? mod.config;
   if (!config) {
@@ -27082,7 +27091,7 @@ var init_hotResources = __esm(() => {
 });
 
 // src/plugins/openApiPlugin.ts
-import { existsSync as existsSync41, readFileSync as readFileSync34 } from "fs";
+import { existsSync as existsSync41, readFileSync as readFileSync35 } from "fs";
 import { join as join52 } from "path";
 var FALLBACK_NAME = "AbsoluteJS API", FALLBACK_VERSION = "1.0.0", projectInfo = (cwd) => {
   const path = join52(cwd, "package.json");
@@ -27090,7 +27099,7 @@ var FALLBACK_NAME = "AbsoluteJS API", FALLBACK_VERSION = "1.0.0", projectInfo =
     return { name: FALLBACK_NAME, version: FALLBACK_VERSION };
   }
   try {
-    const pkg = JSON.parse(readFileSync34(path, "utf-8"));
+    const pkg = JSON.parse(readFileSync35(path, "utf-8"));
     return {
       name: typeof pkg.name === "string" ? pkg.name : FALLBACK_NAME,
       version: typeof pkg.version === "string" ? pkg.version : FALLBACK_VERSION
@@ -27139,14 +27148,14 @@ var FALLBACK_NAME = "AbsoluteJS API", FALLBACK_VERSION = "1.0.0", projectInfo =
 var init_openApiPlugin = () => {};
 
 // src/plugins/telemetryPlugin.ts
-import { existsSync as existsSync42, readFileSync as readFileSync35 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync36 } from "fs";
 import { join as join53 } from "path";
 var OTEL_PACKAGE = "@elysia/opentelemetry", readPackageName = (cwd) => {
   const path = join53(cwd, "package.json");
   if (!existsSync42(path))
     return null;
   try {
-    const pkg = JSON.parse(readFileSync35(path, "utf-8"));
+    const pkg = JSON.parse(readFileSync36(path, "utf-8"));
     return typeof pkg.name === "string" ? pkg.name : null;
   } catch {
     return null;
@@ -27539,7 +27548,7 @@ var init_requestContext = __esm(() => {
 });
 
 // src/core/loadIslandRegistry.ts
-import { resolve as resolve46 } from "path";
+import { resolve as resolve47 } from "path";
 var isRecord6 = (value) => typeof value === "object" && value !== null, resolveRegistryExport2 = (mod) => {
   if (isRecord6(mod.islandRegistry))
     return mod.islandRegistry;
@@ -27547,7 +27556,7 @@ var isRecord6 = (value) => typeof value === "object" && value !== null, resolveR
     return mod.default;
   throw new Error("Island registry module must export `islandRegistry` or a default registry object.");
 }, isRegistryModuleExport = (value) => isRecord6(value), isIslandRegistryInput = (value) => isRecord6(value), loadIslandRegistry = async (registryPath) => {
-  const resolvedRegistryPath = resolve46(registryPath);
+  const resolvedRegistryPath = resolve47(registryPath);
   const buildInfo = await loadIslandRegistryBuildInfo(resolvedRegistryPath);
   if (buildInfo.definitions.length > 0) {
     return buildInfo.registry;
@@ -27754,12 +27763,12 @@ var exports_config = {};
 __export(exports_config, {
   normalizeAbsoluteMobileConfig: () => normalizeAbsoluteMobileConfig
 });
-import { readFileSync as readFileSync36 } from "fs";
-import { resolve as resolve47 } from "path";
+import { readFileSync as readFileSync37 } from "fs";
+import { resolve as resolve48 } from "path";
 import { createHash as createHash4, createPublicKey, X509Certificate } from "crypto";
 var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FINGERPRINT_PATTERN, UPDATE_NAME_PATTERN, RELEASE_TARGET_PATTERN, UPDATE_PUBLIC_KEY_PATTERN, ENVIRONMENT_NAME_PATTERN, COLOR_PATTERN, DEFAULT_UPDATE_BOOT_TIMEOUT_MS = 20000, DEFAULT_UPDATE_HEALTH_FAILURE_RATE = 0.2, DEFAULT_UPDATE_HEALTH_MINIMUM_REPORTS = 20, DEFAULT_UPDATE_ROLLOUT_FAILURE_RATE = 0.05, DEFAULT_UPDATE_ROLLOUT_OBSERVATION_MINUTES = 60, MINUTE_MS, DEFAULT_UPDATE_ROLLOUT_STAGES, MINIMUM_UPDATE_BOOT_TIMEOUT_MS = 5000, MAXIMUM_UPDATE_BOOT_TIMEOUT_MS = 120000, HOSTNAME_PATTERN, EXPO_RESERVED_ROUTE_PREFIXES, resolveProjectPath = (projectRoot, value, field) => {
-  const root = resolve47(projectRoot);
-  const path = resolve47(root, value);
+  const root = resolve48(projectRoot);
+  const path = resolve48(root, value);
   if (path !== root && !path.startsWith(`${root}/`)) {
     throw new TypeError(`${field} must remain inside the project root.`);
   }
@@ -27953,7 +27962,7 @@ var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FIN
   }))
 ].sort(), readExpoCodeSigningCertificate = (certificatePath) => {
   try {
-    const certificateSource = readFileSync36(certificatePath, "utf8");
+    const certificateSource = readFileSync37(certificatePath, "utf8");
     const certificatePem = certificateSource.endsWith(`
 `) ? certificateSource : `${certificateSource}
 `;
@@ -28278,7 +28287,7 @@ import {
   rm as rm11,
   writeFile as writeFile10
 } from "fs/promises";
-import { resolve as resolve48 } from "path";
+import { resolve as resolve49 } from "path";
 import { Elysia as Elysia4 } from "elysia";
 var JSON_HEADERS, OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_OK = 200, VERIFY_TIMEOUT_MS = 1e4, ANDROID_ASSOCIATION_PATH = "/.well-known/assetlinks.json", APPLE_ASSOCIATION_PATH = "/.well-known/apple-app-site-association", missingIdentity = (field, platform) => new TypeError(`${field} is required to publish ${platform} deep-link association files.`), createAppleDocument = (config, requireAll) => {
   if (!config.platforms.includes("ios"))
@@ -28365,7 +28374,7 @@ var JSON_HEADERS, OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_
     return false;
   }
 }, assertOwnedOutput = async (root) => {
-  const path = resolve48(root, OWNERSHIP_FILE);
+  const path = resolve49(root, OWNERSHIP_FILE);
   let ownership;
   try {
     ownership = JSON.parse(await readFile9(path, "utf8"));
@@ -28392,10 +28401,10 @@ var JSON_HEADERS, OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_
   if (hasCurrent)
     await rm11(backup, { force: true, recursive: true });
 }, materializeHost = async (root, host, files) => {
-  const directory = resolve48(root, host, ".well-known");
+  const directory = resolve49(root, host, ".well-known");
   await mkdir12(directory, { recursive: true });
   return Promise.all(files.map(async ([name, document2]) => {
-    const path = resolve48(directory, name);
+    const path = resolve49(directory, name);
     await writeAtomic(path, `${JSON.stringify(document2, null, 2)}
 `);
     return path;
@@ -28418,7 +28427,7 @@ var JSON_HEADERS, OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_
     });
   return endpoints;
 }), materializeAbsoluteMobileAssociationFiles = async (config, outputDirectory) => {
-  const root = resolve48(outputDirectory);
+  const root = resolve49(outputDirectory);
   const temporary = `${root}.${crypto.randomUUID()}.tmp`;
   const documents = createAbsoluteMobileAssociationDocuments(config, {
     requireAll: true
@@ -28432,10 +28441,10 @@ var JSON_HEADERS, OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_
   await mkdir12(temporary, { recursive: true });
   try {
     const temporaryPaths = (await Promise.all(config.deepLinkHosts.map((host) => materializeHost(temporary, host, files)))).flat();
-    await writeAtomic(resolve48(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
+    await writeAtomic(resolve49(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
 `);
     await publishGeneratedDirectory(temporary, root);
-    const written = temporaryPaths.map((path) => resolve48(root, path.slice(temporary.length + 1)));
+    const written = temporaryPaths.map((path) => resolve49(root, path.slice(temporary.length + 1)));
     return { root, written };
   } catch (error) {
     await rm11(temporary, { force: true, recursive: true });
@@ -28555,11 +28564,11 @@ var init_mobilePreview = __esm(() => {
 });
 
 // src/mobile/nativeAuth.ts
-import { readFileSync as readFileSync37 } from "fs";
+import { readFileSync as readFileSync38 } from "fs";
 import { join as join54 } from "path";
 var ABSOLUTE_AUTH_PACKAGE = "@absolutejs/auth", ABSOLUTE_EXPO_AUTH_CORE_VERSION = "0.76.3", ABSOLUTE_EXPO_AUTH_PACKAGE = "@absolutejs/auth-expo", ABSOLUTE_EXPO_AUTH_VERSION = "0.0.6", ABSOLUTE_EXPO_SYNC_CORE_VERSION = "2.31.0", ABSOLUTE_EXPO_SYNC_PACKAGE = "@absolutejs/sync-expo", ABSOLUTE_EXPO_SYNC_VERSION = "0.0.4", ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV = "ABSOLUTE_AUTH_NATIVE_CLIENTS", ABSOLUTE_NATIVE_AUTH_SCOPES, ABSOLUTE_SYNC_PACKAGE = "@absolutejs/sync", readPackageManifest = (projectRoot) => {
   try {
-    return JSON.parse(readFileSync37(join54(projectRoot, "package.json"), "utf8"));
+    return JSON.parse(readFileSync38(join54(projectRoot, "package.json"), "utf8"));
   } catch {
     return;
   }
@@ -29224,12 +29233,12 @@ import {
   X509Certificate as X509Certificate3
 } from "crypto";
 import { access as access4, mkdir as mkdir13 } from "fs/promises";
-import { dirname as dirname31, isAbsolute as isAbsolute9, relative as relative21, resolve as resolve49, sep as sep7 } from "path";
+import { dirname as dirname32, isAbsolute as isAbsolute9, relative as relative21, resolve as resolve50, sep as sep7 } from "path";
 import { pathToFileURL as pathToFileURL3 } from "url";
 import { Elysia as Elysia6 } from "elysia";
 var ABSOLUTE_MOBILE_UPDATE_SERVER_FORMAT = 1, DEFAULT_MOBILE_UPDATE_REGISTRY_MODULE = "mobile.update.ts", object4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), projectPath = (projectRoot, requested) => {
-  const root = resolve49(projectRoot);
-  const path = resolve49(root, requested);
+  const root = resolve50(projectRoot);
+  const path = resolve50(root, requested);
   const projectRelative = relative21(root, path);
   if (projectRelative === ".." || projectRelative.startsWith(`..${sep7}`) || isAbsolute9(projectRelative))
     throw new TypeError("mobile.updates.server.registry must remain inside the project.");
@@ -29449,7 +29458,7 @@ ${generated}`);
       return;
     });
   }
-  await mkdir13(dirname31(path), { recursive: true });
+  await mkdir13(dirname32(path), { recursive: true });
   await Bun.write(path, renderAbsoluteMobileUpdateRegistry({
     ...options.health ? { health: options.health } : {},
     ...options.rollout ? { rollout: options.rollout } : {},
@@ -29500,7 +29509,7 @@ var init_bridgeInternals = __esm(() => {
 });
 
 // src/dev/angular/hmrCompiler.ts
-import { dirname as dirname32, relative as relative22, resolve as resolve50 } from "path";
+import { dirname as dirname33, relative as relative22, resolve as resolve51 } from "path";
 import { performance as performance2 } from "perf_hooks";
 var encodeHmrComponentId = (absoluteFilePath, className) => {
   const projectRel = relative22(process.cwd(), absoluteFilePath).replace(/\\/g, "/");
@@ -29512,7 +29521,7 @@ var encodeHmrComponentId = (absoluteFilePath, className) => {
     return null;
   const filePathRel = decoded.slice(0, separatorIndex);
   const className = decoded.slice(separatorIndex + 1);
-  const componentFilePath = resolve50(process.cwd(), filePathRel);
+  const componentFilePath = resolve51(process.cwd(), filePathRel);
   const projectRelPath = relative22(process.cwd(), componentFilePath).replace(/\\/g, "/");
   const cacheKey = encodeURIComponent(`${projectRelPath}@${className}`);
   await Promise.resolve().then(() => init_fastHmrCompiler());
@@ -29523,7 +29532,7 @@ var encodeHmrComponentId = (absoluteFilePath, className) => {
   await Promise.resolve().then(() => init_resolveOwningComponents());
   const owners = resolveOwningComponents({
     changedFilePath: componentFilePath,
-    userAngularRoot: dirname32(componentFilePath)
+    userAngularRoot: dirname33(componentFilePath)
   });
   const owner = owners.find((o) => o.className === className);
   const kind = owner?.kind ?? "component";
@@ -29717,17 +29726,17 @@ var init_hmr = __esm(() => {
 });
 
 // src/plugins/devtoolsJson.ts
-import { existsSync as existsSync43, mkdirSync as mkdirSync14, readFileSync as readFileSync38, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname33, join as join57, resolve as resolve51 } from "path";
+import { existsSync as existsSync43, mkdirSync as mkdirSync14, readFileSync as readFileSync39, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname34, join as join57, resolve as resolve52 } from "path";
 import { Elysia as Elysia8 } 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) => resolve51(uuidCachePath ?? join57(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (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) => resolve52(uuidCachePath ?? join57(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
   if (!existsSync43(cachePath))
     return null;
   try {
-    const value = readFileSync38(cachePath, "utf-8").trim();
+    const value = readFileSync39(cachePath, "utf-8").trim();
     return isUuidV4(value) ? value : null;
   } catch {
     return null;
@@ -29745,11 +29754,11 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   if (cachedUuid)
     return setGlobalUuid(cachedUuid);
   const uuid = crypto.randomUUID();
-  mkdirSync14(dirname33(cachePath), { recursive: true });
+  mkdirSync14(dirname34(cachePath), { recursive: true });
   writeFileSync10(cachePath, uuid, "utf-8");
   return setGlobalUuid(uuid);
 }, devtoolsJson = (buildDir, options = {}) => {
-  const rootPath = resolve51(options.projectRoot ?? process.cwd());
+  const rootPath = resolve52(options.projectRoot ?? process.cwd());
   const root = options.normalizeForWindowsContainer === false ? rootPath : normalizeDevtoolsWorkspaceRoot(rootPath);
   const uuid = getOrCreateUuid(buildDir, options);
   return new Elysia8({ name: "absolute-devtools-json" }).get(ENDPOINT, () => ({
@@ -29774,7 +29783,7 @@ var init_devtoolsJson = () => {};
 
 // src/plugins/imageOptimizer.ts
 import { existsSync as existsSync44 } from "fs";
-import { resolve as resolve52 } from "path";
+import { resolve as resolve53 } from "path";
 import { Elysia as Elysia9 } from "elysia";
 var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avifInProgress, safeResolve = (path, baseDir) => {
   try {
@@ -29787,7 +29796,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, resolve52(process.cwd()));
+  return safeResolve(cleanPath, buildDir) ?? safeResolve(cleanPath, resolve53(process.cwd()));
 }, parseQueryParams = (query, allowedSizes, defaultQuality) => {
   const url = typeof query["url"] === "string" ? query["url"] : undefined;
   const wParam = typeof query["w"] === "string" ? query["w"] : undefined;
@@ -30514,7 +30523,7 @@ import {
   rm as rm14,
   writeFile as writeFile13
 } from "fs/promises";
-import { dirname as dirname34, join as join59, resolve as resolvePath2 } from "path";
+import { dirname as dirname35, join as join59, resolve as resolvePath2 } from "path";
 import { pathToFileURL as pathToFileURL5 } from "url";
 var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "current.json", BUNDLES_DIRECTORY = "bundles", ARTIFACT_FILE2 = "artifact.json", BUNDLE_ID_PATTERN, isRecord9 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), errorHasCode2 = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code, bundleIdFor = (currentReleaseId, releases) => {
   const identity = JSON.stringify({
@@ -30547,7 +30556,7 @@ var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "curre
 }, writeRelease = async (root, release) => {
   const directory = join59(root, release.artifact.releaseId);
   const producerPath = join59(directory, release.artifact.producer.module);
-  await mkdir15(dirname34(producerPath), { recursive: true });
+  await mkdir15(dirname35(producerPath), { recursive: true });
   await Promise.all([
     writeFile13(join59(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
 `),
@@ -31185,7 +31194,7 @@ var init_compatibilityDispatcher = __esm(() => {
 });
 
 // src/core/prerender.ts
-import { mkdirSync as mkdirSync15, readFileSync as readFileSync39 } from "fs";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync40 } from "fs";
 import { join as join60 } from "path";
 var 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");
@@ -31193,7 +31202,7 @@ var DEFAULT_FETCH_TIMEOUT_MS = 1e4, PRERENDER_BYPASS_HEADER = "X-Absolute-Preren
 }, readTimestamp = (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   try {
-    const content = readFileSync39(metaPath, "utf-8");
+    const content = readFileSync40(metaPath, "utf-8");
     return Number(content) || 0;
   } catch {
     return 0;
@@ -31229,7 +31238,7 @@ var init_prerender = () => {};
 
 // src/core/prepare.ts
 import { createHash as createHash9 } from "crypto";
-import { existsSync as existsSync45, readdirSync as readdirSync12, readFileSync as readFileSync40 } from "fs";
+import { existsSync as existsSync45, readdirSync as readdirSync12, readFileSync as readFileSync41 } from "fs";
 import { basename as basename19, join as join61, relative as relative23, resolve as resolvePath3 } from "path";
 import { Elysia as Elysia12, NotFound } from "elysia";
 var MS_PER_SECOND2 = 1000, DEFAULT_PORT2 = 3000, MAX_STATIC_ROUTE_COUNT, STATIC_PLUGIN_RETRY_DELAY_MS = 50, waitForStaticPluginRetry = () => new Promise((resolve) => {
@@ -31374,7 +31383,7 @@ var MS_PER_SECOND2 = 1000, DEFAULT_PORT2 = 3000, MAX_STATIC_ROUTE_COUNT, STATIC_
     const filePath = join61(buildDir, path);
     let versioned = href;
     if (existsSync45(filePath)) {
-      const hash = createHash9("sha256").update(readFileSync40(filePath)).digest("hex").slice(0, ICON_HASH_LENGTH);
+      const hash = createHash9("sha256").update(readFileSync41(filePath)).digest("hex").slice(0, ICON_HASH_LENGTH);
       versioned = href.includes("?") ? `${href}&v=${hash}` : `${href}?v=${hash}`;
     }
     cache.set(href, versioned);
@@ -31569,7 +31578,7 @@ var MS_PER_SECOND2 = 1000, DEFAULT_PORT2 = 3000, MAX_STATIC_ROUTE_COUNT, STATIC_
     return result;
   }
   stepStartedAt = performance.now();
-  const manifest = JSON.parse(readFileSync40(`${buildDir}/manifest.json`, "utf-8"));
+  const manifest = JSON.parse(readFileSync41(`${buildDir}/manifest.json`, "utf-8"));
   setCurrentIslandManifest(manifest);
   if (config.islands?.registry) {
     setCurrentIslandRegistry(await loadIslandRegistry(config.islands.registry));
@@ -31579,12 +31588,12 @@ var MS_PER_SECOND2 = 1000, DEFAULT_PORT2 = 3000, MAX_STATIC_ROUTE_COUNT, STATIC_
   stepStartedAt = performance.now();
   const conventionsPath = join61(buildDir, "conventions.json");
   if (existsSync45(conventionsPath)) {
-    const conventions = JSON.parse(readFileSync40(conventionsPath, "utf-8"));
+    const conventions = JSON.parse(readFileSync41(conventionsPath, "utf-8"));
     setConventions(conventions);
   }
   const spaRoutesPath = join61(buildDir, "spa-routes.json");
   if (existsSync45(spaRoutesPath)) {
-    setSpaRouteManifest(JSON.parse(readFileSync40(spaRoutesPath, "utf-8")));
+    setSpaRouteManifest(JSON.parse(readFileSync41(spaRoutesPath, "utf-8")));
   }
   recordStep("load production conventions", stepStartedAt);
   stepStartedAt = performance.now();
@@ -31755,8 +31764,8 @@ __export(exports_moduleServer, {
   warmPage: () => warmPage,
   warnIfReactFastRefreshUnsupported: () => warnIfReactFastRefreshUnsupported
 });
-import { existsSync as existsSync46, readFileSync as readFileSync41, realpathSync as realpathSync6, statSync as statSync9 } from "fs";
-import { basename as basename20, dirname as dirname35, extname as extname16, join as join62, resolve as resolve53, relative as relative24 } from "path";
+import { existsSync as existsSync46, readFileSync as readFileSync42, realpathSync as realpathSync7, statSync as statSync9 } from "fs";
+import { basename as basename20, dirname as dirname36, extname as extname16, join as join62, resolve as resolve54, relative as relative24 } 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 = [];
@@ -31776,10 +31785,10 @@ var SRC_PREFIX = "/@src/", BROWSER_DEFINE, jsTranspiler2, legacyDecoratorTsconfi
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const directHit = extensions.find((ext) => existsSync46(resolve53(projectRoot, srcPath + ext)));
+  const directHit = extensions.find((ext) => existsSync46(resolve54(projectRoot, srcPath + ext)));
   if (directHit)
     return srcPath + directHit;
-  const indexHit = extensions.find((ext) => existsSync46(resolve53(projectRoot, srcPath, `index${ext}`)));
+  const indexHit = extensions.find((ext) => existsSync46(resolve54(projectRoot, srcPath, `index${ext}`)));
   if (indexHit)
     return `${srcPath}/index${indexHit}`;
   return srcPath;
@@ -31808,7 +31817,7 @@ ${stubs}
   return invalidationVersion > 0 ? `${mtime}.${invalidationVersion}` : `${mtime}`;
 }, srcUrl = (relPath, projectRoot) => {
   const base = `${SRC_PREFIX}${encodeSrcPath(relPath)}`;
-  const absPath = resolve53(projectRoot, relPath);
+  const absPath = resolve54(projectRoot, relPath);
   const cached = mtimeCache.get(absPath);
   if (cached !== undefined)
     return `${base}?v=${buildVersion(cached, absPath)}`;
@@ -31820,12 +31829,12 @@ ${stubs}
     return base;
   }
 }, resolveRelativeImport = (relPath, fileDir, projectRoot, extensions) => {
-  const absPath = resolve53(fileDir, relPath);
+  const absPath = resolve54(fileDir, relPath);
   const rel = relative24(projectRoot, absPath);
   const extension = extname16(rel);
   let srcPath = RESOLVED_MODULE_EXTENSIONS.has(extension) ? rel : resolveRelativeExtension(rel, projectRoot, extensions);
   if (extname16(srcPath) === ".svelte") {
-    srcPath = relative24(projectRoot, resolveSvelteModulePath(resolve53(projectRoot, srcPath)));
+    srcPath = relative24(projectRoot, resolveSvelteModulePath(resolve54(projectRoot, srcPath)));
   }
   return srcUrl(srcPath, projectRoot);
 }, NODE_BUILTIN_RE, resolveAbsoluteSpecifier = (specifier, projectRoot) => {
@@ -31844,13 +31853,13 @@ ${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 = resolve53(projectRoot, "node_modules", packageName ?? "");
+        const pkgDir = resolve54(projectRoot, "node_modules", packageName ?? "");
         const pkgJsonPath = join62(pkgDir, "package.json");
         if (existsSync46(pkgJsonPath)) {
-          const pkg = JSON.parse(readFileSync41(pkgJsonPath, "utf-8"));
+          const pkg = JSON.parse(readFileSync42(pkgJsonPath, "utf-8"));
           const esmEntry = typeof pkg.module === "string" && pkg.module || typeof pkg.browser === "string" && pkg.browser;
           if (esmEntry) {
-            const resolved = resolve53(pkgDir, esmEntry);
+            const resolved = resolve54(pkgDir, esmEntry);
             if (existsSync46(resolved))
               return relative24(projectRoot, resolved);
           }
@@ -31890,7 +31899,7 @@ ${stubs}
   };
   result = result.replace(/^((?:import\s+[^"'`;]+?\s+from|export\s+[^"'`;]+?\s+from|import)\s*["'])([^"'./][^"']*)(["'])/gm, stubReplace);
   result = result.replace(/(import\s*\(\s*["'])([^"'./][^"']*)(["']\s*\))/g, stubReplace);
-  const fileDir = dirname35(filePath);
+  const fileDir = dirname36(filePath);
   result = result.replace(/(from\s*["'])(\.\.?\/[^"']+)(["'])/g, (_match, prefix, relPath, suffix) => isRealImport(relPath) ? `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, IMPORT_EXTENSIONS)}${suffix}` : _match);
   result = result.replace(/(import\s*\(\s*["'])(\.\.?\/[^"']+)(["']\s*\))/g, (_match, prefix, relPath, suffix) => isRealImport(relPath) ? `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, IMPORT_EXTENSIONS)}${suffix}` : _match);
   result = result.replace(/(import\s*["'])(\.\.?\/[^"']+)(["']\s*;?)/g, (_match, prefix, relPath, suffix) => isRealImport(relPath) ? `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, SIDE_EFFECT_EXTENSIONS)}${suffix}` : _match);
@@ -31907,12 +31916,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 = resolve53(fileDir, relPath);
+    const absPath = resolve54(fileDir, relPath);
     const rel = relative24(projectRoot, absPath);
     return `new URL('${srcUrl(rel, projectRoot)}', import.meta.url)`;
   });
   result = result.replace(/import\.meta\.resolve\(\s*["'](\.\.?\/[^"']+)["']\s*\)/g, (_match, relPath) => {
-    const absPath = resolve53(fileDir, relPath);
+    const absPath = resolve54(fileDir, relPath);
     const rel = relative24(projectRoot, absPath);
     return `'${srcUrl(rel, projectRoot)}'`;
   });
@@ -31958,7 +31967,7 @@ ${code}`;
   reactFastRefreshWarningEmitted = true;
   logWarn("React edits remount the page instead of keeping component state: " + "this Bun ignores `reactFastRefresh` on Bun.Transpiler " + "(https://github.com/oven-sh/bun/issues/32919). Run " + "`absolute bun-patch install` to use AbsoluteJS's patched Bun, " + "which has the fix; `absolute dev` then uses it automatically.");
 }, transformReactFile = (filePath, projectRoot, rewriter) => {
-  const raw = readFileSync41(filePath, "utf-8");
+  const raw = readFileSync42(filePath, "utf-8");
   const valueExports = tsxTranspiler.scan(raw).exports;
   let transpiled = reactTranspiler.transformSync(raw);
   transpiled = preserveTypeExports(raw, transpiled, valueExports);
@@ -31974,7 +31983,7 @@ ${transpiled}`;
   transpiled += buildIslandMetadataExports(raw);
   return rewriteImports(transpiled, filePath, projectRoot, rewriter);
 }, transformPlainFile = (filePath, projectRoot, rewriter, vueDir) => {
-  const raw = readFileSync41(filePath, "utf-8");
+  const raw = readFileSync42(filePath, "utf-8");
   const ext = extname16(filePath);
   const isTS = ext === ".ts" || ext === ".tsx";
   const isTSX = ext === ".tsx" || ext === ".jsx";
@@ -32140,7 +32149,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 = readFileSync41(filePath, "utf-8");
+  const raw = readFileSync42(filePath, "utf-8");
   if (!svelteCompiler) {
     svelteCompiler = await import("svelte/compiler");
   }
@@ -32189,7 +32198,7 @@ export default __script__;`;
     filename: filePath,
     id: `data-v-${componentId}`,
     scoped: Boolean(style.scoped),
-    source: style.lang ? await compileStyleSource(filePath, style.content, style.lang, stylePreprocessors) : style.content,
+    source: inlineCssImports(style.lang ? await compileStyleSource(filePath, style.content, style.lang, stylePreprocessors) : style.content, filePath),
     trim: true
   }).code))).join(`
 `);
@@ -32206,7 +32215,7 @@ export default __script__;`;
   return `${cssInjection}
 ${code}`;
 }, transformVueFile = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
-  const rawSource = readFileSync41(filePath, "utf-8");
+  const rawSource = readFileSync42(filePath, "utf-8");
   const raw = addAutoRouterSetupApp(rawSource);
   if (!vueCompiler) {
     vueCompiler = await loadVueCompiler();
@@ -32218,8 +32227,8 @@ ${code}`;
   const compiledScript = hasScript ? vueCompiler.compileScript(descriptor, {
     fs: {
       fileExists: isFile,
-      realpath: realpathSync6,
-      readFile: (file) => isFile(file) ? readFileSync41(file, "utf-8") : undefined
+      realpath: realpathSync7,
+      readFile: (file) => isFile(file) ? readFileSync42(file, "utf-8") : undefined
     },
     id: componentId,
     inlineTemplate: false
@@ -32234,7 +32243,7 @@ ${code}`;
   code = injectVueHmr(code, filePath, projectRoot, vueDir);
   return rewriteImports(code, filePath, projectRoot, rewriter);
 }, injectVueHmr = (code, filePath, projectRoot, vueDir) => {
-  const hmrBase = vueDir ? resolve53(vueDir) : projectRoot;
+  const hmrBase = vueDir ? resolve54(vueDir) : projectRoot;
   const hmrId = relative24(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
   let result = code.replace(/export\s+default\s+/, "var __hmr_comp__ = ");
   result += [
@@ -32266,7 +32275,7 @@ ${code}`;
     }
   });
 }, handleCssRequest = (filePath) => {
-  const raw = readFileSync41(filePath, "utf-8");
+  const raw = readFileSync42(filePath, "utf-8");
   const escaped = raw.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return [
     `const style = document.createElement('style');`,
@@ -32395,7 +32404,7 @@ export default {};
   const escaped = virtualCss.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return jsResponse(`var s=document.createElement('style');s.textContent=\`${escaped}\`;s.dataset.svelteHmr=${JSON.stringify(cssCheckPath)};var p=document.querySelector('style[data-svelte-hmr="${cssCheckPath}"]');if(p)p.remove();document.head.appendChild(s);`);
 }, resolveSourcePath2 = (relPath, projectRoot) => {
-  const filePath = resolve53(projectRoot, decodeSrcPath(relPath));
+  const filePath = resolve54(projectRoot, decodeSrcPath(relPath));
   const ext = extname16(filePath);
   if (ext === ".svelte")
     return { ext, filePath: resolveSvelteModulePath(filePath) };
@@ -32432,14 +32441,14 @@ export default {};
           const absoluteCandidate = `/${tail.replace(/^\/+/, "")}`;
           const candidates = [
             absoluteCandidate,
-            resolve53(projectRoot, tail)
+            resolve54(projectRoot, tail)
           ];
           try {
             await Promise.resolve().then(() => init_loadConfig());
             const cfg = await loadConfig();
-            const angularDir = cfg.angularDirectory && resolve53(projectRoot, cfg.angularDirectory);
+            const angularDir = cfg.angularDirectory && resolve54(projectRoot, cfg.angularDirectory);
             if (angularDir)
-              candidates.push(resolve53(angularDir, tail));
+              candidates.push(resolve54(angularDir, tail));
           } catch {}
           for (const candidate of candidates) {
             if (await fileExists(candidate)) {
@@ -32470,7 +32479,7 @@ export default {};
   if (!TRANSPILABLE.has(ext))
     return;
   const stat = statSync9(filePath);
-  const resolvedVueDir = vueDir ? resolve53(vueDir) : undefined;
+  const resolvedVueDir = vueDir ? resolve54(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) {
@@ -32526,7 +32535,7 @@ export default {};
   const ownMessage = source && typeof source === "object" ? Reflect.get(source, "message") : undefined;
   const message = typeof ownMessage === "string" ? ownMessage : String(source);
   return { message, ...readPosition(first) };
-}, getTransformError = (filePath) => transformErrors.get(resolve53(filePath)), transformErrorResponse = (err) => {
+}, getTransformError = (filePath) => transformErrors.get(resolve54(filePath)), transformErrorResponse = (err) => {
   const errMsg = err instanceof Error ? err.message : String(err);
   return new Response(`console.error('[ModuleServer] Transform error:', ${JSON.stringify(errMsg)});`, {
     headers: { "Content-Type": "application/javascript" },
@@ -32549,16 +32558,16 @@ export default {};
     const relPath = pathname.slice(SRC_PREFIX.length);
     if (relPath === "bun:wrap" || relPath.startsWith("bun:wrap?"))
       return handleBunWrapRequest();
-    const virtualCssResponse = handleVirtualSvelteCss(resolve53(projectRoot, decodeSrcPath(relPath)));
+    const virtualCssResponse = handleVirtualSvelteCss(resolve54(projectRoot, decodeSrcPath(relPath)));
     if (virtualCssResponse)
       return virtualCssResponse;
     const { filePath, ext } = resolveSourcePath2(relPath, projectRoot);
     try {
       const response = await transformAndCache(filePath, ext, projectRoot, rewriter, frameworkDirs?.vue, stylePreprocessors);
-      transformErrors.delete(resolve53(filePath));
+      transformErrors.delete(resolve54(filePath));
       return response;
     } catch (err) {
-      transformErrors.set(resolve53(filePath), describeTransformError(err));
+      transformErrors.set(resolve54(filePath), describeTransformError(err));
       return transformErrorResponse(err);
     }
   };
@@ -32568,11 +32577,11 @@ export default {};
   SRC_IMPORT_RE.lastIndex = 0;
   while ((match = SRC_IMPORT_RE.exec(content)) !== null) {
     if (match[1])
-      files.push(resolve53(projectRoot, decodeSrcPath(match[1])));
+      files.push(resolve54(projectRoot, decodeSrcPath(match[1])));
   }
   return files;
 }, SRC_URL_PREFIX2, invalidateModule = (filePath) => {
-  const resolved = resolve53(filePath);
+  const resolved = resolve54(filePath);
   transformErrors.delete(resolved);
   invalidate(filePath);
   if (resolved !== filePath)
@@ -32638,7 +32647,7 @@ export default {};
     return false;
   }
   await Promise.resolve().then(() => init_prepare());
-  patchManifestIndexes(cached.manifest, resolve53(state.resolvedPaths.buildDir, "_src_indexes"), SRC_PREFIX);
+  patchManifestIndexes(cached.manifest, resolve54(state.resolvedPaths.buildDir, "_src_indexes"), SRC_PREFIX);
   logPageBuild(entry.source, entry.framework, Math.round(durationMs));
   logStartupTimingBlock("AbsoluteJS on-demand page build", [
     { durationMs, label: entry.name }
@@ -32661,6 +32670,7 @@ export default {};
 };
 var init_moduleServer = __esm(() => {
   init_constants();
+  init_inlineCssImports();
   init_resolvePackageImport();
   init_vueAutoRouterTransform();
   init_sourceMetadata();
@@ -32897,11 +32907,11 @@ var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { resolve as resolve54 } from "path";
+import { resolve as resolve55 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve54(htmlFilePath);
+    const resolvedPath = resolve55(htmlFilePath);
     const file = Bun.file(resolvedPath);
     if (!await file.exists()) {
       return null;
@@ -32927,11 +32937,11 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { resolve as resolve55 } from "path";
+import { resolve as resolve56 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve55(htmxFilePath);
+    const resolvedPath = resolve56(htmxFilePath);
     const file = Bun.file(resolvedPath);
     if (!await file.exists()) {
       return null;
@@ -32953,8 +32963,8 @@ var handleHTMXUpdate = async (htmxFilePath) => {
 var init_simpleHTMXHMR = () => {};
 
 // src/dev/backendGraph.ts
-import { readFileSync as readFileSync42, realpathSync as realpathSync7, statSync as statSync10 } from "fs";
-import { dirname as dirname36, extname as extname17, resolve as resolve56 } from "path";
+import { readFileSync as readFileSync43, realpathSync as realpathSync8, statSync as statSync10 } from "fs";
+import { dirname as dirname37, extname as extname17, resolve as resolve57 } from "path";
 var SOURCE_FILE, VENDORED, LOADERS, fileCache, transpilers, transpilerFor = (path) => {
   const loader = LOADERS[extname17(path)] ?? "ts";
   const existing = transpilers.get(loader);
@@ -32965,13 +32975,13 @@ var SOURCE_FILE, VENDORED, LOADERS, fileCache, transpilers, transpilerFor = (pat
   return created;
 }, realPath2 = (path) => {
   try {
-    return realpathSync7(path);
+    return realpathSync8(path);
   } catch {
     return path;
   }
-}, isProjectModule = (path, root = process.cwd()) => SOURCE_FILE.test(path) && !VENDORED.test(path) && resolve56(path).startsWith(resolve56(root)), resolveImport = (specifier, fromFile) => {
+}, isProjectModule = (path, root = process.cwd()) => SOURCE_FILE.test(path) && !VENDORED.test(path) && resolve57(path).startsWith(resolve57(root)), resolveImport = (specifier, fromFile) => {
   try {
-    return realPath2(Bun.resolveSync(specifier, dirname36(fromFile)));
+    return realPath2(Bun.resolveSync(specifier, dirname37(fromFile)));
   } catch {
     return;
   }
@@ -32988,20 +32998,20 @@ var SOURCE_FILE, VENDORED, LOADERS, fileCache, transpilers, transpilerFor = (pat
     return cached.imports;
   let imports = [];
   try {
-    const source = readFileSync42(path, "utf-8");
+    const source = readFileSync43(path, "utf-8");
     imports = transpilerFor(path).scanImports(source).map((entry) => resolveImport(entry.path, path)).filter((target) => target !== undefined);
   } catch {}
   fileCache.set(path, { imports, mtimeMs });
   return imports;
 }, importersOf = (target, entry, loaded = loadedProjectModules(entry)) => {
-  const goal = realPath2(resolve56(target));
+  const goal = realPath2(resolve57(target));
   const importers = [];
   for (const file of loaded)
     if (readImports(file).includes(goal))
       importers.push(file);
   return importers;
 }, loadedProjectModules = (entry, loaded = Object.keys(__require.cache), root = process.cwd()) => {
-  const entryPath = realPath2(resolve56(entry));
+  const entryPath = realPath2(resolve57(entry));
   const modules = new Set([entryPath]);
   for (const path of loaded) {
     if (isAbsoluteServerEntryCopyPath(path))
@@ -33030,7 +33040,7 @@ var init_backendGraph = __esm(() => {
 });
 
 // src/dev/hot/analyze.ts
-import { dirname as dirname37, extname as extname18 } from "path";
+import { dirname as dirname38, extname as extname18 } from "path";
 var ANALYZER_VERSION = 1, hashText = (text) => Bun.hash(text).toString(36), scriptKindFor = (tsc, path) => {
   switch (extname18(path)) {
     case ".tsx":
@@ -33712,7 +33722,7 @@ var ANALYZER_VERSION = 1, hashText = (text) => Bun.hash(text).toString(36), scri
   return analysis;
 }, resolveFrom = (fromFile, isManaged) => (specifier) => {
   try {
-    const resolved = Bun.resolveSync(specifier, dirname37(fromFile));
+    const resolved = Bun.resolveSync(specifier, dirname38(fromFile));
     return isManaged(resolved) ? resolved : undefined;
   } catch {
     return;
@@ -33786,11 +33796,11 @@ var init_runtime = __esm(() => {
 });
 
 // src/dev/hot/plugin.ts
-import { mkdirSync as mkdirSync16, readFileSync as readFileSync43, realpathSync as realpathSync8, writeFileSync as writeFileSync11 } from "fs";
-import { extname as extname19, join as join63, relative as relative25, resolve as resolve57, sep as sep8 } from "path";
+import { mkdirSync as mkdirSync16, readFileSync as readFileSync44, realpathSync as realpathSync9, writeFileSync as writeFileSync11 } from "fs";
+import { extname as extname19, join as join63, relative as relative25, resolve as resolve58, sep as sep8 } from "path";
 var SOURCE, TEST_FILE, GENERATED, ABSOLUTE_ROOT, realPath3 = (path) => {
   try {
-    return realpathSync8(path);
+    return realpathSync9(path);
   } catch {
     return path;
   }
@@ -33832,7 +33842,7 @@ var SOURCE, TEST_FILE, GENERATED, ABSOLUTE_ROOT, realPath3 = (path) => {
   if (!state)
     return;
   try {
-    const cached = JSON.parse(readFileSync43(cachePath(state.cacheDir, key), "utf-8"));
+    const cached = JSON.parse(readFileSync44(cachePath(state.cacheDir, key), "utf-8"));
     return isAnalysis(cached) ? cached : undefined;
   } catch {
     return;
@@ -33866,7 +33876,7 @@ var init_plugin = __esm(() => {
   SOURCE = /\.(?:[cm]?[jt]sx?)$/;
   TEST_FILE = /(?:\.(?:spec|test)\.[cm]?[jt]sx?$)|(?:[\\/]__tests__[\\/])/;
   GENERATED = /(?:^|[\\/])(?:build|generated|compiled|indexes|\.absolutejs|node_modules|dist)(?:[\\/]|$)/;
-  ABSOLUTE_ROOT = resolve57(import.meta.dir, "..", "..", "..");
+  ABSOLUTE_ROOT = resolve58(import.meta.dir, "..", "..", "..");
   shared = globalThis.__absoluteHotPlugin ??= {
     analyses: new Map,
     installed: undefined
@@ -33875,11 +33885,11 @@ var init_plugin = __esm(() => {
 });
 
 // src/dev/hot/reload.ts
-import { readFileSync as readFileSync44, realpathSync as realpathSync9 } from "fs";
+import { readFileSync as readFileSync45, realpathSync as realpathSync10 } from "fs";
 import { relative as relative26 } from "path";
 var MAX_PROPAGATION_STEPS = 500, realPath4 = (path) => {
   try {
-    return realpathSync9(path);
+    return realpathSync10(path);
   } catch {
     return path;
   }
@@ -33953,7 +33963,7 @@ var MAX_PROPAGATION_STEPS = 500, realPath4 = (path) => {
     return { status: "entry" };
   if (!moduleRecord(path) || !isHotManaged(path))
     return { status: "unmanaged" };
-  const source = readFileSync44(path, "utf-8");
+  const source = readFileSync45(path, "utf-8");
   if (moduleRecord(path)?.source === source)
     return { status: "unchanged" };
   const analysis = await analyzeSource(path, source);
@@ -34045,7 +34055,7 @@ var init_reload = __esm(() => {
 import { existsSync as existsSync47, readdirSync as readdirSync13, rmSync as rmSync4, statSync as statSync11 } from "fs";
 import {
   basename as basename21,
-  dirname as dirname38,
+  dirname as dirname39,
   isAbsolute as isAbsolute10,
   join as join64,
   relative as relative27,
@@ -34414,7 +34424,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
       const { buildDir } = state.resolvedPaths;
       const destPath = resolvePath4(buildDir, urlPrefix ? `${urlPrefix}/${relFromDir}` : relFromDir);
       const { mkdir, copyFile, readFile } = await import("fs/promises");
-      await mkdir(dirname38(destPath), { recursive: true });
+      await mkdir(dirname39(destPath), { recursive: true });
       await copyFile(absSource, destPath);
       const bytes = await readFile(destPath);
       const webPath = urlPrefix ? `/${urlPrefix}/${relFromDir}` : `/${relFromDir}`;
@@ -34610,7 +34620,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   const keepStemsByDir = new Map;
   const prefixByDir = new Map;
   for (const artifact of freshOutputs) {
-    const dir = dirname38(artifact.path);
+    const dir = dirname39(artifact.path);
     const name = basename21(artifact.path);
     const [prefix] = name.split(".");
     if (!prefix)
@@ -36012,7 +36022,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   if (!buildReference?.source) {
     return;
   }
-  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolvePath4(dirname38(buildInfo.resolvedRegistryPath), buildReference.source);
+  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolvePath4(dirname39(buildInfo.resolvedRegistryPath), buildReference.source);
   islandFiles.add(resolvePath4(sourcePath));
 }, resolveIslandSourceFiles = async (config) => {
   const registryPath = config.islands?.registry;
@@ -37188,10 +37198,10 @@ import {
   existsSync as existsSync48,
   mkdirSync as mkdirSync18,
   readdirSync as readdirSync14,
-  readFileSync as readFileSync45
+  readFileSync as readFileSync46
 } from "fs";
 import { mkdir as mkdir16, readFile as readFile12, rename as rename7, rm as rm16, writeFile as writeFile14 } from "fs/promises";
-import { basename as basename22, join as join66, resolve as resolve58 } from "path";
+import { basename as basename22, join as join66, resolve as resolve59 } from "path";
 var CACHE_ROOT2, CACHE_FORMAT_VERSION3 = 1, KEY_LENGTH = 32, LOCKFILES, computeVendorCacheKey = (inputs) => {
   const hash = createHash11("sha256");
   hash.update(String(CACHE_FORMAT_VERSION3));
@@ -37211,7 +37221,7 @@ var CACHE_ROOT2, CACHE_FORMAT_VERSION3 = 1, KEY_LENGTH = 32, LOCKFILES, computeV
   }
   for (const dir of inputs.vendorDirs) {
     hash.update("\x00v");
-    hash.update(basename22(resolve58(dir, "..")));
+    hash.update(basename22(resolve59(dir, "..")));
   }
   return hash.digest("hex").slice(0, KEY_LENGTH);
 }, readLockfileHash = (projectRoot = process.cwd()) => {
@@ -37223,7 +37233,7 @@ var CACHE_ROOT2, CACHE_FORMAT_VERSION3 = 1, KEY_LENGTH = 32, LOCKFILES, computeV
       continue;
     found = true;
     hash.update(name);
-    hash.update(readFileSync45(path));
+    hash.update(readFileSync46(path));
   }
   return found ? hash.digest("hex") : null;
 }, vendorCacheEnabled = () => process.env.ABSOLUTE_DEV_VENDOR_CACHE !== "0", copyTree = (fromDir, toDir) => {
@@ -37250,7 +37260,7 @@ var CACHE_ROOT2, CACHE_FORMAT_VERSION3 = 1, KEY_LENGTH = 32, LOCKFILES, computeV
       continue;
     copyTree(dir, join66(stagingDir, slotName(index, dir)));
   }
-}, isVendorCachePayload = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "depPaths") === "object", cacheDirFor = (key, projectRoot) => resolve58(projectRoot, CACHE_ROOT2, key), slotName = (index, dir) => `${index}-${basename22(resolve58(dir, ".."))}`, restoreVendorCache = async (key, vendorDirs, projectRoot = process.cwd()) => {
+}, isVendorCachePayload = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "depPaths") === "object", cacheDirFor = (key, projectRoot) => resolve59(projectRoot, CACHE_ROOT2, key), slotName = (index, dir) => `${index}-${basename22(resolve59(dir, ".."))}`, restoreVendorCache = async (key, vendorDirs, projectRoot = process.cwd()) => {
   const cacheDir = cacheDirFor(key, projectRoot);
   const payloadPath = join66(cacheDir, "payload.json");
   if (!existsSync48(payloadPath))
@@ -37296,7 +37306,7 @@ var init_vendorCache = __esm(() => {
 // src/core/devBuild.ts
 import { readdir as readdir7 } from "fs/promises";
 import { existsSync as existsSync49, statSync as statSync12 } from "fs";
-import { resolve as resolve59 } from "path";
+import { resolve as resolve60 } from "path";
 var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir, collectDepVendorSourceDirs = (config) => {
   const configuredDirs = [
     ...collectConfigVendorSourceDirs(config),
@@ -37320,7 +37330,7 @@ var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir, collectDepVendorSourceDirs = (
   return Object.keys(config).length > 0 ? config : null;
 }, reloadConfig = async () => {
   try {
-    const configPath = resolve59(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+    const configPath = resolve60(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
     const source = await Bun.file(configPath).text();
     return parseDirectoryConfig(source);
   } catch {
@@ -37435,7 +37445,7 @@ var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir, collectDepVendorSourceDirs = (
     });
   }
 }, handleCachedReload = async () => {
-  const serverMtime = statSync12(resolve59(Bun.main)).mtimeMs;
+  const serverMtime = statSync12(resolve60(Bun.main)).mtimeMs;
   const lastMtime = globalThis.__hmrServerMtime;
   globalThis.__hmrServerMtime = serverMtime;
   const cached = globalThis.__hmrDevResult;
@@ -37476,8 +37486,8 @@ var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir, collectDepVendorSourceDirs = (
   return true;
 }, resolveAbsoluteVersion2 = async () => {
   const candidates = [
-    resolve59(import.meta.dir, "..", "..", "package.json"),
-    resolve59(import.meta.dir, "..", "package.json")
+    resolve60(import.meta.dir, "..", "..", "package.json"),
+    resolve60(import.meta.dir, "..", "package.json")
   ];
   const [candidate, ...remaining] = candidates;
   if (!candidate) {
@@ -37503,7 +37513,7 @@ var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir, collectDepVendorSourceDirs = (
   const entries = await readdir7(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(resolve59(vendorDir, entry)).bytes();
+    const bytes = await Bun.file(resolve60(vendorDir, entry)).bytes();
     assetStore.set(webPath, bytes);
   }));
 }, devBuild = async (config) => {
@@ -37689,11 +37699,11 @@ var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir, collectDepVendorSourceDirs = (
   }
   stepStartedAt = performance.now();
   setBootPhase("build vendor bundles");
-  const reactVendorDir = resolve59(state.resolvedPaths.buildDir, "react", "vendor");
-  const angularVendorDir = resolve59(state.resolvedPaths.buildDir, "angular", "vendor");
-  const svelteVendorDir = resolve59(state.resolvedPaths.buildDir, "svelte", "vendor");
-  const vueVendorDir = resolve59(state.resolvedPaths.buildDir, "vue", "vendor");
-  const depVendorDir = resolve59(state.resolvedPaths.buildDir, "vendor");
+  const reactVendorDir = resolve60(state.resolvedPaths.buildDir, "react", "vendor");
+  const angularVendorDir = resolve60(state.resolvedPaths.buildDir, "angular", "vendor");
+  const svelteVendorDir = resolve60(state.resolvedPaths.buildDir, "svelte", "vendor");
+  const vueVendorDir = resolve60(state.resolvedPaths.buildDir, "vue", "vendor");
+  const depVendorDir = resolve60(state.resolvedPaths.buildDir, "vendor");
   await Promise.resolve().then(() => init_buildDepVendor());
   const activeVendorDirs = [
     config.reactDirectory ? reactVendorDir : null,
@@ -37810,7 +37820,7 @@ var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir, collectDepVendorSourceDirs = (
     manifest
   };
   globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync12(resolve59(Bun.main)).mtimeMs;
+  globalThis.__hmrServerMtime = statSync12(resolve60(Bun.main)).mtimeMs;
   return result;
 };
 var init_devBuild = __esm(() => {
@@ -37853,5 +37863,5 @@ export {
   devBuild
 };
 
-//# debugId=0F7A4A3B094DC6C964756E2164756E21
+//# debugId=AA60B6F5F10DA90864756E2164756E21
 //# sourceMappingURL=build.js.map