@absolutejs/absolute 0.19.0-beta.984 → 0.19.0-beta.985

package/dist/build.js

@@ -11558,7 +11558,7 @@ var init_validateSafePath = () => {};
 
 // src/build/scanAngularHandlerCalls.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync12 } from "fs";
-import { dirname as dirname11, isAbsolute as isAbsolute3, join as join22, resolve as resolve19 } from "path";
+import { join as join22 } from "path";
 import ts6 from "typescript";
 var ELYSIA_ROUTE_METHODS2, SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind2 = (filePath) => {
   if (filePath.endsWith(".tsx"))
@@ -11598,86 +11598,7 @@ var ELYSIA_ROUTE_METHODS2, SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind2 = (fil
     }
   }
   return out;
-}, fileMayContainAngularHandler = (source) => source.includes("handleAngularPageRequest"), collectFileImports = (sf, filePath) => {
-  const map = new Map;
-  const fileDir = dirname11(filePath);
-  const recordSpec = (localName, spec) => {
-    map.set(localName, spec);
-  };
-  const resolveSource = (specifier) => {
-    if (specifier.startsWith(".")) {
-      return resolve19(fileDir, specifier);
-    }
-    if (isAbsolute3(specifier)) {
-      return specifier;
-    }
-    return null;
-  };
-  for (const statement of sf.statements) {
-    if (!ts6.isImportDeclaration(statement))
-      continue;
-    if (!ts6.isStringLiteral(statement.moduleSpecifier))
-      continue;
-    if (statement.importClause?.isTypeOnly)
-      continue;
-    const source = statement.moduleSpecifier.text;
-    const resolvedAbsPath = resolveSource(source);
-    const clause = statement.importClause;
-    if (!clause)
-      continue;
-    if (clause.name) {
-      recordSpec(clause.name.text, {
-        importedName: "default",
-        isDefault: true,
-        localName: clause.name.text,
-        resolvedAbsPath,
-        source
-      });
-    }
-    const bindings = clause.namedBindings;
-    if (!bindings)
-      continue;
-    if (ts6.isNamespaceImport(bindings)) {
-      recordSpec(bindings.name.text, {
-        importedName: "*",
-        isDefault: false,
-        localName: bindings.name.text,
-        resolvedAbsPath,
-        source
-      });
-      continue;
-    }
-    for (const element of bindings.elements) {
-      if (element.isTypeOnly)
-        continue;
-      const localName = element.name.text;
-      const importedName = element.propertyName?.text ?? localName;
-      recordSpec(localName, {
-        importedName,
-        isDefault: false,
-        localName,
-        resolvedAbsPath,
-        source
-      });
-    }
-  }
-  return map;
-}, collectExpressionIdentifiers = (expr) => {
-  const out = new Set;
-  const visit = (node) => {
-    if (ts6.isIdentifier(node)) {
-      out.add(node.text);
-      return;
-    }
-    if (ts6.isPropertyAccessExpression(node)) {
-      visit(node.expression);
-      return;
-    }
-    ts6.forEachChild(node, visit);
-  };
-  visit(expr);
-  return out;
-}, extractManifestKey = (pagePathValue) => {
+}, fileMayContainAngularHandler = (source) => source.includes("handleAngularPageRequest"), extractManifestKey = (pagePathValue) => {
   if (!ts6.isCallExpression(pagePathValue))
     return null;
   const callee = pagePathValue.expression;
@@ -11714,13 +11635,11 @@ var ELYSIA_ROUTE_METHODS2, SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind2 = (fil
   if (!fileMayContainAngularHandler(source))
     return;
   const sf = ts6.createSourceFile(filePath, source, ts6.ScriptTarget.Latest, true, getScriptKind2(filePath));
-  const imports = collectFileImports(sf, filePath);
   const visit = (node) => {
     if (ts6.isCallExpression(node) && ts6.isIdentifier(node.expression) && node.expression.text === "handleAngularPageRequest") {
       const [arg] = node.arguments;
       if (arg && ts6.isObjectLiteralExpression(arg)) {
         let manifestKey = null;
-        let providersExpr = null;
         for (const prop of arg.properties) {
           if (ts6.isPropertyAssignment(prop)) {
             if (!prop.name)
@@ -11728,8 +11647,6 @@ var ELYSIA_ROUTE_METHODS2, SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind2 = (fil
             const name = ts6.isIdentifier(prop.name) ? prop.name.text : ts6.isStringLiteral(prop.name) ? prop.name.text : null;
             if (name === "pagePath") {
               manifestKey = extractManifestKey(prop.initializer);
-            } else if (name === "providers") {
-              providersExpr = prop.initializer;
             }
           } else if (ts6.isSpreadAssignment(prop)) {
             if (manifestKey)
@@ -11744,22 +11661,9 @@ var ELYSIA_ROUTE_METHODS2, SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind2 = (fil
           }
         }
         if (manifestKey) {
-          const providerImports = [];
-          let providersExprText = null;
-          if (providersExpr) {
-            providersExprText = providersExpr.getText(sf);
-            const idents = collectExpressionIdentifiers(providersExpr);
-            for (const ident of idents) {
-              const spec = imports.get(ident);
-              if (spec)
-                providerImports.push(spec);
-            }
-          }
           out.push({
             manifestKey,
             mountPath: findEnclosingMountPath(node),
-            providerImports,
-            providersExpr: providersExprText,
             sourceFile: filePath
           });
         }
@@ -11923,7 +11827,7 @@ __export(exports_parseAngularConfigImports, {
   parseAngularProvidersImport: () => parseAngularProvidersImport
 });
 import { existsSync as existsSync19, readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname12, isAbsolute as isAbsolute4, join as join24 } from "path";
+import { dirname as dirname11, isAbsolute as isAbsolute3, join as join24 } from "path";
 import ts8 from "typescript";
 var findDefineConfigCall = (sf) => {
   let result = null;
@@ -12012,8 +11916,8 @@ var findDefineConfigCall = (sf) => {
   const importInfo = findImportForBinding(sf, binding);
   if (!importInfo)
     return null;
-  const configDir2 = dirname12(configPath2);
-  const absolutePath = importInfo.source.startsWith(".") ? join24(configDir2, importInfo.source).replace(/\.[cm]?[tj]sx?$/, "") : isAbsolute4(importInfo.source) ? importInfo.source.replace(/\.[cm]?[tj]sx?$/, "") : importInfo.source;
+  const configDir2 = dirname11(configPath2);
+  const absolutePath = importInfo.source.startsWith(".") ? join24(configDir2, importInfo.source).replace(/\.[cm]?[tj]sx?$/, "") : isAbsolute3(importInfo.source) ? importInfo.source.replace(/\.[cm]?[tj]sx?$/, "") : importInfo.source;
   return {
     absolutePath,
     bindingName: binding,
@@ -12164,11 +12068,11 @@ __export(exports_compileSvelte, {
 import { existsSync as existsSync20 } from "fs";
 import { mkdir as mkdir4, stat as stat2 } from "fs/promises";
 import {
-  dirname as dirname13,
+  dirname as dirname12,
   join as join25,
   basename as basename6,
   extname as extname5,
-  resolve as resolve20,
+  resolve as resolve19,
   relative as relative9,
   sep as sep2
 } from "path";
@@ -12176,14 +12080,14 @@ import { env } from "process";
 var {write: write2, file, Transpiler: Transpiler2 } = globalThis.Bun;
 var resolveDevClientDir2 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve20(import.meta.dir, "../dev/client");
+  const fromSource = resolve19(import.meta.dir, "../dev/client");
   if (existsSync20(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve20(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve19(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync20(fromNodeModules))
     return fromNodeModules;
-  return resolve20(import.meta.dir, "./dev/client");
+  return resolve19(import.meta.dir, "./dev/client");
 }, devClientDir2, hmrClientPath3, persistentCache, sourceHashCache, clearSvelteCompilerCache = () => {
   persistentCache.clear();
   sourceHashCache.clear();
@@ -12213,7 +12117,7 @@ var resolveDevClientDir2 = () => {
 }, resolveRelativeModule2 = async (spec, from) => {
   if (!spec.startsWith("."))
     return null;
-  const basePath = resolve20(dirname13(from), spec);
+  const basePath = resolve19(dirname12(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -12240,7 +12144,7 @@ var resolveDevClientDir2 = () => {
     const resolved = resolvePackageImport(spec);
     return resolved && /\.svelte(\.(?:ts|js))?$/.test(resolved) ? resolved : null;
   }
-  const basePath = resolve20(dirname13(from), spec);
+  const basePath = resolve19(dirname12(from), spec);
   const explicit = /\.(svelte|svelte\.(?:ts|js))$/.test(basePath);
   if (!explicit) {
     const extensions = [".svelte", ".svelte.ts", ".svelte.js"];
@@ -12300,8 +12204,8 @@ var resolveDevClientDir2 = () => {
     const preprocessedClient = isModule ? loweredClientSource.code : (await preprocess(loweredClientSource.code, svelteStylePreprocessor)).code;
     const transpiledServer = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler3.transformSync(preprocessedServer) : preprocessedServer;
     const transpiledClient = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler3.transformSync(preprocessedClient) : preprocessedClient;
-    const rawRel = dirname13(relative9(svelteRoot, src)).replace(/\\/g, "/");
-    const relDir = rawRel.startsWith("..") ? `_ext/${relative9(process.cwd(), dirname13(src)).replace(/\\/g, "/")}` : rawRel;
+    const rawRel = dirname12(relative9(svelteRoot, src)).replace(/\\/g, "/");
+    const relDir = rawRel.startsWith("..") ? `_ext/${relative9(process.cwd(), dirname12(src)).replace(/\\/g, "/")}` : rawRel;
     const baseName = basename6(src).replace(/\.svelte(\.(ts|js))?$/, "");
     const importPaths = Array.from(transpiledServer.matchAll(/from\s+['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((path) => path !== undefined);
     const resolvedModuleImports = await Promise.all(importPaths.map((importPath) => resolveRelativeModule2(importPath, src)));
@@ -12310,8 +12214,8 @@ var resolveDevClientDir2 = () => {
     const childBuilt = await Promise.all(childSources.map((child) => build(child)));
     const hasAwaitSlotFromChildren = childBuilt.some((child) => child.hasAwaitSlot);
     const externalRewrites = new Map;
-    const ssrOutputDir = dirname13(join25(serverDir, relDir, `${baseName}.js`));
-    const clientOutputDir = dirname13(join25(clientDir, relDir, `${baseName}.js`));
+    const ssrOutputDir = dirname12(join25(serverDir, relDir, `${baseName}.js`));
+    const clientOutputDir = dirname12(join25(clientDir, relDir, `${baseName}.js`));
     for (let idx = 0;idx < importPaths.length; idx++) {
       const rawSpec = importPaths[idx];
       if (!rawSpec)
@@ -12379,8 +12283,8 @@ var resolveDevClientDir2 = () => {
     const ssrPath = join25(serverDir, relDir, `${baseName}.js`);
     const clientPath = join25(clientDir, relDir, `${baseName}.js`);
     await Promise.all([
-      mkdir4(dirname13(ssrPath), { recursive: true }),
-      mkdir4(dirname13(clientPath), { recursive: true })
+      mkdir4(dirname12(ssrPath), { recursive: true }),
+      mkdir4(dirname12(clientPath), { recursive: true })
     ]);
     const inlineMap = (map) => map ? `
 //# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(map)).toString("base64")}
@@ -12413,10 +12317,10 @@ var resolveDevClientDir2 = () => {
   };
   const roots = await Promise.all(entryPoints.map(build));
   await Promise.all(roots.map(async ({ client, hasAwaitSlot }) => {
-    const relClientDir = dirname13(relative9(clientDir, client));
+    const relClientDir = dirname12(relative9(clientDir, client));
     const name = basename6(client, extname5(client));
     const indexPath = join25(indexDir, relClientDir, `${name}.js`);
-    const importRaw = relative9(dirname13(indexPath), client).split(sep2).join("/");
+    const importRaw = relative9(dirname12(indexPath), client).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev ? `window.__HMR_FRAMEWORK__ = "svelte";
 import "${hmrClientPath3}";
@@ -12487,13 +12391,13 @@ if (typeof window !== "undefined") {
     setTimeout(releaseStreamingSlots, 0);
   }
 }`;
-    await mkdir4(dirname13(indexPath), { recursive: true });
+    await mkdir4(dirname12(indexPath), { recursive: true });
     return write2(indexPath, bootstrap);
   }));
   return {
     svelteClientPaths: roots.map(({ client }) => client),
     svelteIndexPaths: roots.map(({ client }) => {
-      const rel = dirname13(relative9(clientDir, client));
+      const rel = dirname12(relative9(clientDir, client));
       return join25(indexDir, rel, basename6(client));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
@@ -12905,23 +12809,23 @@ import { existsSync as existsSync21 } from "fs";
 import { mkdir as mkdir5 } from "fs/promises";
 import {
   basename as basename7,
-  dirname as dirname14,
-  isAbsolute as isAbsolute5,
+  dirname as dirname13,
+  isAbsolute as isAbsolute4,
   join as join26,
   relative as relative10,
-  resolve as resolve21
+  resolve as resolve20
 } from "path";
 var {file: file2, write: write3, Transpiler: Transpiler3 } = globalThis.Bun;
 var resolveDevClientDir3 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve21(import.meta.dir, "../dev/client");
+  const fromSource = resolve20(import.meta.dir, "../dev/client");
   if (existsSync21(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve21(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve20(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync21(fromNodeModules))
     return fromNodeModules;
-  return resolve21(import.meta.dir, "./dev/client");
+  return resolve20(import.meta.dir, "./dev/client");
 }, devClientDir3, hmrClientPath4, transpiler4, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, clearVueHmrCaches = () => {
   scriptCache.clear();
   scriptSetupCache.clear();
@@ -12967,7 +12871,7 @@ var resolveDevClientDir3 = () => {
     return filePath.replace(/\.ts$/, ".js");
   if (isStylePath(filePath)) {
     if (sourceDir && (filePath.startsWith("./") || filePath.startsWith("../"))) {
-      return resolve21(sourceDir, filePath);
+      return resolve20(sourceDir, filePath);
     }
     return filePath;
   }
@@ -13031,12 +12935,12 @@ var resolveDevClientDir3 = () => {
   const childComponentPaths = importPaths.filter((path) => path.startsWith(".") && path.endsWith(".vue"));
   const packageComponentPaths = Array.from(resolvedPackageVueImports.entries());
   const helperModulePaths = importPaths.filter((path) => path.startsWith(".") && !path.endsWith(".vue") && !isStylePath(path));
-  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute5(path)) && isStylePath(path)).map((path) => isAbsolute5(path) ? path : resolve21(dirname14(sourceFilePath), path));
+  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute4(path)) && isStylePath(path)).map((path) => isAbsolute4(path) ? path : resolve20(dirname13(sourceFilePath), path));
   for (const stylePath of stylePathsImported) {
     addStyleImporter(sourceFilePath, stylePath);
   }
   const childBuildResults = await Promise.all([
-    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve21(dirname14(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
+    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve20(dirname13(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
     ...packageComponentPaths.map(([, absolutePath]) => compileVueFile(absolutePath, outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors))
   ]);
   const hasScript = descriptor.script || descriptor.scriptSetup;
@@ -13046,7 +12950,7 @@ var resolveDevClientDir3 = () => {
     sourceMap: true
   }) : { bindings: {}, content: "export default {};", map: undefined };
   const strippedScript = stripExports2(compiledScript.content);
-  const sourceDir = dirname14(sourceFilePath);
+  const sourceDir = dirname13(sourceFilePath);
   const transpiledScript = transpiler4.transformSync(strippedScript).replace(/(['"])(\.{1,2}\/[^'"]+)(['"])/g, (_2, quoteStart, relativeImport, quoteEnd) => `${quoteStart}${toJs(relativeImport, sourceDir)}${quoteEnd}`);
   const packageImportRewrites = new Map;
   for (const [bareImport, absolutePath] of packageComponentPaths) {
@@ -13086,7 +12990,7 @@ var resolveDevClientDir3 = () => {
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
     const cssOutputFile = join26(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
-    await mkdir5(dirname14(cssOutputFile), { recursive: true });
+    await mkdir5(dirname13(cssOutputFile), { recursive: true });
     await write3(cssOutputFile, allCss.join(`
 `));
     cssOutputPaths = [cssOutputFile];
@@ -13118,7 +13022,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   const serverCode = assembleModule(generateRenderFunction(true), "ssrRender", false) + islandMetadataExports;
   const clientOutputPath = join26(outputDirs.client, `${relativeWithoutExtension}.js`);
   const serverOutputPath = join26(outputDirs.server, `${relativeWithoutExtension}.js`);
-  const relDir = dirname14(relativeFilePath);
+  const relDir = dirname13(relativeFilePath);
   const relDepth = relDir === "." ? 0 : relDir.split("/").length;
   const adjustImports = (code) => code.replace(/(from\s+['"])(\.\.\/(?:\.\.\/)*)/g, (_2, prefix, dots) => {
     const upCount = dots.split("/").length - 1;
@@ -13130,15 +13034,15 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     let result2 = code;
     for (const [bareImport, paths] of packageImportRewrites) {
       const targetPath = mode === "server" ? paths.server : paths.client;
-      let rel = relative10(dirname14(outputPath), targetPath).replace(/\\/g, "/");
+      let rel = relative10(dirname13(outputPath), targetPath).replace(/\\/g, "/");
       if (!rel.startsWith("."))
         rel = `./${rel}`;
       result2 = result2.replaceAll(bareImport, rel);
     }
     return result2;
   };
-  await mkdir5(dirname14(clientOutputPath), { recursive: true });
-  await mkdir5(dirname14(serverOutputPath), { recursive: true });
+  await mkdir5(dirname13(clientOutputPath), { recursive: true });
+  await mkdir5(dirname13(serverOutputPath), { recursive: true });
   const clientFinal = rewritePackageImports(adjustImports(clientCode), clientOutputPath, "client");
   const serverFinal = rewritePackageImports(adjustImports(serverCode), serverOutputPath, "server");
   const inlineSourceMapFor = (finalContent) => {
@@ -13160,7 +13064,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     hmrId,
     serverPath: serverOutputPath,
     tsHelperPaths: [
-      ...helperModulePaths.map((helper) => resolve21(dirname14(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
+      ...helperModulePaths.map((helper) => resolve20(dirname13(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
       ...childBuildResults.flatMap((child) => child.tsHelperPaths)
     ]
   };
@@ -13183,7 +13087,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   const buildCache = new Map;
   const allTsHelperPaths = new Set;
   const compiledPages = await Promise.all(entryPoints.map(async (entryPath) => {
-    const result = await compileVueFile(resolve21(entryPath), {
+    const result = await compileVueFile(resolve20(entryPath), {
       client: clientOutputDir,
       css: cssOutputDir,
       server: serverOutputDir
@@ -13192,14 +13096,14 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     const entryBaseName = basename7(entryPath, ".vue");
     const indexOutputFile = join26(indexOutputDir, `${entryBaseName}.js`);
     const clientOutputFile = join26(clientOutputDir, relative10(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
-    await mkdir5(dirname14(indexOutputFile), { recursive: true });
+    await mkdir5(dirname13(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
       `import "${hmrClientPath4}";`
     ] : [];
     await write3(indexOutputFile, [
       ...vueHmrImports,
-      `import Comp, * as PageModule from "${relative10(dirname14(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
+      `import Comp, * as PageModule from "${relative10(dirname13(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
       'import { createSSRApp, createApp } from "vue";',
       "",
       "// HMR State Preservation: Check for preserved state from HMR",
@@ -13346,8 +13250,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     const relativeJsPath = relative10(vueRootDir, tsPath).replace(/\.ts$/, ".js");
     const outClientPath = join26(clientOutputDir, relativeJsPath);
     const outServerPath = join26(serverOutputDir, relativeJsPath);
-    await mkdir5(dirname14(outClientPath), { recursive: true });
-    await mkdir5(dirname14(outServerPath), { recursive: true });
+    await mkdir5(dirname13(outClientPath), { recursive: true });
+    await mkdir5(dirname13(outServerPath), { recursive: true });
     await write3(outClientPath, transpiledCode);
     await write3(outServerPath, transpiledCode);
   }));
@@ -13850,7 +13754,7 @@ __export(exports_compileAngular, {
   compileAngular: () => compileAngular
 });
 import { existsSync as existsSync22, readFileSync as readFileSync16, promises as fs5 } from "fs";
-import { join as join27, basename as basename8, sep as sep3, dirname as dirname15, resolve as resolve22, relative as relative11 } from "path";
+import { join as join27, basename as basename8, sep as sep3, dirname as dirname14, resolve as resolve21, relative as relative11 } from "path";
 var {Glob: Glob6 } = globalThis.Bun;
 import ts9 from "typescript";
 var traceAngularPhase = async (name, fn2, metadata) => {
@@ -13858,10 +13762,10 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   return tracePhase ? tracePhase(`compile/angular/${name}`, fn2, metadata) : await fn2();
 }, readTsconfigPathAliases = () => {
   try {
-    const configPath2 = resolve22(process.cwd(), "tsconfig.json");
+    const configPath2 = resolve21(process.cwd(), "tsconfig.json");
     const config = ts9.readConfigFile(configPath2, ts9.sys.readFile).config;
     const compilerOptions = config?.compilerOptions ?? {};
-    const baseUrl = resolve22(process.cwd(), compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve21(process.cwd(), compilerOptions.baseUrl ?? ".");
     const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
     return { aliases, baseUrl };
   } catch {
@@ -13881,7 +13785,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     const wildcardValue = exactMatch ? "" : specifier.slice(prefix.length, specifier.length - suffix.length);
     for (const replacement of alias.replacements) {
       const candidate = replacement.replace("*", wildcardValue);
-      const resolved = resolveSourceFile(resolve22(baseUrl, candidate));
+      const resolved = resolveSourceFile(resolve21(baseUrl, candidate));
       if (resolved)
         return resolved;
     }
@@ -13900,13 +13804,13 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   ];
   return candidates.find((file3) => existsSync22(file3));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
-  const baseDir = resolve22(rootDir);
+  const baseDir = resolve21(rootDir);
   const tsconfigAliases = readTsconfigPathAliases();
   const transpiler5 = new Bun.Transpiler({ loader: "tsx" });
   const scanCache = new Map;
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile(resolve22(fromDir, specifier));
+      return resolveSourceFile(resolve21(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile);
     if (aliased)
@@ -13915,7 +13819,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve22(resolved);
+      const absolute = resolve21(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile(absolute);
@@ -13931,7 +13835,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
         usesLegacyAnimations: false
       });
     }
-    const resolved = resolve22(actualPath);
+    const resolved = resolve21(actualPath);
     const cached = scanCache.get(resolved);
     if (cached)
       return cached;
@@ -13960,7 +13864,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     const actualPath = resolveSourceFile(filePath);
     if (!actualPath)
       return false;
-    const resolved = resolve22(actualPath);
+    const resolved = resolve21(actualPath);
     if (visited.has(resolved))
       return false;
     visited.add(resolved);
@@ -13968,7 +13872,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     if (scan.usesLegacyAnimations)
       return true;
     for (const specifier of scan.imports) {
-      const importedPath = resolveLocalImport(specifier, dirname15(resolved));
+      const importedPath = resolveLocalImport(specifier, dirname14(resolved));
       if (importedPath && await visit(importedPath, visited)) {
         return true;
       }
@@ -13978,14 +13882,14 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   return (entryPath) => visit(entryPath);
 }, resolveDevClientDir4 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve22(import.meta.dir, "../dev/client");
+  const fromSource = resolve21(import.meta.dir, "../dev/client");
   if (existsSync22(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve22(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve21(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync22(fromNodeModules))
     return fromNodeModules;
-  return resolve22(import.meta.dir, "./dev/client");
+  return resolve21(import.meta.dir, "./dev/client");
 }, devClientDir4, hmrClientPath5, formatDiagnosticMessage = (diagnostic) => {
   try {
     return ts9.flattenDiagnosticMessageText(diagnostic.messageText, `
@@ -14027,12 +13931,12 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     return `${path.replace(/\.ts$/, ".js")}${query}`;
   if (hasJsLikeExtension(path))
     return `${path}${query}`;
-  const importerDir = dirname15(importerOutputPath);
-  const fileCandidate = resolve22(importerDir, `${path}.js`);
+  const importerDir = dirname14(importerOutputPath);
+  const fileCandidate = resolve21(importerDir, `${path}.js`);
   if (outputFiles?.has(fileCandidate) || existsSync22(fileCandidate)) {
     return `${path}.js${query}`;
   }
-  const indexCandidate = resolve22(importerDir, path, "index.js");
+  const indexCandidate = resolve21(importerDir, path, "index.js");
   if (outputFiles?.has(indexCandidate) || existsSync22(indexCandidate)) {
     return `${path}/index.js${query}`;
   }
@@ -14060,7 +13964,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve22(dirname15(fromFile), specifier);
+  const basePath = resolve21(dirname14(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
@@ -14071,7 +13975,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     join27(basePath, "index.mts"),
     join27(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve22(candidate)).find((candidate) => existsSync22(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+  return candidates.map((candidate) => resolve21(candidate)).find((candidate) => existsSync22(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile6) => {
   const hostSource = readFile6?.(fileName);
   if (typeof hostSource === "string")
@@ -14106,7 +14010,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
       paths.push(join27(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
-  return paths.map((path) => resolve22(path));
+  return paths.map((path) => resolve21(path));
 }, readResourceCacheFile = async (cachePath) => {
   try {
     const entry = JSON.parse(await fs5.readFile(cachePath, "utf-8"));
@@ -14118,13 +14022,13 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     return null;
   }
 }, writeResourceCacheFile = async (cachePath, source) => {
-  await fs5.mkdir(dirname15(cachePath), { recursive: true });
+  await fs5.mkdir(dirname14(cachePath), { recursive: true });
   await fs5.writeFile(cachePath, JSON.stringify({
     source,
     version: 1
   }), "utf-8");
 }, resolveResourceTransformCachePath = async (filePath, source, stylePreprocessors) => {
-  const resourcePaths = collectAngularResourcePaths(source, dirname15(filePath));
+  const resourcePaths = collectAngularResourcePaths(source, dirname14(filePath));
   const resourceContents = await Promise.all(resourcePaths.map(async (resourcePath) => {
     const content = await fs5.readFile(resourcePath, "utf-8");
     return `${resourcePath}\x00${content}`;
@@ -14148,7 +14052,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     transformedFiles: 0
   };
   const transformFile = async (filePath) => {
-    const resolvedPath = resolve22(filePath);
+    const resolvedPath = resolve21(filePath);
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
@@ -14164,7 +14068,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
       transformedSource = cached.source;
     } else {
       stats.cacheMisses += 1;
-      const transformed = await inlineResources(source, dirname15(resolvedPath), stylePreprocessors);
+      const transformed = await inlineResources(source, dirname14(resolvedPath), stylePreprocessors);
       transformedSource = transformed.source;
       await writeResourceCacheFile(cachePath, transformedSource);
     }
@@ -14183,7 +14087,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   return { stats, transformedSources };
 }, compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
   const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
-    const outputPath = resolve22(join27(outDir, relative11(process.cwd(), resolve22(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve21(join27(outDir, relative11(process.cwd(), resolve21(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
       buildIslandMetadataExports(readFileSync16(inputPath, "utf-8"))
@@ -14193,8 +14097,8 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   const { readConfiguration, performCompilation, EmitFlags } = await traceAngularPhase("aot/import-compiler-cli", () => import("@angular/compiler-cli"));
   const tsLibDir = await traceAngularPhase("aot/resolve-typescript-lib", () => {
     const tsPath = __require.resolve("typescript");
-    const tsRootDir = dirname15(tsPath);
-    return tsRootDir.endsWith("lib") ? tsRootDir : resolve22(tsRootDir, "lib");
+    const tsRootDir = dirname14(tsPath);
+    return tsRootDir.endsWith("lib") ? tsRootDir : resolve21(tsRootDir, "lib");
   });
   const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
   const options = {
@@ -14236,7 +14140,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
   };
   const emitted = {};
-  const resolvedOutDir = resolve22(outDir);
+  const resolvedOutDir = resolve21(outDir);
   host.writeFile = (fileName, text) => {
     const relativePath = resolveRelativePath(fileName, resolvedOutDir, outDir);
     emitted[relativePath] = text;
@@ -14258,12 +14162,12 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     if (!fileName.endsWith(".ts") || fileName.endsWith(".d.ts")) {
       return source;
     }
-    const resolvedPath = resolve22(fileName);
+    const resolvedPath = resolve21(fileName);
     return transformedSources.get(resolvedPath) ?? source;
   };
   const originalGetSourceFileForCompile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
-    const source = transformedSources.get(resolve22(fileName));
+    const source = transformedSources.get(resolve21(fileName));
     if (source) {
       return ts9.createSourceFile(fileName, source, languageVersion, true);
     }
@@ -14287,7 +14191,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
       content,
       target: join27(outDir, fileName)
     }));
-    const outputFiles = new Set(rawEntries.map(({ target }) => resolve22(target)));
+    const outputFiles = new Set(rawEntries.map(({ target }) => resolve21(target)));
     return rawEntries.map(({ content, target }) => {
       let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
         const rewritten = rewriteRelativeJsSpecifier(target, path, outputFiles);
@@ -14302,17 +14206,17 @@ var traceAngularPhase = async (name, fn2, metadata) => {
         return cleaned ? `import { ${cleaned}, InternalInjectFlags } from '@angular/core'` : `import { InternalInjectFlags } from '@angular/core'`;
       });
       processedContent = processedContent.replace(/\b(?<!Internal)InjectFlags\b/g, "InternalInjectFlags");
-      processedContent += islandMetadataByOutputPath.get(resolve22(target)) ?? "";
+      processedContent += islandMetadataByOutputPath.get(resolve21(target)) ?? "";
       return { content: processedContent, target };
     });
   });
   await traceAngularPhase("aot/write-output", () => Promise.all(entries.map(async ({ target, content }) => {
-    await fs5.mkdir(dirname15(target), { recursive: true });
+    await fs5.mkdir(dirname14(target), { recursive: true });
     await fs5.writeFile(target, content, "utf-8");
   })), { outputs: entries.length });
   return await traceAngularPhase("aot/collect-output-paths", () => entries.map(({ target }) => target), { outputs: entries.length });
 }, compileAngularFile = async (inputPath, outDir, stylePreprocessors) => compileAngularFiles([inputPath], outDir, stylePreprocessors), jitContentCache, invalidateAngularJitCache = (filePath) => {
-  jitContentCache.delete(resolve22(filePath));
+  jitContentCache.delete(resolve21(filePath));
 }, wrapperOutputCache, escapeTemplateContent = (content) => content.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${"), findUncommentedMatch = (source, pattern) => {
   const re2 = new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g");
   let match;
@@ -14325,7 +14229,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   }
   return null;
 }, resolveAngularDeferImportSpecifier = () => {
-  const sourceEntry = resolve22(import.meta.dir, "../angular/components/index.ts");
+  const sourceEntry = resolve21(import.meta.dir, "../angular/components/index.ts");
   if (existsSync22(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
@@ -14555,10 +14459,10 @@ ${fields}
     source: result
   };
 }, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors, cacheBuster) => {
-  const entryPath = resolve22(inputPath);
+  const entryPath = resolve21(inputPath);
   const allOutputs = [];
   const visited = new Set;
-  const baseDir = resolve22(rootDir ?? process.cwd());
+  const baseDir = resolve21(rootDir ?? process.cwd());
   let usesLegacyAnimations = false;
   const angularTranspiler = new Bun.Transpiler({
     loader: "ts",
@@ -14586,7 +14490,7 @@ ${fields}
   };
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile2(resolve22(fromDir, specifier));
+      return resolveSourceFile2(resolve21(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile2);
     if (aliased)
@@ -14595,7 +14499,7 @@ ${fields}
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve22(resolved);
+      const absolute = resolve21(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile2(absolute);
@@ -14604,7 +14508,7 @@ ${fields}
     }
   };
   const toOutputPath = (sourcePath) => {
-    const inputDir = dirname15(sourcePath);
+    const inputDir = dirname14(sourcePath);
     const fileBase = basename8(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
     if (inputDir === outDir || inputDir.startsWith(`${outDir}${sep3}`)) {
       return join27(inputDir, fileBase);
@@ -14647,18 +14551,18 @@ ${fields}
         return `${prefix}${dots}`;
       return `${prefix}../${dots}`;
     });
-    if (resolve22(actualPath) === entryPath) {
+    if (resolve21(actualPath) === entryPath) {
       processedContent += buildIslandMetadataExports(sourceCode);
     }
     return processedContent;
   };
   const transpileFile = async (filePath) => {
-    const resolved = resolve22(filePath);
+    const resolved = resolve21(filePath);
     if (visited.has(resolved))
       return;
     visited.add(resolved);
     if (resolved.endsWith(".json") && existsSync22(resolved)) {
-      const inputDir2 = dirname15(resolved);
+      const inputDir2 = dirname14(resolved);
       const relativeDir2 = inputDir2.startsWith(baseDir) ? inputDir2.substring(baseDir.length + 1) : inputDir2;
       const targetDir2 = join27(outDir, relativeDir2);
       const targetPath2 = join27(targetDir2, basename8(resolved));
@@ -14673,12 +14577,12 @@ ${fields}
     if (!existsSync22(actualPath))
       return;
     let sourceCode = await fs5.readFile(actualPath, "utf-8");
-    const inlined = await inlineResources(sourceCode, dirname15(actualPath), stylePreprocessors);
-    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname15(actualPath)).source;
-    const inputDir = dirname15(actualPath);
+    const inlined = await inlineResources(sourceCode, dirname14(actualPath), stylePreprocessors);
+    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname14(actualPath)).source;
+    const inputDir = dirname14(actualPath);
     const fileBase = basename8(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
     const targetPath = toOutputPath(actualPath);
-    const targetDir = dirname15(targetPath);
+    const targetDir = dirname14(targetPath);
     const relativeDir = relative11(outDir, targetDir).replace(/\\/g, "/");
     const localImports = [];
     const importRewrites = new Map;
@@ -14705,7 +14609,7 @@ ${fields}
       importRewrites.set(specifier, relativeRewrite);
       return resolved2;
     }).filter((path) => Boolean(path));
-    const isEntry = resolve22(actualPath) === resolve22(entryPath);
+    const isEntry = resolve21(actualPath) === resolve21(entryPath);
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey2 = actualPath;
     const shouldWriteFile = cacheBuster && isEntry ? true : jitContentCache.get(cacheKey2) !== contentHash || !existsSync22(targetPath);
@@ -14741,11 +14645,11 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
   const compiledRoot = compiledParent;
   const indexesDir = join27(compiledParent, "indexes");
   await traceAngularPhase("setup/create-indexes-dir", () => fs5.mkdir(indexesDir, { recursive: true }));
-  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve22(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
+  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve21(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   if (!hmr) {
     await traceAngularPhase("aot/copy-json-resources", async () => {
       const cwd = process.cwd();
-      const angularSrcDir = resolve22(outRoot);
+      const angularSrcDir = resolve21(outRoot);
       if (!existsSync22(angularSrcDir))
         return;
       const jsonGlob = new Glob6("**/*.json");
@@ -14756,14 +14660,14 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
         const sourcePath = join27(angularSrcDir, rel);
         const cwdRel = relative11(cwd, sourcePath);
         const targetPath = join27(compiledRoot, cwdRel);
-        await fs5.mkdir(dirname15(targetPath), { recursive: true });
+        await fs5.mkdir(dirname14(targetPath), { recursive: true });
         await fs5.copyFile(sourcePath, targetPath);
       }
     });
   }
   const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
   const compileTasks = entryPoints.map(async (entry) => {
-    const resolvedEntry = resolve22(entry);
+    const resolvedEntry = resolve21(entry);
     const relativeEntry = relative11(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
     const compileEntry = () => compileAngularFileJIT(resolvedEntry, compiledRoot, outRoot, stylePreprocessors);
     let outputs = hmr ? await traceAngularPhase("jit/compile-entry", compileEntry, {
@@ -14775,10 +14679,10 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
       join27(compiledRoot, relativeEntry),
       join27(compiledRoot, "pages", jsName),
       join27(compiledRoot, jsName)
-    ].map((file3) => resolve22(file3));
+    ].map((file3) => resolve21(file3));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
-        ...candidatePaths.map((file3) => resolve22(file3)),
+        ...candidatePaths.map((file3) => resolve21(file3)),
         ...compiledFallbackPaths
       ];
       let candidate = normalizedCandidates.find((file3) => existsSync22(file3) && file3.endsWith(`${sep3}${relativeEntry}`));
@@ -14850,13 +14754,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const pageInjection = providersInjection?.pagesByFile.get(resolvedEntry);
     if (providersInjection && pageInjection) {
       const compiledAppProvidersPath = (() => {
-        const angularDirAbs = resolve22(outRoot);
-        const appSourceAbs = resolve22(providersInjection.appProvidersSource);
+        const angularDirAbs = resolve21(outRoot);
+        const appSourceAbs = resolve21(providersInjection.appProvidersSource);
         const rel = relative11(angularDirAbs, appSourceAbs).replace(/\\/g, "/");
         return join27(compiledParent, rel).replace(/\.[cm]?[tj]sx?$/, ".js");
       })();
       const appProvidersSpec = (() => {
-        const rel = relative11(dirname15(rawServerFile), compiledAppProvidersPath).replace(/\\/g, "/");
+        const rel = relative11(dirname14(rawServerFile), compiledAppProvidersPath).replace(/\\/g, "/");
         return rel.startsWith(".") ? rel : `./${rel}`;
       })();
       const importLines = [
@@ -15798,7 +15702,7 @@ __export(exports_fastHmrCompiler, {
   invalidateFingerprintCache: () => invalidateFingerprintCache
 });
 import { existsSync as existsSync23, readFileSync as readFileSync17, statSync as statSync2 } from "fs";
-import { dirname as dirname16, extname as extname6, relative as relative12, resolve as resolve23 } from "path";
+import { dirname as dirname15, extname as extname6, relative as relative12, resolve as resolve22 } from "path";
 import ts13 from "typescript";
 var fail = (reason, detail, location) => ({
   ok: false,
@@ -15926,7 +15830,7 @@ var fail = (reason, detail, location) => ({
         continue;
       const decoratorMeta = readDecoratorMeta(args);
       const { inputs, outputs } = extractInputsAndOutputs(stmt, null);
-      const componentDir = dirname16(componentFilePath);
+      const componentDir = dirname15(componentFilePath);
       const fingerprint = extractFingerprint(stmt, className, decoratorMeta, inputs, outputs, sourceFile, componentDir);
       fingerprintCache.set(id, fingerprint);
     } else {
@@ -16102,7 +16006,7 @@ var fail = (reason, detail, location) => ({
     if (!spec.startsWith(".") && !spec.startsWith("/")) {
       return true;
     }
-    const base = resolve23(componentDir, spec);
+    const base = resolve22(componentDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -16886,7 +16790,7 @@ var fail = (reason, detail, location) => ({
     });
     if (!names.includes(className))
       continue;
-    const nextDts = resolveDtsFromSpec(fromPath, dirname16(startDtsPath));
+    const nextDts = resolveDtsFromSpec(fromPath, dirname15(startDtsPath));
     if (!nextDts)
       continue;
     const found = findDtsContainingClass(nextDts, className, visited);
@@ -16896,7 +16800,7 @@ var fail = (reason, detail, location) => ({
   const starReExportRe = /export\s*\*\s*from\s*["']([^"']+)["']/g;
   while ((m = starReExportRe.exec(content)) !== null) {
     const fromPath = m[1] || "";
-    const nextDts = resolveDtsFromSpec(fromPath, dirname16(startDtsPath));
+    const nextDts = resolveDtsFromSpec(fromPath, dirname15(startDtsPath));
     if (!nextDts)
       continue;
     const found = findDtsContainingClass(nextDts, className, visited);
@@ -16906,7 +16810,7 @@ var fail = (reason, detail, location) => ({
   return null;
 }, resolveDtsFromSpec = (spec, fromDir) => {
   const stripped = spec.replace(/\.[mc]?js$/, "");
-  const base = resolve23(fromDir, stripped);
+  const base = resolve22(fromDir, stripped);
   const candidates = [
     `${base}.d.ts`,
     `${base}.d.mts`,
@@ -16930,7 +16834,7 @@ var fail = (reason, detail, location) => ({
   return null;
 }, resolveChildComponentInfo = (className, spec, componentDir, projectRoot) => {
   if (spec.startsWith(".") || spec.startsWith("/")) {
-    const base = resolve23(componentDir, spec);
+    const base = resolve22(componentDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -17149,13 +17053,13 @@ var fail = (reason, detail, location) => ({
     }
     if (!matches)
       continue;
-    const resolved = resolve23(componentDir, spec);
+    const resolved = resolve22(componentDir, spec);
     for (const ext of TS_EXTENSIONS) {
       const candidate = resolved + ext;
       if (existsSync23(candidate))
         return candidate;
     }
-    const indexCandidate = resolve23(resolved, "index.ts");
+    const indexCandidate = resolve22(resolved, "index.ts");
     if (existsSync23(indexCandidate))
       return indexCandidate;
   }
@@ -17388,7 +17292,7 @@ ${transpiled}
     }
 }${staticPatch}`;
 }, STYLE_PREPROCESSED_EXT, resolveAndReadStyleResource = (componentDir, url) => {
-  const abs = resolve23(componentDir, url);
+  const abs = resolve22(componentDir, url);
   if (!existsSync23(abs))
     return null;
   const ext = extname6(abs).toLowerCase();
@@ -17428,7 +17332,7 @@ ${block}
   const cached = projectOptionsCache.get(projectRoot);
   if (cached !== undefined)
     return cached;
-  const tsconfigPath = resolve23(projectRoot, "tsconfig.json");
+  const tsconfigPath = resolve22(projectRoot, "tsconfig.json");
   const opts = {};
   if (existsSync23(tsconfigPath)) {
     try {
@@ -17493,7 +17397,7 @@ ${block}
       rebootstrapRequired: false
     };
   }
-  if (inheritsDecoratedClass(classNode, sourceFile, dirname16(componentFilePath), projectRoot)) {
+  if (inheritsDecoratedClass(classNode, sourceFile, dirname15(componentFilePath), projectRoot)) {
     return fail("inherits-decorated-class");
   }
   const decorator = findComponentDecorator(classNode);
@@ -17505,14 +17409,14 @@ ${block}
   const projectDefaults = readProjectAngularCompilerOptions(projectRoot);
   const decoratorMeta = readDecoratorMeta(decoratorArgs, projectDefaults);
   const advancedMetadata = extractAdvancedMetadata(classNode, decoratorArgs, compiler);
-  const componentDir = dirname16(componentFilePath);
+  const componentDir = dirname15(componentFilePath);
   let templateText;
   let templatePath;
   if (decoratorMeta.template !== null) {
     templateText = decoratorMeta.template;
     templatePath = componentFilePath;
   } else if (decoratorMeta.templateUrl) {
-    const tplAbs = resolve23(componentDir, decoratorMeta.templateUrl);
+    const tplAbs = resolve22(componentDir, decoratorMeta.templateUrl);
     if (!existsSync23(tplAbs)) {
       return fail("template-resource-not-found", `Template file not found: ${tplAbs}`, { file: componentFilePath });
     }
@@ -18266,7 +18170,7 @@ __export(exports_compileEmber, {
   getEmberServerCompiledDir: () => getEmberServerCompiledDir,
   getEmberCompiledRoot: () => getEmberCompiledRoot,
   getEmberClientCompiledDir: () => getEmberClientCompiledDir,
-  dirname: () => dirname17,
+  dirname: () => dirname16,
   compileEmberFileSource: () => compileEmberFileSource,
   compileEmberFile: () => compileEmberFile,
   compileEmber: () => compileEmber,
@@ -18275,7 +18179,7 @@ __export(exports_compileEmber, {
 });
 import { existsSync as existsSync24 } from "fs";
 import { mkdir as mkdir6, rm as rm4 } from "fs/promises";
-import { basename as basename9, dirname as dirname17, extname as extname7, join as join28, resolve as resolve24 } from "path";
+import { basename as basename9, dirname as dirname16, extname as extname7, join as join28, resolve as resolve23 } from "path";
 var {build: bunBuild2, Transpiler: Transpiler4, write: write4, file: file3 } = globalThis.Bun;
 var cachedPreprocessor = null, getPreprocessor = async () => {
   if (cachedPreprocessor)
@@ -18371,7 +18275,7 @@ export const importSync = (specifier) => {
         const originalImporter = stagedSourceMap.get(args.importer);
         if (!originalImporter)
           return;
-        const candidateBase = resolve24(dirname17(originalImporter), args.path);
+        const candidateBase = resolve23(dirname16(originalImporter), args.path);
         const extensionsToTry = ["", ".gts", ".gjs", ".ts", ".js"];
         for (const ext of extensionsToTry) {
           const candidate = candidateBase + ext;
@@ -18430,7 +18334,7 @@ export const renderToHTML = (props = {}) => {
 export { PageComponent };
 export default PageComponent;
 `, compileEmberFile = async (entry, compiledRoot, cwd = process.cwd()) => {
-  const resolvedEntry = resolve24(entry);
+  const resolvedEntry = resolve23(entry);
   const source = await file3(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -18450,8 +18354,8 @@ export default PageComponent;
     mkdir6(serverDir, { recursive: true }),
     mkdir6(clientDir, { recursive: true })
   ]);
-  const tmpPagePath = resolve24(join28(tmpDir, `${baseName}.module.js`));
-  const tmpHarnessPath = resolve24(join28(tmpDir, `${baseName}.harness.js`));
+  const tmpPagePath = resolve23(join28(tmpDir, `${baseName}.module.js`));
+  const tmpHarnessPath = resolve23(join28(tmpDir, `${baseName}.harness.js`));
   await Promise.all([
     write4(tmpPagePath, transpiled),
     write4(tmpHarnessPath, generateServerHarness(tmpPagePath))
@@ -18493,7 +18397,7 @@ export default PageComponent;
     serverPaths: outputs.map((o3) => o3.serverPath)
   };
 }, compileEmberFileSource = async (entry) => {
-  const resolvedEntry = resolve24(entry);
+  const resolvedEntry = resolve23(entry);
   const source = await file3(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -18526,24 +18430,24 @@ __export(exports_buildReactVendor, {
   buildReactVendor: () => buildReactVendor
 });
 import { existsSync as existsSync25, mkdirSync as mkdirSync8 } from "fs";
-import { join as join29, resolve as resolve25 } from "path";
+import { join as join29, resolve as resolve24 } from "path";
 import { rm as rm5 } from "fs/promises";
 var {build: bunBuild3 } = globalThis.Bun;
 var resolveJsxDevRuntimeCompatPath = () => {
   const candidates = [
-    resolve25(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
-    resolve25(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve25(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve25(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve25(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve25(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve24(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
+    resolve24(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve24(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve24(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve24(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve24(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
     if (existsSync25(candidate)) {
       return candidate.replace(/\\/g, "/");
     }
   }
-  return (candidates[0] ?? resolve25(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
+  return (candidates[0] ?? resolve24(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
 }, jsxDevRuntimeCompatPath, reactSpecifiers, isResolvable = (specifier) => {
   try {
     Bun.resolveSync(specifier, process.cwd());
@@ -19193,7 +19097,7 @@ import {
   statSync as statSync3,
   writeFileSync as writeFileSync8
 } from "fs";
-import { basename as basename10, dirname as dirname18, extname as extname8, join as join34, relative as relative13, resolve as resolve26 } from "path";
+import { basename as basename10, dirname as dirname17, extname as extname8, join as join34, relative as relative13, resolve as resolve25 } from "path";
 import { cwd, env as env2, exit } from "process";
 var {build: bunBuild7, Glob: Glob8 } = globalThis.Bun;
 var isDev, isBuildTraceEnabled = () => {
@@ -19284,8 +19188,8 @@ var isDev, isBuildTraceEnabled = () => {
   }
 }, resolveAbsoluteVersion = async () => {
   const candidates = [
-    resolve26(import.meta.dir, "..", "..", "package.json"),
-    resolve26(import.meta.dir, "..", "package.json")
+    resolve25(import.meta.dir, "..", "..", "package.json"),
+    resolve25(import.meta.dir, "..", "package.json")
   ];
   const resolveCandidate = async (remaining) => {
     const [candidate, ...rest] = remaining;
@@ -19301,7 +19205,7 @@ var isDev, isBuildTraceEnabled = () => {
   };
   await resolveCandidate(candidates);
 }, SKIP_DIRS4, addWorkerPathIfExists = (file4, relPath, workerPaths) => {
-  const absPath = resolve26(file4, "..", relPath);
+  const absPath = resolve25(file4, "..", relPath);
   try {
     statSync3(absPath);
     workerPaths.add(absPath);
@@ -19363,7 +19267,7 @@ var isDev, isBuildTraceEnabled = () => {
     return;
   }
   const indexFiles = readDir(reactIndexesPath).filter((file4) => file4.endsWith(".tsx"));
-  const pagesRel = relative13(process.cwd(), resolve26(reactPagesPath)).replace(/\\/g, "/");
+  const pagesRel = relative13(process.cwd(), resolve25(reactPagesPath)).replace(/\\/g, "/");
   for (const file4 of indexFiles) {
     let content = readFileSync18(join34(reactIndexesPath, file4), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
@@ -19371,27 +19275,27 @@ var isDev, isBuildTraceEnabled = () => {
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
   const svelteIndexDir = join34(getFrameworkGeneratedDir("svelte"), "indexes");
-  const sveltePageEntries = svelteEntries.filter((file4) => resolve26(file4).startsWith(resolve26(sveltePagesPath)));
+  const sveltePageEntries = svelteEntries.filter((file4) => resolve25(file4).startsWith(resolve25(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename10(entry).replace(/\.svelte(\.(ts|js))?$/, "");
     const indexFile = join34(svelteIndexDir, "pages", `${name}.js`);
     if (!existsSync26(indexFile))
       continue;
     let content = readFileSync18(indexFile, "utf-8");
-    const srcRel = relative13(process.cwd(), resolve26(entry)).replace(/\\/g, "/");
+    const srcRel = relative13(process.cwd(), resolve25(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
     writeFileSync8(join34(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
   const vueIndexDir = join34(getFrameworkGeneratedDir("vue"), "indexes");
-  const vuePageEntries = vueEntries.filter((file4) => resolve26(file4).startsWith(resolve26(vuePagesPath)));
+  const vuePageEntries = vueEntries.filter((file4) => resolve25(file4).startsWith(resolve25(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename10(entry, ".vue");
     const indexFile = join34(vueIndexDir, `${name}.js`);
     if (!existsSync26(indexFile))
       continue;
     let content = readFileSync18(indexFile, "utf-8");
-    const srcRel = relative13(process.cwd(), resolve26(entry)).replace(/\\/g, "/");
+    const srcRel = relative13(process.cwd(), resolve25(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Comp(?:\s*,\s*\*\s+as\s+\w+)?\s+from\s+['"]([^'"]+)['"]/, (match) => match.replace(/from\s+['"][^'"]+['"]/, `from "/@src/${srcRel}"`));
     writeFileSync8(join34(devIndexDir, `${name}.vue.js`), content);
   }
@@ -19404,7 +19308,7 @@ var isDev, isBuildTraceEnabled = () => {
   const last = allComments[allComments.length - 1];
   if (!last?.[1])
     return JSON.stringify(outputPath);
-  const srcPath = resolve26(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
+  const srcPath = resolve25(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
   return JSON.stringify(srcPath);
 }, QUOTE_CHARS, OPEN_BRACES, CLOSE_BRACES, findFunctionExpressionEnd = (content, startPos) => {
   let depth = 0;
@@ -19689,7 +19593,7 @@ ${content.slice(firstUseIdx)}`;
   const sourceClientRoots = [
     htmlDir,
     htmxDir,
-    islandBootstrapPath && dirname18(islandBootstrapPath)
+    islandBootstrapPath && dirname17(islandBootstrapPath)
   ].filter((dir) => Boolean(dir));
   const usesGenerated = Boolean(reactDir) || Boolean(svelteDir) || Boolean(vueDir) || Boolean(angularDir);
   if (usesGenerated)
@@ -19730,13 +19634,13 @@ ${content.slice(firstUseIdx)}`;
   const filterToIncrementalEntries = (entryPoints, mapToSource) => {
     if (!isIncremental || !incrementalFiles)
       return entryPoints;
-    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve26(f2)));
+    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve25(f2)));
     const matchingEntries = [];
     for (const entry of entryPoints) {
       const sourceFile = mapToSource(entry);
       if (!sourceFile)
         continue;
-      if (!normalizedIncremental.has(resolve26(sourceFile)))
+      if (!normalizedIncremental.has(resolve25(sourceFile)))
         continue;
       matchingEntries.push(entry);
     }
@@ -19901,7 +19805,7 @@ ${content.slice(firstUseIdx)}`;
   }
   const shouldIncludeHtmlAssets = !isIncremental || normalizedIncrementalFiles?.some((f2) => f2.includes("/html/") && (f2.endsWith(".html") || isStylePath(f2)));
   const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
-    if (entry.startsWith(resolve26(reactIndexesPath))) {
+    if (entry.startsWith(resolve25(reactIndexesPath))) {
       const pageName = basename10(entry, ".tsx");
       return join34(reactPagesPath, `${pageName}.tsx`);
     }
@@ -20051,7 +19955,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandSvelteClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandSvelteClientPathMap.set(resolve26(sourcePath), clientPath);
+    islandSvelteClientPathMap.set(resolve25(sourcePath), clientPath);
   }
   const islandVueClientPathMap = new Map;
   for (let idx = 0;idx < islandVueSources.length; idx++) {
@@ -20059,7 +19963,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandVueClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandVueClientPathMap.set(resolve26(sourcePath), clientPath);
+    islandVueClientPathMap.set(resolve25(sourcePath), clientPath);
   }
   const islandAngularClientPathMap = new Map;
   for (let idx = 0;idx < islandAngularSources.length; idx++) {
@@ -20067,7 +19971,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandAngularClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandAngularClientPathMap.set(resolve26(sourcePath), clientPath);
+    islandAngularClientPathMap.set(resolve25(sourcePath), clientPath);
   }
   const reactConventionSources = collectConventionSourceFiles(conventionsMap.react);
   const svelteConventionSources = collectConventionSourceFiles(conventionsMap.svelte);
@@ -20094,7 +19998,7 @@ ${content.slice(firstUseIdx)}`;
           naming: `${idx}-[name].[ext]`,
           outdir: destDir,
           plugins: [stylePreprocessorPlugin2],
-          root: dirname18(source),
+          root: dirname17(source),
           target: "bun",
           throw: false,
           tsconfig: "./tsconfig.json"
@@ -20518,7 +20422,7 @@ ${content.slice(firstUseIdx)}`;
   if (serverOutputs.length > 0 && angularServerVendorPaths2 && Object.keys(angularServerVendorPaths2).length > 0) {
     const { rewriteBuildOutputsWith: rewriteBuildOutputsWith2 } = await Promise.resolve().then(() => (init_rewriteImportsPlugin(), exports_rewriteImportsPlugin));
     await tracePhase("postprocess/server-angular-vendor-imports", () => rewriteBuildOutputsWith2(serverOutputs, (artifact) => {
-      const fileDir = dirname18(artifact.path);
+      const fileDir = dirname17(artifact.path);
       const relativePaths = {};
       for (const [specifier, absolute] of Object.entries(angularServerVendorPaths2)) {
         const rel = relative13(fileDir, absolute);
@@ -20992,7 +20896,7 @@ __export(exports_dependencyGraph, {
 });
 import { existsSync as existsSync28, readFileSync as readFileSync19 } from "fs";
 var {Glob: Glob9 } = globalThis.Bun;
-import { resolve as resolve27 } from "path";
+import { resolve as resolve26 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
   const lower = filePath.toLowerCase();
   if (lower.endsWith(".ts") || lower.endsWith(".tsx") || lower.endsWith(".jsx"))
@@ -21006,8 +20910,8 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
     return null;
   }
-  const fromDir = resolve27(fromFile, "..");
-  const normalized = resolve27(fromDir, importPath);
+  const fromDir = resolve26(fromFile, "..");
+  const normalized = resolve26(fromDir, importPath);
   const extensions = [
     ".ts",
     ".tsx",
@@ -21037,7 +20941,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     dependents.delete(normalizedPath);
   }
 }, addFileToGraph = (graph, filePath) => {
-  const normalizedPath = resolve27(filePath);
+  const normalizedPath = resolve26(filePath);
   if (!existsSync28(normalizedPath))
     return;
   const dependencies = extractDependencies(normalizedPath);
@@ -21064,10 +20968,10 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
 }, IGNORED_SEGMENTS, buildInitialDependencyGraph = (graph, directories) => {
   const processedFiles = new Set;
   const glob = new Glob9("**/*.{ts,tsx,js,jsx,vue,svelte,html,htm}");
-  const resolvedDirs = directories.map((dir) => resolve27(dir)).filter((dir) => existsSync28(dir));
+  const resolvedDirs = directories.map((dir) => resolve26(dir)).filter((dir) => existsSync28(dir));
   const allFiles = resolvedDirs.flatMap((dir) => Array.from(glob.scanSync({ absolute: true, cwd: dir })));
   for (const file4 of allFiles) {
-    const fullPath = resolve27(file4);
+    const fullPath = resolve26(file4);
     if (IGNORED_SEGMENTS.some((seg) => fullPath.includes(seg)))
       continue;
     if (processedFiles.has(fullPath))
@@ -21180,7 +21084,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     return [];
   }
 }, getAffectedFiles = (graph, changedFile) => {
-  const normalizedPath = resolve27(changedFile);
+  const normalizedPath = resolve26(changedFile);
   const affected = new Set;
   const toProcess = [normalizedPath];
   const processNode = (current) => {
@@ -21211,7 +21115,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
 }, removeDependentsForFile = (graph, normalizedPath) => {
   graph.dependents.delete(normalizedPath);
 }, removeFileFromGraph = (graph, filePath) => {
-  const normalizedPath = resolve27(filePath);
+  const normalizedPath = resolve26(filePath);
   removeDepsForFile(graph, normalizedPath);
   removeDependentsForFile(graph, normalizedPath);
 };
@@ -21254,12 +21158,12 @@ var globalVersionCounter = 0, createModuleVersionTracker = () => new Map, getNex
 };
 
 // src/dev/configResolver.ts
-import { resolve as resolve28 } from "path";
+import { resolve as resolve27 } from "path";
 var resolveBuildPaths = (config) => {
   const cwd2 = process.cwd();
   const normalize = (path) => path.replace(/\\/g, "/");
-  const withDefault = (value, fallback) => normalize(resolve28(cwd2, value ?? fallback));
-  const optional = (value) => value ? normalize(resolve28(cwd2, value)) : undefined;
+  const withDefault = (value, fallback) => normalize(resolve27(cwd2, value ?? fallback));
+  const optional = (value) => value ? normalize(resolve27(cwd2, value)) : undefined;
   return {
     angularDir: optional(config.angularDirectory),
     assetsDir: optional(config.assetsDirectory),
@@ -21313,7 +21217,7 @@ var init_clientManager = __esm(() => {
 
 // src/dev/pathUtils.ts
 import { existsSync as existsSync29, readdirSync as readdirSync4, readFileSync as readFileSync20 } from "fs";
-import { dirname as dirname19, resolve as resolve29 } from "path";
+import { dirname as dirname18, resolve as resolve28 } from "path";
 var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   if (shouldIgnorePath(filePath, resolved)) {
     return "ignored";
@@ -21389,7 +21293,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   return "unknown";
 }, collectAngularResourceDirs = (angularDir) => {
   const out = new Set;
-  const angularRoot = resolve29(angularDir);
+  const angularRoot = resolve28(angularDir);
   const angularRootNormalized = normalizePath(angularRoot);
   const walk = (dir) => {
     let entries;
@@ -21402,7 +21306,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const full = resolve29(dir, entry.name);
+      const full = resolve28(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
         continue;
@@ -21441,10 +21345,10 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
             refs.push(strMatch[1]);
         }
       }
-      const componentDir = dirname19(full);
+      const componentDir = dirname18(full);
       for (const ref of refs) {
-        const refAbs = normalizePath(resolve29(componentDir, ref));
-        const refDir = normalizePath(dirname19(refAbs));
+        const refAbs = normalizePath(resolve28(componentDir, ref));
+        const refDir = normalizePath(dirname18(refAbs));
         if (refDir === angularRootNormalized || refDir.startsWith(angularRootNormalized + "/")) {
           continue;
         }
@@ -21460,7 +21364,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   const push = (path) => {
     if (!path)
       return;
-    const abs = normalizePath(resolve29(cwd2, path));
+    const abs = normalizePath(resolve28(cwd2, path));
     if (!roots.includes(abs))
       roots.push(abs);
   };
@@ -21485,7 +21389,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   push(cfg.assetsDir);
   push(cfg.stylesDir);
   for (const candidate of ["src", "db", "assets", "styles"]) {
-    const abs = normalizePath(resolve29(cwd2, candidate));
+    const abs = normalizePath(resolve28(cwd2, candidate));
     if (existsSync29(abs) && !roots.includes(abs))
       roots.push(abs);
   }
@@ -21497,7 +21401,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
         continue;
       if (entry.name.startsWith("."))
         continue;
-      const abs = normalizePath(resolve29(cwd2, entry.name));
+      const abs = normalizePath(resolve28(cwd2, entry.name));
       if (roots.includes(abs))
         continue;
       if (shouldIgnorePath(abs, resolved))
@@ -21572,7 +21476,7 @@ var init_pathUtils = __esm(() => {
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
 import { existsSync as existsSync30, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
-import { dirname as dirname20, join as join36, resolve as resolve30 } from "path";
+import { dirname as dirname19, join as join36, resolve as resolve29 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -21630,7 +21534,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
       return;
     if (shouldSkipFilename(filename, isStylesDir)) {
       if (event === "rename") {
-        const eventDir = dirname20(join36(absolutePath, filename)).replace(/\\/g, "/");
+        const eventDir = dirname19(join36(absolutePath, filename)).replace(/\\/g, "/");
         atomicRecoveryScan(eventDir);
       }
       return;
@@ -21653,7 +21557,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
 }, addFileWatchers = (state, paths, onFileChange) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
-    const absolutePath = resolve30(path).replace(/\\/g, "/");
+    const absolutePath = resolve29(path).replace(/\\/g, "/");
     if (!existsSync30(absolutePath)) {
       return;
     }
@@ -21664,7 +21568,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const watchPaths = getWatchPaths(config, state.resolvedPaths);
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
-    const absolutePath = resolve30(path).replace(/\\/g, "/");
+    const absolutePath = resolve29(path).replace(/\\/g, "/");
     if (!existsSync30(absolutePath)) {
       return;
     }
@@ -21683,13 +21587,13 @@ var init_fileWatcher = __esm(() => {
 });
 
 // src/dev/assetStore.ts
-import { resolve as resolve31 } from "path";
+import { resolve as resolve30 } from "path";
 import { readdir as readdir4, unlink } from "fs/promises";
 var mimeTypes, getMimeType = (filePath) => {
   const ext = filePath.slice(filePath.lastIndexOf("."));
   return mimeTypes[ext] ?? "application/octet-stream";
 }, HASHED_FILE_RE, stripHash = (webPath) => webPath.replace(/\.[a-z0-9]{8}(\.(js|css|mjs))$/, "$1"), processWalkEntry = (entry, dir, liveByIdentity, walkAndClean) => {
-  const fullPath = resolve31(dir, entry.name);
+  const fullPath = resolve30(dir, entry.name);
   if (entry.isDirectory()) {
     return walkAndClean(fullPath);
   }
@@ -21705,10 +21609,10 @@ var mimeTypes, getMimeType = (filePath) => {
 }, cleanStaleAssets = async (store, manifest, buildDir) => {
   const liveByIdentity = new Map;
   for (const webPath of store.keys()) {
-    const diskPath = resolve31(buildDir, webPath.slice(1));
+    const diskPath = resolve30(buildDir, webPath.slice(1));
     liveByIdentity.set(stripHash(diskPath), diskPath);
   }
-  const absBuildDir = resolve31(buildDir);
+  const absBuildDir = resolve30(buildDir);
   Object.values(manifest).forEach((val) => {
     if (!HASHED_FILE_RE.test(val))
       return;
@@ -21726,7 +21630,7 @@ var mimeTypes, getMimeType = (filePath) => {
   } catch {}
 }, lookupAsset = (store, path) => store.get(path), processScanEntry = (entry, dir, prefix, store, scanDir) => {
   if (entry.isDirectory()) {
-    return scanDir(resolve31(dir, entry.name), `${prefix}${entry.name}/`);
+    return scanDir(resolve30(dir, entry.name), `${prefix}${entry.name}/`);
   }
   if (!entry.name.startsWith("chunk-")) {
     return null;
@@ -21735,7 +21639,7 @@ var mimeTypes, getMimeType = (filePath) => {
   if (store.has(webPath)) {
     return null;
   }
-  return Bun.file(resolve31(dir, entry.name)).bytes().then((bytes) => {
+  return Bun.file(resolve30(dir, entry.name)).bytes().then((bytes) => {
     store.set(webPath, bytes);
     return;
   }).catch(() => {});
@@ -21757,7 +21661,7 @@ var mimeTypes, getMimeType = (filePath) => {
   for (const webPath of newIdentities.values()) {
     if (store.has(webPath))
       continue;
-    loadPromises.push(Bun.file(resolve31(buildDir, webPath.slice(1))).bytes().then((bytes) => {
+    loadPromises.push(Bun.file(resolve30(buildDir, webPath.slice(1))).bytes().then((bytes) => {
       store.set(webPath, bytes);
       return;
     }).catch(() => {}));
@@ -21788,7 +21692,7 @@ var init_assetStore = __esm(() => {
 
 // src/islands/pageMetadata.ts
 import { readFileSync as readFileSync21 } from "fs";
-import { dirname as dirname21, resolve as resolve32 } from "path";
+import { dirname as dirname20, resolve as resolve31 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
   { dir: config.emberDirectory, framework: "ember" },
@@ -21808,15 +21712,15 @@ var pagePatterns, getPageDirs = (config) => [
     const source = definition.buildReference?.source;
     if (!source)
       continue;
-    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve32(dirname21(buildInfo.resolvedRegistryPath), source);
-    lookup.set(`${definition.framework}:${definition.component}`, resolve32(resolvedSource));
+    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve31(dirname20(buildInfo.resolvedRegistryPath), source);
+    lookup.set(`${definition.framework}:${definition.component}`, resolve31(resolvedSource));
   }
   return lookup;
 }, getCurrentPageIslandMetadata = () => globalThis.__absolutePageIslandMetadata ?? new Map, metadataUsesSource = (metadata, target) => metadata.islands.some((usage) => {
   const candidate = usage.source;
-  return candidate ? resolve32(candidate) === target : false;
+  return candidate ? resolve31(candidate) === target : false;
 }), getPagesUsingIslandSource = (sourcePath) => {
-  const target = resolve32(sourcePath);
+  const target = resolve31(sourcePath);
   return [...getCurrentPageIslandMetadata().values()].filter((metadata) => metadataUsesSource(metadata, target)).map((metadata) => metadata.pagePath);
 }, resolveIslandUsages = (islands, islandSourceLookup) => islands.map((usage) => {
   const sourcePath = islandSourceLookup.get(`${usage.framework}:${usage.component}`);
@@ -21828,13 +21732,13 @@ var pagePatterns, getPageDirs = (config) => [
   const pattern = pagePatterns[entry.framework];
   if (!pattern)
     return;
-  const files = await scanEntryPoints(resolve32(entry.dir), pattern);
+  const files = await scanEntryPoints(resolve31(entry.dir), pattern);
   for (const filePath of files) {
     const source = readFileSync21(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
-    pageMetadata.set(resolve32(filePath), {
+    pageMetadata.set(resolve31(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
-      pagePath: resolve32(filePath)
+      pagePath: resolve31(filePath)
     });
   }
 }, loadPageIslandMetadata = async (config) => {
@@ -21957,9 +21861,9 @@ var init_transformCache = __esm(() => {
 });
 
 // src/dev/reactComponentClassifier.ts
-import { resolve as resolve33 } from "path";
+import { resolve as resolve32 } from "path";
 var classifyComponent = (filePath) => {
-  const normalizedPath = resolve33(filePath);
+  const normalizedPath = resolve32(filePath);
   if (normalizedPath.includes("/react/pages/")) {
     return "server";
   }
@@ -21971,7 +21875,7 @@ var classifyComponent = (filePath) => {
 var init_reactComponentClassifier = () => {};
 
 // src/dev/moduleMapper.ts
-import { basename as basename11, resolve as resolve34 } from "path";
+import { basename as basename11, resolve as resolve33 } from "path";
 var buildModulePaths = (moduleKeys, manifest) => {
   const modulePaths = {};
   moduleKeys.forEach((key) => {
@@ -21981,7 +21885,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return modulePaths;
 }, processChangedFile = (sourceFile, framework, manifest, resolvedPaths, processedFiles) => {
-  const normalizedFile = resolve34(sourceFile);
+  const normalizedFile = resolve33(sourceFile);
   const normalizedPath = normalizedFile.replace(/\\/g, "/");
   if (processedFiles.has(normalizedFile)) {
     return null;
@@ -22017,7 +21921,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return grouped;
 }, mapSourceFileToManifestKeys = (sourceFile, framework, resolvedPaths) => {
-  const normalizedFile = resolve34(sourceFile);
+  const normalizedFile = resolve33(sourceFile);
   const fileName = basename11(normalizedFile);
   const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|css|html)$/, "");
   const pascalName = toPascal(baseName);
@@ -22079,7 +21983,7 @@ __export(exports_resolveOwningComponents, {
   invalidateResourceIndex: () => invalidateResourceIndex
 });
 import { readdirSync as readdirSync6, readFileSync as readFileSync23, statSync as statSync5 } from "fs";
-import { dirname as dirname22, extname as extname9, join as join37, resolve as resolve35 } from "path";
+import { dirname as dirname21, extname as extname9, join as join37, resolve as resolve34 } from "path";
 import ts14 from "typescript";
 var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") || file4.endsWith(".tsx"), walkAngularSourceFiles = (root) => {
   const out = [];
@@ -22192,7 +22096,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
   };
   visit(sourceFile);
   return out;
-}, safeNormalize = (path) => resolve35(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
+}, safeNormalize = (path) => resolve34(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
   const { changedFilePath, userAngularRoot } = params;
   const changedAbs = safeNormalize(changedFilePath);
   const out = [];
@@ -22233,7 +22137,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
     return null;
   }
   const sf = ts14.createSourceFile(childFilePath, source, ts14.ScriptTarget.ES2022, true, ts14.ScriptKind.TS);
-  const childDir = dirname22(childFilePath);
+  const childDir = dirname21(childFilePath);
   for (const stmt of sf.statements) {
     if (!ts14.isImportDeclaration(stmt))
       continue;
@@ -22261,7 +22165,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
     if (!spec.startsWith(".") && !spec.startsWith("/")) {
       return null;
     }
-    const base = resolve35(childDir, spec);
+    const base = resolve34(childDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -22290,7 +22194,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
   const parentFile = new Map;
   for (const tsPath of walkAngularSourceFiles(userAngularRoot)) {
     const classes = parseDecoratedClasses(tsPath);
-    const componentDir = dirname22(tsPath);
+    const componentDir = dirname21(tsPath);
     for (const cls of classes) {
       const entity = {
         className: cls.className,
@@ -22299,7 +22203,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
       };
       if (cls.kind === "component") {
         for (const url of [...cls.templateUrls, ...cls.styleUrls]) {
-          const abs = safeNormalize(resolve35(componentDir, url));
+          const abs = safeNormalize(resolve34(componentDir, url));
           const existing = resource.get(abs);
           if (existing)
             existing.push(entity);
@@ -22484,7 +22388,7 @@ __export(exports_loadConfig, {
   isWorkspaceConfig: () => isWorkspaceConfig,
   getWorkspaceServices: () => getWorkspaceServices
 });
-import { resolve as resolve36 } from "path";
+import { resolve as resolve35 } from "path";
 var RESERVED_TOP_LEVEL_KEYS, isObject2 = (value) => typeof value === "object" && value !== null, isCommandService = (service) => service.kind === "command" || Array.isArray(service.command), isServiceCandidate = (value) => isObject2(value) && (typeof value.entry === "string" || Array.isArray(value.command)), isWorkspaceConfig = (config) => {
   if (!isObject2(config)) {
     return false;
@@ -22535,7 +22439,7 @@ var RESERVED_TOP_LEVEL_KEYS, isObject2 = (value) => typeof value === "object" &&
   }
   return config;
 }, loadRawConfig = async (configPath2) => {
-  const resolved = resolve36(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+  const resolved = resolve35(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
   const mod = await import(resolved);
   const config = mod.default ?? mod.config;
   if (!config) {
@@ -22596,7 +22500,7 @@ __export(exports_moduleServer, {
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
 import { existsSync as existsSync31, readFileSync as readFileSync24, statSync as statSync6 } from "fs";
-import { basename as basename12, dirname as dirname23, extname as extname10, join as join38, resolve as resolve37, relative as relative14 } from "path";
+import { basename as basename12, dirname as dirname22, extname as extname10, join as join38, resolve as resolve36, relative as relative14 } from "path";
 var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPILABLE, ALL_EXPORTS_RE, STRING_CONTENTS_RE, preserveTypeExports = (originalSource, transpiled, valueExports) => {
   const codeOnly = originalSource.replace(STRING_CONTENTS_RE, '""');
   const allExports = [];
@@ -22616,7 +22520,7 @@ var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPIL
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const found = extensions.find((ext) => existsSync31(resolve37(projectRoot, srcPath + ext)));
+  const found = extensions.find((ext) => existsSync31(resolve36(projectRoot, srcPath + ext)));
   return found ? srcPath + found : srcPath;
 }, IMPORT_EXTENSIONS, SIDE_EFFECT_EXTENSIONS, MODULE_EXTENSIONS, RESOLVED_MODULE_EXTENSIONS, REACT_EXTENSIONS, escapeRegex3 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), buildImportRewriter = (vendorPaths) => {
   const entries = Object.entries(vendorPaths).sort(([a], [b2]) => b2.length - a.length);
@@ -22631,7 +22535,7 @@ ${stubs}
   return invalidationVersion > 0 ? `${mtime}.${invalidationVersion}` : `${mtime}`;
 }, srcUrl = (relPath, projectRoot) => {
   const base = `${SRC_PREFIX}${relPath.replace(/\\/g, "/")}`;
-  const absPath = resolve37(projectRoot, relPath);
+  const absPath = resolve36(projectRoot, relPath);
   const cached = mtimeCache.get(absPath);
   if (cached !== undefined)
     return `${base}?v=${buildVersion(cached, absPath)}`;
@@ -22643,12 +22547,12 @@ ${stubs}
     return base;
   }
 }, resolveRelativeImport = (relPath, fileDir, projectRoot, extensions) => {
-  const absPath = resolve37(fileDir, relPath);
+  const absPath = resolve36(fileDir, relPath);
   const rel = relative14(projectRoot, absPath);
   const extension = extname10(rel);
   let srcPath = RESOLVED_MODULE_EXTENSIONS.has(extension) ? rel : resolveRelativeExtension(rel, projectRoot, extensions);
   if (extname10(srcPath) === ".svelte") {
-    srcPath = relative14(projectRoot, resolveSvelteModulePath(resolve37(projectRoot, srcPath)));
+    srcPath = relative14(projectRoot, resolveSvelteModulePath(resolve36(projectRoot, srcPath)));
   }
   return srcUrl(srcPath, projectRoot);
 }, NODE_BUILTIN_RE, resolveAbsoluteSpecifier = (specifier, projectRoot) => {
@@ -22667,13 +22571,13 @@ ${stubs}
       const packageName = isScoped ? `${parts[0]}/${parts[1]}` : parts[0];
       const subpath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
       if (!subpath) {
-        const pkgDir = resolve37(projectRoot, "node_modules", packageName ?? "");
+        const pkgDir = resolve36(projectRoot, "node_modules", packageName ?? "");
         const pkgJsonPath = join38(pkgDir, "package.json");
         if (existsSync31(pkgJsonPath)) {
           const pkg = JSON.parse(readFileSync24(pkgJsonPath, "utf-8"));
           const esmEntry = typeof pkg.module === "string" && pkg.module || typeof pkg.browser === "string" && pkg.browser;
           if (esmEntry) {
-            const resolved = resolve37(pkgDir, esmEntry);
+            const resolved = resolve36(pkgDir, esmEntry);
             if (existsSync31(resolved))
               return relative14(projectRoot, resolved);
           }
@@ -22705,7 +22609,7 @@ ${stubs}
   };
   result = result.replace(/^((?:import\s+[\s\S]+?\s+from|export\s+[\s\S]+?\s+from|import)\s*["'])([^"'./][^"']*)(["'])/gm, stubReplace);
   result = result.replace(/(import\s*\(\s*["'])([^"'./][^"']*)(["']\s*\))/g, stubReplace);
-  const fileDir = dirname23(filePath);
+  const fileDir = dirname22(filePath);
   result = result.replace(/(from\s*["'])(\.\.?\/[^"']+)(["'])/g, (_match, prefix, relPath, suffix) => `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, IMPORT_EXTENSIONS)}${suffix}`);
   result = result.replace(/(import\s*\(\s*["'])(\.\.?\/[^"']+)(["']\s*\))/g, (_match, prefix, relPath, suffix) => `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, IMPORT_EXTENSIONS)}${suffix}`);
   result = result.replace(/(import\s*["'])(\.\.?\/[^"']+)(["']\s*;?)/g, (_match, prefix, relPath, suffix) => `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, SIDE_EFFECT_EXTENSIONS)}${suffix}`);
@@ -22720,12 +22624,12 @@ ${stubs}
   result = result.replace(/((?:from|import)\s*["'])(\/[^"']+\.(tsx?|jsx?|ts))(["'])/g, rewriteAbsoluteToSrc);
   result = result.replace(/(import\s*\(\s*["'])(\/[^"']+\.(tsx?|jsx?|ts))(["']\s*\))/g, rewriteAbsoluteToSrc);
   result = result.replace(/new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g, (_match, relPath) => {
-    const absPath = resolve37(fileDir, relPath);
+    const absPath = resolve36(fileDir, relPath);
     const rel = relative14(projectRoot, absPath);
     return `new URL('${srcUrl(rel, projectRoot)}', import.meta.url)`;
   });
   result = result.replace(/import\.meta\.resolve\(\s*["'](\.\.?\/[^"']+)["']\s*\)/g, (_match, relPath) => {
-    const absPath = resolve37(fileDir, relPath);
+    const absPath = resolve36(fileDir, relPath);
     const rel = relative14(projectRoot, absPath);
     return `'${srcUrl(rel, projectRoot)}'`;
   });
@@ -23038,7 +22942,7 @@ ${code}`;
   code = injectVueHmr(code, filePath, projectRoot, vueDir);
   return rewriteImports(code, filePath, projectRoot, rewriter);
 }, injectVueHmr = (code, filePath, projectRoot, vueDir) => {
-  const hmrBase = vueDir ? resolve37(vueDir) : projectRoot;
+  const hmrBase = vueDir ? resolve36(vueDir) : projectRoot;
   const hmrId = relative14(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
   let result = code.replace(/export\s+default\s+/, "var __hmr_comp__ = ");
   result += [
@@ -23202,7 +23106,7 @@ export default {};
   const escaped = virtualCss.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return jsResponse(`var s=document.createElement('style');s.textContent=\`${escaped}\`;s.dataset.svelteHmr=${JSON.stringify(cssCheckPath)};var p=document.querySelector('style[data-svelte-hmr="${cssCheckPath}"]');if(p)p.remove();document.head.appendChild(s);`);
 }, resolveSourcePath = (relPath, projectRoot) => {
-  const filePath = resolve37(projectRoot, relPath);
+  const filePath = resolve36(projectRoot, relPath);
   const ext = extname10(filePath);
   if (ext === ".svelte")
     return { ext, filePath: resolveSvelteModulePath(filePath) };
@@ -23239,14 +23143,14 @@ export default {};
           const absoluteCandidate = "/" + tail.replace(/^\/+/, "");
           const candidates = [
             absoluteCandidate,
-            resolve37(projectRoot, tail)
+            resolve36(projectRoot, tail)
           ];
           try {
             const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_loadConfig(), exports_loadConfig));
             const cfg = await loadConfig2();
-            const angularDir = cfg.angularDirectory && resolve37(projectRoot, cfg.angularDirectory);
+            const angularDir = cfg.angularDirectory && resolve36(projectRoot, cfg.angularDirectory);
             if (angularDir)
-              candidates.push(resolve37(angularDir, tail));
+              candidates.push(resolve36(angularDir, tail));
           } catch {}
           for (const candidate of candidates) {
             if (await fileExists(candidate)) {
@@ -23277,7 +23181,7 @@ export default {};
   if (!TRANSPILABLE.has(ext))
     return;
   const stat3 = statSync6(filePath);
-  const resolvedVueDir = vueDir ? resolve37(vueDir) : undefined;
+  const resolvedVueDir = vueDir ? resolve36(vueDir) : undefined;
   let content = REACT_EXTENSIONS.has(ext) ? transformReactFile(filePath, projectRoot, rewriter) : transformPlainFile(filePath, projectRoot, rewriter, resolvedVueDir);
   const isAngularGeneratedJs = ext === ".js" && filePath.replace(/\\/g, "/").includes("/.absolutejs/generated/angular/");
   if (isAngularGeneratedJs) {
@@ -23336,7 +23240,7 @@ export default {};
     const relPath = pathname.slice(SRC_PREFIX.length);
     if (relPath === "bun:wrap" || relPath.startsWith("bun:wrap?"))
       return handleBunWrapRequest();
-    const virtualCssResponse = handleVirtualSvelteCss(resolve37(projectRoot, relPath));
+    const virtualCssResponse = handleVirtualSvelteCss(resolve36(projectRoot, relPath));
     if (virtualCssResponse)
       return virtualCssResponse;
     const { filePath, ext } = resolveSourcePath(relPath, projectRoot);
@@ -23352,11 +23256,11 @@ export default {};
   SRC_IMPORT_RE.lastIndex = 0;
   while ((match = SRC_IMPORT_RE.exec(content)) !== null) {
     if (match[1])
-      files.push(resolve37(projectRoot, match[1]));
+      files.push(resolve36(projectRoot, match[1]));
   }
   return files;
 }, invalidateModule = (filePath) => {
-  const resolved = resolve37(filePath);
+  const resolved = resolve36(filePath);
   invalidate(filePath);
   if (resolved !== filePath)
     invalidate(resolved);
@@ -23501,7 +23405,7 @@ __export(exports_hmrCompiler, {
   getApplyMetadataModule: () => getApplyMetadataModule,
   encodeHmrComponentId: () => encodeHmrComponentId
 });
-import { dirname as dirname24, relative as relative15, resolve as resolve38 } from "path";
+import { dirname as dirname23, relative as relative15, resolve as resolve37 } from "path";
 import { performance as performance2 } from "perf_hooks";
 var getApplyMetadataModule = async (encodedId) => {
   const decoded = decodeURIComponent(encodedId);
@@ -23510,7 +23414,7 @@ var getApplyMetadataModule = async (encodedId) => {
     return null;
   const filePathRel = decoded.slice(0, at2);
   const className = decoded.slice(at2 + 1);
-  const componentFilePath = resolve38(process.cwd(), filePathRel);
+  const componentFilePath = resolve37(process.cwd(), filePathRel);
   const projectRelPath = relative15(process.cwd(), componentFilePath).replace(/\\/g, "/");
   const cacheKey2 = encodeURIComponent(`${projectRelPath}@${className}`);
   const { takePendingModule: takePendingModule2 } = await Promise.resolve().then(() => (init_fastHmrCompiler(), exports_fastHmrCompiler));
@@ -23521,7 +23425,7 @@ var getApplyMetadataModule = async (encodedId) => {
   const { resolveOwningComponents: resolveOwningComponents2 } = await Promise.resolve().then(() => (init_resolveOwningComponents(), exports_resolveOwningComponents));
   const owners = resolveOwningComponents2({
     changedFilePath: componentFilePath,
-    userAngularRoot: dirname24(componentFilePath)
+    userAngularRoot: dirname23(componentFilePath)
   });
   const owner = owners.find((o3) => o3.className === className);
   const kind = owner?.kind ?? "component";
@@ -23672,11 +23576,11 @@ var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { resolve as resolve39 } from "path";
+import { resolve as resolve38 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve39(htmlFilePath);
+    const resolvedPath = resolve38(htmlFilePath);
     const file4 = Bun.file(resolvedPath);
     if (!await file4.exists()) {
       return null;
@@ -23702,11 +23606,11 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { resolve as resolve40 } from "path";
+import { resolve as resolve39 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve40(htmxFilePath);
+    const resolvedPath = resolve39(htmxFilePath);
     const file4 = Bun.file(resolvedPath);
     if (!await file4.exists()) {
       return null;
@@ -23729,7 +23633,7 @@ var init_simpleHTMXHMR = () => {};
 
 // src/dev/rebuildTrigger.ts
 import { existsSync as existsSync32, rmSync as rmSync3 } from "fs";
-import { basename as basename13, dirname as dirname25, join as join39, relative as relative16, resolve as resolve41, sep as sep4 } from "path";
+import { basename as basename13, dirname as dirname24, join as join39, relative as relative16, resolve as resolve40, sep as sep4 } from "path";
 var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequentially = (items, action) => items.reduce((chain, item) => chain.then(() => action(item)), Promise.resolve()), getStyleTransformConfig = (config) => createStyleTransformConfig(config.stylePreprocessors, config.postcss), recompileTailwindForFastPath = async (state, config, files) => {
   if (!config.tailwind)
     return;
@@ -23741,7 +23645,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     if (!cssChanged)
       return;
     try {
-      const outputPath = resolve41(state.resolvedPaths.buildDir, config.tailwind.output);
+      const outputPath = resolve40(state.resolvedPaths.buildDir, config.tailwind.output);
       const bytes = await Bun.file(outputPath).bytes();
       const webPath = `/${config.tailwind.output.replace(/^\/+/, "")}`;
       state.assetStore.set(webPath, bytes);
@@ -23831,12 +23735,12 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
 }, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync32(affectedFile), FRAMEWORK_DIR_KEYS_FOR_CLEANUP, removeStaleGenerated = (state, deletedFile) => {
   const config = state.config;
   const cwd2 = process.cwd();
-  const absDeleted = resolve41(deletedFile).replace(/\\/g, "/");
+  const absDeleted = resolve40(deletedFile).replace(/\\/g, "/");
   for (const { configKey, framework } of FRAMEWORK_DIR_KEYS_FOR_CLEANUP) {
     const dir = config[configKey];
     if (!dir)
       continue;
-    const absDir = resolve41(cwd2, dir).replace(/\\/g, "/");
+    const absDir = resolve40(cwd2, dir).replace(/\\/g, "/");
     if (!absDeleted.startsWith(`${absDir}/`))
       continue;
     const rel = absDeleted.slice(absDir.length + 1);
@@ -23860,7 +23764,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   removeStaleGenerated(state, filePathInSet);
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, filePathInSet);
-    const deletedPathResolved = resolve41(filePathInSet);
+    const deletedPathResolved = resolve40(filePathInSet);
     affectedFiles.forEach((affectedFile) => {
       if (isValidDeletedAffectedFile(affectedFile, deletedPathResolved, processedFiles)) {
         validFiles.push(affectedFile);
@@ -23904,7 +23808,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (storedHash !== undefined && storedHash === fileHash) {
     return;
   }
-  const normalizedFilePath = resolve41(filePathInSet);
+  const normalizedFilePath = resolve40(filePathInSet);
   if (!processedFiles.has(normalizedFilePath)) {
     validFiles.push(normalizedFilePath);
     processedFiles.add(normalizedFilePath);
@@ -24042,7 +23946,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const publicDir = state.resolvedPaths.publicDir;
   const assetsDir = state.resolvedPaths.assetsDir;
   const handleStaticMirror = async (sourceDir, urlPrefix) => {
-    const absSource = resolve41(filePath);
+    const absSource = resolve40(filePath);
     const normalizedSource = absSource.replace(/\\/g, "/");
     const normalizedDir = sourceDir.replace(/\\/g, "/");
     if (!normalizedSource.startsWith(normalizedDir + "/"))
@@ -24050,10 +23954,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     try {
       const relFromDir = normalizedSource.slice(normalizedDir.length + 1);
       const buildDir = state.resolvedPaths.buildDir;
-      const destPath = resolve41(buildDir, urlPrefix ? `${urlPrefix}/${relFromDir}` : relFromDir);
+      const destPath = resolve40(buildDir, urlPrefix ? `${urlPrefix}/${relFromDir}` : relFromDir);
       const { mkdir: mkdir7, copyFile, readFile: readFile6 } = await import("fs/promises");
-      const { dirname: dirname26 } = await import("path");
-      await mkdir7(dirname26(destPath), { recursive: true });
+      const { dirname: dirname25 } = await import("path");
+      await mkdir7(dirname25(destPath), { recursive: true });
       await copyFile(absSource, destPath);
       const bytes = await readFile6(destPath);
       const webPath = urlPrefix ? `/${urlPrefix}/${relFromDir}` : `/${relFromDir}`;
@@ -24076,7 +23980,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (assetsDir && await handleStaticMirror(assetsDir, "assets"))
     return;
   if (framework === "unknown") {
-    invalidate(resolve41(filePath));
+    invalidate(resolve40(filePath));
     const relPath = relative16(process.cwd(), filePath);
     logHmrUpdate(relPath);
     const angularDir = state.resolvedPaths.angularDir;
@@ -24084,10 +23988,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     if (angularDir && state.dependencyGraph) {
       try {
         const { addFileToGraph: addFileToGraph2 } = await Promise.resolve().then(() => (init_dependencyGraph(), exports_dependencyGraph));
-        addFileToGraph2(state.dependencyGraph, resolve41(filePath));
-        const affected = getAffectedFiles(state.dependencyGraph, resolve41(filePath));
+        addFileToGraph2(state.dependencyGraph, resolve40(filePath));
+        const affected = getAffectedFiles(state.dependencyGraph, resolve40(filePath));
         for (const dependent of affected) {
-          if (dependent === resolve41(filePath))
+          if (dependent === resolve40(filePath))
             continue;
           const dependentFramework = detectFramework(dependent, state.resolvedPaths);
           if (dependentFramework !== "angular")
@@ -24104,14 +24008,14 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
       } catch {}
     }
     if (!hasAngularDependent) {
-      console.log(`[abs:restart] ${resolve41(filePath)}`);
+      console.log(`[abs:restart] ${resolve40(filePath)}`);
       return;
     }
     try {
       const { getFrameworkGeneratedDir: getFrameworkGeneratedDir2 } = await Promise.resolve().then(() => (init_generatedDir(), exports_generatedDir));
       const { invalidateModule: invalidateModuleServer } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
       const generatedAngularRoot = getFrameworkGeneratedDir2("angular");
-      const sourceAbs = resolve41(filePath).replace(/\\/g, "/");
+      const sourceAbs = resolve40(filePath).replace(/\\/g, "/");
       const generatedTwin = `${generatedAngularRoot.replace(/\\/g, "/")}${sourceAbs.replace(/\.ts$/, ".js")}`;
       invalidateModuleServer(generatedTwin);
     } catch {}
@@ -24145,7 +24049,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const userEditedFiles = new Set;
     state.fileChangeQueue.forEach((filePaths) => {
       for (const filePath2 of filePaths) {
-        userEditedFiles.add(resolve41(filePath2));
+        userEditedFiles.add(resolve40(filePath2));
       }
     });
     state.lastUserEditedFiles = userEditedFiles;
@@ -24174,7 +24078,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   if (!graph)
     return componentFile;
-  const dependents = graph.dependents.get(resolve41(componentFile));
+  const dependents = graph.dependents.get(resolve40(componentFile));
   if (!dependents)
     return componentFile;
   for (const dep of dependents) {
@@ -24183,7 +24087,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   return componentFile;
 }, resolveAngularPageEntries = (state, angularFiles, angularPagesPath) => {
-  const pageEntries = angularFiles.filter((file4) => file4.endsWith(".ts") && resolve41(file4).startsWith(angularPagesPath));
+  const pageEntries = angularFiles.filter((file4) => file4.endsWith(".ts") && resolve40(file4).startsWith(angularPagesPath));
   if (pageEntries.length > 0 || !state.dependencyGraph) {
     return pageEntries;
   }
@@ -24192,7 +24096,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const lookupFile = resolveComponentLookupFile(componentFile, state.dependencyGraph);
     const affected = getAffectedFiles(state.dependencyGraph, lookupFile);
     affected.forEach((file4) => {
-      if (file4.endsWith(".ts") && resolve41(file4).startsWith(angularPagesPath)) {
+      if (file4.endsWith(".ts") && resolve40(file4).startsWith(angularPagesPath)) {
         resolvedPages.add(file4);
       }
     });
@@ -24233,8 +24137,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (serverDirs.length <= 1) {
     const dir = getFrameworkGeneratedDir2(framework, projectRoot);
     return {
-      serverOutDir: resolve41(resolvedPaths.buildDir, basename13(dir)),
-      serverRoot: resolve41(dir, "server")
+      serverOutDir: resolve40(resolvedPaths.buildDir, basename13(dir)),
+      serverRoot: resolve40(dir, "server")
     };
   }
   return {
@@ -24255,7 +24159,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const keepByDir = new Map;
   const prefixByDir = new Map;
   for (const artifact of freshOutputs) {
-    const dir = dirname25(artifact.path);
+    const dir = dirname24(artifact.path);
     const name = basename13(artifact.path);
     const [prefix] = name.split(".");
     if (!prefix)
@@ -24395,8 +24299,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     if (detected !== "unknown")
       continue;
     try {
-      const affected = getAffectedFiles(state.dependencyGraph, resolve41(editedFile));
-      const hasAngularConsumer = affected.some((dep) => dep !== resolve41(editedFile) && detectFramework(dep, state.resolvedPaths) === "angular");
+      const affected = getAffectedFiles(state.dependencyGraph, resolve40(editedFile));
+      const hasAngularConsumer = affected.some((dep) => dep !== resolve40(editedFile) && detectFramework(dep, state.resolvedPaths) === "angular");
       if (hasAngularConsumer) {
         return {
           kind: "rebootstrap",
@@ -24443,7 +24347,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     }
     if (owners.length === 0 && (editedFile.endsWith(".ts") || editedFile.endsWith(".json")) && !editedFile.endsWith(".d.ts")) {
       const normalized = editedFile.replace(/\\/g, "/");
-      const angularDirAbs = resolve41(angularDir).replace(/\\/g, "/");
+      const angularDirAbs = resolve40(angularDir).replace(/\\/g, "/");
       if (normalized.startsWith(angularDirAbs + "/")) {
         return {
           kind: "rebootstrap",
@@ -24586,16 +24490,16 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   };
   const fire = () => {
     ctx.debounceTimer = null;
-    const resolve42 = ctx.debouncedResolve;
+    const resolve41 = ctx.debouncedResolve;
     ctx.debouncedResolve = null;
     ctx.debouncedPromise = null;
     if (ctx.inFlight) {
       ctx.pending = true;
-      ctx.inFlight.finally(() => resolve42?.());
+      ctx.inFlight.finally(() => resolve41?.());
       return;
     }
     ctx.inFlight = drive();
-    ctx.inFlight.finally(() => resolve42?.());
+    ctx.inFlight.finally(() => resolve41?.());
   };
   return ({ immediate = false } = {}) => {
     if (!ctx.debouncedPromise) {
@@ -24622,9 +24526,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const diskRefreshPromise = (async () => {
     if (!angularDir || editedFiles.size === 0)
       return;
-    const angularDirAbs = resolve41(angularDir);
+    const angularDirAbs = resolve40(angularDir);
     const filesUnderAngular = Array.from(editedFiles).filter((file4) => {
-      const abs = resolve41(file4);
+      const abs = resolve40(file4);
       return abs === angularDirAbs || abs.startsWith(angularDirAbs + sep4);
     });
     if (filesUnderAngular.length === 0)
@@ -24646,7 +24550,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
         if (!ext)
           continue;
         if (ext === ".ts" || ext === ".tsx") {
-          tsFilesToRefresh.add(resolve41(file4));
+          tsFilesToRefresh.add(resolve40(file4));
           continue;
         }
         const owners = resolveOwningComponents2({
@@ -24654,7 +24558,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
           userAngularRoot: angularDirAbs
         });
         for (const owner of owners) {
-          tsFilesToRefresh.add(resolve41(owner.componentFilePath));
+          tsFilesToRefresh.add(resolve40(owner.componentFilePath));
         }
       }
       if (tsFilesToRefresh.size === 0)
@@ -24669,7 +24573,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
         const { invalidateModule: invalidateModule2 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
         for (const tsFile of tsFilesToRefresh) {
           const rel = relative16(angularDirAbs, tsFile).replace(/\\/g, "/").replace(/\.[tj]sx?$/, ".js");
-          const compiledFile = resolve41(compiledRoot, rel);
+          const compiledFile = resolve40(compiledRoot, rel);
           invalidateModule2(compiledFile);
         }
       } catch {}
@@ -24743,7 +24647,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   serverPaths.forEach((serverPath, idx) => {
     const fileBase = basename13(serverPath, ".js");
     const ssrPath = ssrPaths[idx] ?? serverPath;
-    state.manifest[toPascal(fileBase)] = resolve41(ssrPath);
+    state.manifest[toPascal(fileBase)] = resolve40(ssrPath);
   });
   if (clientPaths.length > 0) {
     await bundleAngularClient(state, clientPaths, state.resolvedPaths.buildDir, angularDir);
@@ -24756,9 +24660,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const angularDir = config.angularDirectory ?? "";
   const angularFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "angular");
   for (const file4 of angularFiles) {
-    state.fileHashes.set(resolve41(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve40(file4), computeFileHash(file4));
   }
-  const angularPagesPath = resolve41(angularDir, "pages");
+  const angularPagesPath = resolve40(angularDir, "pages");
   const pageEntries = resolveAngularPageEntries(state, angularFiles, angularPagesPath);
   const tierStart = performance.now();
   const verdict = await decideAngularTier(state, angularDir);
@@ -24799,11 +24703,11 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (isComponentFile2)
     return primaryFile;
   const { findNearestComponent: findNearestComponent2 } = await Promise.resolve().then(() => (init_transformCache(), exports_transformCache));
-  const nearest = findNearestComponent2(resolve41(primaryFile));
+  const nearest = findNearestComponent2(resolve40(primaryFile));
   return nearest ?? primaryFile;
 }, handleReactModuleServerPath = async (state, reactFiles, startTime, onRebuildComplete) => {
   for (const file4 of reactFiles) {
-    state.fileHashes.set(resolve41(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve40(file4), computeFileHash(file4));
   }
   const primaryFile = reactFiles.find((file4) => !file4.replace(/\\/g, "/").includes("/pages/")) ?? reactFiles[0];
   if (!primaryFile) {
@@ -24884,7 +24788,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, handleSvelteModuleServerPath = async (state, svelteFiles, config, startTime, onRebuildComplete) => {
   for (const file4 of svelteFiles) {
-    state.fileHashes.set(resolve41(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve40(file4), computeFileHash(file4));
   }
   const serverDuration = Date.now() - startTime;
   await runSequentially(svelteFiles, (changedFile) => broadcastSvelteModuleUpdate(state, changedFile, svelteFiles, serverDuration));
@@ -25131,7 +25035,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, handleVueModuleServerPath = async (state, vueFiles, nonVueFiles, config, startTime, onRebuildComplete) => {
   for (const file4 of [...vueFiles, ...nonVueFiles]) {
-    state.fileHashes.set(resolve41(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve40(file4), computeFileHash(file4));
   }
   await invalidateNonVueModules(nonVueFiles);
   const serverDuration = Date.now() - startTime;
@@ -25280,7 +25184,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
       recursive: true,
       withFileTypes: true
     });
-    return entries.filter((entry) => entry.isFile() && EMBER_PAGE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))).map((entry) => resolve41(emberPagesPath, entry.name));
+    return entries.filter((entry) => entry.isFile() && EMBER_PAGE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))).map((entry) => resolve40(emberPagesPath, entry.name));
   } catch {
     return [];
   }
@@ -25292,10 +25196,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return state.manifest;
   }
   for (const file4 of emberFiles) {
-    state.fileHashes.set(resolve41(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve40(file4), computeFileHash(file4));
   }
-  const emberPagesPath = resolve41(emberDir, "pages");
-  const directPageEntries = emberFiles.filter((file4) => resolve41(file4).startsWith(emberPagesPath));
+  const emberPagesPath = resolve40(emberDir, "pages");
+  const directPageEntries = emberFiles.filter((file4) => resolve40(file4).startsWith(emberPagesPath));
   const allPageEntries = directPageEntries.length > 0 ? directPageEntries : await collectAllEmberPages(emberPagesPath);
   if (allPageEntries.length === 0) {
     onRebuildComplete({ hmrState: state, manifest: state.manifest });
@@ -25305,7 +25209,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const { serverPaths } = await compileEmber2(allPageEntries, emberDir, process.cwd(), true);
   for (const serverPath of serverPaths) {
     const fileBase = basename13(serverPath, ".js");
-    state.manifest[toPascal(fileBase)] = resolve41(serverPath);
+    state.manifest[toPascal(fileBase)] = resolve40(serverPath);
   }
   const { invalidateEmberSsrCache: invalidateEmberSsrCache2 } = await Promise.resolve().then(() => (init_ember(), exports_ember));
   invalidateEmberSsrCache2();
@@ -25397,8 +25301,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!buildReference?.source) {
     return;
   }
-  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve41(dirname25(buildInfo.resolvedRegistryPath), buildReference.source);
-  islandFiles.add(resolve41(sourcePath));
+  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve40(dirname24(buildInfo.resolvedRegistryPath), buildReference.source);
+  islandFiles.add(resolve40(sourcePath));
 }, resolveIslandSourceFiles = async (config) => {
   const registryPath = config.islands?.registry;
   if (!registryPath) {
@@ -25406,7 +25310,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   const buildInfo = await loadIslandRegistryBuildInfo(registryPath);
   const islandFiles = new Set([
-    resolve41(buildInfo.resolvedRegistryPath)
+    resolve40(buildInfo.resolvedRegistryPath)
   ]);
   for (const definition of buildInfo.definitions) {
     resolveIslandDefinitionSource(definition, buildInfo, islandFiles);
@@ -25417,7 +25321,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (islandFiles.size === 0) {
     return false;
   }
-  return filesToRebuild.some((file4) => islandFiles.has(resolve41(file4)));
+  return filesToRebuild.some((file4) => islandFiles.has(resolve40(file4)));
 }, handleIslandSourceReload = async (state, config, filesToRebuild, manifest) => {
   const shouldReload = await didStaticPagesNeedIslandRefresh(config, filesToRebuild);
   if (!shouldReload) {
@@ -25452,10 +25356,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
 }, computeOutputPagesDir = (state, config, framework) => {
   const isSingle = !config.reactDirectory && !config.svelteDirectory && !config.vueDirectory && (framework === "html" ? !config.htmxDirectory : !config.htmlDirectory);
   if (isSingle) {
-    return resolve41(state.resolvedPaths.buildDir, "pages");
+    return resolve40(state.resolvedPaths.buildDir, "pages");
   }
   const dirName = framework === "html" ? basename13(config.htmlDirectory ?? "html") : basename13(config.htmxDirectory ?? "htmx");
-  return resolve41(state.resolvedPaths.buildDir, dirName, "pages");
+  return resolve40(state.resolvedPaths.buildDir, dirName, "pages");
 }, processHtmlPageUpdate = async (state, pageFile, builtHtmlPagePath, manifest, duration) => {
   try {
     const { handleHTMLUpdate: handleHTMLUpdate2 } = await Promise.resolve().then(() => (init_simpleHTMLHMR(), exports_simpleHTMLHMR));
@@ -25494,7 +25398,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmlPages, "*.html") : htmlPageFiles;
   await runSequentially(pageFilesToUpdate, async (pageFile) => {
     const htmlPageName = basename13(pageFile);
-    const builtHtmlPagePath = resolve41(outputHtmlPages, htmlPageName);
+    const builtHtmlPagePath = resolve40(outputHtmlPages, htmlPageName);
     await processHtmlPageUpdate(state, pageFile, builtHtmlPagePath, manifest, duration);
   });
 }, handleVueCssOnlyUpdate = (state, vueCssFiles, manifest, duration) => {
@@ -25559,7 +25463,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const cssKey = `${pascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
   const { vueHmrMetadata: vueHmrMetadata2 } = await Promise.resolve().then(() => (init_compileVue(), exports_compileVue));
-  const hmrMeta = vueHmrMetadata2.get(resolve41(vuePagePath));
+  const hmrMeta = vueHmrMetadata2.get(resolve40(vuePagePath));
   const changeType = hmrMeta?.changeType ?? "full";
   if (changeType === "style-only") {
     broadcastVueStyleOnly(state, vuePagePath, baseName, cssUrl, hmrId, manifest, duration);
@@ -25744,7 +25648,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmxPages, "*.html") : htmxPageFiles;
   await runSequentially(pageFilesToUpdate, async (htmxPageFile) => {
     const htmxPageName = basename13(htmxPageFile);
-    const builtHtmxPagePath = resolve41(outputHtmxPages, htmxPageName);
+    const builtHtmxPagePath = resolve40(outputHtmxPages, htmxPageName);
     await processHtmxPageUpdate(state, htmxPageFile, builtHtmxPagePath, manifest, duration);
   });
 }, collectUpdatedModulePaths = (allModuleUpdates) => {
@@ -25853,7 +25757,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   html = html.slice(0, bodyClose.index) + hmrScript + html.slice(bodyClose.index);
   writeFs(destPath, html);
 }, processMarkupFileFastPath = async (state, sourceFile, outputDir, framework, startTime, updateAssetPaths2, handleUpdate, readFs, writeFs) => {
-  const destPath = resolve41(outputDir, basename13(sourceFile));
+  const destPath = resolve40(outputDir, basename13(sourceFile));
   const hmrScript = extractHmrScript(destPath, readFs);
   const source = await Bun.file(sourceFile).text();
   await Bun.write(destPath, source);
@@ -25995,7 +25899,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
   if (config.tailwind && filesToRebuild && filesToRebuild.some(isTailwindCandidate)) {
     try {
-      const outputPath = resolve41(state.resolvedPaths.buildDir, config.tailwind.output);
+      const outputPath = resolve40(state.resolvedPaths.buildDir, config.tailwind.output);
       const bytes = await Bun.file(outputPath).bytes();
       const webPath = `/${config.tailwind.output.replace(/^\/+/, "")}`;
       state.assetStore.set(webPath, bytes);
@@ -26429,7 +26333,7 @@ __export(exports_devBuild, {
 });
 import { readdir as readdir5 } from "fs/promises";
 import { statSync as statSync7 } from "fs";
-import { resolve as resolve42 } from "path";
+import { resolve as resolve41 } from "path";
 var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const configuredDirs = [
     config.reactDirectory,
@@ -26452,7 +26356,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return Object.keys(config).length > 0 ? config : null;
 }, reloadConfig = async () => {
   try {
-    const configPath2 = resolve42(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+    const configPath2 = resolve41(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
     const source = await Bun.file(configPath2).text();
     return parseDirectoryConfig(source);
   } catch {
@@ -26559,7 +26463,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     state.fileChangeQueue.clear();
   }
 }, handleCachedReload = async () => {
-  const serverMtime = statSync7(resolve42(Bun.main)).mtimeMs;
+  const serverMtime = statSync7(resolve41(Bun.main)).mtimeMs;
   const lastMtime = globalThis.__hmrServerMtime;
   globalThis.__hmrServerMtime = serverMtime;
   const cached = globalThis.__hmrDevResult;
@@ -26596,8 +26500,8 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return true;
 }, resolveAbsoluteVersion2 = async () => {
   const candidates = [
-    resolve42(import.meta.dir, "..", "..", "package.json"),
-    resolve42(import.meta.dir, "..", "package.json")
+    resolve41(import.meta.dir, "..", "..", "package.json"),
+    resolve41(import.meta.dir, "..", "package.json")
   ];
   const [candidate, ...remaining] = candidates;
   if (!candidate) {
@@ -26623,7 +26527,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const entries = await readdir5(vendorDir).catch(() => emptyStringArray);
   await Promise.all(entries.filter((entry) => entry.endsWith(".js")).map(async (entry) => {
     const webPath = `/${framework}/vendor/${entry}`;
-    const bytes = await Bun.file(resolve42(vendorDir, entry)).bytes();
+    const bytes = await Bun.file(resolve41(vendorDir, entry)).bytes();
     assetStore.set(webPath, bytes);
   }));
 }, devBuild = async (config) => {
@@ -26702,11 +26606,11 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   cleanStaleAssets(state.assetStore, manifest, state.resolvedPaths.buildDir);
   recordStep("populate asset store", stepStartedAt);
   stepStartedAt = performance.now();
-  const reactVendorDir = resolve42(state.resolvedPaths.buildDir, "react", "vendor");
-  const angularVendorDir = resolve42(state.resolvedPaths.buildDir, "angular", "vendor");
-  const svelteVendorDir = resolve42(state.resolvedPaths.buildDir, "svelte", "vendor");
-  const vueVendorDir = resolve42(state.resolvedPaths.buildDir, "vue", "vendor");
-  const depVendorDir = resolve42(state.resolvedPaths.buildDir, "vendor");
+  const reactVendorDir = resolve41(state.resolvedPaths.buildDir, "react", "vendor");
+  const angularVendorDir = resolve41(state.resolvedPaths.buildDir, "angular", "vendor");
+  const svelteVendorDir = resolve41(state.resolvedPaths.buildDir, "svelte", "vendor");
+  const vueVendorDir = resolve41(state.resolvedPaths.buildDir, "vue", "vendor");
+  const depVendorDir = resolve41(state.resolvedPaths.buildDir, "vendor");
   const { buildDepVendor: buildDepVendor2 } = await Promise.resolve().then(() => (init_buildDepVendor(), exports_buildDepVendor));
   const [, angularSpecs, , , , , depPaths] = await Promise.all([
     config.reactDirectory ? buildReactVendor(state.resolvedPaths.buildDir) : Promise.resolve(undefined),
@@ -26817,7 +26721,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     manifest
   };
   globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync7(resolve42(Bun.main)).mtimeMs;
+  globalThis.__hmrServerMtime = statSync7(resolve41(Bun.main)).mtimeMs;
   return result;
 };
 var init_devBuild = __esm(() => {
@@ -26857,5 +26761,5 @@ export {
   build
 };
 
-//# debugId=AFDCA0EAFC10E90864756E2164756E21
+//# debugId=078CF7870DEFB49E64756E2164756E21
 //# sourceMappingURL=build.js.map