@absolutejs/absolute 0.19.0-beta.772 → 0.19.0-beta.774

package/dist/index.js

@@ -5422,6 +5422,7 @@ __export(exports_tailwindCompiler, {
   disposeTailwindCompiler: () => disposeTailwindCompiler
 });
 import { createHash } from "crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { readFile as readFile2, stat } from "fs/promises";
 import { dirname as dirname2, isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
 var compilerCache, cachedTailwindCompile = null, loadTailwindCompile = async () => {
@@ -5441,8 +5442,42 @@ var compilerCache, cachedTailwindCompile = null, loadTailwindCompile = async ()
   } catch {
     deps.set(path, 0);
   }
+}, resolveBareCssImport = (id, base) => {
+  const slashIndex = id.indexOf("/");
+  const pkgName = id.startsWith("@") ? id.split("/").slice(0, 2).join("/") : slashIndex === -1 ? id : id.slice(0, slashIndex);
+  const subpath = id.slice(pkgName.length);
+  if (subpath !== "") {
+    return Bun.resolveSync(id, base);
+  }
+  let pkgJsonPath;
+  try {
+    pkgJsonPath = Bun.resolveSync(`${pkgName}/package.json`, base);
+  } catch {
+    return Bun.resolveSync(id, base);
+  }
+  const pkgDir = dirname2(pkgJsonPath);
+  let pkg = {};
+  try {
+    pkg = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
+  } catch {
+    return Bun.resolveSync(id, base);
+  }
+  const exportsField = pkg.exports;
+  const styleFromExports = exportsField?.["."]?.style;
+  const candidates = [
+    styleFromExports,
+    typeof pkg.style === "string" ? pkg.style : undefined,
+    "index.css",
+    "dist/index.css"
+  ].filter((entry) => typeof entry === "string");
+  for (const candidate of candidates) {
+    const candidatePath = resolve2(pkgDir, candidate);
+    if (existsSync2(candidatePath))
+      return candidatePath;
+  }
+  return Bun.resolveSync(id, base);
 }, createLoadStylesheet = (deps) => async (id, base) => {
-  const path = id.startsWith(".") || isAbsolute2(id) ? resolve2(base, id) : Bun.resolveSync(id, base);
+  const path = id.startsWith(".") || isAbsolute2(id) ? resolve2(base, id) : resolveBareCssImport(id, base);
   const content = await readFile2(path, "utf-8");
   await recordDependency(deps, path);
   return { base: dirname2(path), content, path };
@@ -6367,24 +6402,38 @@ var init_streamingSlots = __esm(() => {
 });
 
 // src/angular/resolveAngularPackage.ts
-import { existsSync as existsSync2 } from "fs";
-import { resolve as resolve3 } from "path";
-var resolveAngularPackage = (specifier) => {
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3, resolve as resolve3 } from "path";
+var resolveAngularPackageDir = (specifier) => {
   const fromCompiledRuntime = process.env.ABSOLUTE_BUILD_DIR ? resolve3(process.env.ABSOLUTE_BUILD_DIR, "node_modules", specifier) : null;
-  if (fromCompiledRuntime && existsSync2(fromCompiledRuntime)) {
+  if (fromCompiledRuntime && existsSync3(fromCompiledRuntime)) {
     return fromCompiledRuntime;
   }
   const fromProject = resolve3(process.cwd(), "node_modules", specifier);
-  if (existsSync2(fromProject)) {
+  if (existsSync3(fromProject)) {
     return fromProject;
   }
+  return null;
+}, resolvePackageEntry = (packageDir) => {
+  try {
+    const pkg = JSON.parse(readFileSync3(join3(packageDir, "package.json"), "utf-8"));
+    const rootExport = pkg.exports?.["."];
+    const entry = (typeof rootExport === "string" ? rootExport : rootExport?.default) ?? pkg.module ?? pkg.main ?? "index.js";
+    return join3(packageDir, entry);
+  } catch {
+    return packageDir;
+  }
+}, resolveAngularPackage = (specifier) => {
+  const packageDir = resolveAngularPackageDir(specifier);
+  if (packageDir)
+    return resolvePackageEntry(packageDir);
   return specifier;
 };
 var init_resolveAngularPackage = () => {};
 
 // src/angular/injectorPatch.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { dirname as dirname4, join as join3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { dirname as dirname4, join as join4 } from "path";
 var applyInjectorPatch = (chunkPath, content) => {
   if (content.includes('Symbol.for("angular.currentInjector")')) {
     return;
@@ -6420,16 +6469,16 @@ var applyInjectorPatch = (chunkPath, content) => {
   }
   writeFileSync(chunkPath, patched, "utf-8");
 }, resolveAngularCoreDir = () => {
-  const resolved = resolveAngularPackage("@angular/core");
-  if (existsSync3(join3(resolved, "package.json"))) {
+  const resolved = resolveAngularPackageDir("@angular/core");
+  if (resolved && existsSync4(join4(resolved, "package.json"))) {
     return resolved;
   }
   return dirname4(__require.resolve("@angular/core/package.json"));
 }, patchAngularInjectorSingleton = () => {
   try {
     const coreDir = resolveAngularCoreDir();
-    const chunkPath = join3(coreDir, "fesm2022", "_not_found-chunk.mjs");
-    const content = readFileSync2(chunkPath, "utf-8");
+    const chunkPath = join4(coreDir, "fesm2022", "_not_found-chunk.mjs");
+    const content = readFileSync4(chunkPath, "utf-8");
     applyInjectorPatch(chunkPath, content);
   } catch {}
 };
@@ -7049,8 +7098,8 @@ var init_islandSsr = __esm(() => {
 });
 
 // src/build/resolvePackageImport.ts
-import { resolve as resolve4, join as join4 } from "path";
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve4, join as join5 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 var resolveExportPath = (entry, conditions) => {
   if (typeof entry === "string")
     return entry;
@@ -7072,14 +7121,14 @@ var resolveExportPath = (entry, conditions) => {
   const subpath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
   const exportKey = subpath ? `./${subpath}` : ".";
   const currentPackageJsonPath = resolve4(process.cwd(), "package.json");
-  const currentPackageJson = existsSync4(currentPackageJsonPath) ? JSON.parse(readFileSync3(currentPackageJsonPath, "utf-8")) : null;
+  const currentPackageJson = existsSync5(currentPackageJsonPath) ? JSON.parse(readFileSync5(currentPackageJsonPath, "utf-8")) : null;
   const currentPackageDir = currentPackageJson?.name === packageName ? process.cwd() : null;
   const packageDir = currentPackageDir ?? resolve4(process.cwd(), "node_modules", packageName ?? "");
-  const packageJsonPath = join4(packageDir, "package.json");
-  if (!existsSync4(packageJsonPath))
+  const packageJsonPath = join5(packageDir, "package.json");
+  if (!existsSync5(packageJsonPath))
     return null;
   try {
-    const packageJson = currentPackageDir && currentPackageJson ? currentPackageJson : JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+    const packageJson = currentPackageDir && currentPackageJson ? currentPackageJson : JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
     const { exports } = packageJson;
     if (!exports)
       return null;
@@ -7091,12 +7140,12 @@ var resolveExportPath = (entry, conditions) => {
       return null;
     if (currentPackageDir && importPath.startsWith("./dist/")) {
       const sourceCandidate = resolve4(packageDir, importPath.replace(/^\.\/dist\//, "./src/"));
-      if (existsSync4(sourceCandidate)) {
+      if (existsSync5(sourceCandidate)) {
         return sourceCandidate;
       }
     }
     const resolved = resolve4(packageDir, importPath);
-    return existsSync4(resolved) ? resolved : null;
+    return existsSync5(resolved) ? resolved : null;
   } catch {
     return null;
   }
@@ -7229,13 +7278,13 @@ var init_lowerAwaitSlotSyntax = __esm(() => {
 
 // src/core/svelteServerModule.ts
 import { mkdir as mkdir2, readdir } from "fs/promises";
-import { basename, dirname as dirname5, extname as extname2, join as join5, relative as relative2, resolve as resolve5 } from "path";
+import { basename, dirname as dirname5, extname as extname2, join as join6, relative as relative2, resolve as resolve5 } from "path";
 var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
   const importPath = relative2(dirname5(from), target).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
 }, processDirectoryEntries = (entries, dir, targetFileName, stack) => {
   for (const entry of entries) {
-    const entryPath = join5(dir, entry.name);
+    const entryPath = join6(dir, entry.name);
     if (entry.isDirectory())
       stack.push(entryPath);
     if (entry.isFile() && entry.name === targetFileName) {
@@ -7265,11 +7314,11 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (cachedPath !== undefined) {
     return cachedPath;
   }
-  if (!sourcePath.includes(`${join5(process.cwd(), "build")}${process.platform === "win32" ? "" : "/"}`) && !sourcePath.includes("/build/")) {
+  if (!sourcePath.includes(`${join6(process.cwd(), "build")}${process.platform === "win32" ? "" : "/"}`) && !sourcePath.includes("/build/")) {
     originalSourcePathCache.set(sourcePath, sourcePath);
     return sourcePath;
   }
-  const resolvedSourcePath = await findSourceFileByBasename(join5(process.cwd(), "src"), normalizeBuiltSvelteFileName(sourcePath));
+  const resolvedSourcePath = await findSourceFileByBasename(join6(process.cwd(), "src"), normalizeBuiltSvelteFileName(sourcePath));
   const nextPath = resolvedSourcePath ?? sourcePath;
   originalSourcePathCache.set(sourcePath, nextPath);
   return nextPath;
@@ -7285,11 +7334,11 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
     `${basePath}.mjs`,
     `${basePath}.cjs`,
     `${basePath}.json`,
-    join5(basePath, "index.ts"),
-    join5(basePath, "index.js"),
-    join5(basePath, "index.mjs"),
-    join5(basePath, "index.cjs"),
-    join5(basePath, "index.json")
+    join6(basePath, "index.ts"),
+    join6(basePath, "index.js"),
+    join6(basePath, "index.mjs"),
+    join6(basePath, "index.cjs"),
+    join6(basePath, "index.json")
   ];
   const existResults = await Promise.all(candidates.map((candidate) => Bun.file(candidate).exists()));
   const foundIndex = existResults.indexOf(true);
@@ -7297,7 +7346,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
 }, getCachedModulePath = (sourcePath) => {
   const relativeSourcePath = relative2(process.cwd(), sourcePath).replace(/\\/g, "/");
   const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
-  return join5(serverCacheRoot, `${normalizedSourcePath}.server.js`);
+  return join6(serverCacheRoot, `${normalizedSourcePath}.server.js`);
 }, resolveSvelteImport = async (spec, from) => {
   if (!spec.startsWith(".") && !spec.startsWith("/")) {
     const resolved = resolvePackageImport(spec);
@@ -7398,7 +7447,7 @@ var init_svelteServerModule = __esm(() => {
   init_lowerIslandSyntax();
   init_lowerAwaitSlotSyntax();
   init_stylePreprocessor();
-  serverCacheRoot = join5(process.cwd(), ".absolutejs", "islands", "svelte");
+  serverCacheRoot = join6(process.cwd(), ".absolutejs", "islands", "svelte");
   compiledModuleCache = new Map;
   originalSourcePathCache = new Map;
   transpiler = new Bun.Transpiler({
@@ -7556,7 +7605,7 @@ var init_renderIslandMarkup = __esm(() => {
 
 // src/build/islandEntries.ts
 import { mkdirSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname6, extname as extname3, join as join6, relative as relative3, resolve as resolve6 } from "path";
+import { dirname as dirname6, extname as extname3, join as join7, relative as relative3, resolve as resolve6 } from "path";
 import ts from "typescript";
 var frameworks, isRecord4 = (value) => typeof value === "object" && value !== null, resolveRegistryExport = (mod) => {
   if (isRecord4(mod.islandRegistry))
@@ -7789,11 +7838,11 @@ export default component;
   buildPath,
   clientPathMaps = {}
 }) => {
-  const generatedRoot = join6(buildPath, "_island_entries");
+  const generatedRoot = join7(buildPath, "_island_entries");
   rmSync(generatedRoot, { force: true, recursive: true });
   const entries = [];
   for (const definition of buildInfo.definitions) {
-    const entryPath = join6(generatedRoot, "islands", definition.framework, `${definition.component}.ts`);
+    const entryPath = join7(generatedRoot, "islands", definition.framework, `${definition.component}.ts`);
     const { buildReference } = definition;
     const source = buildReference ? resolveIslandSourcePath(buildInfo.resolvedRegistryPath, buildReference.source) : null;
     const compiledSourcePath = source && shouldUseCompiledClientPath(definition.framework, source) ? clientPathMaps[definition.framework]?.get(source) : undefined;
@@ -7906,7 +7955,7 @@ var init_staticStreaming = __esm(() => {
 });
 
 // src/build/staticIslandPages.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
 var ISLAND_TAG_RE_SOURCE = "<(?:absolute-island|island)\\b([^>]*?)(?:\\/\\>|>(?:[\\s\\S]*?)<\\/(?:absolute-island|island)>)", ATTRIBUTE_RE_SOURCE = `([A-Za-z_:][-A-Za-z0-9_:.]*)\\s*=\\s*(?:"([^"]*)"|'([^']*)')`, islandFrameworks, islandHydrationModes, isRecord5 = (value) => typeof value === "object" && value !== null, isIslandFramework = (value) => islandFrameworks.some((framework) => framework === value), isIslandHydrationMode = (value) => islandHydrationModes.some((mode) => mode === value), parseHtmlAttributes = (attributeString) => {
   const attributeRe = new RegExp(ATTRIBUTE_RE_SOURCE, "g");
   const attributes = new Map;
@@ -8035,7 +8084,7 @@ var ISLAND_TAG_RE_SOURCE = "<(?:absolute-island|island)\\b([^>]*?)(?:\\/\\>|>(?:
   }
   return result + originalHtml.slice(nextIndex);
 }, transformStaticPage = async (pagePath, registry) => {
-  const originalHtml = readFileSync4(pagePath, "utf-8");
+  const originalHtml = readFileSync6(pagePath, "utf-8");
   const transformedHtml = await transformStaticPageHtml(originalHtml, registry);
   if (transformedHtml !== originalHtml) {
     writeFileSync3(pagePath, transformedHtml);
@@ -8071,10 +8120,10 @@ var init_staticIslandPages = __esm(() => {
 });
 
 // src/build/scanEntryPoints.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 var {Glob } = globalThis.Bun;
 var scanEntryPoints = async (dir, pattern) => {
-  if (!existsSync5(dir))
+  if (!existsSync6(dir))
     return [];
   const entryPaths = [];
   const glob = new Glob(pattern);
@@ -8163,7 +8212,7 @@ var init_sourceMetadata = __esm(() => {
 });
 
 // src/islands/pageMetadata.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 import { dirname as dirname7, resolve as resolve9 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
@@ -8205,7 +8254,7 @@ var pagePatterns, getPageDirs = (config) => [
     return;
   const files = await scanEntryPoints(resolve9(entry.dir), pattern);
   for (const filePath of files) {
-    const source = readFileSync5(filePath, "utf-8");
+    const source = readFileSync7(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
     pageMetadata.set(resolve9(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
@@ -8568,22 +8617,22 @@ var exports_generateReactIndexes = {};
 __export(exports_generateReactIndexes, {
   generateReactIndexFiles: () => generateReactIndexFiles
 });
-import { existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2 } from "fs";
 import { readdir as readdir2, rm, writeFile } from "fs/promises";
-import { basename as basename3, join as join7, relative as relative4, resolve as resolve10, sep } from "path";
+import { basename as basename3, join as join8, relative as relative4, resolve as resolve10, sep } from "path";
 var {Glob: Glob2 } = globalThis.Bun;
 var indexContentCache, resolveDevClientDir = () => {
   const projectRoot = process.cwd();
   const fromSource = resolve10(import.meta.dir, "../dev/client");
-  if (existsSync6(fromSource) && fromSource.startsWith(projectRoot)) {
+  if (existsSync7(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
   const fromNodeModules = resolve10(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync6(fromNodeModules))
+  if (existsSync7(fromNodeModules))
     return fromNodeModules;
   return resolve10(import.meta.dir, "./dev/client");
 }, devClientDir, errorOverlayPath, hmrClientPath, refreshSetupPath, generateReactIndexFiles = async (reactPagesDirectory, reactIndexesDirectory, isDev2 = false) => {
-  if (!existsSync6(reactIndexesDirectory)) {
+  if (!existsSync7(reactIndexesDirectory)) {
     mkdirSync2(reactIndexesDirectory, { recursive: true });
   }
   const CONVENTION_RE = /^(?:(.+)\.)?(error|loading|not-found)\.[^.]+$/;
@@ -8603,8 +8652,8 @@ var indexContentCache, resolveDevClientDir = () => {
   });
   if (staleIndexes.length > 0) {
     await Promise.all(staleIndexes.map((indexFile) => {
-      indexContentCache.delete(join7(reactIndexesDirectory, indexFile));
-      return rm(join7(reactIndexesDirectory, indexFile), {
+      indexContentCache.delete(join8(reactIndexesDirectory, indexFile));
+      return rm(join8(reactIndexesDirectory, indexFile), {
         force: true
       });
     }));
@@ -8873,11 +8922,11 @@ var indexContentCache, resolveDevClientDir = () => {
       ] : []
     ].join(`
 `);
-    const indexPath = join7(reactIndexesDirectory, `${componentName}.tsx`);
+    const indexPath = join8(reactIndexesDirectory, `${componentName}.tsx`);
     const hasher = new Bun.CryptoHasher("md5");
     hasher.update(content);
     const contentHash = hasher.digest("hex");
-    if (indexContentCache.get(indexPath) === contentHash && existsSync6(indexPath)) {
+    if (indexContentCache.get(indexPath) === contentHash && existsSync7(indexPath)) {
       return;
     }
     indexContentCache.set(indexPath, contentHash);
@@ -8887,8 +8936,8 @@ var indexContentCache, resolveDevClientDir = () => {
   if (!isDev2) {
     return;
   }
-  const refreshPath = join7(reactIndexesDirectory, "_refresh.tsx");
-  if (!existsSync6(refreshPath)) {
+  const refreshPath = join8(reactIndexesDirectory, "_refresh.tsx");
+  if (!existsSync7(refreshPath)) {
     await writeFile(refreshPath, `import '${refreshSetupPath}';
 import 'react';
 import 'react-dom/client';
@@ -8898,9 +8947,9 @@ import 'react-dom/client';
 var init_generateReactIndexes = __esm(() => {
   indexContentCache = new Map;
   devClientDir = resolveDevClientDir();
-  errorOverlayPath = join7(devClientDir, "errorOverlay.ts").replace(/\\/g, "/");
-  hmrClientPath = join7(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
-  refreshSetupPath = join7(devClientDir, "reactRefreshSetup.ts").replace(/\\/g, "/");
+  errorOverlayPath = join8(devClientDir, "errorOverlay.ts").replace(/\\/g, "/");
+  hmrClientPath = join8(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
+  refreshSetupPath = join8(devClientDir, "reactRefreshSetup.ts").replace(/\\/g, "/");
 });
 
 // src/build/wrapHTMLScript.ts
@@ -8968,7 +9017,7 @@ var init_outputLogs = __esm(() => {
 // src/build/scanConventions.ts
 import { basename as basename4 } from "path";
 var {Glob: Glob3 } = globalThis.Bun;
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 var CONVENTION_RE, classifyFile = (file2, pageFiles, defaults, pages) => {
   const fileName = basename4(file2);
   const match = CONVENTION_RE.exec(fileName);
@@ -8993,7 +9042,7 @@ var CONVENTION_RE, classifyFile = (file2, pageFiles, defaults, pages) => {
   else if (kind === "loading")
     pages[pageName].loading = file2;
 }, scanConventions = async (pagesDir, pattern) => {
-  if (!existsSync7(pagesDir)) {
+  if (!existsSync8(pagesDir)) {
     const pageFiles2 = [];
     return { conventions: undefined, pageFiles: pageFiles2 };
   }
@@ -9016,10 +9065,10 @@ var init_scanConventions = __esm(() => {
 });
 
 // src/build/scanCssEntryPoints.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 var {Glob: Glob4 } = globalThis.Bun;
 var scanCssEntryPoints = async (dir, ignore) => {
-  if (!existsSync8(dir))
+  if (!existsSync9(dir))
     return [];
   const entryPaths = [];
   const glob = new Glob4("**/*.{css,scss,sass,less,styl,stylus}");
@@ -9036,8 +9085,8 @@ var init_scanCssEntryPoints = __esm(() => {
 });
 
 // src/utils/imageProcessing.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
-import { join as join8, resolve as resolve11 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
+import { join as join9, resolve as resolve11 } from "path";
 var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_ENDPOINT = "/_absolute/image", BLUR_DEVIATION = 20, sharpModule = undefined, sharpLoaded = false, sharpWarned = false, snapToSize = (target, sizes) => {
   for (const size of sizes) {
     if (size >= target)
@@ -9092,8 +9141,8 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_END
   const image2 = config?.imageSizes ?? DEFAULT_IMAGE_SIZES;
   return [...device, ...image2].sort((left, right) => left - right);
 }, getCacheDir = (buildDir) => {
-  const dir = join8(buildDir, ".cache", "images");
-  if (!existsSync9(dir))
+  const dir = join9(buildDir, ".cache", "images");
+  if (!existsSync10(dir))
     mkdirSync3(dir, { recursive: true });
   return dir;
 }, getCacheKey = (url, width, quality, format) => {
@@ -9149,13 +9198,13 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_END
       return toBuffer(buffer);
   }
 }, readFromCache = (cacheDir, cacheKey) => {
-  const metaPath = join8(cacheDir, `${cacheKey}.meta`);
-  const dataPath = join8(cacheDir, `${cacheKey}.data`);
-  if (!existsSync9(metaPath) || !existsSync9(dataPath))
+  const metaPath = join9(cacheDir, `${cacheKey}.meta`);
+  const dataPath = join9(cacheDir, `${cacheKey}.data`);
+  if (!existsSync10(metaPath) || !existsSync10(dataPath))
     return null;
   try {
-    const meta = JSON.parse(readFileSync6(metaPath, "utf-8"));
-    const buffer = readFileSync6(dataPath);
+    const meta = JSON.parse(readFileSync8(metaPath, "utf-8"));
+    const buffer = readFileSync8(dataPath);
     return { buffer, meta };
   } catch {
     return null;
@@ -9177,8 +9226,8 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_END
     return null;
   }
 }, writeToCache = (cacheDir, cacheKey, buffer, meta) => {
-  const metaPath = join8(cacheDir, `${cacheKey}.meta`);
-  const dataPath = join8(cacheDir, `${cacheKey}.data`);
+  const metaPath = join9(cacheDir, `${cacheKey}.meta`);
+  const dataPath = join9(cacheDir, `${cacheKey}.data`);
   writeFileSync4(dataPath, buffer);
   writeFileSync4(metaPath, JSON.stringify(meta));
 };
@@ -9264,14 +9313,14 @@ var init_optimizeHtmlImages = __esm(() => {
 });
 
 // src/cli/scripts/telemetry.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
 import { homedir } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var configDir, configPath, getTelemetryConfig = () => {
   try {
-    if (!existsSync10(configPath))
+    if (!existsSync11(configPath))
       return null;
-    const raw = readFileSync7(configPath, "utf-8");
+    const raw = readFileSync9(configPath, "utf-8");
     const config = JSON.parse(raw);
     return config;
   } catch {
@@ -9279,19 +9328,19 @@ var configDir, configPath, getTelemetryConfig = () => {
   }
 };
 var init_telemetry = __esm(() => {
-  configDir = join9(homedir(), ".absolutejs");
-  configPath = join9(configDir, "telemetry.json");
+  configDir = join10(homedir(), ".absolutejs");
+  configPath = join10(configDir, "telemetry.json");
 });
 
 // src/cli/telemetryEvent.ts
-import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
 import { arch, platform } from "os";
-import { dirname as dirname8, join as join10, parse } from "path";
+import { dirname as dirname8, join as join11, parse } from "path";
 var checkCandidate = (candidate) => {
-  if (!existsSync11(candidate)) {
+  if (!existsSync12(candidate)) {
     return null;
   }
-  const pkg = JSON.parse(readFileSync8(candidate, "utf-8"));
+  const pkg = JSON.parse(readFileSync10(candidate, "utf-8"));
   if (pkg.name === "@absolutejs/absolute") {
     const ver = pkg.version;
     return ver;
@@ -9306,7 +9355,7 @@ var checkCandidate = (candidate) => {
 }, findPackageVersion = () => {
   let { dir } = import.meta;
   while (dir !== parse(dir).root) {
-    const candidate = join10(dir, "package.json");
+    const candidate = join11(dir, "package.json");
     const version = checkCandidate(candidate);
     if (version) {
       return version;
@@ -9396,17 +9445,17 @@ var init_updateAssetPaths = __esm(() => {
 });
 
 // src/dev/buildHMRClient.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { resolve as resolve12 } from "path";
 var {build: bunBuild } = globalThis.Bun;
 var resolveHmrClientPath = () => {
   const projectRoot = process.cwd();
   const fromSource = resolve12(import.meta.dir, "client/hmrClient.ts");
-  if (existsSync12(fromSource) && fromSource.startsWith(projectRoot)) {
+  if (existsSync13(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
   const fromNodeModules = resolve12(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client/hmrClient.ts");
-  if (existsSync12(fromNodeModules))
+  if (existsSync13(fromNodeModules))
     return fromNodeModules;
   return resolve12(import.meta.dir, "dev/client/hmrClient.ts");
 }, hmrClientPath2, buildHMRClient = async () => {
@@ -9598,8 +9647,8 @@ var devVendorPaths = null, getDevVendorPaths = () => devVendorPaths, setDevVendo
 };
 
 // src/build/angularLinkerPlugin.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname9, join as join11, relative as relative5, resolve as resolve14 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname9, join as join12, relative as relative5, resolve as resolve14 } from "path";
 import { createHash as createHash2 } from "crypto";
 var CACHE_ROOT, createAngularLinkerPlugin = (linkerJitMode) => ({
   name: "angular-linker",
@@ -9607,7 +9656,7 @@ var CACHE_ROOT, createAngularLinkerPlugin = (linkerJitMode) => ({
     let needsLinking;
     let babelTransform;
     let linkerPlugin;
-    const cacheDir = join11(CACHE_ROOT, linkerJitMode ? "jit" : "aot");
+    const cacheDir = join12(CACHE_ROOT, linkerJitMode ? "jit" : "aot");
     bld.onLoad({ filter: /[\\/]@angular[\\/].*\.m?js$/ }, async (args) => {
       const source = await Bun.file(args.path).text();
       if (!needsLinking) {
@@ -9620,10 +9669,10 @@ var CACHE_ROOT, createAngularLinkerPlugin = (linkerJitMode) => ({
         return;
       }
       const hash = createHash2("md5").update(source).digest("hex");
-      const cachePath = join11(cacheDir, `${hash}.js`);
-      if (existsSync13(cachePath)) {
+      const cachePath = join12(cacheDir, `${hash}.js`);
+      if (existsSync14(cachePath)) {
         return {
-          contents: readFileSync9(cachePath, "utf-8"),
+          contents: readFileSync11(cachePath, "utf-8"),
           loader: "js"
         };
       }
@@ -9638,8 +9687,8 @@ var CACHE_ROOT, createAngularLinkerPlugin = (linkerJitMode) => ({
         linkerPlugin = mod.createEs2015LinkerPlugin({
           fileSystem: {
             dirname: dirname9,
-            exists: existsSync13,
-            readFile: readFileSync9,
+            exists: existsSync14,
+            readFile: readFileSync11,
             relative: relative5,
             resolve: resolve14
           },
@@ -9700,7 +9749,7 @@ var init_cleanStaleOutputs = __esm(() => {
 
 // src/utils/cleanup.ts
 import { rm as rm3 } from "fs/promises";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 var cleanup = async ({
   angularDir,
   reactDir,
@@ -9708,19 +9757,19 @@ var cleanup = async ({
   vueDir
 }) => {
   await Promise.all([
-    angularDir ? rm3(join12(angularDir, "generated"), {
+    angularDir ? rm3(join13(angularDir, "generated"), {
       force: true,
       recursive: true
     }) : undefined,
-    reactDir ? rm3(join12(reactDir, "generated"), {
+    reactDir ? rm3(join13(reactDir, "generated"), {
       force: true,
       recursive: true
     }) : undefined,
-    svelteDir ? rm3(join12(svelteDir, "generated"), {
+    svelteDir ? rm3(join13(svelteDir, "generated"), {
       force: true,
       recursive: true
     }) : undefined,
-    vueDir ? rm3(join12(vueDir, "generated"), {
+    vueDir ? rm3(join13(vueDir, "generated"), {
       force: true,
       recursive: true
     }) : undefined
@@ -9820,11 +9869,11 @@ __export(exports_compileSvelte, {
   compileSvelte: () => compileSvelte,
   clearSvelteCompilerCache: () => clearSvelteCompilerCache
 });
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { mkdir as mkdir3, stat as stat2 } from "fs/promises";
 import {
   dirname as dirname10,
-  join as join13,
+  join as join14,
   basename as basename5,
   extname as extname5,
   resolve as resolve17,
@@ -9836,11 +9885,11 @@ var {write, file: file2, Transpiler } = globalThis.Bun;
 var resolveDevClientDir2 = () => {
   const projectRoot = process.cwd();
   const fromSource = resolve17(import.meta.dir, "../dev/client");
-  if (existsSync14(fromSource) && fromSource.startsWith(projectRoot)) {
+  if (existsSync15(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
   const fromNodeModules = resolve17(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync14(fromNodeModules))
+  if (existsSync15(fromNodeModules))
     return fromNodeModules;
   return resolve17(import.meta.dir, "./dev/client");
 }, devClientDir2, hmrClientPath3, persistentCache, sourceHashCache, clearSvelteCompilerCache = () => {
@@ -9883,14 +9932,14 @@ var resolveDevClientDir2 = () => {
     `${basePath}.svelte`,
     `${basePath}.svelte.ts`,
     `${basePath}.svelte.js`,
-    join13(basePath, "index.ts"),
-    join13(basePath, "index.js"),
-    join13(basePath, "index.mjs"),
-    join13(basePath, "index.cjs"),
-    join13(basePath, "index.json"),
-    join13(basePath, "index.svelte"),
-    join13(basePath, "index.svelte.ts"),
-    join13(basePath, "index.svelte.js")
+    join14(basePath, "index.ts"),
+    join14(basePath, "index.js"),
+    join14(basePath, "index.mjs"),
+    join14(basePath, "index.cjs"),
+    join14(basePath, "index.json"),
+    join14(basePath, "index.svelte"),
+    join14(basePath, "index.svelte.ts"),
+    join14(basePath, "index.svelte.js")
   ];
   const checks = await Promise.all(candidates.map(exists));
   return candidates.find((_2, index) => checks[index]) ?? null;
@@ -9928,10 +9977,10 @@ var resolveDevClientDir2 = () => {
   });
 }, compileSvelte = async (entryPoints, svelteRoot, cache = new Map, isDev2 = false, stylePreprocessors) => {
   const { compile, compileModule, preprocess } = await import("svelte/compiler");
-  const generatedDir = join13(svelteRoot, "generated");
-  const clientDir = join13(generatedDir, "client");
-  const indexDir = join13(generatedDir, "indexes");
-  const serverDir = join13(generatedDir, "server");
+  const generatedDir = join14(svelteRoot, "generated");
+  const clientDir = join14(generatedDir, "client");
+  const indexDir = join14(generatedDir, "indexes");
+  const serverDir = join14(generatedDir, "server");
   await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir3(dir, { recursive: true })));
   const dev = env2.NODE_ENV !== "production";
   const build2 = async (src) => {
@@ -9969,8 +10018,8 @@ var resolveDevClientDir2 = () => {
     const childBuilt = await Promise.all(childSources.map((child) => build2(child)));
     const hasAwaitSlotFromChildren = childBuilt.some((child) => child.hasAwaitSlot);
     const externalRewrites = new Map;
-    const ssrOutputDir = dirname10(join13(serverDir, relDir, `${baseName}.js`));
-    const clientOutputDir = dirname10(join13(clientDir, relDir, `${baseName}.js`));
+    const ssrOutputDir = dirname10(join14(serverDir, relDir, `${baseName}.js`));
+    const clientOutputDir = dirname10(join14(clientDir, relDir, `${baseName}.js`));
     for (let idx = 0;idx < importPaths.length; idx++) {
       const rawSpec = importPaths[idx];
       if (!rawSpec)
@@ -10035,8 +10084,8 @@ var resolveDevClientDir2 = () => {
       code += islandMetadataExports;
       return code;
     };
-    const ssrPath = join13(serverDir, relDir, `${baseName}.js`);
-    const clientPath = join13(clientDir, relDir, `${baseName}.js`);
+    const ssrPath = join14(serverDir, relDir, `${baseName}.js`);
+    const clientPath = join14(clientDir, relDir, `${baseName}.js`);
     await Promise.all([
       mkdir3(dirname10(ssrPath), { recursive: true }),
       mkdir3(dirname10(clientPath), { recursive: true })
@@ -10068,7 +10117,7 @@ var resolveDevClientDir2 = () => {
   await Promise.all(roots.map(async ({ client: client2, hasAwaitSlot }) => {
     const relClientDir = dirname10(relative7(clientDir, client2));
     const name = basename5(client2, extname5(client2));
-    const indexPath = join13(indexDir, relClientDir, `${name}.js`);
+    const indexPath = join14(indexDir, relClientDir, `${name}.js`);
     const importRaw = relative7(dirname10(indexPath), client2).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev2 ? `window.__HMR_FRAMEWORK__ = "svelte";
@@ -10147,7 +10196,7 @@ if (typeof window !== "undefined") {
     svelteClientPaths: roots.map(({ client: client2 }) => client2),
     svelteIndexPaths: roots.map(({ client: client2 }) => {
       const rel = dirname10(relative7(clientDir, client2));
-      return join13(indexDir, rel, basename5(client2));
+      return join14(indexDir, rel, basename5(client2));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
   };
@@ -10161,7 +10210,7 @@ var init_compileSvelte = __esm(() => {
   init_lowerAwaitSlotSyntax();
   init_renderToReadableStream();
   devClientDir2 = resolveDevClientDir2();
-  hmrClientPath3 = join13(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath3 = join14(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
   persistentCache = new Map;
   sourceHashCache = new Map;
   transpiler2 = new Transpiler({ loader: "ts", target: "browser" });
@@ -10176,18 +10225,18 @@ __export(exports_compileVue, {
   compileVue: () => compileVue,
   clearVueHmrCaches: () => clearVueHmrCaches
 });
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { mkdir as mkdir4 } from "fs/promises";
-import { basename as basename6, dirname as dirname11, join as join14, relative as relative8, resolve as resolve18 } from "path";
+import { basename as basename6, dirname as dirname11, join as join15, relative as relative8, resolve as resolve18 } from "path";
 var {file: file3, write: write2, Transpiler: Transpiler2 } = globalThis.Bun;
 var resolveDevClientDir3 = () => {
   const projectRoot = process.cwd();
   const fromSource = resolve18(import.meta.dir, "../dev/client");
-  if (existsSync15(fromSource) && fromSource.startsWith(projectRoot)) {
+  if (existsSync16(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
   const fromNodeModules = resolve18(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync15(fromNodeModules))
+  if (existsSync16(fromNodeModules))
     return fromNodeModules;
   return resolve18(import.meta.dir, "./dev/client");
 }, devClientDir3, hmrClientPath4, transpiler3, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, clearVueHmrCaches = () => {
@@ -10334,7 +10383,7 @@ var resolveDevClientDir3 = () => {
   ];
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
-    const cssOutputFile = join14(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
+    const cssOutputFile = join15(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
     await mkdir4(dirname11(cssOutputFile), { recursive: true });
     await write2(cssOutputFile, allCss.join(`
 `));
@@ -10365,8 +10414,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
   const clientCode = assembleModule(generateRenderFunction(false), "render", true) + islandMetadataExports;
   const serverCode = assembleModule(generateRenderFunction(true), "ssrRender", false) + islandMetadataExports;
-  const clientOutputPath = join14(outputDirs.client, `${relativeWithoutExtension}.js`);
-  const serverOutputPath = join14(outputDirs.server, `${relativeWithoutExtension}.js`);
+  const clientOutputPath = join15(outputDirs.client, `${relativeWithoutExtension}.js`);
+  const serverOutputPath = join15(outputDirs.server, `${relativeWithoutExtension}.js`);
   const relDir = dirname11(relativeFilePath);
   const relDepth = relDir === "." ? 0 : relDir.split("/").length;
   const adjustImports = (code) => code.replace(/(from\s+['"])(\.\.\/(?:\.\.\/)*)/g, (_2, prefix, dots) => {
@@ -10406,11 +10455,11 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   return result;
 }, compileVue = async (entryPoints, vueRootDir, isDev2 = false, stylePreprocessors) => {
   const compiler = await import("@vue/compiler-sfc");
-  const generatedDir = join14(vueRootDir, "generated");
-  const clientOutputDir = join14(generatedDir, "client");
-  const indexOutputDir = join14(generatedDir, "indexes");
-  const serverOutputDir = join14(generatedDir, "server");
-  const cssOutputDir = join14(generatedDir, "compiled");
+  const generatedDir = join15(vueRootDir, "generated");
+  const clientOutputDir = join15(generatedDir, "client");
+  const indexOutputDir = join15(generatedDir, "indexes");
+  const serverOutputDir = join15(generatedDir, "server");
+  const cssOutputDir = join15(generatedDir, "compiled");
   await Promise.all([
     mkdir4(clientOutputDir, { recursive: true }),
     mkdir4(indexOutputDir, { recursive: true }),
@@ -10427,8 +10476,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     }, buildCache, true, vueRootDir, compiler, stylePreprocessors);
     result.tsHelperPaths.forEach((path) => allTsHelperPaths.add(path));
     const entryBaseName = basename6(entryPath, ".vue");
-    const indexOutputFile = join14(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join14(clientOutputDir, relative8(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    const indexOutputFile = join15(indexOutputDir, `${entryBaseName}.js`);
+    const clientOutputFile = join15(clientOutputDir, relative8(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
     await mkdir4(dirname11(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev2 ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
@@ -10557,8 +10606,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     const sourceCode = await file3(tsPath).text();
     const transpiledCode = transpiler3.transformSync(sourceCode);
     const relativeJsPath = relative8(vueRootDir, tsPath).replace(/\.ts$/, ".js");
-    const outClientPath = join14(clientOutputDir, relativeJsPath);
-    const outServerPath = join14(serverOutputDir, relativeJsPath);
+    const outClientPath = join15(clientOutputDir, relativeJsPath);
+    const outServerPath = join15(serverOutputDir, relativeJsPath);
     await mkdir4(dirname11(outClientPath), { recursive: true });
     await mkdir4(dirname11(outServerPath), { recursive: true });
     await write2(outClientPath, transpiledCode);
@@ -10578,7 +10627,7 @@ var init_compileVue = __esm(() => {
   init_sourceMetadata();
   init_stylePreprocessor();
   devClientDir3 = resolveDevClientDir3();
-  hmrClientPath4 = join14(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath4 = join15(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
   transpiler3 = new Transpiler2({ loader: "ts", target: "browser" });
   scriptCache = new Map;
   scriptSetupCache = new Map;
@@ -11058,8 +11107,8 @@ __export(exports_compileAngular, {
   compileAngularFile: () => compileAngularFile,
   compileAngular: () => compileAngular
 });
-import { existsSync as existsSync16, readFileSync as readFileSync10, promises as fs } from "fs";
-import { join as join15, basename as basename7, sep as sep3, dirname as dirname12, resolve as resolve19, relative as relative9 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync12, promises as fs } from "fs";
+import { join as join16, basename as basename7, sep as sep3, dirname as dirname12, resolve as resolve19, relative as relative9 } from "path";
 import ts2 from "typescript";
 var traceAngularPhase = async (name, fn2, metadata2) => {
   const tracePhase = globalThis.__absoluteBuildTracePhase;
@@ -11101,12 +11150,12 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     `${candidate}.tsx`,
     `${candidate}.js`,
     `${candidate}.jsx`,
-    join15(candidate, "index.ts"),
-    join15(candidate, "index.tsx"),
-    join15(candidate, "index.js"),
-    join15(candidate, "index.jsx")
+    join16(candidate, "index.ts"),
+    join16(candidate, "index.tsx"),
+    join16(candidate, "index.js"),
+    join16(candidate, "index.jsx")
   ];
-  return candidates.find((file4) => existsSync16(file4));
+  return candidates.find((file4) => existsSync17(file4));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
   const baseDir = resolve19(rootDir);
   const tsconfigAliases = readTsconfigPathAliases();
@@ -11187,11 +11236,11 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
 }, resolveDevClientDir4 = () => {
   const projectRoot = process.cwd();
   const fromSource = resolve19(import.meta.dir, "../dev/client");
-  if (existsSync16(fromSource) && fromSource.startsWith(projectRoot)) {
+  if (existsSync17(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
   const fromNodeModules = resolve19(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync16(fromNodeModules))
+  if (existsSync17(fromNodeModules))
     return fromNodeModules;
   return resolve19(import.meta.dir, "./dev/client");
 }, devClientDir4, hmrClientPath5, hmrRuntimePath, injectHMRRegistration = (content, sourceId) => {
@@ -11243,11 +11292,11 @@ ${registrations}
     return specifier;
   const importerDir = dirname12(importerOutputPath);
   const fileCandidate = resolve19(importerDir, `${specifier}.js`);
-  if (outputFiles?.has(fileCandidate) || existsSync16(fileCandidate)) {
+  if (outputFiles?.has(fileCandidate) || existsSync17(fileCandidate)) {
     return `${specifier}.js`;
   }
   const indexCandidate = resolve19(importerDir, specifier, "index.js");
-  if (outputFiles?.has(indexCandidate) || existsSync16(indexCandidate)) {
+  if (outputFiles?.has(indexCandidate) || existsSync17(indexCandidate)) {
     return `${specifier}/index.js`;
   }
   return `${specifier}.js`;
@@ -11280,12 +11329,12 @@ ${registrations}
     `${basePath}.tsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join15(basePath, "index.ts"),
-    join15(basePath, "index.tsx"),
-    join15(basePath, "index.mts"),
-    join15(basePath, "index.cts")
+    join16(basePath, "index.ts"),
+    join16(basePath, "index.tsx"),
+    join16(basePath, "index.mts"),
+    join16(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve19(candidate)).find((candidate) => existsSync16(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+  return candidates.map((candidate) => resolve19(candidate)).find((candidate) => existsSync17(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile5) => {
   const hostSource = readFile5?.(fileName);
   if (typeof hostSource === "string")
@@ -11309,15 +11358,15 @@ ${registrations}
   const paths = [];
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1])
-    paths.push(join15(fileDir, templateUrlMatch[1]));
+    paths.push(join16(fileDir, templateUrlMatch[1]));
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (styleUrlMatch?.[1])
-    paths.push(join15(fileDir, styleUrlMatch[1]));
+    paths.push(join16(fileDir, styleUrlMatch[1]));
   const styleUrlsMatch = findUncommentedMatch(source, /styleUrls\s*:\s*\[([^\]]+)\]/);
   const urlMatches = styleUrlsMatch?.[1]?.match(/['"]([^'"]+)['"]/g);
   if (urlMatches) {
     for (const urlMatch of urlMatches) {
-      paths.push(join15(fileDir, urlMatch.replace(/['"]/g, "")));
+      paths.push(join16(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
   return paths.map((path) => resolve19(path));
@@ -11351,7 +11400,7 @@ ${registrations}
     safeStableStringify(stylePreprocessors ?? null)
   ].join("\x00");
   const cacheKey2 = Bun.hash(cacheInput).toString(BASE_36_RADIX);
-  return join15(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
+  return join16(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
 }, precomputeAotResourceTransforms = async (inputPaths, readFile5, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
@@ -11366,7 +11415,7 @@ ${registrations}
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
-    if (!existsSync16(resolvedPath) || resolvedPath.endsWith(".d.ts"))
+    if (!existsSync17(resolvedPath) || resolvedPath.endsWith(".d.ts"))
       return;
     stats.filesVisited += 1;
     const source = await readFileForAotTransform(resolvedPath, readFile5);
@@ -11397,10 +11446,10 @@ ${registrations}
   return { stats, transformedSources };
 }, compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
   const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
-    const outputPath = resolve19(join15(outDir, relative9(process.cwd(), resolve19(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve19(join16(outDir, relative9(process.cwd(), resolve19(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
-      buildIslandMetadataExports(readFileSync10(inputPath, "utf-8"))
+      buildIslandMetadataExports(readFileSync12(inputPath, "utf-8"))
     ];
   })), { entries: inputPaths.length });
   const { readConfiguration, performCompilation, EmitFlags } = await traceAngularPhase("aot/import-compiler-cli", () => import("@angular/compiler-cli"));
@@ -11443,7 +11492,7 @@ ${registrations}
   const originalGetSourceFile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
     if (fileName.startsWith("lib.") && fileName.endsWith(".d.ts") && tsLibDir) {
-      const resolvedPath = join15(tsLibDir, fileName);
+      const resolvedPath = join16(tsLibDir, fileName);
       return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
     }
     return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
@@ -11498,7 +11547,7 @@ ${registrations}
   const entries = await traceAngularPhase("aot/postprocess-emitted-js", () => {
     const rawEntries = Object.entries(emitted).filter(([fileName]) => fileName.endsWith(".js")).map(([fileName, content]) => ({
       content,
-      target: join15(outDir, fileName)
+      target: join16(outDir, fileName)
     }));
     const outputFiles = new Set(rawEntries.map(({ target }) => resolve19(target)));
     return rawEntries.map(({ content, target }) => {
@@ -11537,7 +11586,7 @@ ${registrations}
   return null;
 }, resolveAngularDeferImportSpecifier = () => {
   const sourceEntry = resolve19(import.meta.dir, "../angular/components/index.ts");
-  if (existsSync16(sourceEntry)) {
+  if (existsSync17(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
   return "@absolutejs/absolute/angular/components";
@@ -11665,7 +11714,7 @@ ${slot.resolvedBindings.map((binding) => `		"${binding.key}": this.__absoluteDef
 ${fields}
 `);
 }, readAndEscapeFile = async (filePath, stylePreprocessors) => {
-  if (!existsSync16(filePath)) {
+  if (!existsSync17(filePath)) {
     throw new Error(`Unable to inline Angular style resource: file not found at ${filePath}`);
   }
   const content = await compileStyleFileIfNeeded(filePath, stylePreprocessors);
@@ -11673,8 +11722,8 @@ ${fields}
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join15(fileDir, templateUrlMatch[1]);
-    if (!existsSync16(templatePath)) {
+    const templatePath = join16(fileDir, templateUrlMatch[1]);
+    if (!existsSync17(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
     const templateRaw2 = await fs.readFile(templatePath, "utf-8");
@@ -11704,11 +11753,11 @@ ${fields}
 }, inlineTemplateAndLowerDeferSync = (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join15(fileDir, templateUrlMatch[1]);
-    if (!existsSync16(templatePath)) {
+    const templatePath = join16(fileDir, templateUrlMatch[1]);
+    if (!existsSync17(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
-    const templateRaw2 = readFileSync10(templatePath, "utf-8");
+    const templateRaw2 = readFileSync12(templatePath, "utf-8");
     const lowered2 = lowerAngularDeferSyntax(templateRaw2);
     const escaped2 = escapeTemplateContent(lowered2.template);
     const replacedSource2 = source.slice(0, templateUrlMatch.index) + `template: \`${escaped2}\`` + source.slice(templateUrlMatch.index + templateUrlMatch[0].length);
@@ -11741,7 +11790,7 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join15(fileDir, styleUrl), stylePreprocessors);
+    return readAndEscapeFile(join16(fileDir, styleUrl), stylePreprocessors);
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -11752,7 +11801,7 @@ ${fields}
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join15(fileDir, styleUrlMatch[1]), stylePreprocessors);
+  const escaped = await readAndEscapeFile(join16(fileDir, styleUrlMatch[1]), stylePreprocessors);
   if (!escaped)
     return source;
   return source.slice(0, styleUrlMatch.index) + `styles: [\`${escaped}\`]` + source.slice(styleUrlMatch.index + styleUrlMatch[0].length);
@@ -11787,12 +11836,12 @@ ${fields}
       `${candidate}.tsx`,
       `${candidate}.js`,
       `${candidate}.jsx`,
-      join15(candidate, "index.ts"),
-      join15(candidate, "index.tsx"),
-      join15(candidate, "index.js"),
-      join15(candidate, "index.jsx")
+      join16(candidate, "index.ts"),
+      join16(candidate, "index.tsx"),
+      join16(candidate, "index.js"),
+      join16(candidate, "index.jsx")
     ];
-    return candidates.find((file4) => existsSync16(file4));
+    return candidates.find((file4) => existsSync17(file4));
   };
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
@@ -11817,7 +11866,7 @@ ${fields}
     const inputDir = dirname12(sourcePath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename7(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    return join15(outDir, relativeDir, fileBase);
+    return join16(outDir, relativeDir, fileBase);
   };
   const transpileAndRewrite = (sourceCode, relativeDir, actualPath, importRewrites) => {
     let processedContent = angularTranspiler.transformSync(sourceCode);
@@ -11862,7 +11911,7 @@ ${fields}
     let actualPath = resolved;
     if (!actualPath.endsWith(".ts"))
       actualPath += ".ts";
-    if (!existsSync16(actualPath))
+    if (!existsSync17(actualPath))
       return;
     let sourceCode = await fs.readFile(actualPath, "utf-8");
     const inlined = await inlineResources(sourceCode, dirname12(actualPath), stylePreprocessors);
@@ -11870,7 +11919,7 @@ ${fields}
     const inputDir = dirname12(actualPath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename7(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    const targetDir = join15(outDir, relativeDir);
+    const targetDir = join16(outDir, relativeDir);
     const targetPath = toOutputPath(actualPath);
     const localImports = [];
     const importRewrites = new Map;
@@ -11898,7 +11947,7 @@ ${fields}
     }).filter((path) => Boolean(path));
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey2 = actualPath;
-    if (jitContentCache.get(cacheKey2) === contentHash && existsSync16(targetPath)) {
+    if (jitContentCache.get(cacheKey2) === contentHash && existsSync17(targetPath)) {
       allOutputs.push(targetPath);
     } else {
       const processedContent = transpileAndRewrite(sourceCode, relativeDir, actualPath, importRewrites);
@@ -11911,7 +11960,7 @@ ${fields}
   };
   await transpileFile(inputPath);
   const entryOutputPath = toOutputPath(entryPath);
-  if (existsSync16(entryOutputPath)) {
+  if (existsSync17(entryOutputPath)) {
     const entryOutput = await fs.readFile(entryOutputPath, "utf-8");
     const withoutLegacyFlag = entryOutput.replace(/\nexport const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;\n?/g, `
 `);
@@ -11924,13 +11973,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
   }
   return allOutputs;
 }, compileAngular = async (entryPoints, outRoot, hmr = false, stylePreprocessors) => {
-  const compiledParent = join15(outRoot, "generated");
+  const compiledParent = join16(outRoot, "generated");
   if (entryPoints.length === 0) {
     const emptyPaths = [];
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join15(compiledParent, "indexes");
+  const indexesDir = join16(compiledParent, "indexes");
   await traceAngularPhase("setup/create-indexes-dir", () => fs.mkdir(indexesDir, { recursive: true }));
   const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve19(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
@@ -11944,21 +11993,21 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const fileBase = basename7(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
     const compiledFallbackPaths = [
-      join15(compiledRoot, relativeEntry),
-      join15(compiledRoot, "pages", jsName),
-      join15(compiledRoot, jsName)
+      join16(compiledRoot, relativeEntry),
+      join16(compiledRoot, "pages", jsName),
+      join16(compiledRoot, jsName)
     ].map((file4) => resolve19(file4));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
         ...candidatePaths.map((file4) => resolve19(file4)),
         ...compiledFallbackPaths
       ];
-      let candidate = normalizedCandidates.find((file4) => existsSync16(file4) && file4.endsWith(`${sep3}pages${sep3}${jsName}`));
+      let candidate = normalizedCandidates.find((file4) => existsSync17(file4) && file4.endsWith(`${sep3}pages${sep3}${jsName}`));
       if (!candidate) {
-        candidate = normalizedCandidates.find((file4) => existsSync16(file4) && file4.endsWith(`${sep3}${jsName}`));
+        candidate = normalizedCandidates.find((file4) => existsSync17(file4) && file4.endsWith(`${sep3}${jsName}`));
       }
       if (!candidate) {
-        candidate = normalizedCandidates.find((file4) => existsSync16(file4));
+        candidate = normalizedCandidates.find((file4) => existsSync17(file4));
       }
       return candidate;
     };
@@ -11966,11 +12015,11 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     if (!rawServerFile) {
       rawServerFile = await traceAngularPhase("wrapper/resolve-server-output-fallback", () => resolveRawServerFile([]), { entry: resolvedEntry });
     }
-    if (rawServerFile && !existsSync16(rawServerFile)) {
+    if (rawServerFile && !existsSync17(rawServerFile)) {
       outputs = hmr ? await compileEntry() : aotOutputs;
       rawServerFile = await traceAngularPhase("wrapper/resolve-server-output-retry", () => resolveRawServerFile(outputs), { entry: resolvedEntry });
     }
-    if (!rawServerFile || !existsSync16(rawServerFile)) {
+    if (!rawServerFile || !existsSync17(rawServerFile)) {
       throw new Error(`Compiled output not found for ${entry}. Looking for: ${jsName}. Available: ${[
         ...outputs,
         ...compiledFallbackPaths
@@ -11990,8 +12039,8 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const usesLegacyAnimations = await traceAngularPhase("wrapper/detect-legacy-animations", () => usesLegacyAngularAnimations(resolvedEntry), { entry: resolvedEntry });
     const serverContentHash = Bun.hash(original).toString(BASE_36_RADIX);
     const cachedWrapper = wrapperOutputCache.get(resolvedEntry);
-    const clientFile = join15(indexesDir, jsName);
-    if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync16(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
+    const clientFile = join16(indexesDir, jsName);
+    if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync17(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
       return {
         clientPath: clientFile,
         indexUnchanged: true,
@@ -12238,8 +12287,8 @@ var init_compileAngular = __esm(() => {
   init_lowerDeferSyntax();
   init_stylePreprocessor();
   devClientDir4 = resolveDevClientDir4();
-  hmrClientPath5 = join15(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
-  hmrRuntimePath = join15(devClientDir4, "handlers", "angularRuntime.ts").replace(/\\/g, "/");
+  hmrClientPath5 = join16(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
+  hmrRuntimePath = join16(devClientDir4, "handlers", "angularRuntime.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
 });
@@ -12250,8 +12299,8 @@ __export(exports_buildReactVendor, {
   computeVendorPaths: () => computeVendorPaths,
   buildReactVendor: () => buildReactVendor
 });
-import { existsSync as existsSync17, mkdirSync as mkdirSync6 } from "fs";
-import { join as join16, resolve as resolve20 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync6 } from "fs";
+import { join as join17, resolve as resolve20 } from "path";
 import { rm as rm4 } from "fs/promises";
 var {build: bunBuild2 } = globalThis.Bun;
 var resolveJsxDevRuntimeCompatPath = () => {
@@ -12264,7 +12313,7 @@ var resolveJsxDevRuntimeCompatPath = () => {
     resolve20(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
-    if (existsSync17(candidate)) {
+    if (existsSync18(candidate)) {
       return candidate.replace(/\\/g, "/");
     }
   }
@@ -12305,14 +12354,14 @@ var resolveJsxDevRuntimeCompatPath = () => {
 `)}
 `;
 }, buildReactVendor = async (buildDir) => {
-  const vendorDir = join16(buildDir, "react", "vendor");
+  const vendorDir = join17(buildDir, "react", "vendor");
   mkdirSync6(vendorDir, { recursive: true });
-  const tmpDir = join16(buildDir, "_vendor_tmp");
+  const tmpDir = join17(buildDir, "_vendor_tmp");
   mkdirSync6(tmpDir, { recursive: true });
   const specifiers = resolveVendorSpecifiers();
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName(specifier);
-    const entryPath = join16(tmpDir, `${safeName}.ts`);
+    const entryPath = join17(tmpDir, `${safeName}.ts`);
     const source = await generateEntrySource(specifier);
     await Bun.write(entryPath, source);
     return entryPath;
@@ -12357,7 +12406,7 @@ __export(exports_buildAngularVendor, {
   buildAngularVendor: () => buildAngularVendor
 });
 import { mkdirSync as mkdirSync7 } from "fs";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 import { rm as rm5 } from "fs/promises";
 var {build: bunBuild3, Glob: Glob6 } = globalThis.Bun;
 var REQUIRED_ANGULAR_SPECIFIERS, SERVER_ONLY_ANGULAR_SPECIFIERS, SCAN_SKIP_DIRS, isResolvable2 = (specifier) => {
@@ -12394,7 +12443,7 @@ var REQUIRED_ANGULAR_SPECIFIERS, SERVER_ONLY_ANGULAR_SPECIFIERS, SCAN_SKIP_DIRS,
   }
   return { angular, transitiveRoots };
 }, collectTransitiveAngularSpecs = async (roots, angularFound) => {
-  const { readFileSync: readFileSync11 } = await import("fs");
+  const { readFileSync: readFileSync13 } = await import("fs");
   const transpiler4 = new Bun.Transpiler({ loader: "js" });
   const visited = new Set;
   const frontier = [];
@@ -12415,7 +12464,7 @@ var REQUIRED_ANGULAR_SPECIFIERS, SERVER_ONLY_ANGULAR_SPECIFIERS, SCAN_SKIP_DIRS,
       }
       let content;
       try {
-        content = readFileSync11(resolved, "utf-8");
+        content = readFileSync13(resolved, "utf-8");
       } catch {
         continue;
       }
@@ -12450,14 +12499,14 @@ var REQUIRED_ANGULAR_SPECIFIERS, SERVER_ONLY_ANGULAR_SPECIFIERS, SCAN_SKIP_DIRS,
   await collectTransitiveAngularSpecs([...angular, ...transitiveRoots], angular);
   return Array.from(angular).filter(isResolvable2);
 }, buildAngularVendor = async (buildDir, directories = [], linkerJitMode = false, depVendorSpecifiers = []) => {
-  const vendorDir = join17(buildDir, "angular", "vendor");
+  const vendorDir = join18(buildDir, "angular", "vendor");
   mkdirSync7(vendorDir, { recursive: true });
-  const tmpDir = join17(buildDir, "_angular_vendor_tmp");
+  const tmpDir = join18(buildDir, "_angular_vendor_tmp");
   mkdirSync7(tmpDir, { recursive: true });
   const specifiers = await resolveAngularSpecifiers(directories);
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
-    const entryPath = join17(tmpDir, `${safeName}.ts`);
+    const entryPath = join18(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -12518,17 +12567,17 @@ __export(exports_buildVueVendor, {
   buildVueVendor: () => buildVueVendor
 });
 import { mkdirSync as mkdirSync8 } from "fs";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 import { rm as rm6 } from "fs/promises";
 var {build: bunBuild4 } = globalThis.Bun;
 var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"), buildVueVendor = async (buildDir) => {
-  const vendorDir = join18(buildDir, "vue", "vendor");
+  const vendorDir = join19(buildDir, "vue", "vendor");
   mkdirSync8(vendorDir, { recursive: true });
-  const tmpDir = join18(buildDir, "_vue_vendor_tmp");
+  const tmpDir = join19(buildDir, "_vue_vendor_tmp");
   mkdirSync8(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(vueSpecifiers.map(async (specifier) => {
     const safeName = toSafeFileName3(specifier);
-    const entryPath = join18(tmpDir, `${safeName}.ts`);
+    const entryPath = join19(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -12553,11 +12602,11 @@ var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"
     console.warn("\u26A0\uFE0F Vue vendor build had errors:", result.logs);
     return;
   }
-  const { readFileSync: readFileSync11, writeFileSync: writeFileSync7, readdirSync } = await import("fs");
+  const { readFileSync: readFileSync13, writeFileSync: writeFileSync7, readdirSync } = await import("fs");
   const files = readdirSync(vendorDir).filter((f2) => f2.endsWith(".js"));
   for (const file4 of files) {
-    const filePath = join18(vendorDir, file4);
-    const content = readFileSync11(filePath, "utf-8");
+    const filePath = join19(vendorDir, file4);
+    const content = readFileSync13(filePath, "utf-8");
     if (!content.includes("__VUE_HMR_RUNTIME__"))
       continue;
     const patched = content.replace(/getGlobalThis\(\)\.__VUE_HMR_RUNTIME__\s*=\s*\{/, "getGlobalThis().__VUE_HMR_RUNTIME__ = getGlobalThis().__VUE_HMR_RUNTIME__ || {");
@@ -12583,7 +12632,7 @@ __export(exports_buildSvelteVendor, {
   buildSvelteVendor: () => buildSvelteVendor
 });
 import { mkdirSync as mkdirSync9 } from "fs";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 import { rm as rm7 } from "fs/promises";
 var {build: bunBuild5 } = globalThis.Bun;
 var svelteSpecifiers, isResolvable3 = (specifier) => {
@@ -12597,13 +12646,13 @@ var svelteSpecifiers, isResolvable3 = (specifier) => {
   const specifiers = resolveVendorSpecifiers2();
   if (specifiers.length === 0)
     return;
-  const vendorDir = join19(buildDir, "svelte", "vendor");
+  const vendorDir = join20(buildDir, "svelte", "vendor");
   mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join19(buildDir, "_svelte_vendor_tmp");
+  const tmpDir = join20(buildDir, "_svelte_vendor_tmp");
   mkdirSync9(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName4(specifier);
-    const entryPath = join19(tmpDir, `${safeName}.ts`);
+    const entryPath = join20(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -12676,11 +12725,11 @@ var escapeRegex2 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewrit
   if (Object.keys(vendorPaths).length === 0)
     return;
   const { readdirSync } = await import("fs");
-  const { join: join20 } = await import("path");
+  const { join: join21 } = await import("path");
   const allFiles = [];
   for (const dir of vendorDirs) {
     try {
-      const files = readdirSync(dir).filter((f2) => f2.endsWith(".js")).map((f2) => join20(dir, f2));
+      const files = readdirSync(dir).filter((f2) => f2.endsWith(".js")).map((f2) => join21(dir, f2));
       allFiles.push(...files);
     } catch {}
   }
@@ -12749,14 +12798,14 @@ var init_rewriteImports = __esm(() => {
 import {
   copyFileSync,
   cpSync,
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   mkdirSync as mkdirSync10,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync13,
   rmSync as rmSync2,
   statSync,
   writeFileSync as writeFileSync7
 } from "fs";
-import { basename as basename8, dirname as dirname13, join as join20, relative as relative10, resolve as resolve21 } from "path";
+import { basename as basename8, dirname as dirname13, join as join21, relative as relative10, resolve as resolve21 } from "path";
 import { cwd, env as env3, exit } from "process";
 var {build: bunBuild6, Glob: Glob7 } = globalThis.Bun;
 var isDev2, isBuildTraceEnabled = () => {
@@ -12834,8 +12883,8 @@ var isDev2, isBuildTraceEnabled = () => {
   mkdirSync10(htmxDestDir, { recursive: true });
   const glob = new Glob7("htmx*.min.js");
   for (const relPath of glob.scanSync({ cwd: htmxDir })) {
-    const src = join20(htmxDir, relPath);
-    const dest = join20(htmxDestDir, "htmx.min.js");
+    const src = join21(htmxDir, relPath);
+    const dest = join21(htmxDestDir, "htmx.min.js");
     copyFileSync(src, dest);
     return;
   }
@@ -12879,7 +12928,7 @@ var isDev2, isBuildTraceEnabled = () => {
     addWorkerPathIfExists(file4, relPath, workerPaths);
   }
 }, collectWorkerPathsFromFile = (file4, patterns, workerPaths) => {
-  const content = readFileSync11(file4, "utf-8");
+  const content = readFileSync13(file4, "utf-8");
   for (const pattern of patterns) {
     collectWorkerPathsFromContent(content, pattern, file4, workerPaths);
   }
@@ -12910,7 +12959,7 @@ var isDev2, isBuildTraceEnabled = () => {
   vuePagesPath
 }) => {
   const { readdirSync: readDir } = await import("fs");
-  const devIndexDir = join20(buildPath, "_src_indexes");
+  const devIndexDir = join21(buildPath, "_src_indexes");
   mkdirSync10(devIndexDir, { recursive: true });
   if (reactIndexesPath && reactPagesPath) {
     copyReactDevIndexes(reactIndexesPath, reactPagesPath, devIndexDir, readDir);
@@ -12922,41 +12971,41 @@ var isDev2, isBuildTraceEnabled = () => {
     copyVueDevIndexes(vueDir, vuePagesPath, vueEntries, devIndexDir);
   }
 }, copyReactDevIndexes = (reactIndexesPath, reactPagesPath, devIndexDir, readDir) => {
-  if (!existsSync18(reactIndexesPath)) {
+  if (!existsSync19(reactIndexesPath)) {
     return;
   }
   const indexFiles = readDir(reactIndexesPath).filter((file4) => file4.endsWith(".tsx"));
   const pagesRel = relative10(process.cwd(), resolve21(reactPagesPath)).replace(/\\/g, "/");
   for (const file4 of indexFiles) {
-    let content = readFileSync11(join20(reactIndexesPath, file4), "utf-8");
+    let content = readFileSync13(join21(reactIndexesPath, file4), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
-    writeFileSync7(join20(devIndexDir, file4), content);
+    writeFileSync7(join21(devIndexDir, file4), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
-  const svelteIndexDir = join20(svelteDir, "generated", "indexes");
+  const svelteIndexDir = join21(svelteDir, "generated", "indexes");
   const sveltePageEntries = svelteEntries.filter((file4) => resolve21(file4).startsWith(resolve21(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename8(entry).replace(/\.svelte(\.(ts|js))?$/, "");
-    const indexFile = join20(svelteIndexDir, "pages", `${name}.js`);
-    if (!existsSync18(indexFile))
+    const indexFile = join21(svelteIndexDir, "pages", `${name}.js`);
+    if (!existsSync19(indexFile))
       continue;
-    let content = readFileSync11(indexFile, "utf-8");
+    let content = readFileSync13(indexFile, "utf-8");
     const srcRel = relative10(process.cwd(), resolve21(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
-    writeFileSync7(join20(devIndexDir, `${name}.svelte.js`), content);
+    writeFileSync7(join21(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
-  const vueIndexDir = join20(vueDir, "generated", "indexes");
+  const vueIndexDir = join21(vueDir, "generated", "indexes");
   const vuePageEntries = vueEntries.filter((file4) => resolve21(file4).startsWith(resolve21(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename8(entry, ".vue");
-    const indexFile = join20(vueIndexDir, `${name}.js`);
-    if (!existsSync18(indexFile))
+    const indexFile = join21(vueIndexDir, `${name}.js`);
+    if (!existsSync19(indexFile))
       continue;
-    let content = readFileSync11(indexFile, "utf-8");
+    let content = readFileSync13(indexFile, "utf-8");
     const srcRel = relative10(process.cwd(), resolve21(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Comp\s+from\s+['"]([^'"]+)['"]/, `import Comp from "/@src/${srcRel}"`);
-    writeFileSync7(join20(devIndexDir, `${name}.vue.js`), content);
+    writeFileSync7(join21(devIndexDir, `${name}.vue.js`), content);
   }
 }, resolveVueRuntimeId = (content, firstUseName, outputPath, projectRoot) => {
   const varIdx = content.indexOf(`var ${firstUseName} =`);
@@ -13004,7 +13053,7 @@ var isDev2, isBuildTraceEnabled = () => {
   }
   return result;
 }, VUE_HMR_RUNTIME, injectVueComposableTracking = (outputPath, projectRoot) => {
-  let content = readFileSync11(outputPath, "utf-8");
+  let content = readFileSync13(outputPath, "utf-8");
   const usePattern = /^var\s+(use[A-Z]\w*)\s*=/gm;
   const useNames = [];
   let match;
@@ -13054,7 +13103,7 @@ ${content.slice(firstUseIdx)}`;
 }, rewriteUrlReferences = (outputPaths, urlFileMap) => {
   const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
   for (const outputPath of outputPaths) {
-    let content = readFileSync11(outputPath, "utf-8");
+    let content = readFileSync13(outputPath, "utf-8");
     let changed = false;
     content = content.replace(urlPattern, (_match, relPath) => {
       const targetName = basename8(relPath);
@@ -13173,10 +13222,10 @@ ${content.slice(firstUseIdx)}`;
       restoreTracePhase();
       return;
     }
-    const traceDir = join20(buildPath2, ".absolute-trace");
+    const traceDir = join21(buildPath2, ".absolute-trace");
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
     mkdirSync10(traceDir, { recursive: true });
-    writeFileSync7(join20(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
+    writeFileSync7(join21(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
       events: traceEvents,
       frameworks: traceFrameworkNames,
       generatedAt: new Date().toISOString(),
@@ -13206,14 +13255,14 @@ ${content.slice(firstUseIdx)}`;
   const stylesPath = typeof stylesConfig === "string" ? stylesConfig : stylesConfig?.path;
   const stylesIgnore = typeof stylesConfig === "object" ? stylesConfig.ignore : undefined;
   const stylesDir = stylesPath && validateSafePath(stylesPath, projectRoot);
-  const reactIndexesPath = reactDir && join20(reactDir, "generated", "indexes");
-  const reactPagesPath = reactDir && join20(reactDir, "pages");
-  const htmlPagesPath = htmlDir && join20(htmlDir, "pages");
-  const htmlScriptsPath = htmlDir && join20(htmlDir, "scripts");
-  const sveltePagesPath = svelteDir && join20(svelteDir, "pages");
-  const vuePagesPath = vueDir && join20(vueDir, "pages");
-  const htmxPagesPath = htmxDir && join20(htmxDir, "pages");
-  const angularPagesPath = angularDir && join20(angularDir, "pages");
+  const reactIndexesPath = reactDir && join21(reactDir, "generated", "indexes");
+  const reactPagesPath = reactDir && join21(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join21(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join21(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join21(svelteDir, "pages");
+  const vuePagesPath = vueDir && join21(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join21(htmxDir, "pages");
+  const angularPagesPath = angularDir && join21(angularDir, "pages");
   const frontends = [
     reactDir,
     htmlDir,
@@ -13251,12 +13300,12 @@ ${content.slice(firstUseIdx)}`;
   if (svelteDir)
     serverDirMap.push({
       dir: svelteDir,
-      subdir: join20("generated", "server")
+      subdir: join21("generated", "server")
     });
   if (vueDir)
     serverDirMap.push({
       dir: vueDir,
-      subdir: join20("generated", "server")
+      subdir: join21("generated", "server")
     });
   if (angularDir)
     serverDirMap.push({ dir: angularDir, subdir: "generated" });
@@ -13266,8 +13315,8 @@ ${content.slice(firstUseIdx)}`;
     const [firstEntry] = serverDirMap;
     if (!firstEntry)
       throw new Error("Expected at least one server directory entry");
-    serverRoot = join20(firstEntry.dir, firstEntry.subdir);
-    serverOutDir = join20(buildPath, basename8(firstEntry.dir));
+    serverRoot = join21(firstEntry.dir, firstEntry.subdir);
+    serverOutDir = join21(buildPath, basename8(firstEntry.dir));
   } else if (serverDirMap.length > 1) {
     serverRoot = commonAncestor(serverDirMap.map((entry) => entry.dir), projectRoot);
     serverOutDir = buildPath;
@@ -13295,7 +13344,7 @@ ${content.slice(firstUseIdx)}`;
     await tracePhase("react/index-generation", () => generateReactIndexFiles(reactPagesPath, reactIndexesPath, hmr));
   }
   if (assetsPath && (!isIncremental || normalizedIncrementalFiles?.some((f2) => f2.includes("/assets/")))) {
-    await tracePhase("assets/copy", () => cpSync(assetsPath, join20(buildPath, "assets"), {
+    await tracePhase("assets/copy", () => cpSync(assetsPath, join21(buildPath, "assets"), {
       force: true,
       recursive: true
     }));
@@ -13344,7 +13393,7 @@ ${content.slice(firstUseIdx)}`;
   const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
     if (entry.startsWith(resolve21(reactIndexesPath))) {
       const pageName = basename8(entry, ".tsx");
-      return join20(reactPagesPath, `${pageName}.tsx`);
+      return join21(reactPagesPath, `${pageName}.tsx`);
     }
     return null;
   }) : allReactEntries;
@@ -13441,7 +13490,7 @@ ${content.slice(firstUseIdx)}`;
     const compileReactConventions = async () => {
       if (reactConventionSources.length === 0)
         return emptyStringArray;
-      const destDir = join20(buildPath, "conventions", "react");
+      const destDir = join21(buildPath, "conventions", "react");
       rmSync2(destDir, { force: true, recursive: true });
       mkdirSync10(destDir, { recursive: true });
       const destPaths = [];
@@ -13485,7 +13534,7 @@ ${content.slice(firstUseIdx)}`;
       angularConventionSources.length > 0 && angularDir ? tracePhase("compile/convention-angular", () => Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular)).then((mod) => mod.compileAngular(angularConventionSources, angularDir, hmr, styleTransformConfig))) : { serverPaths: emptyStringArray }
     ]);
     const bundleConventionFiles = async (framework, compiledPaths) => {
-      const destDir = join20(buildPath, "conventions", framework);
+      const destDir = join21(buildPath, "conventions", framework);
       rmSync2(destDir, { force: true, recursive: true });
       mkdirSync10(destDir, { recursive: true });
       const destPaths = [];
@@ -13558,7 +13607,7 @@ ${content.slice(firstUseIdx)}`;
     }
   })) : {
     entries: [],
-    generatedRoot: join20(buildPath, "_island_entries")
+    generatedRoot: join21(buildPath, "_island_entries")
   };
   const islandClientEntryPoints = islandEntryResult.entries.map((entry) => entry.entryPath);
   if (serverEntryPoints.length === 0 && reactClientEntryPoints.length === 0 && nonReactClientEntryPoints.length === 0 && islandClientEntryPoints.length === 0 && htmxDir === undefined && htmlDir === undefined) {
@@ -13594,7 +13643,7 @@ ${content.slice(firstUseIdx)}`;
     return {};
   }
   if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
-    const refreshEntry = join20(reactIndexesPath, "_refresh.tsx");
+    const refreshEntry = join21(reactIndexesPath, "_refresh.tsx");
     if (!reactClientEntryPoints.includes(refreshEntry))
       reactClientEntryPoints.push(refreshEntry);
   }
@@ -13664,19 +13713,19 @@ ${content.slice(firstUseIdx)}`;
     throw: false
   }, resolveBunBuildOverride(bunBuildConfig, "reactClient")) : undefined;
   if (reactDir && reactClientEntryPoints.length > 0) {
-    rmSync2(join20(buildPath, "react", "generated", "indexes"), {
+    rmSync2(join21(buildPath, "react", "generated", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (angularDir && angularClientPaths.length > 0) {
-    rmSync2(join20(buildPath, "angular", "indexes"), {
+    rmSync2(join21(buildPath, "angular", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (islandClientEntryPoints.length > 0) {
-    rmSync2(join20(buildPath, "islands"), {
+    rmSync2(join21(buildPath, "islands"), {
       force: true,
       recursive: true
     });
@@ -13742,7 +13791,7 @@ ${content.slice(firstUseIdx)}`;
     globalCssEntries.length > 0 ? tracePhase("bun/global-css", () => bunBuild6(mergeBunBuildConfig({
       entrypoints: globalCssEntries,
       naming: `[dir]/[name].[hash].[ext]`,
-      outdir: stylesDir ? join20(buildPath, basename8(stylesDir)) : buildPath,
+      outdir: stylesDir ? join21(buildPath, basename8(stylesDir)) : buildPath,
       plugins: [stylePreprocessorPlugin2],
       root: stylesDir || clientRoot,
       target: "browser",
@@ -13751,7 +13800,7 @@ ${content.slice(firstUseIdx)}`;
     vueCssPaths.length > 0 ? tracePhase("bun/vue-css", () => bunBuild6(mergeBunBuildConfig({
       entrypoints: vueCssPaths,
       naming: `[name].[hash].[ext]`,
-      outdir: join20(buildPath, assetsPath ? basename8(assetsPath) : "assets", "css"),
+      outdir: join21(buildPath, assetsPath ? basename8(assetsPath) : "assets", "css"),
       target: "browser",
       throw: false
     }, resolveBunBuildOverride(bunBuildConfig, "vueCss")))) : undefined
@@ -13873,7 +13922,7 @@ ${content.slice(firstUseIdx)}`;
   const injectHMRIntoHTMLFile = (filePath, framework) => {
     if (!hmrClientBundle)
       return;
-    let html = readFileSync11(filePath, "utf-8");
+    let html = readFileSync13(filePath, "utf-8");
     if (html.includes("data-hmr-client"))
       return;
     const tag = `<script>window.__HMR_FRAMEWORK__="${framework}";</script><script data-hmr-client>${hmrClientBundle}</script>`;
@@ -13884,7 +13933,7 @@ ${content.slice(firstUseIdx)}`;
   const processHtmlPages = async () => {
     if (!(htmlDir && htmlPagesPath))
       return;
-    const outputHtmlPages = isSingle ? join20(buildPath, "pages") : join20(buildPath, basename8(htmlDir), "pages");
+    const outputHtmlPages = isSingle ? join21(buildPath, "pages") : join21(buildPath, basename8(htmlDir), "pages");
     mkdirSync10(outputHtmlPages, { recursive: true });
     cpSync(htmlPagesPath, outputHtmlPages, {
       force: true,
@@ -13906,14 +13955,14 @@ ${content.slice(firstUseIdx)}`;
   const processHtmxPages = async () => {
     if (!(htmxDir && htmxPagesPath))
       return;
-    const outputHtmxPages = isSingle ? join20(buildPath, "pages") : join20(buildPath, basename8(htmxDir), "pages");
+    const outputHtmxPages = isSingle ? join21(buildPath, "pages") : join21(buildPath, basename8(htmxDir), "pages");
     mkdirSync10(outputHtmxPages, { recursive: true });
     cpSync(htmxPagesPath, outputHtmxPages, {
       force: true,
       recursive: true
     });
     if (shouldCopyHtmx) {
-      const htmxDestDir = isSingle ? buildPath : join20(buildPath, basename8(htmxDir));
+      const htmxDestDir = isSingle ? buildPath : join21(buildPath, basename8(htmxDir));
       copyHtmxVendor(htmxDir, htmxDestDir);
     }
     if (shouldUpdateHtmxAssetPaths) {
@@ -13974,9 +14023,9 @@ ${content.slice(firstUseIdx)}`;
     writeBuildTrace(buildPath);
     return { conventions: conventionsMap, manifest };
   }
-  writeFileSync7(join20(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
+  writeFileSync7(join21(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
   if (Object.keys(conventionsMap).length > 0) {
-    writeFileSync7(join20(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
+    writeFileSync7(join21(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
   }
   writeBuildTrace(buildPath);
   if (tailwind && mode === "production") {
@@ -14065,7 +14114,7 @@ var init_build = __esm(() => {
 });
 
 // src/dev/dependencyGraph.ts
-import { existsSync as existsSync19, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync14 } from "fs";
 var {Glob: Glob8 } = globalThis.Bun;
 import { resolve as resolve22 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
@@ -14095,10 +14144,10 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   ];
   for (const ext of extensions) {
     const withExt = normalized + ext;
-    if (existsSync19(withExt))
+    if (existsSync20(withExt))
       return withExt;
   }
-  if (existsSync19(normalized))
+  if (existsSync20(normalized))
     return normalized;
   return null;
 }, clearExistingDependents = (graph, normalizedPath) => {
@@ -14113,7 +14162,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   }
 }, addFileToGraph = (graph, filePath) => {
   const normalizedPath = resolve22(filePath);
-  if (!existsSync19(normalizedPath))
+  if (!existsSync20(normalizedPath))
     return;
   const dependencies = extractDependencies(normalizedPath);
   clearExistingDependents(graph, normalizedPath);
@@ -14129,7 +14178,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
 }, IGNORED_SEGMENTS, buildInitialDependencyGraph = (graph, directories) => {
   const processedFiles = new Set;
   const glob = new Glob8("**/*.{ts,tsx,js,jsx,vue,svelte,html,htm}");
-  const resolvedDirs = directories.map((dir) => resolve22(dir)).filter((dir) => existsSync19(dir));
+  const resolvedDirs = directories.map((dir) => resolve22(dir)).filter((dir) => existsSync20(dir));
   const allFiles = resolvedDirs.flatMap((dir) => Array.from(glob.scanSync({ absolute: true, cwd: dir })));
   for (const file4 of allFiles) {
     const fullPath = resolve22(file4);
@@ -14226,15 +14275,15 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   const lowerPath = filePath.toLowerCase();
   const isSvelteOrVue = lowerPath.endsWith(".svelte") || lowerPath.endsWith(".vue");
   if (loader === "html") {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync14(filePath, "utf-8");
     return extractHtmlDependencies(filePath, content);
   }
   if (loader === "tsx" || loader === "js") {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync14(filePath, "utf-8");
     return extractJsDependencies(filePath, content, loader);
   }
   if (isSvelteOrVue) {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync14(filePath, "utf-8");
     return extractSvelteVueDependencies(filePath, content);
   }
   return [];
@@ -14522,8 +14571,8 @@ var init_pathUtils = __esm(() => {
 
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
-import { existsSync as existsSync20 } from "fs";
-import { join as join21, resolve as resolve24 } from "path";
+import { existsSync as existsSync21 } from "fs";
+import { join as join22, resolve as resolve24 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -14550,16 +14599,16 @@ var safeRemoveFromGraph = (graph, fullPath) => {
     if (shouldSkipFilename(filename, isStylesDir)) {
       return;
     }
-    const fullPath = join21(absolutePath, filename).replace(/\\/g, "/");
+    const fullPath = join22(absolutePath, filename).replace(/\\/g, "/");
     if (shouldIgnorePath(fullPath, state.resolvedPaths)) {
       return;
     }
-    if (event === "rename" && !existsSync20(fullPath)) {
+    if (event === "rename" && !existsSync21(fullPath)) {
       safeRemoveFromGraph(state.dependencyGraph, fullPath);
       onFileChange(fullPath);
       return;
     }
-    if (existsSync20(fullPath)) {
+    if (existsSync21(fullPath)) {
       onFileChange(fullPath);
       safeAddToGraph(state.dependencyGraph, fullPath);
     }
@@ -14569,7 +14618,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
     const absolutePath = resolve24(path).replace(/\\/g, "/");
-    if (!existsSync20(absolutePath)) {
+    if (!existsSync21(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -14580,7 +14629,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
     const absolutePath = resolve24(path).replace(/\\/g, "/");
-    if (!existsSync20(absolutePath)) {
+    if (!existsSync21(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -14698,10 +14747,10 @@ var init_assetStore = __esm(() => {
 });
 
 // src/dev/fileHashTracker.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync15 } from "fs";
 var computeFileHash = (filePath) => {
   try {
-    const fileContent = readFileSync13(filePath);
+    const fileContent = readFileSync15(filePath);
     return Number(Bun.hash(fileContent));
   } catch {
     return UNFOUND_INDEX;
@@ -15010,7 +15059,7 @@ __export(exports_moduleServer, {
   createModuleServer: () => createModuleServer,
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
-import { existsSync as existsSync21, readFileSync as readFileSync14, statSync as statSync2 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync16, statSync as statSync2 } from "fs";
 import { basename as basename10, dirname as dirname14, extname as extname6, resolve as resolve28, relative as relative11 } from "path";
 var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPILABLE, ALL_EXPORTS_RE, STRING_CONTENTS_RE, preserveTypeExports = (originalSource, transpiled, valueExports) => {
   const codeOnly = originalSource.replace(STRING_CONTENTS_RE, '""');
@@ -15031,7 +15080,7 @@ var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPIL
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const found = extensions.find((ext) => existsSync21(resolve28(projectRoot, srcPath + ext)));
+  const found = extensions.find((ext) => existsSync22(resolve28(projectRoot, srcPath + ext)));
   return found ? srcPath + found : srcPath;
 }, IMPORT_EXTENSIONS, SIDE_EFFECT_EXTENSIONS, MODULE_EXTENSIONS, RESOLVED_MODULE_EXTENSIONS, REACT_EXTENSIONS, escapeRegex3 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), buildImportRewriter = (vendorPaths) => {
   const entries = Object.entries(vendorPaths).sort(([a], [b2]) => b2.length - a.length);
@@ -15143,7 +15192,7 @@ ${stubs}
 `)}
 ${code}`;
 }, reactTranspilerOptions, reactTranspiler, transformReactFile = (filePath, projectRoot, rewriter) => {
-  const raw = readFileSync14(filePath, "utf-8");
+  const raw = readFileSync16(filePath, "utf-8");
   const valueExports = tsxTranspiler.scan(raw).exports;
   let transpiled = reactTranspiler.transformSync(raw);
   transpiled = preserveTypeExports(raw, transpiled, valueExports);
@@ -15159,7 +15208,7 @@ ${transpiled}`;
   transpiled += buildIslandMetadataExports(raw);
   return rewriteImports2(transpiled, filePath, projectRoot, rewriter);
 }, transformPlainFile = (filePath, projectRoot, rewriter, vueDir) => {
-  const raw = readFileSync14(filePath, "utf-8");
+  const raw = readFileSync16(filePath, "utf-8");
   const ext = extname6(filePath);
   const isTS = ext === ".ts" || ext === ".tsx";
   const isTSX = ext === ".tsx" || ext === ".jsx";
@@ -15325,7 +15374,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 = readFileSync14(filePath, "utf-8");
+  const raw = readFileSync16(filePath, "utf-8");
   if (!svelteCompiler) {
     svelteCompiler = await import("svelte/compiler");
   }
@@ -15385,7 +15434,7 @@ export default __script__;`;
   return `${cssInjection}
 ${code}`;
 }, transformVueFile = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
-  const raw = readFileSync14(filePath, "utf-8");
+  const raw = readFileSync16(filePath, "utf-8");
   if (!vueCompiler) {
     vueCompiler = await import("@vue/compiler-sfc");
   }
@@ -15421,11 +15470,11 @@ ${code}`;
 `);
   return result;
 }, resolveSvelteModulePath = (path) => {
-  if (existsSync21(path))
+  if (existsSync22(path))
     return path;
-  if (existsSync21(`${path}.ts`))
+  if (existsSync22(`${path}.ts`))
     return `${path}.ts`;
-  if (existsSync21(`${path}.js`))
+  if (existsSync22(`${path}.js`))
     return `${path}.js`;
   return path;
 }, jsResponse = (body) => {
@@ -15438,7 +15487,7 @@ ${code}`;
     }
   });
 }, handleCssRequest = (filePath) => {
-  const raw = readFileSync14(filePath, "utf-8");
+  const raw = readFileSync16(filePath, "utf-8");
   const escaped = raw.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return [
     `const style = document.createElement('style');`,
@@ -15571,7 +15620,7 @@ export default {};
     return { ext, filePath: resolveSvelteModulePath(filePath) };
   if (ext)
     return { ext, filePath };
-  const found = MODULE_EXTENSIONS.find((candidate) => existsSync21(filePath + candidate));
+  const found = MODULE_EXTENSIONS.find((candidate) => existsSync22(filePath + candidate));
   if (!found)
     return { ext, filePath };
   const resolved = filePath + found;
@@ -15776,7 +15825,7 @@ var handleHTMXUpdate = async (htmxFilePath) => {
 var init_simpleHTMXHMR = () => {};
 
 // src/dev/rebuildTrigger.ts
-import { existsSync as existsSync22 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import { basename as basename11, dirname as dirname15, relative as relative12, resolve as resolve31 } from "path";
 var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequentially = (items, action) => items.reduce((chain, item) => chain.then(() => action(item)), Promise.resolve()), getStyleTransformConfig = (config) => createStyleTransformConfig(config.stylePreprocessors, config.postcss), recompileTailwindForFastPath = async (state, config, files) => {
   if (!config.tailwind)
@@ -15865,7 +15914,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     detectedFw = detected !== "ignored" ? detected : affectedFrameworks[0];
   }
   return { ...parsed, framework: detectedFw };
-}, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync22(affectedFile), collectDeletedFileAffected = (state, filePathInSet, processedFiles, validFiles) => {
+}, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync23(affectedFile), collectDeletedFileAffected = (state, filePathInSet, processedFiles, validFiles) => {
   state.fileHashes.delete(filePathInSet);
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, filePathInSet);
@@ -15883,7 +15932,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     if (!dependents || dependents.size === 0) {
       return;
     }
-    const dependentFiles = Array.from(dependents).filter((file4) => existsSync22(file4));
+    const dependentFiles = Array.from(dependents).filter((file4) => existsSync23(file4));
     if (dependentFiles.length === 0) {
       return;
     }
@@ -15899,7 +15948,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, normalizedFilePath);
     affectedFiles.forEach((affectedFile) => {
-      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync22(affectedFile)) {
+      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync23(affectedFile)) {
         validFiles.push(affectedFile);
         processedFiles.add(affectedFile);
       }
@@ -15924,7 +15973,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   collectChangedFileAffected(state, normalizedFilePath, processedFiles, validFiles);
 }, processFilePathSet = (state, filePathSet, processedFiles, validFiles) => {
   filePathSet.forEach((filePathInSet) => {
-    if (!existsSync22(filePathInSet)) {
+    if (!existsSync23(filePathInSet)) {
       collectDeletedFileAffected(state, filePathInSet, processedFiles, validFiles);
       return;
     }
@@ -16043,7 +16092,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return componentFile;
   }
   const tsCounterpart = componentFile.replace(/\.html$/, ".ts");
-  if (existsSync22(tsCounterpart)) {
+  if (existsSync23(tsCounterpart)) {
     return tsCounterpart;
   }
   if (!graph)
@@ -16189,7 +16238,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
 }, resolveReactEntryForPageFile = (normalized, pagesPathResolved, reactIndexesPath) => {
   const pageName = basename11(normalized, ".tsx");
   const indexPath = resolve31(reactIndexesPath, `${pageName}.tsx`);
-  if (!existsSync22(indexPath)) {
+  if (!existsSync23(indexPath)) {
     return;
   }
   return indexPath;
@@ -16201,7 +16250,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     }
     const pageName = basename11(dep, ".tsx");
     const indexPath = resolve31(reactIndexesPath, `${pageName}.tsx`);
-    if (existsSync22(indexPath) && !reactEntries.includes(indexPath)) {
+    if (existsSync23(indexPath) && !reactEntries.includes(indexPath)) {
       reactEntries.push(indexPath);
     }
   });
@@ -17377,7 +17426,7 @@ __export(exports_buildDepVendor, {
   buildDepVendor: () => buildDepVendor
 });
 import { mkdirSync as mkdirSync11 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 import { rm as rm8 } from "fs/promises";
 var {build: bunBuild7, Glob: Glob9 } = globalThis.Bun;
 var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g, "").replace(/-/g, "_"), isResolvable4 = (specifier) => {
@@ -17428,7 +17477,7 @@ var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g,
     framework: Array.from(framework).filter(isResolvable4)
   };
 }, collectTransitiveImports = async (specs, alreadyVendored, alreadyScanned) => {
-  const { readFileSync: readFileSync15 } = await import("fs");
+  const { readFileSync: readFileSync17 } = await import("fs");
   const transpiler4 = new Bun.Transpiler({ loader: "js" });
   const newSpecs = new Set;
   for (const spec of specs) {
@@ -17443,7 +17492,7 @@ var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g,
     }
     let content;
     try {
-      content = readFileSync15(resolved, "utf-8");
+      content = readFileSync17(resolved, "utf-8");
     } catch {
       continue;
     }
@@ -17472,7 +17521,7 @@ var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g,
 }, buildDepVendorPass = async (specifiers, vendorDir, tmpDir) => {
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName5(specifier);
-    const entryPath = join22(tmpDir, `${safeName}.ts`);
+    const entryPath = join23(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -17491,9 +17540,9 @@ var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g,
   const { dep: initialSpecs, framework: frameworkRoots } = await scanBareImports(directories);
   if (initialSpecs.length === 0 && frameworkRoots.length === 0)
     return {};
-  const vendorDir = join22(buildDir, "vendor");
+  const vendorDir = join23(buildDir, "vendor");
   mkdirSync11(vendorDir, { recursive: true });
-  const tmpDir = join22(buildDir, "_dep_vendor_tmp");
+  const tmpDir = join23(buildDir, "_dep_vendor_tmp");
   mkdirSync11(tmpDir, { recursive: true });
   const allSpecs = new Set(initialSpecs);
   const alreadyScanned = new Set;
@@ -18032,17 +18081,17 @@ __export(exports_devtoolsJson, {
   normalizeDevtoolsWorkspaceRoot: () => normalizeDevtoolsWorkspaceRoot,
   devtoolsJson: () => devtoolsJson
 });
-import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname16, join as join23, resolve as resolve33 } from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync12, readFileSync as readFileSync17, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname16, join as join24, resolve as resolve33 } from "path";
 import { Elysia as Elysia3 } from "elysia";
 var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_KEY = "__absoluteDevtoolsWorkspaceUuid", getGlobalUuid = () => Reflect.get(globalThis, UUID_CACHE_KEY), setGlobalUuid = (uuid) => {
   Reflect.set(globalThis, UUID_CACHE_KEY, uuid);
   return uuid;
-}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve33(uuidCachePath ?? join23(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
-  if (!existsSync23(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) => resolve33(uuidCachePath ?? join24(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
+  if (!existsSync24(cachePath))
     return null;
   try {
-    const value = readFileSync15(cachePath, "utf-8").trim();
+    const value = readFileSync17(cachePath, "utf-8").trim();
     return isUuidV4(value) ? value : null;
   } catch {
     return null;
@@ -18077,11 +18126,11 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   if (process.env.WSL_DISTRO_NAME) {
     const distro = process.env.WSL_DISTRO_NAME;
     const withoutLeadingSlash = root.replace(/^\//, "");
-    return join23("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
+    return join24("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
   }
   if (process.env.DOCKER_DESKTOP && !root.startsWith("\\\\")) {
     const withoutLeadingSlash = root.replace(/^\//, "");
-    return join23("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
+    return join24("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
   }
   return root;
 };
@@ -18092,13 +18141,13 @@ var exports_imageOptimizer = {};
 __export(exports_imageOptimizer, {
   imageOptimizer: () => imageOptimizer
 });
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import { resolve as resolve34 } from "path";
 import { Elysia as Elysia4 } from "elysia";
 var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avifInProgress, safeResolve = (path, baseDir) => {
   try {
     const resolved = validateSafePath(path, baseDir);
-    if (existsSync24(resolved))
+    if (existsSync25(resolved))
       return resolved;
     return null;
   } catch {
@@ -18397,15 +18446,15 @@ __export(exports_prerender, {
   prerender: () => prerender,
   PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER
 });
-import { mkdirSync as mkdirSync13, readFileSync as readFileSync16 } from "fs";
-import { join as join24 } from "path";
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync18 } from "fs";
+import { join as join25 } from "path";
 var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_TIMEOUT_MS = 30000, PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass", routeToFilename = (route) => route === "/" ? "index.html" : `${route.slice(1).replace(/\//g, "-")}.html`, writeTimestamp = async (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   await Bun.write(metaPath, String(Date.now()));
 }, readTimestamp = (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   try {
-    const content = readFileSync16(metaPath, "utf-8");
+    const content = readFileSync18(metaPath, "utf-8");
     return Number(content) || 0;
   } catch {
     return 0;
@@ -18463,7 +18512,7 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
       return false;
     const html = await res.text();
     const fileName = routeToFilename(route);
-    const filePath = join24(prerenderDir, fileName);
+    const filePath = join25(prerenderDir, fileName);
     await Bun.write(filePath, html);
     await writeTimestamp(filePath);
     return true;
@@ -18487,13 +18536,13 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
   }
   const html = await res.text();
   const fileName = routeToFilename(route);
-  const filePath = join24(prerenderDir, fileName);
+  const filePath = join25(prerenderDir, fileName);
   await Bun.write(filePath, html);
   await writeTimestamp(filePath);
   result.routes.set(route, filePath);
   log2?.(`  Pre-rendered ${route} \u2192 ${fileName} (${html.length} bytes)`);
 }, prerender = async (port, outDir, staticConfig, log2) => {
-  const prerenderDir = join24(outDir, "_prerendered");
+  const prerenderDir = join25(outDir, "_prerendered");
   mkdirSync13(prerenderDir, { recursive: true });
   const baseUrl = `http://localhost:${port}`;
   let routes;
@@ -19022,8 +19071,8 @@ var handleHTMXPageRequest = async (pagePath) => {
   });
 };
 // src/core/prepare.ts
-import { existsSync as existsSync25, readdirSync as readdirSync2, readFileSync as readFileSync17 } from "fs";
-import { basename as basename12, join as join25, relative as relative13, resolve as resolve35 } from "path";
+import { existsSync as existsSync26, readdirSync as readdirSync2, readFileSync as readFileSync19 } from "fs";
+import { basename as basename12, join as join26, relative as relative13, resolve as resolve35 } from "path";
 import { Elysia as Elysia5 } from "elysia";
 
 // src/utils/loadConfig.ts
@@ -19478,7 +19527,7 @@ var patchManifestIndexes = (manifest, devIndexDir, SRC_URL_PREFIX2) => {
     if (!fileName)
       continue;
     const srcPath = resolve35(devIndexDir, fileName);
-    if (!existsSync25(srcPath))
+    if (!existsSync26(srcPath))
       continue;
     const rel = relative13(process.cwd(), srcPath).replace(/\\/g, "/");
     manifest[key] = `${SRC_URL_PREFIX2}${rel}`;
@@ -19586,7 +19635,7 @@ var prepareDev = async (config, buildDir) => {
 };
 var loadPrerenderMap = (prerenderDir) => {
   const map = new Map;
-  if (!existsSync25(prerenderDir))
+  if (!existsSync26(prerenderDir))
     return map;
   let entries;
   try {
@@ -19599,7 +19648,7 @@ var loadPrerenderMap = (prerenderDir) => {
       continue;
     const name = basename12(entry, ".html");
     const route = name === "index" ? "/" : `/${name}`;
-    map.set(route, join25(prerenderDir, entry));
+    map.set(route, join26(prerenderDir, entry));
   }
   return map;
 };
@@ -19640,7 +19689,7 @@ var prepare = async (configOrPath) => {
     return result;
   }
   stepStartedAt = performance.now();
-  const manifest = JSON.parse(readFileSync17(`${buildDir}/manifest.json`, "utf-8"));
+  const manifest = JSON.parse(readFileSync19(`${buildDir}/manifest.json`, "utf-8"));
   setCurrentIslandManifest(manifest);
   if (config.islands?.registry) {
     setCurrentIslandRegistry(await loadIslandRegistry(config.islands.registry));
@@ -19648,9 +19697,9 @@ var prepare = async (configOrPath) => {
   setCurrentPageIslandMetadata(await loadPageIslandMetadata(config));
   recordStep("load production manifest and island metadata", stepStartedAt);
   stepStartedAt = performance.now();
-  const conventionsPath = join25(buildDir, "conventions.json");
-  if (existsSync25(conventionsPath)) {
-    const conventions2 = JSON.parse(readFileSync17(conventionsPath, "utf-8"));
+  const conventionsPath = join26(buildDir, "conventions.json");
+  if (existsSync26(conventionsPath)) {
+    const conventions2 = JSON.parse(readFileSync19(conventionsPath, "utf-8"));
     setConventions(conventions2);
   }
   recordStep("load production conventions", stepStartedAt);
@@ -19664,7 +19713,7 @@ var prepare = async (configOrPath) => {
   });
   recordStep("create static plugin", stepStartedAt);
   stepStartedAt = performance.now();
-  const prerenderDir = join25(buildDir, "_prerendered");
+  const prerenderDir = join26(buildDir, "_prerendered");
   const prerenderMap = loadPrerenderMap(prerenderDir);
   recordStep("load prerender map", stepStartedAt);
   if (prerenderMap.size > 0) {
@@ -19722,18 +19771,18 @@ import { argv } from "process";
 var {env: env4 } = globalThis.Bun;
 
 // src/dev/devCert.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync14, readFileSync as readFileSync18, rmSync as rmSync3 } from "fs";
-import { join as join26 } from "path";
-var CERT_DIR = join26(process.cwd(), ".absolutejs");
-var CERT_PATH = join26(CERT_DIR, "cert.pem");
-var KEY_PATH = join26(CERT_DIR, "key.pem");
+import { existsSync as existsSync27, mkdirSync as mkdirSync14, readFileSync as readFileSync20, rmSync as rmSync3 } from "fs";
+import { join as join27 } from "path";
+var CERT_DIR = join27(process.cwd(), ".absolutejs");
+var CERT_PATH = join27(CERT_DIR, "cert.pem");
+var KEY_PATH = join27(CERT_DIR, "key.pem");
 var CERT_VALIDITY_DAYS = 365;
 var devLog = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[36m[dev]\x1B[0m ${msg}`);
 var devWarn = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[33m[dev]\x1B[0m \x1B[33m${msg}\x1B[0m`);
-var certFilesExist = () => existsSync26(CERT_PATH) && existsSync26(KEY_PATH);
+var certFilesExist = () => existsSync27(CERT_PATH) && existsSync27(KEY_PATH);
 var isCertExpired = () => {
   try {
-    const certPem = readFileSync18(CERT_PATH, "utf-8");
+    const certPem = readFileSync20(CERT_PATH, "utf-8");
     const proc = Bun.spawnSync(["openssl", "x509", "-enddate", "-noout"], {
       stdin: new TextEncoder().encode(certPem)
     });
@@ -19829,8 +19878,8 @@ var loadDevCert = () => {
     return null;
   try {
     return {
-      cert: readFileSync18(paths.cert, "utf-8"),
-      key: readFileSync18(paths.key, "utf-8")
+      cert: readFileSync20(paths.cert, "utf-8"),
+      key: readFileSync20(paths.key, "utf-8")
     };
   } catch {
     return null;
@@ -20058,7 +20107,7 @@ var jsonLd2 = (schema) => {
 };
 // src/utils/defineEnv.ts
 var {env: bunEnv } = globalThis.Bun;
-import { existsSync as existsSync27, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync21 } from "fs";
 import { resolve as resolve36 } from "path";
 
 // node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
@@ -26095,18 +26144,18 @@ ${lines.join(`
 var checkEnvFileSecurity = (properties) => {
   const cwd2 = process.cwd();
   const envPath = resolve36(cwd2, ".env");
-  if (!existsSync27(envPath))
+  if (!existsSync28(envPath))
     return;
   const sensitiveKeys = Object.keys(properties).filter(isSensitive);
   if (sensitiveKeys.length === 0)
     return;
-  const envContent = readFileSync19(envPath, "utf-8");
+  const envContent = readFileSync21(envPath, "utf-8");
   const presentKeys = sensitiveKeys.filter((key) => envContent.includes(`${key}=`));
   if (presentKeys.length === 0)
     return;
   const gitignorePath = resolve36(cwd2, ".gitignore");
-  if (existsSync27(gitignorePath)) {
-    const gitignore = readFileSync19(gitignorePath, "utf-8");
+  if (existsSync28(gitignorePath)) {
+    const gitignore = readFileSync21(gitignorePath, "utf-8");
     if (gitignore.split(`
 `).some((line) => line.trim() === ".env"))
       return;
@@ -26344,5 +26393,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=68CB53491B77A09D64756E2164756E21
+//# debugId=52CC4E293EDAC09064756E2164756E21
 //# sourceMappingURL=index.js.map