@absolutejs/absolute 0.19.0-beta.690 → 0.19.0-beta.692

package/dist/index.js

@@ -2502,10 +2502,10 @@ var init_lowerAwaitSlotSyntax = __esm(() => {
 });
 
 // src/build/stylePreprocessor.ts
-import { readFileSync as readFileSync3 } from "fs";
 import { readFile } from "fs/promises";
-import { dirname as dirname2, extname } from "path";
-var STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATTERN, importOptionalPeer, requireOptionalPeer, isPreprocessableStylePath = (filePath) => STYLE_EXTENSION_PATTERN.test(filePath), isStyleModulePath = (filePath) => STYLE_MODULE_EXTENSION_PATTERN.test(filePath), isStylePath = (filePath) => /\.(css|s[ac]ss|less)$/i.test(filePath), getStyleBaseName = (filePath) => filePath.replace(/\.(css|s[ac]ss|less)$/i, ""), getStyleLanguage = (filePathOrLanguage) => {
+import { createRequire } from "module";
+import { dirname as dirname2, extname, join as join3 } from "path";
+var STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATTERN, importOptionalPeer, requireOptionalPeer, requireFromCwd, isPreprocessableStylePath = (filePath) => STYLE_EXTENSION_PATTERN.test(filePath), isStyleModulePath = (filePath) => STYLE_MODULE_EXTENSION_PATTERN.test(filePath), isStylePath = (filePath) => /\.(css|s[ac]ss|less)$/i.test(filePath), getStyleBaseName = (filePath) => filePath.replace(/\.(css|s[ac]ss|less)$/i, ""), getStyleLanguage = (filePathOrLanguage) => {
   const normalized = filePathOrLanguage.toLowerCase();
   if (normalized === "scss" || normalized.endsWith(".scss"))
     return "scss";
@@ -2569,27 +2569,6 @@ var STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATT
     return readFile(filePath, "utf-8");
   }
   return compileStyleSource(filePath);
-}, compileStyleFileIfNeededSync = (filePath) => {
-  const contents = readFileSync3(filePath, "utf-8");
-  const language = getStyleLanguage(filePath);
-  if (language === "scss" || language === "sass") {
-    let sass;
-    try {
-      sass = requireOptionalPeer("sass");
-    } catch {
-      throw missingDependencyError("sass", filePath);
-    }
-    return sass.compileString(contents, {
-      loadPaths: [dirname2(filePath), process.cwd()],
-      style: "expanded",
-      syntax: language === "sass" ? "indented" : "scss",
-      url: new URL(`file://${filePath}`)
-    }).css;
-  }
-  if (language === "less") {
-    throw new Error(`Unable to compile ${filePath}: Less styleUrl preprocessing is async-only. Import the Less file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
-  }
-  return contents;
 };
 var init_stylePreprocessor = __esm(() => {
   STYLE_EXTENSION_PATTERN = /\.(s[ac]ss|less)$/i;
@@ -2597,6 +2576,7 @@ var init_stylePreprocessor = __esm(() => {
   STYLE_LANGUAGE_PATTERN = /^(s[ac]ss|less)$/i;
   importOptionalPeer = new Function("specifier", "return import(specifier)");
   requireOptionalPeer = new Function("specifier", "return require(specifier)");
+  requireFromCwd = createRequire(join3(process.cwd(), "package.json"));
   stylePreprocessorPlugin = {
     name: "absolute-style-preprocessor",
     setup(build) {
@@ -2635,13 +2615,13 @@ var init_stylePreprocessor = __esm(() => {
 
 // src/core/svelteServerModule.ts
 import { mkdir, readdir } from "fs/promises";
-import { basename as basename2, dirname as dirname3, extname as extname2, join as join3, relative, resolve as resolve4 } from "path";
+import { basename as basename2, dirname as dirname3, extname as extname2, join as join4, relative, resolve as resolve4 } from "path";
 var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
   const importPath = relative(dirname3(from), target).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
 }, processDirectoryEntries = (entries, dir, targetFileName, stack) => {
   for (const entry of entries) {
-    const entryPath = join3(dir, entry.name);
+    const entryPath = join4(dir, entry.name);
     if (entry.isDirectory())
       stack.push(entryPath);
     if (entry.isFile() && entry.name === targetFileName) {
@@ -2671,11 +2651,11 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (cachedPath !== undefined) {
     return cachedPath;
   }
-  if (!sourcePath.includes(`${join3(process.cwd(), "build")}${process.platform === "win32" ? "" : "/"}`) && !sourcePath.includes("/build/")) {
+  if (!sourcePath.includes(`${join4(process.cwd(), "build")}${process.platform === "win32" ? "" : "/"}`) && !sourcePath.includes("/build/")) {
     originalSourcePathCache.set(sourcePath, sourcePath);
     return sourcePath;
   }
-  const resolvedSourcePath = await findSourceFileByBasename(join3(process.cwd(), "src"), normalizeBuiltSvelteFileName(sourcePath));
+  const resolvedSourcePath = await findSourceFileByBasename(join4(process.cwd(), "src"), normalizeBuiltSvelteFileName(sourcePath));
   const nextPath = resolvedSourcePath ?? sourcePath;
   originalSourcePathCache.set(sourcePath, nextPath);
   return nextPath;
@@ -2691,11 +2671,11 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
     `${basePath}.mjs`,
     `${basePath}.cjs`,
     `${basePath}.json`,
-    join3(basePath, "index.ts"),
-    join3(basePath, "index.js"),
-    join3(basePath, "index.mjs"),
-    join3(basePath, "index.cjs"),
-    join3(basePath, "index.json")
+    join4(basePath, "index.ts"),
+    join4(basePath, "index.js"),
+    join4(basePath, "index.mjs"),
+    join4(basePath, "index.cjs"),
+    join4(basePath, "index.json")
   ];
   const existResults = await Promise.all(candidates.map((candidate) => Bun.file(candidate).exists()));
   const foundIndex = existResults.indexOf(true);
@@ -2703,7 +2683,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
 }, getCachedModulePath = (sourcePath) => {
   const relativeSourcePath = relative(process.cwd(), sourcePath).replace(/\\/g, "/");
   const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
-  return join3(serverCacheRoot, `${normalizedSourcePath}.server.js`);
+  return join4(serverCacheRoot, `${normalizedSourcePath}.server.js`);
 }, resolveSvelteImport = async (spec, from) => {
   if (!spec.startsWith(".") && !spec.startsWith("/")) {
     const resolved = resolvePackageImport(spec);
@@ -2804,7 +2784,7 @@ var init_svelteServerModule = __esm(() => {
   init_lowerIslandSyntax();
   init_lowerAwaitSlotSyntax();
   init_stylePreprocessor();
-  serverCacheRoot = join3(process.cwd(), ".absolutejs", "islands", "svelte");
+  serverCacheRoot = join4(process.cwd(), ".absolutejs", "islands", "svelte");
   compiledModuleCache = new Map;
   originalSourcePathCache = new Map;
   transpiler = new Bun.Transpiler({
@@ -2970,7 +2950,7 @@ import {
   rmSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { dirname as dirname4, extname as extname3, join as join4, relative as relative2, resolve as resolve5 } from "path";
+import { dirname as dirname4, extname as extname3, join as join5, relative as relative2, resolve as resolve5 } from "path";
 import ts from "typescript";
 var frameworks, isRecord4 = (value) => typeof value === "object" && value !== null, resolveRegistryExport = (mod) => {
   if (isRecord4(mod.islandRegistry))
@@ -3126,11 +3106,11 @@ export default component;
   buildPath,
   clientPathMaps = {}
 }) => {
-  const generatedRoot = join4(buildPath, "_island_entries");
+  const generatedRoot = join5(buildPath, "_island_entries");
   rmSync(generatedRoot, { force: true, recursive: true });
   const entries = [];
   for (const definition of buildInfo.definitions) {
-    const entryPath = join4(generatedRoot, "islands", definition.framework, `${definition.component}.ts`);
+    const entryPath = join5(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;
@@ -3237,7 +3217,7 @@ var init_staticStreaming = __esm(() => {
 });
 
 // src/build/staticIslandPages.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync3, 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;
@@ -3366,7 +3346,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 = readFileSync3(pagePath, "utf-8");
   const transformedHtml = await transformStaticPageHtml(originalHtml, registry);
   if (transformedHtml !== originalHtml) {
     writeFileSync3(pagePath, transformedHtml);
@@ -3494,7 +3474,7 @@ var init_sourceMetadata = __esm(() => {
 });
 
 // src/islands/pageMetadata.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { dirname as dirname5, resolve as resolve8 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
@@ -3536,7 +3516,7 @@ var pagePatterns, getPageDirs = (config) => [
     return;
   const files = await scanEntryPoints(resolve8(entry.dir), pattern);
   for (const filePath of files) {
-    const source = readFileSync5(filePath, "utf-8");
+    const source = readFileSync4(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
     pageMetadata.set(resolve8(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
@@ -3670,7 +3650,7 @@ __export(exports_generateReactIndexes, {
 });
 import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
 import { readdir as readdir2, rm, writeFile } from "fs/promises";
-import { basename as basename3, join as join5, relative as relative3, resolve as resolve9, sep } from "path";
+import { basename as basename3, join as join6, relative as relative3, resolve as resolve9, sep } from "path";
 var {Glob: Glob2 } = globalThis.Bun;
 var indexContentCache, resolveDevClientDir = () => {
   const projectRoot = process.cwd();
@@ -3703,8 +3683,8 @@ var indexContentCache, resolveDevClientDir = () => {
   });
   if (staleIndexes.length > 0) {
     await Promise.all(staleIndexes.map((indexFile) => {
-      indexContentCache.delete(join5(reactIndexesDirectory, indexFile));
-      return rm(join5(reactIndexesDirectory, indexFile), {
+      indexContentCache.delete(join6(reactIndexesDirectory, indexFile));
+      return rm(join6(reactIndexesDirectory, indexFile), {
         force: true
       });
     }));
@@ -3973,7 +3953,7 @@ var indexContentCache, resolveDevClientDir = () => {
       ] : []
     ].join(`
 `);
-    const indexPath = join5(reactIndexesDirectory, `${componentName}.tsx`);
+    const indexPath = join6(reactIndexesDirectory, `${componentName}.tsx`);
     const hasher = new Bun.CryptoHasher("md5");
     hasher.update(content);
     const contentHash = hasher.digest("hex");
@@ -3987,7 +3967,7 @@ var indexContentCache, resolveDevClientDir = () => {
   if (!isDev2) {
     return;
   }
-  const refreshPath = join5(reactIndexesDirectory, "_refresh.tsx");
+  const refreshPath = join6(reactIndexesDirectory, "_refresh.tsx");
   if (!existsSync5(refreshPath)) {
     await writeFile(refreshPath, `import '${refreshSetupPath}';
 import 'react';
@@ -3998,9 +3978,9 @@ import 'react-dom/client';
 var init_generateReactIndexes = __esm(() => {
   indexContentCache = new Map;
   devClientDir = resolveDevClientDir();
-  errorOverlayPath = join5(devClientDir, "errorOverlay.ts").replace(/\\/g, "/");
-  hmrClientPath = join5(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
-  refreshSetupPath = join5(devClientDir, "reactRefreshSetup.ts").replace(/\\/g, "/");
+  errorOverlayPath = join6(devClientDir, "errorOverlay.ts").replace(/\\/g, "/");
+  hmrClientPath = join6(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
+  refreshSetupPath = join6(devClientDir, "reactRefreshSetup.ts").replace(/\\/g, "/");
 });
 
 // src/build/wrapHTMLScript.ts
@@ -4136,8 +4116,8 @@ var init_scanCssEntryPoints = __esm(() => {
 });
 
 // src/utils/imageProcessing.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
-import { join as join6, resolve as resolve10 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join7, resolve as resolve10 } from "path";
 var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY = 75, OPTIMIZATION_ENDPOINT = "/_absolute/image", BLUR_DEVIATION = 20, sharpModule = undefined, sharpLoaded = false, sharpWarned = false, snapToSize = (target, sizes) => {
   for (const size of sizes) {
     if (size >= target)
@@ -4190,7 +4170,7 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY = 75, OPTIMIZATIO
   const image2 = config?.imageSizes ?? DEFAULT_IMAGE_SIZES;
   return [...device, ...image2].sort((left, right) => left - right);
 }, getCacheDir = (buildDir) => {
-  const dir = join6(buildDir, ".cache", "images");
+  const dir = join7(buildDir, ".cache", "images");
   if (!existsSync8(dir))
     mkdirSync3(dir, { recursive: true });
   return dir;
@@ -4247,13 +4227,13 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY = 75, OPTIMIZATIO
       return toBuffer(buffer);
   }
 }, readFromCache = (cacheDir, cacheKey) => {
-  const metaPath = join6(cacheDir, `${cacheKey}.meta`);
-  const dataPath = join6(cacheDir, `${cacheKey}.data`);
+  const metaPath = join7(cacheDir, `${cacheKey}.meta`);
+  const dataPath = join7(cacheDir, `${cacheKey}.data`);
   if (!existsSync8(metaPath) || !existsSync8(dataPath))
     return null;
   try {
-    const meta = JSON.parse(readFileSync6(metaPath, "utf-8"));
-    const buffer = readFileSync6(dataPath);
+    const meta = JSON.parse(readFileSync5(metaPath, "utf-8"));
+    const buffer = readFileSync5(dataPath);
     return { buffer, meta };
   } catch {
     return null;
@@ -4275,8 +4255,8 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY = 75, OPTIMIZATIO
     return null;
   }
 }, writeToCache = (cacheDir, cacheKey, buffer, meta) => {
-  const metaPath = join6(cacheDir, `${cacheKey}.meta`);
-  const dataPath = join6(cacheDir, `${cacheKey}.data`);
+  const metaPath = join7(cacheDir, `${cacheKey}.meta`);
+  const dataPath = join7(cacheDir, `${cacheKey}.data`);
   writeFileSync4(dataPath, buffer);
   writeFileSync4(metaPath, JSON.stringify(meta));
 };
@@ -4368,14 +4348,14 @@ var init_optimizeHtmlImages = __esm(() => {
 });
 
 // src/cli/scripts/telemetry.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
 import { homedir } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var configDir, configPath, getTelemetryConfig = () => {
   try {
     if (!existsSync9(configPath))
       return null;
-    const raw = readFileSync7(configPath, "utf-8");
+    const raw = readFileSync6(configPath, "utf-8");
     const config = JSON.parse(raw);
     return config;
   } catch {
@@ -4383,19 +4363,19 @@ var configDir, configPath, getTelemetryConfig = () => {
   }
 };
 var init_telemetry = __esm(() => {
-  configDir = join7(homedir(), ".absolutejs");
-  configPath = join7(configDir, "telemetry.json");
+  configDir = join8(homedir(), ".absolutejs");
+  configPath = join8(configDir, "telemetry.json");
 });
 
 // src/cli/telemetryEvent.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
 import { arch, platform } from "os";
-import { dirname as dirname6, join as join8, parse } from "path";
+import { dirname as dirname6, join as join9, parse } from "path";
 var checkCandidate = (candidate) => {
   if (!existsSync10(candidate)) {
     return null;
   }
-  const pkg = JSON.parse(readFileSync8(candidate, "utf-8"));
+  const pkg = JSON.parse(readFileSync7(candidate, "utf-8"));
   if (pkg.name === "@absolutejs/absolute") {
     const ver = pkg.version;
     return ver;
@@ -4410,7 +4390,7 @@ var checkCandidate = (candidate) => {
 }, findPackageVersion = () => {
   let { dir } = import.meta;
   while (dir !== parse(dir).root) {
-    const candidate = join8(dir, "package.json");
+    const candidate = join9(dir, "package.json");
     const version = checkCandidate(candidate);
     if (version) {
       return version;
@@ -4702,8 +4682,8 @@ var devVendorPaths = null, getDevVendorPaths = () => devVendorPaths, setDevVendo
 };
 
 // src/build/angularLinkerPlugin.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname7, join as join9, relative as relative4, resolve as resolve13 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname7, join as join10, relative as relative4, resolve as resolve13 } from "path";
 import { createHash } from "crypto";
 var CACHE_DIR, angularLinkerPlugin;
 var init_angularLinkerPlugin = __esm(() => {
@@ -4726,10 +4706,10 @@ var init_angularLinkerPlugin = __esm(() => {
           return;
         }
         const hash = createHash("md5").update(source).digest("hex");
-        const cachePath = join9(CACHE_DIR, `${hash}.js`);
+        const cachePath = join10(CACHE_DIR, `${hash}.js`);
         if (existsSync12(cachePath)) {
           return {
-            contents: readFileSync9(cachePath, "utf-8"),
+            contents: readFileSync8(cachePath, "utf-8"),
             loader: "js"
           };
         }
@@ -4745,7 +4725,7 @@ var init_angularLinkerPlugin = __esm(() => {
             fileSystem: {
               dirname: dirname7,
               exists: existsSync12,
-              readFile: readFileSync9,
+              readFile: readFileSync8,
               relative: relative4,
               resolve: resolve13
             },
@@ -4803,7 +4783,7 @@ var init_cleanStaleOutputs = __esm(() => {
 
 // src/utils/cleanup.ts
 import { rm as rm3 } from "fs/promises";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var cleanup = async ({
   angularDir,
   reactDir,
@@ -4811,19 +4791,19 @@ var cleanup = async ({
   vueDir
 }) => {
   await Promise.all([
-    angularDir ? rm3(join10(angularDir, "generated"), {
+    angularDir ? rm3(join11(angularDir, "generated"), {
       force: true,
       recursive: true
     }) : undefined,
-    reactDir ? rm3(join10(reactDir, "generated"), {
+    reactDir ? rm3(join11(reactDir, "generated"), {
       force: true,
       recursive: true
     }) : undefined,
-    svelteDir ? rm3(join10(svelteDir, "generated"), {
+    svelteDir ? rm3(join11(svelteDir, "generated"), {
       force: true,
       recursive: true
     }) : undefined,
-    vueDir ? rm3(join10(vueDir, "generated"), {
+    vueDir ? rm3(join11(vueDir, "generated"), {
       force: true,
       recursive: true
     }) : undefined
@@ -4926,7 +4906,7 @@ import { existsSync as existsSync13 } from "fs";
 import { mkdir as mkdir2, stat } from "fs/promises";
 import {
   dirname as dirname8,
-  join as join11,
+  join as join12,
   basename as basename5,
   extname as extname5,
   resolve as resolve16,
@@ -4985,14 +4965,14 @@ var resolveDevClientDir2 = () => {
     `${basePath}.svelte`,
     `${basePath}.svelte.ts`,
     `${basePath}.svelte.js`,
-    join11(basePath, "index.ts"),
-    join11(basePath, "index.js"),
-    join11(basePath, "index.mjs"),
-    join11(basePath, "index.cjs"),
-    join11(basePath, "index.json"),
-    join11(basePath, "index.svelte"),
-    join11(basePath, "index.svelte.ts"),
-    join11(basePath, "index.svelte.js")
+    join12(basePath, "index.ts"),
+    join12(basePath, "index.js"),
+    join12(basePath, "index.mjs"),
+    join12(basePath, "index.cjs"),
+    join12(basePath, "index.json"),
+    join12(basePath, "index.svelte"),
+    join12(basePath, "index.svelte.ts"),
+    join12(basePath, "index.svelte.js")
   ];
   const checks = await Promise.all(candidates.map(exists));
   return candidates.find((_, index) => checks[index]) ?? null;
@@ -5030,10 +5010,10 @@ var resolveDevClientDir2 = () => {
   });
 }, compileSvelte = async (entryPoints, svelteRoot, cache = new Map, isDev2 = false) => {
   const { compile, compileModule, preprocess } = await import("svelte/compiler");
-  const generatedDir = join11(svelteRoot, "generated");
-  const clientDir = join11(generatedDir, "client");
-  const indexDir = join11(generatedDir, "indexes");
-  const serverDir = join11(generatedDir, "server");
+  const generatedDir = join12(svelteRoot, "generated");
+  const clientDir = join12(generatedDir, "client");
+  const indexDir = join12(generatedDir, "indexes");
+  const serverDir = join12(generatedDir, "server");
   await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir2(dir, { recursive: true })));
   const dev = env2.NODE_ENV !== "production";
   const build2 = async (src) => {
@@ -5071,8 +5051,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 = dirname8(join11(serverDir, relDir, `${baseName}.js`));
-    const clientOutputDir = dirname8(join11(clientDir, relDir, `${baseName}.js`));
+    const ssrOutputDir = dirname8(join12(serverDir, relDir, `${baseName}.js`));
+    const clientOutputDir = dirname8(join12(clientDir, relDir, `${baseName}.js`));
     for (let idx = 0;idx < importPaths.length; idx++) {
       const rawSpec = importPaths[idx];
       if (!rawSpec)
@@ -5138,8 +5118,8 @@ var resolveDevClientDir2 = () => {
       code += islandMetadataExports;
       return code;
     };
-    const ssrPath = join11(serverDir, relDir, `${baseName}.js`);
-    const clientPath = join11(clientDir, relDir, `${baseName}.js`);
+    const ssrPath = join12(serverDir, relDir, `${baseName}.js`);
+    const clientPath = join12(clientDir, relDir, `${baseName}.js`);
     await Promise.all([
       mkdir2(dirname8(ssrPath), { recursive: true }),
       mkdir2(dirname8(clientPath), { recursive: true })
@@ -5171,7 +5151,7 @@ var resolveDevClientDir2 = () => {
   await Promise.all(roots.map(async ({ client: client2, hasAwaitSlot }) => {
     const relClientDir = dirname8(relative6(clientDir, client2));
     const name = basename5(client2, extname5(client2));
-    const indexPath = join11(indexDir, relClientDir, `${name}.js`);
+    const indexPath = join12(indexDir, relClientDir, `${name}.js`);
     const importRaw = relative6(dirname8(indexPath), client2).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev2 ? `window.__HMR_FRAMEWORK__ = "svelte";
@@ -5250,7 +5230,7 @@ if (typeof window !== "undefined") {
     svelteClientPaths: roots.map(({ client: client2 }) => client2),
     svelteIndexPaths: roots.map(({ client: client2 }) => {
       const rel = dirname8(relative6(clientDir, client2));
-      return join11(indexDir, rel, basename5(client2));
+      return join12(indexDir, rel, basename5(client2));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
   };
@@ -5264,7 +5244,7 @@ var init_compileSvelte = __esm(() => {
   init_lowerAwaitSlotSyntax();
   init_renderToReadableStream();
   devClientDir2 = resolveDevClientDir2();
-  hmrClientPath3 = join11(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath3 = join12(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
   persistentCache = new Map;
   sourceHashCache = new Map;
   transpiler2 = new Transpiler({ loader: "ts", target: "browser" });
@@ -5281,7 +5261,7 @@ __export(exports_compileVue, {
 });
 import { existsSync as existsSync14 } from "fs";
 import { mkdir as mkdir3 } from "fs/promises";
-import { basename as basename6, dirname as dirname9, join as join12, relative as relative7, resolve as resolve17 } from "path";
+import { basename as basename6, dirname as dirname9, join as join13, relative as relative7, resolve as resolve17 } from "path";
 var {file: file3, write: write2, Transpiler: Transpiler2 } = globalThis.Bun;
 var resolveDevClientDir3 = () => {
   const projectRoot = process.cwd();
@@ -5437,7 +5417,7 @@ var resolveDevClientDir3 = () => {
   ];
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
-    const cssOutputFile = join12(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
+    const cssOutputFile = join13(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
     await mkdir3(dirname9(cssOutputFile), { recursive: true });
     await write2(cssOutputFile, allCss.join(`
 `));
@@ -5468,8 +5448,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 = join12(outputDirs.client, `${relativeWithoutExtension}.js`);
-  const serverOutputPath = join12(outputDirs.server, `${relativeWithoutExtension}.js`);
+  const clientOutputPath = join13(outputDirs.client, `${relativeWithoutExtension}.js`);
+  const serverOutputPath = join13(outputDirs.server, `${relativeWithoutExtension}.js`);
   const relDir = dirname9(relativeFilePath);
   const relDepth = relDir === "." ? 0 : relDir.split("/").length;
   const adjustImports = (code) => code.replace(/(from\s+['"])(\.\.\/(?:\.\.\/)*)/g, (_, prefix, dots) => {
@@ -5509,11 +5489,11 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   return result;
 }, compileVue = async (entryPoints, vueRootDir, isDev2 = false) => {
   const compiler = await import("@vue/compiler-sfc");
-  const generatedDir = join12(vueRootDir, "generated");
-  const clientOutputDir = join12(generatedDir, "client");
-  const indexOutputDir = join12(generatedDir, "indexes");
-  const serverOutputDir = join12(generatedDir, "server");
-  const cssOutputDir = join12(generatedDir, "compiled");
+  const generatedDir = join13(vueRootDir, "generated");
+  const clientOutputDir = join13(generatedDir, "client");
+  const indexOutputDir = join13(generatedDir, "indexes");
+  const serverOutputDir = join13(generatedDir, "server");
+  const cssOutputDir = join13(generatedDir, "compiled");
   await Promise.all([
     mkdir3(clientOutputDir, { recursive: true }),
     mkdir3(indexOutputDir, { recursive: true }),
@@ -5530,8 +5510,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     }, buildCache, true, vueRootDir, compiler);
     result.tsHelperPaths.forEach((path) => allTsHelperPaths.add(path));
     const entryBaseName = basename6(entryPath, ".vue");
-    const indexOutputFile = join12(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join12(clientOutputDir, relative7(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    const indexOutputFile = join13(indexOutputDir, `${entryBaseName}.js`);
+    const clientOutputFile = join13(clientOutputDir, relative7(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
     await mkdir3(dirname9(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev2 ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
@@ -5660,8 +5640,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     const sourceCode = await file3(tsPath).text();
     const transpiledCode = transpiler3.transformSync(sourceCode);
     const relativeJsPath = relative7(vueRootDir, tsPath).replace(/\.ts$/, ".js");
-    const outClientPath = join12(clientOutputDir, relativeJsPath);
-    const outServerPath = join12(serverOutputDir, relativeJsPath);
+    const outClientPath = join13(clientOutputDir, relativeJsPath);
+    const outServerPath = join13(serverOutputDir, relativeJsPath);
     await mkdir3(dirname9(outClientPath), { recursive: true });
     await mkdir3(dirname9(outServerPath), { recursive: true });
     await write2(outClientPath, transpiledCode);
@@ -5681,7 +5661,7 @@ var init_compileVue = __esm(() => {
   init_sourceMetadata();
   init_stylePreprocessor();
   devClientDir3 = resolveDevClientDir3();
-  hmrClientPath4 = join12(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath4 = join13(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
   transpiler3 = new Transpiler2({ loader: "ts", target: "browser" });
   scriptCache = new Map;
   scriptSetupCache = new Map;
@@ -6160,13 +6140,13 @@ __export(exports_compileAngular, {
   compileAngularFile: () => compileAngularFile,
   compileAngular: () => compileAngular
 });
-import { existsSync as existsSync15, readFileSync as readFileSync10, promises as fs } from "fs";
-import { join as join13, basename as basename7, sep as sep3, dirname as dirname10, resolve as resolve18, relative as relative8 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync9, promises as fs } from "fs";
+import { join as join14, basename as basename7, sep as sep3, dirname as dirname10, resolve as resolve18, relative as relative8 } from "path";
 import ts2 from "typescript";
 import { createHash as createHash2 } from "crypto";
 var computeConfigHash = () => {
   try {
-    const content = readFileSync10("./tsconfig.json", "utf-8");
+    const content = readFileSync9("./tsconfig.json", "utf-8");
     return createHash2("md5").update(content).digest("hex");
   } catch {
     return "";
@@ -6223,8 +6203,70 @@ ${registrations}
   if (fileName.startsWith(outDir))
     return fileName.substring(outDir.length + 1);
   return fileName;
+}, isRelativeModuleSpecifier = (specifier) => specifier.startsWith("./") || specifier.startsWith("../"), extractLocalImportSpecifiers = (source, fileName) => {
+  const sourceFile = ts2.createSourceFile(fileName, source, ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TS);
+  const specifiers = [];
+  const addSpecifier = (node) => {
+    if (!node || !ts2.isStringLiteralLike(node))
+      return;
+    const specifier = node.text;
+    if (isRelativeModuleSpecifier(specifier))
+      specifiers.push(specifier);
+  };
+  const visit = (node) => {
+    if (ts2.isImportDeclaration(node) || ts2.isExportDeclaration(node)) {
+      addSpecifier(node.moduleSpecifier);
+    } else if (ts2.isCallExpression(node) && node.expression.kind === ts2.SyntaxKind.ImportKeyword) {
+      addSpecifier(node.arguments[0]);
+    }
+    ts2.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return specifiers;
+}, resolveLocalTsImport = (fromFile, specifier) => {
+  if (!isRelativeModuleSpecifier(specifier))
+    return null;
+  const basePath = resolve18(dirname10(fromFile), specifier);
+  const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
+    `${basePath}.ts`,
+    `${basePath}.tsx`,
+    `${basePath}.mts`,
+    `${basePath}.cts`,
+    join14(basePath, "index.ts"),
+    join14(basePath, "index.tsx"),
+    join14(basePath, "index.mts"),
+    join14(basePath, "index.cts")
+  ];
+  return candidates.map((candidate) => resolve18(candidate)).find((candidate) => existsSync15(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+}, readFileForAotTransform = async (fileName, readFile4) => {
+  const hostSource = readFile4?.(fileName);
+  if (typeof hostSource === "string")
+    return hostSource;
+  return fs.readFile(fileName, "utf-8");
+}, precomputeAotResourceTransforms = async (inputPath, readFile4) => {
+  const transformedSources = new Map;
+  const visited = new Set;
+  const transformFile = async (filePath) => {
+    const resolvedPath = resolve18(filePath);
+    if (visited.has(resolvedPath))
+      return;
+    visited.add(resolvedPath);
+    if (!existsSync15(resolvedPath) || resolvedPath.endsWith(".d.ts"))
+      return;
+    const source = await readFileForAotTransform(resolvedPath, readFile4);
+    const transformed = await inlineResources(source, dirname10(resolvedPath));
+    transformedSources.set(resolvedPath, transformed.source);
+    const imports = extractLocalImportSpecifiers(source, resolvedPath);
+    await Promise.all(imports.map(async (specifier) => {
+      const resolvedImport = resolveLocalTsImport(resolvedPath, specifier);
+      if (resolvedImport)
+        await transformFile(resolvedImport);
+    }));
+  };
+  await transformFile(inputPath);
+  return transformedSources;
 }, compileAngularFile = async (inputPath, outDir) => {
-  const islandMetadataExports = buildIslandMetadataExports(readFileSync10(inputPath, "utf-8"));
+  const islandMetadataExports = buildIslandMetadataExports(readFileSync9(inputPath, "utf-8"));
   const { readConfiguration, performCompilation, EmitFlags } = await import("@angular/compiler-cli");
   const configHash = computeConfigHash();
   const cached = globalThis.__angularCompilerCache;
@@ -6272,7 +6314,7 @@ ${registrations}
     const originalGetSourceFile = host.getSourceFile;
     host.getSourceFile = (fileName, languageVersion, onError) => {
       if (fileName.startsWith("lib.") && fileName.endsWith(".d.ts") && tsLibDir) {
-        const resolvedPath = join13(tsLibDir, fileName);
+        const resolvedPath = join14(tsLibDir, fileName);
         return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
       }
       return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
@@ -6292,7 +6334,7 @@ ${registrations}
     emitted[relativePath] = text;
   };
   const originalReadFile = host.readFile;
-  const aotTransformCache = new Map;
+  const aotTransformedSources = await precomputeAotResourceTransforms(inputPath, originalReadFile?.bind(host));
   host.readFile = (fileName) => {
     const source = originalReadFile ? originalReadFile.call(host, fileName) : undefined;
     if (typeof source !== "string")
@@ -6301,12 +6343,7 @@ ${registrations}
       return source;
     }
     const resolvedPath = resolve18(fileName);
-    const cached2 = aotTransformCache.get(resolvedPath);
-    if (cached2 !== undefined)
-      return cached2;
-    const transformed = inlineResourcesSync(source, dirname10(resolvedPath)).source;
-    aotTransformCache.set(resolvedPath, transformed);
-    return transformed;
+    return aotTransformedSources.get(resolvedPath) ?? source;
   };
   const originalGetSourceFileForCompile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
@@ -6330,7 +6367,7 @@ ${registrations}
   }
   throwOnCompilationErrors(diagnostics);
   const entries = Object.entries(emitted).filter(([fileName]) => fileName.endsWith(".js")).map(([fileName, content]) => {
-    const target = join13(outDir, fileName);
+    const target = join14(outDir, fileName);
     let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
       if (!path.match(/\.(js|ts|mjs|cjs)$/)) {
         return `from ${quote}${path}.js${quote}`;
@@ -6486,7 +6523,7 @@ ${fields}
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = source.match(/templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join13(fileDir, templateUrlMatch[1]);
+    const templatePath = join14(fileDir, templateUrlMatch[1]);
     if (!existsSync15(templatePath)) {
       return { deferSlots: [], source };
     }
@@ -6517,11 +6554,11 @@ ${fields}
 }, inlineTemplateAndLowerDeferSync = (source, fileDir) => {
   const templateUrlMatch = source.match(/templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join13(fileDir, templateUrlMatch[1]);
+    const templatePath = join14(fileDir, templateUrlMatch[1]);
     if (!existsSync15(templatePath)) {
       return { deferSlots: [], source };
     }
-    const templateRaw2 = readFileSync10(templatePath, "utf-8");
+    const templateRaw2 = readFileSync9(templatePath, "utf-8");
     const lowered2 = lowerAngularDeferSyntax(templateRaw2);
     const escaped2 = escapeTemplateContent(lowered2.template);
     const replacedSource2 = source.replace(/templateUrl\s*:\s*['"][^'"]+['"]/, `template: \`${escaped2}\``);
@@ -6545,42 +6582,6 @@ ${fields}
     deferSlots: lowered.slots,
     source: injectDeferSlotFields(replacedSource, lowered.slots, resolveAngularDeferImportSpecifier())
   };
-}, readAndEscapeFileSync = (filePath) => {
-  if (!existsSync15(filePath))
-    return null;
-  const content = compileStyleFileIfNeededSync(filePath);
-  return escapeTemplateContent(content);
-}, inlineStyleUrlsSync = (source, fileDir) => {
-  const styleUrlsMatch = source.match(/styleUrls\s*:\s*\[([^\]]+)\]/);
-  if (!styleUrlsMatch?.[1])
-    return source;
-  const urlMatches = styleUrlsMatch[1].match(/['"]([^'"]+)['"]/g);
-  if (!urlMatches)
-    return source;
-  const inlinedStyles = urlMatches.map((urlMatch) => {
-    const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFileSync(join13(fileDir, styleUrl));
-  }).filter(Boolean).map((escaped) => `\`${escaped}\``);
-  if (inlinedStyles.length === 0)
-    return source;
-  return source.replace(/styleUrls\s*:\s*\[[^\]]+\]/, `styles: [${inlinedStyles.join(", ")}]`);
-}, inlineSingleStyleUrlSync = (source, fileDir) => {
-  const styleUrlMatch = source.match(/styleUrl\s*:\s*['"]([^'"]+)['"]/);
-  if (!styleUrlMatch?.[1])
-    return source;
-  const escaped = readAndEscapeFileSync(join13(fileDir, styleUrlMatch[1]));
-  if (!escaped)
-    return source;
-  return source.replace(/styleUrl\s*:\s*['"][^'"]+['"]/, `styles: [\`${escaped}\`]`);
-}, inlineResourcesSync = (source, fileDir) => {
-  const inlinedTemplate = inlineTemplateAndLowerDeferSync(source, fileDir);
-  let result = inlinedTemplate.source;
-  result = inlineStyleUrlsSync(result, fileDir);
-  result = inlineSingleStyleUrlSync(result, fileDir);
-  return {
-    deferSlots: inlinedTemplate.deferSlots,
-    source: result
-  };
 }, inlineStyleUrls = async (source, fileDir) => {
   const styleUrlsMatch = source.match(/styleUrls\s*:\s*\[([^\]]+)\]/);
   if (!styleUrlsMatch?.[1])
@@ -6590,7 +6591,7 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join13(fileDir, styleUrl));
+    return readAndEscapeFile(join14(fileDir, styleUrl));
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -6601,7 +6602,7 @@ ${fields}
   const styleUrlMatch = source.match(/styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join13(fileDir, styleUrlMatch[1]));
+  const escaped = await readAndEscapeFile(join14(fileDir, styleUrlMatch[1]));
   if (!escaped)
     return source;
   return source.replace(/styleUrl\s*:\s*['"][^'"]+['"]/, `styles: [\`${escaped}\`]`);
@@ -6676,8 +6677,8 @@ ${fields}
     const inputDir = dirname10(actualPath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename7(actualPath).replace(/\.ts$/, ".js");
-    const targetDir = join13(outDir, relativeDir);
-    const targetPath = join13(targetDir, fileBase);
+    const targetDir = join14(outDir, relativeDir);
+    const targetPath = join14(targetDir, fileBase);
     const localImports = [];
     const fromRegex = /(?:from|import)\s+['"](\.\.?\/[^'"]+)['"]/g;
     const dynamicImportRegex = /import\(\s*['"](\.\.?\/[^'"]+)['"]\s*\)/g;
@@ -6710,13 +6711,13 @@ ${fields}
   await transpileFile(inputPath);
   return allOutputs;
 }, compileAngular = async (entryPoints, outRoot, hmr = false) => {
-  const compiledParent = join13(outRoot, "generated");
+  const compiledParent = join14(outRoot, "generated");
   if (entryPoints.length === 0) {
     const emptyPaths = [];
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join13(compiledParent, "indexes");
+  const indexesDir = join14(compiledParent, "indexes");
   await fs.mkdir(indexesDir, { recursive: true });
   const compileTasks = entryPoints.map(async (entry) => {
     const resolvedEntry = resolve18(entry);
@@ -6726,9 +6727,9 @@ ${fields}
     const fileBase = basename7(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
     const compiledFallbackPaths = [
-      join13(compiledRoot, relativeEntry),
-      join13(compiledRoot, "pages", jsName),
-      join13(compiledRoot, jsName)
+      join14(compiledRoot, relativeEntry),
+      join14(compiledRoot, "pages", jsName),
+      join14(compiledRoot, jsName)
     ].map((file4) => resolve18(file4));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
@@ -6762,7 +6763,7 @@ ${fields}
     const componentClassName = `${toPascal(fileBase)}Component`;
     const serverContentHash = Bun.hash(original).toString(BASE_36_RADIX);
     const cachedWrapper = wrapperOutputCache.get(resolvedEntry);
-    const clientFile = join13(indexesDir, jsName);
+    const clientFile = join14(indexesDir, jsName);
     if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync15(clientFile)) {
       return {
         clientPath: clientFile,
@@ -6950,8 +6951,8 @@ var init_compileAngular = __esm(() => {
   init_lowerDeferSyntax();
   init_stylePreprocessor();
   devClientDir4 = resolveDevClientDir4();
-  hmrClientPath5 = join13(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
-  hmrRuntimePath = join13(devClientDir4, "handlers", "angularRuntime.ts").replace(/\\/g, "/");
+  hmrClientPath5 = join14(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
+  hmrRuntimePath = join14(devClientDir4, "handlers", "angularRuntime.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
 });
@@ -6963,7 +6964,7 @@ __export(exports_buildReactVendor, {
   buildReactVendor: () => buildReactVendor
 });
 import { existsSync as existsSync16, mkdirSync as mkdirSync6 } from "fs";
-import { join as join14, resolve as resolve19 } from "path";
+import { join as join15, resolve as resolve19 } from "path";
 import { rm as rm4 } from "fs/promises";
 var {build: bunBuild2 } = globalThis.Bun;
 var resolveJsxDevRuntimeCompatPath = () => {
@@ -7017,14 +7018,14 @@ var resolveJsxDevRuntimeCompatPath = () => {
 `)}
 `;
 }, buildReactVendor = async (buildDir) => {
-  const vendorDir = join14(buildDir, "react", "vendor");
+  const vendorDir = join15(buildDir, "react", "vendor");
   mkdirSync6(vendorDir, { recursive: true });
-  const tmpDir = join14(buildDir, "_vendor_tmp");
+  const tmpDir = join15(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 = join14(tmpDir, `${safeName}.ts`);
+    const entryPath = join15(tmpDir, `${safeName}.ts`);
     const source = await generateEntrySource(specifier);
     await Bun.write(entryPath, source);
     return entryPath;
@@ -7062,17 +7063,17 @@ __export(exports_buildAngularVendor, {
   buildAngularVendor: () => buildAngularVendor
 });
 import { mkdirSync as mkdirSync7 } from "fs";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import { rm as rm5 } from "fs/promises";
 var {build: bunBuild3 } = globalThis.Bun;
 var angularSpecifiers, toSafeFileName2 = (specifier) => specifier.replace(/^@/, "").replace(/\//g, "_"), buildAngularVendor = async (buildDir) => {
-  const vendorDir = join15(buildDir, "angular", "vendor");
+  const vendorDir = join16(buildDir, "angular", "vendor");
   mkdirSync7(vendorDir, { recursive: true });
-  const tmpDir = join15(buildDir, "_angular_vendor_tmp");
+  const tmpDir = join16(buildDir, "_angular_vendor_tmp");
   mkdirSync7(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(angularSpecifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
-    const entryPath = join15(tmpDir, `${safeName}.ts`);
+    const entryPath = join16(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -7117,17 +7118,17 @@ __export(exports_buildVueVendor, {
   buildVueVendor: () => buildVueVendor
 });
 import { mkdirSync as mkdirSync8 } from "fs";
-import { join as join16 } from "path";
+import { join as join17 } 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 = join16(buildDir, "vue", "vendor");
+  const vendorDir = join17(buildDir, "vue", "vendor");
   mkdirSync8(vendorDir, { recursive: true });
-  const tmpDir = join16(buildDir, "_vue_vendor_tmp");
+  const tmpDir = join17(buildDir, "_vue_vendor_tmp");
   mkdirSync8(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(vueSpecifiers.map(async (specifier) => {
     const safeName = toSafeFileName3(specifier);
-    const entryPath = join16(tmpDir, `${safeName}.ts`);
+    const entryPath = join17(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -7152,11 +7153,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: readFileSync10, writeFileSync: writeFileSync7, readdirSync } = await import("fs");
   const files = readdirSync(vendorDir).filter((f) => f.endsWith(".js"));
   for (const file4 of files) {
-    const filePath = join16(vendorDir, file4);
-    const content = readFileSync11(filePath, "utf-8");
+    const filePath = join17(vendorDir, file4);
+    const content = readFileSync10(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__ || {");
@@ -7182,7 +7183,7 @@ __export(exports_buildSvelteVendor, {
   buildSvelteVendor: () => buildSvelteVendor
 });
 import { mkdirSync as mkdirSync9 } from "fs";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 import { rm as rm7 } from "fs/promises";
 var {build: bunBuild5 } = globalThis.Bun;
 var svelteSpecifiers, isResolvable2 = (specifier) => {
@@ -7196,13 +7197,13 @@ var svelteSpecifiers, isResolvable2 = (specifier) => {
   const specifiers = resolveVendorSpecifiers2();
   if (specifiers.length === 0)
     return;
-  const vendorDir = join17(buildDir, "svelte", "vendor");
+  const vendorDir = join18(buildDir, "svelte", "vendor");
   mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join17(buildDir, "_svelte_vendor_tmp");
+  const tmpDir = join18(buildDir, "_svelte_vendor_tmp");
   mkdirSync9(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName4(specifier);
-    const entryPath = join17(tmpDir, `${safeName}.ts`);
+    const entryPath = join18(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -7281,12 +7282,12 @@ import {
   cpSync,
   existsSync as existsSync17,
   mkdirSync as mkdirSync10,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync10,
   rmSync as rmSync2,
   statSync,
   writeFileSync as writeFileSync7
 } from "fs";
-import { basename as basename8, dirname as dirname11, join as join18, relative as relative9, resolve as resolve20 } from "path";
+import { basename as basename8, dirname as dirname11, join as join19, relative as relative9, resolve as resolve20 } from "path";
 import { cwd, env as env3, exit } from "process";
 var {build: bunBuild6, Glob: Glob6 } = globalThis.Bun;
 var isDev2, collectConventionSourceFiles = (entry) => {
@@ -7361,8 +7362,8 @@ var isDev2, collectConventionSourceFiles = (entry) => {
   mkdirSync10(htmxDestDir, { recursive: true });
   const glob = new Glob6("htmx*.min.js");
   for (const relPath of glob.scanSync({ cwd: htmxDir })) {
-    const src = join18(htmxDir, relPath);
-    const dest = join18(htmxDestDir, "htmx.min.js");
+    const src = join19(htmxDir, relPath);
+    const dest = join19(htmxDestDir, "htmx.min.js");
     copyFileSync(src, dest);
     return;
   }
@@ -7402,7 +7403,7 @@ var isDev2, collectConventionSourceFiles = (entry) => {
     addWorkerPathIfExists(file4, relPath, workerPaths);
   }
 }, collectWorkerPathsFromFile = (file4, patterns, workerPaths) => {
-  const content = readFileSync11(file4, "utf-8");
+  const content = readFileSync10(file4, "utf-8");
   for (const pattern of patterns) {
     collectWorkerPathsFromContent(content, pattern, file4, workerPaths);
   }
@@ -7435,7 +7436,7 @@ var isDev2, collectConventionSourceFiles = (entry) => {
   vuePagesPath
 }) => {
   const { readdirSync: readDir } = await import("fs");
-  const devIndexDir = join18(buildPath, "_src_indexes");
+  const devIndexDir = join19(buildPath, "_src_indexes");
   mkdirSync10(devIndexDir, { recursive: true });
   if (reactIndexesPath && reactPagesPath) {
     copyReactDevIndexes(reactIndexesPath, reactPagesPath, devIndexDir, readDir);
@@ -7453,35 +7454,35 @@ var isDev2, collectConventionSourceFiles = (entry) => {
   const indexFiles = readDir(reactIndexesPath).filter((file4) => file4.endsWith(".tsx"));
   const pagesRel = relative9(process.cwd(), resolve20(reactPagesPath)).replace(/\\/g, "/");
   for (const file4 of indexFiles) {
-    let content = readFileSync11(join18(reactIndexesPath, file4), "utf-8");
+    let content = readFileSync10(join19(reactIndexesPath, file4), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
-    writeFileSync7(join18(devIndexDir, file4), content);
+    writeFileSync7(join19(devIndexDir, file4), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
-  const svelteIndexDir = join18(svelteDir, "generated", "indexes");
+  const svelteIndexDir = join19(svelteDir, "generated", "indexes");
   const sveltePageEntries = svelteEntries.filter((file4) => resolve20(file4).startsWith(resolve20(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename8(entry).replace(/\.svelte(\.(ts|js))?$/, "");
-    const indexFile = join18(svelteIndexDir, "pages", `${name}.js`);
+    const indexFile = join19(svelteIndexDir, "pages", `${name}.js`);
     if (!existsSync17(indexFile))
       continue;
-    let content = readFileSync11(indexFile, "utf-8");
+    let content = readFileSync10(indexFile, "utf-8");
     const srcRel = relative9(process.cwd(), resolve20(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
-    writeFileSync7(join18(devIndexDir, `${name}.svelte.js`), content);
+    writeFileSync7(join19(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
-  const vueIndexDir = join18(vueDir, "generated", "indexes");
+  const vueIndexDir = join19(vueDir, "generated", "indexes");
   const vuePageEntries = vueEntries.filter((file4) => resolve20(file4).startsWith(resolve20(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename8(entry, ".vue");
-    const indexFile = join18(vueIndexDir, `${name}.js`);
+    const indexFile = join19(vueIndexDir, `${name}.js`);
     if (!existsSync17(indexFile))
       continue;
-    let content = readFileSync11(indexFile, "utf-8");
+    let content = readFileSync10(indexFile, "utf-8");
     const srcRel = relative9(process.cwd(), resolve20(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Comp\s+from\s+['"]([^'"]+)['"]/, `import Comp from "/@src/${srcRel}"`);
-    writeFileSync7(join18(devIndexDir, `${name}.vue.js`), content);
+    writeFileSync7(join19(devIndexDir, `${name}.vue.js`), content);
   }
 }, resolveVueRuntimeId = (content, firstUseName, outputPath, projectRoot) => {
   const varIdx = content.indexOf(`var ${firstUseName} =`);
@@ -7529,7 +7530,7 @@ var isDev2, collectConventionSourceFiles = (entry) => {
   }
   return result;
 }, VUE_HMR_RUNTIME, injectVueComposableTracking = (outputPath, projectRoot) => {
-  let content = readFileSync11(outputPath, "utf-8");
+  let content = readFileSync10(outputPath, "utf-8");
   const usePattern = /^var\s+(use[A-Z]\w*)\s*=/gm;
   const useNames = [];
   let match;
@@ -7579,7 +7580,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 = readFileSync10(outputPath, "utf-8");
     let changed = false;
     content = content.replace(urlPattern, (_match, relPath) => {
       const targetName = basename8(relPath);
@@ -7629,14 +7630,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 && join18(reactDir, "generated", "indexes");
-  const reactPagesPath = reactDir && join18(reactDir, "pages");
-  const htmlPagesPath = htmlDir && join18(htmlDir, "pages");
-  const htmlScriptsPath = htmlDir && join18(htmlDir, "scripts");
-  const sveltePagesPath = svelteDir && join18(svelteDir, "pages");
-  const vuePagesPath = vueDir && join18(vueDir, "pages");
-  const htmxPagesPath = htmxDir && join18(htmxDir, "pages");
-  const angularPagesPath = angularDir && join18(angularDir, "pages");
+  const reactIndexesPath = reactDir && join19(reactDir, "generated", "indexes");
+  const reactPagesPath = reactDir && join19(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join19(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join19(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join19(svelteDir, "pages");
+  const vuePagesPath = vueDir && join19(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join19(htmxDir, "pages");
+  const angularPagesPath = angularDir && join19(angularDir, "pages");
   const frontends = [
     reactDir,
     htmlDir,
@@ -7673,12 +7674,12 @@ ${content.slice(firstUseIdx)}`;
   if (svelteDir)
     serverDirMap.push({
       dir: svelteDir,
-      subdir: join18("generated", "server")
+      subdir: join19("generated", "server")
     });
   if (vueDir)
     serverDirMap.push({
       dir: vueDir,
-      subdir: join18("generated", "server")
+      subdir: join19("generated", "server")
     });
   if (angularDir)
     serverDirMap.push({ dir: angularDir, subdir: "generated" });
@@ -7688,8 +7689,8 @@ ${content.slice(firstUseIdx)}`;
     const [firstEntry] = serverDirMap;
     if (!firstEntry)
       throw new Error("Expected at least one server directory entry");
-    serverRoot = join18(firstEntry.dir, firstEntry.subdir);
-    serverOutDir = join18(buildPath, basename8(firstEntry.dir));
+    serverRoot = join19(firstEntry.dir, firstEntry.subdir);
+    serverOutDir = join19(buildPath, basename8(firstEntry.dir));
   } else if (serverDirMap.length > 1) {
     serverRoot = commonAncestor(serverDirMap.map((entry) => entry.dir), projectRoot);
     serverOutDir = buildPath;
@@ -7717,7 +7718,7 @@ ${content.slice(firstUseIdx)}`;
     await generateReactIndexFiles(reactPagesPath, reactIndexesPath, hmr);
   }
   if (assetsPath && (!isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/assets/")))) {
-    cpSync(assetsPath, join18(buildPath, "assets"), {
+    cpSync(assetsPath, join19(buildPath, "assets"), {
       force: true,
       recursive: true
     });
@@ -7731,7 +7732,7 @@ ${content.slice(firstUseIdx)}`;
     } catch {
       binPath = "tailwindcss";
     }
-    const proc = Bun.spawn(["bun", binPath, "-i", input, "-o", join18(buildPath, output)], { stderr: "pipe", stdout: "pipe" });
+    const proc = Bun.spawn(["bun", binPath, "-i", input, "-o", join19(buildPath, output)], { stderr: "pipe", stdout: "pipe" });
     await proc.exited;
   };
   const tailwindPromise = tailwind && (!isIncremental || normalizedIncrementalFiles?.some(isStylePath)) ? compileTailwind(tailwind.input, tailwind.output) : undefined;
@@ -7778,7 +7779,7 @@ ${content.slice(firstUseIdx)}`;
   const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
     if (entry.startsWith(resolve20(reactIndexesPath))) {
       const pageName = basename8(entry, ".tsx");
-      return join18(reactPagesPath, `${pageName}.tsx`);
+      return join19(reactPagesPath, `${pageName}.tsx`);
     }
     return null;
   }) : allReactEntries;
@@ -7865,11 +7866,11 @@ ${content.slice(firstUseIdx)}`;
       vueConventionSources.length > 0 && vueDir ? Promise.resolve().then(() => (init_compileVue(), exports_compileVue)).then((mod) => mod.compileVue(vueConventionSources, vueDir, false)) : { vueServerPaths: emptyStringArray }
     ]);
     const copyConventionFiles = (framework, sources, compiledPaths) => {
-      const destDir = join18(buildPath, "conventions", framework);
+      const destDir = join19(buildPath, "conventions", framework);
       mkdirSync10(destDir, { recursive: true });
       const destPaths = [];
       for (const compiledPath of compiledPaths) {
-        const dest = join18(destDir, basename8(compiledPath));
+        const dest = join19(destDir, basename8(compiledPath));
         copyFileSync(compiledPath, dest);
         destPaths.push(dest);
       }
@@ -7915,7 +7916,7 @@ ${content.slice(firstUseIdx)}`;
     }
   }) : {
     entries: [],
-    generatedRoot: join18(buildPath, "_island_entries")
+    generatedRoot: join19(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) {
@@ -7950,7 +7951,7 @@ ${content.slice(firstUseIdx)}`;
     return {};
   }
   if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
-    const refreshEntry = join18(reactIndexesPath, "_refresh.tsx");
+    const refreshEntry = join19(reactIndexesPath, "_refresh.tsx");
     if (!reactClientEntryPoints.includes(refreshEntry))
       reactClientEntryPoints.push(refreshEntry);
   }
@@ -8005,19 +8006,19 @@ ${content.slice(firstUseIdx)}`;
     throw: false
   } : undefined;
   if (reactDir && reactClientEntryPoints.length > 0) {
-    rmSync2(join18(buildPath, "react", "generated", "indexes"), {
+    rmSync2(join19(buildPath, "react", "generated", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (angularDir && angularClientPaths.length > 0) {
-    rmSync2(join18(buildPath, "angular", "indexes"), {
+    rmSync2(join19(buildPath, "angular", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (islandClientEntryPoints.length > 0) {
-    rmSync2(join18(buildPath, "islands"), {
+    rmSync2(join19(buildPath, "islands"), {
       force: true,
       recursive: true
     });
@@ -8103,7 +8104,7 @@ ${content.slice(firstUseIdx)}`;
     globalCssEntries.length > 0 ? bunBuild6({
       entrypoints: globalCssEntries,
       naming: `[dir]/[name].[hash].[ext]`,
-      outdir: stylesDir ? join18(buildPath, basename8(stylesDir)) : buildPath,
+      outdir: stylesDir ? join19(buildPath, basename8(stylesDir)) : buildPath,
       root: stylesDir || clientRoot,
       target: "browser",
       plugins: [stylePreprocessorPlugin],
@@ -8112,7 +8113,7 @@ ${content.slice(firstUseIdx)}`;
     vueCssPaths.length > 0 ? bunBuild6({
       entrypoints: vueCssPaths,
       naming: `[name].[hash].[ext]`,
-      outdir: join18(buildPath, assetsPath ? basename8(assetsPath) : "assets", "css"),
+      outdir: join19(buildPath, assetsPath ? basename8(assetsPath) : "assets", "css"),
       target: "browser",
       throw: false
     }) : undefined
@@ -8234,7 +8235,7 @@ ${content.slice(firstUseIdx)}`;
   const injectHMRIntoHTMLFile = (filePath, framework) => {
     if (!hmrClientBundle)
       return;
-    let html = readFileSync11(filePath, "utf-8");
+    let html = readFileSync10(filePath, "utf-8");
     if (html.includes("data-hmr-client"))
       return;
     const tag = `<script>window.__HMR_FRAMEWORK__="${framework}";</script><script data-hmr-client>${hmrClientBundle}</script>`;
@@ -8245,7 +8246,7 @@ ${content.slice(firstUseIdx)}`;
   const processHtmlPages = async () => {
     if (!(htmlDir && htmlPagesPath))
       return;
-    const outputHtmlPages = isSingle ? join18(buildPath, "pages") : join18(buildPath, basename8(htmlDir), "pages");
+    const outputHtmlPages = isSingle ? join19(buildPath, "pages") : join19(buildPath, basename8(htmlDir), "pages");
     mkdirSync10(outputHtmlPages, { recursive: true });
     cpSync(htmlPagesPath, outputHtmlPages, {
       force: true,
@@ -8267,14 +8268,14 @@ ${content.slice(firstUseIdx)}`;
   const processHtmxPages = async () => {
     if (!(htmxDir && htmxPagesPath))
       return;
-    const outputHtmxPages = isSingle ? join18(buildPath, "pages") : join18(buildPath, basename8(htmxDir), "pages");
+    const outputHtmxPages = isSingle ? join19(buildPath, "pages") : join19(buildPath, basename8(htmxDir), "pages");
     mkdirSync10(outputHtmxPages, { recursive: true });
     cpSync(htmxPagesPath, outputHtmxPages, {
       force: true,
       recursive: true
     });
     if (shouldCopyHtmx) {
-      const htmxDestDir = isSingle ? buildPath : join18(buildPath, basename8(htmxDir));
+      const htmxDestDir = isSingle ? buildPath : join19(buildPath, basename8(htmxDir));
       copyHtmxVendor(htmxDir, htmxDestDir);
     }
     if (shouldUpdateHtmxAssetPaths) {
@@ -8329,9 +8330,9 @@ ${content.slice(firstUseIdx)}`;
   });
   if (isIncremental)
     return { conventions: conventionsMap, manifest };
-  writeFileSync7(join18(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
+  writeFileSync7(join19(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
   if (Object.keys(conventionsMap).length > 0) {
-    writeFileSync7(join18(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
+    writeFileSync7(join19(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
   }
   return { conventions: conventionsMap, manifest };
 };
@@ -8395,7 +8396,7 @@ var init_build = __esm(() => {
 });
 
 // src/dev/dependencyGraph.ts
-import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync11 } from "fs";
 var {Glob: Glob7 } = globalThis.Bun;
 import { resolve as resolve21 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
@@ -8556,15 +8557,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 = readFileSync11(filePath, "utf-8");
     return extractHtmlDependencies(filePath, content);
   }
   if (loader === "tsx" || loader === "js") {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync11(filePath, "utf-8");
     return extractJsDependencies(filePath, content, loader);
   }
   if (isSvelteOrVue) {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync11(filePath, "utf-8");
     return extractSvelteVueDependencies(filePath, content);
   }
   return [];
@@ -8853,7 +8854,7 @@ var init_pathUtils = __esm(() => {
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
 import { existsSync as existsSync19 } from "fs";
-import { join as join19, resolve as resolve23 } from "path";
+import { join as join20, resolve as resolve23 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -8880,7 +8881,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
     if (shouldSkipFilename(filename, isStylesDir)) {
       return;
     }
-    const fullPath = join19(absolutePath, filename).replace(/\\/g, "/");
+    const fullPath = join20(absolutePath, filename).replace(/\\/g, "/");
     if (shouldIgnorePath(fullPath, state.resolvedPaths)) {
       return;
     }
@@ -9031,10 +9032,10 @@ var init_assetStore = __esm(() => {
 });
 
 // src/dev/fileHashTracker.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 var computeFileHash = (filePath) => {
   try {
-    const fileContent = readFileSync13(filePath);
+    const fileContent = readFileSync12(filePath);
     return Number(Bun.hash(fileContent));
   } catch {
     return UNFOUND_INDEX;
@@ -9395,15 +9396,15 @@ var escapeHtml = (str) => String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;
 import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
 import { mkdir as mkdir4, symlink } from "fs/promises";
 import { tmpdir } from "os";
-import { basename as basename10, dirname as dirname12, join as join20, resolve as resolve27 } from "path";
+import { basename as basename10, dirname as dirname12, join as join21, resolve as resolve27 } from "path";
 var ssrDirty2 = false, lastSelector = "angular-page", isRecord8 = (value) => typeof value === "object" && value !== null, isAngularComponent = (value) => typeof value === "function", compilerImportPromise = null, ensureAngularCompiler = () => {
   if (!compilerImportPromise) {
     compilerImportPromise = import("@angular/compiler");
   }
   return compilerImportPromise;
-}, readAngularPageModule = (value) => isRecord8(value) ? value : null, resolveAngularSsrOutDir = () => process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR ?? join20(tmpdir(), "absolutejs", "generated", "angular-ssr"), ensureAngularSsrNodeModules = async (outDir) => {
+}, readAngularPageModule = (value) => isRecord8(value) ? value : null, resolveAngularSsrOutDir = () => process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR ?? join21(tmpdir(), "absolutejs", "generated", "angular-ssr"), ensureAngularSsrNodeModules = async (outDir) => {
   const outRoot = resolve27(dirname12(dirname12(outDir)));
-  const nodeModulesLink = join20(outRoot, "node_modules");
+  const nodeModulesLink = join21(outRoot, "node_modules");
   if (process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR) {
     return;
   }
@@ -9858,7 +9859,7 @@ __export(exports_moduleServer, {
   createModuleServer: () => createModuleServer,
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
-import { existsSync as existsSync20, readFileSync as readFileSync14, statSync as statSync2 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync13, statSync as statSync2 } from "fs";
 import { basename as basename12, dirname as dirname14, extname as extname6, resolve as resolve28, relative as relative10 } 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, '""');
@@ -9991,7 +9992,7 @@ ${stubs}
 `)}
 ${code}`;
 }, reactTranspilerOptions, reactTranspiler, transformReactFile = (filePath, projectRoot, rewriter) => {
-  const raw = readFileSync14(filePath, "utf-8");
+  const raw = readFileSync13(filePath, "utf-8");
   const valueExports = tsxTranspiler.scan(raw).exports;
   let transpiled = reactTranspiler.transformSync(raw);
   transpiled = preserveTypeExports(raw, transpiled, valueExports);
@@ -10007,7 +10008,7 @@ ${transpiled}`;
   transpiled += buildIslandMetadataExports(raw);
   return rewriteImports2(transpiled, filePath, projectRoot, rewriter);
 }, transformPlainFile = (filePath, projectRoot, rewriter, vueDir) => {
-  const raw = readFileSync14(filePath, "utf-8");
+  const raw = readFileSync13(filePath, "utf-8");
   const ext = extname6(filePath);
   const isTS = ext === ".ts" || ext === ".tsx";
   const isTSX = ext === ".tsx" || ext === ".jsx";
@@ -10163,7 +10164,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) => {
-  const raw = readFileSync14(filePath, "utf-8");
+  const raw = readFileSync13(filePath, "utf-8");
   if (!svelteCompiler) {
     svelteCompiler = await import("svelte/compiler");
   }
@@ -10221,7 +10222,7 @@ export default __script__;`;
   return `${cssInjection}
 ${code}`;
 }, transformVueFile = async (filePath, projectRoot, rewriter, vueDir) => {
-  const raw = readFileSync14(filePath, "utf-8");
+  const raw = readFileSync13(filePath, "utf-8");
   if (!vueCompiler) {
     vueCompiler = await import("@vue/compiler-sfc");
   }
@@ -10270,7 +10271,7 @@ ${code}`;
     }
   });
 }, handleCssRequest = (filePath) => {
-  const raw = readFileSync14(filePath, "utf-8");
+  const raw = readFileSync13(filePath, "utf-8");
   const escaped = raw.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return [
     `const style = document.createElement('style');`,
@@ -12160,7 +12161,7 @@ __export(exports_buildDepVendor, {
   buildDepVendor: () => buildDepVendor
 });
 import { mkdirSync as mkdirSync11 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 import { rm as rm8 } from "fs/promises";
 var {build: bunBuild7, Glob: Glob8 } = globalThis.Bun;
 var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g, "").replace(/-/g, "_"), isResolvable3 = (specifier) => {
@@ -12200,7 +12201,7 @@ var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g,
   return Array.from(specifiers).filter(isResolvable3);
 }, generateEntrySource2 = (specifier) => `export * from '${specifier}';
 `, rewriteVendorFiles = async (vendorDir) => {
-  const { readdirSync: readdirSync2, readFileSync: readFileSync15, writeFileSync: writeFileSync8 } = await import("fs");
+  const { readdirSync: readdirSync2, readFileSync: readFileSync14, writeFileSync: writeFileSync8 } = await import("fs");
   const { computeVendorPaths: computeVendorPaths2 } = await Promise.resolve().then(() => (init_buildReactVendor(), exports_buildReactVendor));
   const reactPaths = Object.entries(computeVendorPaths2());
   const rewriteContent = (content) => reactPaths.reduce((acc, [specifier, webPath]) => {
@@ -12210,8 +12211,8 @@ var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g,
   }, content);
   const files = readdirSync2(vendorDir).filter((f) => f.endsWith(".js"));
   for (const file4 of files) {
-    const filePath = join21(vendorDir, file4);
-    const original = readFileSync15(filePath, "utf-8");
+    const filePath = join22(vendorDir, file4);
+    const original = readFileSync14(filePath, "utf-8");
     const rewritten = rewriteContent(original);
     if (rewritten !== original)
       writeFileSync8(filePath, rewritten);
@@ -12220,13 +12221,13 @@ var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g,
   const specifiers = await scanBareImports(directories);
   if (specifiers.length === 0)
     return {};
-  const vendorDir = join21(buildDir, "vendor");
+  const vendorDir = join22(buildDir, "vendor");
   mkdirSync11(vendorDir, { recursive: true });
-  const tmpDir = join21(buildDir, "_dep_vendor_tmp");
+  const tmpDir = join22(buildDir, "_dep_vendor_tmp");
   mkdirSync11(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName5(specifier);
-    const entryPath = join21(tmpDir, `${safeName}.ts`);
+    const entryPath = join22(tmpDir, `${safeName}.ts`);
     const source = await generateEntrySource2(specifier);
     await Bun.write(entryPath, source);
     return entryPath;
@@ -12723,17 +12724,17 @@ __export(exports_devtoolsJson, {
   normalizeDevtoolsWorkspaceRoot: () => normalizeDevtoolsWorkspaceRoot,
   devtoolsJson: () => devtoolsJson
 });
-import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname17, join as join22, resolve as resolve33 } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname17, join as join23, 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 ?? join22(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
+}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve33(uuidCachePath ?? join23(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
   if (!existsSync22(cachePath))
     return null;
   try {
-    const value = readFileSync15(cachePath, "utf-8").trim();
+    const value = readFileSync14(cachePath, "utf-8").trim();
     return isUuidV4(value) ? value : null;
   } catch {
     return null;
@@ -12768,11 +12769,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 join22("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
+    return join23("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
   }
   if (process.env.DOCKER_DESKTOP && !root.startsWith("\\\\")) {
     const withoutLeadingSlash = root.replace(/^\//, "");
-    return join22("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
+    return join23("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
   }
   return root;
 };
@@ -13088,15 +13089,15 @@ __export(exports_prerender, {
   prerender: () => prerender,
   PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER
 });
-import { mkdirSync as mkdirSync13, readFileSync as readFileSync16 } from "fs";
-import { join as join23 } from "path";
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync15 } from "fs";
+import { join as join24 } from "path";
 var MAX_STARTUP_ATTEMPTS = 50, STARTUP_POLL_INTERVAL_MS = 100, 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 = readFileSync15(metaPath, "utf-8");
     return Number(content) || 0;
   } catch {
     return 0;
@@ -13145,7 +13146,7 @@ var MAX_STARTUP_ATTEMPTS = 50, STARTUP_POLL_INTERVAL_MS = 100, PRERENDER_BYPASS_
       return false;
     const html = await res.text();
     const fileName = routeToFilename(route);
-    const filePath = join23(prerenderDir, fileName);
+    const filePath = join24(prerenderDir, fileName);
     await Bun.write(filePath, html);
     await writeTimestamp(filePath);
     return true;
@@ -13164,13 +13165,13 @@ var MAX_STARTUP_ATTEMPTS = 50, STARTUP_POLL_INTERVAL_MS = 100, PRERENDER_BYPASS_
   }
   const html = await res.text();
   const fileName = routeToFilename(route);
-  const filePath = join23(prerenderDir, fileName);
+  const filePath = join24(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 = join23(outDir, "_prerendered");
+  const prerenderDir = join24(outDir, "_prerendered");
   mkdirSync13(prerenderDir, { recursive: true });
   const baseUrl = `http://localhost:${port}`;
   let routes;
@@ -13436,8 +13437,8 @@ var handleHTMXPageRequest = async (pagePath) => {
   });
 };
 // src/core/prepare.ts
-import { existsSync as existsSync24, readdirSync as readdirSync2, readFileSync as readFileSync17 } from "fs";
-import { basename as basename14, join as join24, relative as relative12, resolve as resolve35 } from "path";
+import { existsSync as existsSync24, readdirSync as readdirSync2, readFileSync as readFileSync16 } from "fs";
+import { basename as basename14, join as join25, relative as relative12, resolve as resolve35 } from "path";
 import { Elysia as Elysia5 } from "elysia";
 
 // src/utils/loadConfig.ts
@@ -13758,7 +13759,7 @@ var loadPrerenderMap = (prerenderDir) => {
       continue;
     const name = basename14(entry, ".html");
     const route = name === "index" ? "/" : `/${name}`;
-    map.set(route, join24(prerenderDir, entry));
+    map.set(route, join25(prerenderDir, entry));
   }
   return map;
 };
@@ -13798,7 +13799,7 @@ var prepare = async (configOrPath) => {
     return result;
   }
   stepStartedAt = performance.now();
-  const manifest = JSON.parse(readFileSync17(`${buildDir}/manifest.json`, "utf-8"));
+  const manifest = JSON.parse(readFileSync16(`${buildDir}/manifest.json`, "utf-8"));
   setCurrentIslandManifest(manifest);
   if (config.islands?.registry) {
     setCurrentIslandRegistry(await loadIslandRegistry(config.islands.registry));
@@ -13806,9 +13807,9 @@ var prepare = async (configOrPath) => {
   setCurrentPageIslandMetadata(await loadPageIslandMetadata(config));
   recordStep("load production manifest and island metadata", stepStartedAt);
   stepStartedAt = performance.now();
-  const conventionsPath = join24(buildDir, "conventions.json");
+  const conventionsPath = join25(buildDir, "conventions.json");
   if (existsSync24(conventionsPath)) {
-    const conventions2 = JSON.parse(readFileSync17(conventionsPath, "utf-8"));
+    const conventions2 = JSON.parse(readFileSync16(conventionsPath, "utf-8"));
     setConventions(conventions2);
   }
   recordStep("load production conventions", stepStartedAt);
@@ -13822,7 +13823,7 @@ var prepare = async (configOrPath) => {
   });
   recordStep("create static plugin", stepStartedAt);
   stepStartedAt = performance.now();
-  const prerenderDir = join24(buildDir, "_prerendered");
+  const prerenderDir = join25(buildDir, "_prerendered");
   const prerenderMap = loadPrerenderMap(prerenderDir);
   recordStep("load prerender map", stepStartedAt);
   if (prerenderMap.size > 0) {
@@ -13877,18 +13878,18 @@ import { argv } from "process";
 var {env: env4 } = globalThis.Bun;
 
 // src/dev/devCert.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync14, readFileSync as readFileSync18, rmSync as rmSync3 } from "fs";
-import { join as join25 } from "path";
-var CERT_DIR = join25(process.cwd(), ".absolutejs");
-var CERT_PATH = join25(CERT_DIR, "cert.pem");
-var KEY_PATH = join25(CERT_DIR, "key.pem");
+import { existsSync as existsSync25, mkdirSync as mkdirSync14, readFileSync as readFileSync17, 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");
 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 = () => existsSync25(CERT_PATH) && existsSync25(KEY_PATH);
 var isCertExpired = () => {
   try {
-    const certPem = readFileSync18(CERT_PATH, "utf-8");
+    const certPem = readFileSync17(CERT_PATH, "utf-8");
     const proc = Bun.spawnSync(["openssl", "x509", "-enddate", "-noout"], {
       stdin: new TextEncoder().encode(certPem)
     });
@@ -13984,8 +13985,8 @@ var loadDevCert = () => {
     return null;
   try {
     return {
-      cert: readFileSync18(paths.cert, "utf-8"),
-      key: readFileSync18(paths.key, "utf-8")
+      cert: readFileSync17(paths.cert, "utf-8"),
+      key: readFileSync17(paths.key, "utf-8")
     };
   } catch {
     return null;
@@ -14213,7 +14214,7 @@ var jsonLd2 = (schema) => {
 };
 // src/utils/defineEnv.ts
 var {env: bunEnv } = globalThis.Bun;
-import { existsSync as existsSync26, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync18 } from "fs";
 import { resolve as resolve36 } from "path";
 
 // node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
@@ -20255,13 +20256,13 @@ var checkEnvFileSecurity = (properties) => {
   const sensitiveKeys = Object.keys(properties).filter(isSensitive);
   if (sensitiveKeys.length === 0)
     return;
-  const envContent = readFileSync19(envPath, "utf-8");
+  const envContent = readFileSync18(envPath, "utf-8");
   const presentKeys = sensitiveKeys.filter((key) => envContent.includes(`${key}=`));
   if (presentKeys.length === 0)
     return;
   const gitignorePath = resolve36(cwd2, ".gitignore");
   if (existsSync26(gitignorePath)) {
-    const gitignore = readFileSync19(gitignorePath, "utf-8");
+    const gitignore = readFileSync18(gitignorePath, "utf-8");
     if (gitignore.split(`
 `).some((line) => line.trim() === ".env"))
       return;
@@ -20468,5 +20469,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=6C9DFD7661C7542C64756E2164756E21
+//# debugId=F5E990EFAC399D1764756E2164756E21
 //# sourceMappingURL=index.js.map