@absolutejs/absolute 0.19.0-beta.931 → 0.19.0-beta.932

package/dist/index.js

@@ -7553,6 +7553,100 @@ var init_svelteServerModule = __esm(() => {
   });
 });
 
+// src/core/vueServerModule.ts
+import { mkdir as mkdir3 } from "fs/promises";
+import { dirname as dirname6, join as join7, relative as relative3, resolve as resolve6 } from "path";
+var {Transpiler } = globalThis.Bun;
+var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, transpiler2, ensureRelativeImportPath2 = (from, target) => {
+  const importPath = relative3(dirname6(from), target).replace(/\\/g, "/");
+  return importPath.startsWith(".") ? importPath : `./${importPath}`;
+}, getCachedModulePath2 = (sourcePath) => {
+  const relativeSourcePath = relative3(process.cwd(), sourcePath).replace(/\\/g, "/");
+  const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
+  return join7(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
+}, writeIfChanged2 = async (path, content) => {
+  const targetFile = Bun.file(path);
+  if (await targetFile.exists()) {
+    const currentContent = await targetFile.text();
+    if (currentContent === content)
+      return;
+  }
+  await Bun.write(path, content);
+}, stripExports = (code) => code.replace(/export\s+default/, "const script ="), mergeVueImports = (code) => {
+  const lines = code.split(`
+`);
+  const specifierSet = new Set;
+  const vueImportRegex = /^import\s+{([^}]+)}\s+from\s+['"]vue['"];?$/;
+  lines.forEach((line) => {
+    const match = line.match(vueImportRegex);
+    if (match?.[1])
+      match[1].split(",").forEach((importSpecifier) => specifierSet.add(importSpecifier.trim()));
+  });
+  const nonVueLines = lines.filter((line) => !vueImportRegex.test(line));
+  return specifierSet.size ? [
+    `import { ${[...specifierSet].join(", ")} } from "vue";`,
+    ...nonVueLines
+  ].join(`
+`) : nonVueLines.join(`
+`);
+}, extractRelativeVueImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => typeof importPath === "string" && importPath.startsWith(".") && importPath.endsWith(".vue")), compileVueServerModule = async (sourcePath) => {
+  const cachedModulePath = compiledModuleCache2.get(sourcePath);
+  if (cachedModulePath)
+    return cachedModulePath;
+  const compiler = await import("@vue/compiler-sfc");
+  const source = await Bun.file(sourcePath).text();
+  const { descriptor } = compiler.parse(source, { filename: sourcePath });
+  const componentId = Bun.hash(sourcePath).toString(BASE_36_RADIX).slice(0, ISLAND_COMPONENT_ID_LENGTH);
+  const hasScript = descriptor.script || descriptor.scriptSetup;
+  const compiledScript = hasScript ? compiler.compileScript(descriptor, {
+    id: componentId,
+    inlineTemplate: false
+  }) : { bindings: {}, content: "export default {};" };
+  const renderCode = descriptor.template ? compiler.compileTemplate({
+    compilerOptions: {
+      bindingMetadata: compiledScript.bindings,
+      expressionPlugins: ["typescript"],
+      prefixIdentifiers: true,
+      isCustomElement: (tag) => tag === "absolute-island"
+    },
+    filename: sourcePath,
+    id: componentId,
+    scoped: descriptor.styles.some((styleBlock) => styleBlock.scoped),
+    source: descriptor.template.content,
+    ssr: true,
+    ssrCssVars: descriptor.cssVars
+  }).code : "const ssrRender = () => {};";
+  const childImportPaths = extractRelativeVueImports(compiledScript.content);
+  const compiledChildren = await Promise.all(childImportPaths.map(async (relativeImport) => ({
+    compiledPath: await compileVueServerModule(resolve6(dirname6(sourcePath), relativeImport)),
+    spec: relativeImport
+  })));
+  const strippedScript = stripExports(compiledScript.content);
+  const transpiledScript = transpiler2.transformSync(strippedScript);
+  const assembled = mergeVueImports([
+    transpiledScript,
+    renderCode,
+    "script.ssrRender = ssrRender;",
+    "export default script;"
+  ].join(`
+`));
+  const compiledModulePath = getCachedModulePath2(sourcePath);
+  let rewritten = assembled;
+  for (const child of compiledChildren) {
+    rewritten = rewritten.replaceAll(child.spec, ensureRelativeImportPath2(compiledModulePath, child.compiledPath));
+  }
+  await mkdir3(dirname6(compiledModulePath), { recursive: true });
+  await writeIfChanged2(compiledModulePath, rewritten);
+  compiledModuleCache2.set(sourcePath, compiledModulePath);
+  return compiledModulePath;
+};
+var init_vueServerModule = __esm(() => {
+  init_constants();
+  serverCacheRoot2 = join7(process.cwd(), ".absolutejs", "islands", "vue");
+  compiledModuleCache2 = new Map;
+  transpiler2 = new Transpiler({ loader: "ts", target: "browser" });
+});
+
 // src/core/islandMarkupAttributes.ts
 var getIslandMarkerAttributes = (props, islandId) => ({
   "data-component": props.component,
@@ -7588,9 +7682,17 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
   const loadPromise = loadAndCompileServerBuildComponent(buildReferencePath);
   resolvedServerBuildComponentCache.set(buildReferencePath, loadPromise);
   return loadPromise;
+}, resolveRuntimeImportTarget = async (resolvedModulePath) => {
+  if (resolvedModulePath.endsWith(".svelte")) {
+    return compileSvelteServerModule(resolvedModulePath);
+  }
+  if (resolvedModulePath.endsWith(".vue")) {
+    return compileVueServerModule(resolvedModulePath);
+  }
+  return resolvedModulePath;
 }, loadServerImportComponent = async (resolvedComponent, exportName) => {
   const resolvedModulePath = resolvedComponent.startsWith(".") ? new URL(resolvedComponent, import.meta.url).pathname : resolvedComponent;
-  const importTarget = resolvedModulePath.endsWith(".svelte") ? await compileSvelteServerModule(resolvedModulePath) : resolvedModulePath;
+  const importTarget = await resolveRuntimeImportTarget(resolvedModulePath);
   const loadedModule = await import(importTarget);
   if (exportName && exportName !== "default" && exportName in loadedModule) {
     return loadedModule[exportName];
@@ -7694,6 +7796,7 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
 var init_renderIslandMarkup = __esm(() => {
   init_islandSsr();
   init_svelteServerModule();
+  init_vueServerModule();
   init_islandMarkupAttributes();
   init_islands();
   resolvedServerComponentCache = new Map;
@@ -7702,7 +7805,7 @@ var init_renderIslandMarkup = __esm(() => {
 
 // src/build/islandEntries.ts
 import { mkdirSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname6, extname as extname3, join as join7, relative as relative3, resolve as resolve6 } from "path";
+import { dirname as dirname7, extname as extname3, join as join8, relative as relative4, resolve as resolve7 } from "path";
 import ts from "typescript";
 var frameworks, isRecord4 = (value) => typeof value === "object" && value !== null, resolveRegistryExport = (mod) => {
   if (isRecord4(mod.islandRegistry))
@@ -7711,13 +7814,13 @@ var frameworks, isRecord4 = (value) => typeof value === "object" && value !== nu
     return mod.default;
   throw new Error("Island registry module must export `islandRegistry` or a default registry object.");
 }, hasSvelteImport = (source) => /from\s+['"][^'"]+\.svelte['"]/.test(source), normalizeImportPath = (wrapperPath, targetPath) => {
-  const importPath = relative3(dirname6(wrapperPath), targetPath).replace(/\\/g, "/");
+  const importPath = relative4(dirname7(wrapperPath), targetPath).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
 }, isIdentifier = (value) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value), resolveIslandSourcePath = (registryPath, sourcePath) => {
   if (sourcePath.startsWith("file://")) {
     return new URL(sourcePath).pathname;
   }
-  return resolve6(dirname6(registryPath), sourcePath);
+  return resolve7(dirname7(registryPath), sourcePath);
 }, getObjectPropertyName = (name) => {
   if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
     return name.text;
@@ -7935,16 +8038,16 @@ export default component;
   buildPath,
   clientPathMaps = {}
 }) => {
-  const generatedRoot = join7(buildPath, "_island_entries");
+  const generatedRoot = join8(buildPath, "_island_entries");
   rmSync(generatedRoot, { force: true, recursive: true });
   const entries = [];
   for (const definition of buildInfo.definitions) {
-    const entryPath = join7(generatedRoot, "islands", definition.framework, `${definition.component}.ts`);
+    const entryPath = join8(generatedRoot, "islands", definition.framework, `${definition.component}.ts`);
     const { buildReference } = definition;
     const source = buildReference ? resolveIslandSourcePath(buildInfo.resolvedRegistryPath, buildReference.source) : null;
     const compiledSourcePath = source && shouldUseCompiledClientPath(definition.framework, source) ? clientPathMaps[definition.framework]?.get(source) : undefined;
     const entrySource = source && (compiledSourcePath || !shouldUseCompiledClientPath(definition.framework, source)) ? createDirectEntrySource(entryPath, compiledSourcePath ?? source, compiledSourcePath ? undefined : buildReference?.export) : createRegistryEntrySource(entryPath, buildInfo.resolvedRegistryPath, buildInfo.hasNamedExport, definition.framework, definition.component);
-    mkdirSync(dirname6(entryPath), { recursive: true });
+    mkdirSync(dirname7(entryPath), { recursive: true });
     writeFileSync2(entryPath, entrySource);
     entries.push({
       component: definition.component,
@@ -7957,7 +8060,7 @@ export default component;
     generatedRoot
   };
 }, loadIslandRegistryBuildInfo = async (registryPath) => {
-  const resolvedRegistryPath = resolve6(registryPath);
+  const resolvedRegistryPath = resolve7(registryPath);
   const registrySource = Bun.file(resolvedRegistryPath);
   const registrySourceText = await registrySource.text();
   const parsedInfo = parseIslandRegistryBuildInfo(registrySourceText, resolvedRegistryPath);
@@ -8310,7 +8413,7 @@ var init_sourceMetadata = __esm(() => {
 
 // src/islands/pageMetadata.ts
 import { readFileSync as readFileSync7 } from "fs";
-import { dirname as dirname7, resolve as resolve9 } from "path";
+import { dirname as dirname8, resolve as resolve10 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
   { dir: config.emberDirectory, framework: "ember" },
@@ -8330,15 +8433,15 @@ var pagePatterns, getPageDirs = (config) => [
     const source = definition.buildReference?.source;
     if (!source)
       continue;
-    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve9(dirname7(buildInfo.resolvedRegistryPath), source);
-    lookup.set(`${definition.framework}:${definition.component}`, resolve9(resolvedSource));
+    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve10(dirname8(buildInfo.resolvedRegistryPath), source);
+    lookup.set(`${definition.framework}:${definition.component}`, resolve10(resolvedSource));
   }
   return lookup;
 }, getCurrentPageIslandMetadata = () => globalThis.__absolutePageIslandMetadata ?? new Map, metadataUsesSource = (metadata2, target) => metadata2.islands.some((usage) => {
   const candidate = usage.source;
-  return candidate ? resolve9(candidate) === target : false;
+  return candidate ? resolve10(candidate) === target : false;
 }), getPagesUsingIslandSource = (sourcePath) => {
-  const target = resolve9(sourcePath);
+  const target = resolve10(sourcePath);
   return [...getCurrentPageIslandMetadata().values()].filter((metadata2) => metadataUsesSource(metadata2, target)).map((metadata2) => metadata2.pagePath);
 }, resolveIslandUsages = (islands, islandSourceLookup) => islands.map((usage) => {
   const sourcePath = islandSourceLookup.get(`${usage.framework}:${usage.component}`);
@@ -8350,13 +8453,13 @@ var pagePatterns, getPageDirs = (config) => [
   const pattern = pagePatterns[entry.framework];
   if (!pattern)
     return;
-  const files = await scanEntryPoints(resolve9(entry.dir), pattern);
+  const files = await scanEntryPoints(resolve10(entry.dir), pattern);
   for (const filePath of files) {
     const source = readFileSync7(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
-    pageMetadata.set(resolve9(filePath), {
+    pageMetadata.set(resolve10(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
-      pagePath: resolve9(filePath)
+      pagePath: resolve10(filePath)
     });
   }
 }, loadPageIslandMetadata = async (config) => {
@@ -8561,12 +8664,12 @@ var init_startupBanner = __esm(() => {
 // src/utils/logger.ts
 var colors2, frameworkColors, formatPath = (filePath) => {
   const cwd = process.cwd();
-  let relative4 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
-  relative4 = relative4.replace(/\\/g, "/");
-  if (!relative4.startsWith("/")) {
-    relative4 = `/${relative4}`;
+  let relative5 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+  relative5 = relative5.replace(/\\/g, "/");
+  if (!relative5.startsWith("/")) {
+    relative5 = `/${relative5}`;
   }
-  return relative4;
+  return relative5;
 }, getFrameworkColor = (framework) => frameworkColors[framework] || colors2.white, log = (action, options) => {
   const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
   const tag = `${colors2.cyan}[hmr]${colors2.reset}`;
@@ -8669,9 +8772,9 @@ var getManifestKey = (folder, pascalName, isClientComponent, isReact, isVue, isS
 }, generateManifest = (outputs, buildPath) => outputs.reduce((manifest, artifact) => {
   const normalizedArtifactPath = normalizePath(artifact.path);
   const normalizedBuildPath = normalizePath(buildPath);
-  let relative4 = normalizedArtifactPath.startsWith(normalizedBuildPath) ? normalizedArtifactPath.slice(normalizedBuildPath.length) : normalizedArtifactPath;
-  relative4 = relative4.replace(/^\/+/, "");
-  const segments = relative4.split("/");
+  let relative5 = normalizedArtifactPath.startsWith(normalizedBuildPath) ? normalizedArtifactPath.slice(normalizedBuildPath.length) : normalizedArtifactPath;
+  relative5 = relative5.replace(/^\/+/, "");
+  const segments = relative5.split("/");
   const fileWithHash = segments.pop();
   if (!fileWithHash)
     return manifest;
@@ -8685,15 +8788,15 @@ var getManifestKey = (folder, pascalName, isClientComponent, isReact, isVue, isS
     if (segments.includes("server"))
       return manifest;
     const cssKey = getCssKey(pascalName, segments);
-    if (manifest[cssKey] && manifest[cssKey] !== `/${relative4}`)
-      logWarn(`Duplicate manifest key "${cssKey}" \u2014 "${manifest[cssKey]}" will be overwritten by "/${relative4}". Use unique page names across frameworks.`);
-    manifest[cssKey] = `/${relative4}`;
+    if (manifest[cssKey] && manifest[cssKey] !== `/${relative5}`)
+      logWarn(`Duplicate manifest key "${cssKey}" \u2014 "${manifest[cssKey]}" will be overwritten by "/${relative5}". Use unique page names across frameworks.`);
+    manifest[cssKey] = `/${relative5}`;
     return manifest;
   }
   const frameworkSegment = islandIndex > UNFOUND_INDEX ? segments[islandIndex + 1] : undefined;
   if (frameworkSegment === "react" || frameworkSegment === "svelte" || frameworkSegment === "vue" || frameworkSegment === "angular") {
     const manifestKey2 = getIslandManifestKey(frameworkSegment, pascalName);
-    manifest[manifestKey2] = `/${relative4}`;
+    manifest[manifestKey2] = `/${relative5}`;
     return manifest;
   }
   const idx = segments.findIndex((seg) => seg === "indexes" || seg === "pages" || seg === "client");
@@ -8704,10 +8807,10 @@ var getManifestKey = (folder, pascalName, isClientComponent, isReact, isVue, isS
   const isAngular = segments.some((seg) => seg === "angular");
   const isClientComponent = segments.includes("client");
   const manifestKey = getManifestKey(folder, pascalName, isClientComponent, isReact, isVue, isSvelte, isAngular);
-  if (manifest[manifestKey] && manifest[manifestKey] !== `/${relative4}`) {
-    logWarn(`Duplicate manifest key "${manifestKey}" \u2014 "${manifest[manifestKey]}" will be overwritten by "/${relative4}". Use unique page names across frameworks.`);
+  if (manifest[manifestKey] && manifest[manifestKey] !== `/${relative5}`) {
+    logWarn(`Duplicate manifest key "${manifestKey}" \u2014 "${manifest[manifestKey]}" will be overwritten by "/${relative5}". Use unique page names across frameworks.`);
   }
-  manifest[manifestKey] = `/${relative4}`;
+  manifest[manifestKey] = `/${relative5}`;
   return manifest;
 }, {});
 var init_generateManifest = __esm(() => {
@@ -8716,7 +8819,7 @@ var init_generateManifest = __esm(() => {
 });
 
 // src/build/verifyAngularCoreUniqueness.ts
-import { resolve as resolve10 } from "path";
+import { resolve as resolve11 } from "path";
 var ANGULAR_CORE_IMPORT_RE, ANGULAR_CORE_PACKAGE_RE, classifySpecifier = (specifier, artifactPath, serverOutDir) => {
   if (!ANGULAR_CORE_PACKAGE_RE.test(specifier))
     return null;
@@ -8726,9 +8829,9 @@ var ANGULAR_CORE_IMPORT_RE, ANGULAR_CORE_PACKAGE_RE, classifySpecifier = (specif
   if (specifier.startsWith("/")) {
     absolute = specifier;
   } else if (specifier.startsWith(".")) {
-    absolute = resolve10(artifactPath, "..", specifier);
+    absolute = resolve11(artifactPath, "..", specifier);
   } else {
-    absolute = serverOutDir ? resolve10(serverOutDir, specifier) : resolve10(artifactPath, "..", specifier);
+    absolute = serverOutDir ? resolve11(serverOutDir, specifier) : resolve11(artifactPath, "..", specifier);
   }
   return {
     kind: "resolved",
@@ -8793,18 +8896,18 @@ var init_verifyAngularCoreUniqueness = __esm(() => {
 // src/build/generateReactIndexes.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync2 } from "fs";
 import { readdir as readdir2, rm, writeFile } from "fs/promises";
-import { basename as basename3, join as join8, relative as relative4, resolve as resolve11, sep } from "path";
+import { basename as basename3, join as join9, relative as relative5, resolve as resolve12, sep } from "path";
 var {Glob: Glob2 } = globalThis.Bun;
 var indexContentCache, resolveDevClientDir = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve11(import.meta.dir, "../dev/client");
+  const fromSource = resolve12(import.meta.dir, "../dev/client");
   if (existsSync7(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve11(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve12(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync7(fromNodeModules))
     return fromNodeModules;
-  return resolve11(import.meta.dir, "./dev/client");
+  return resolve12(import.meta.dir, "./dev/client");
 }, devClientDir, errorOverlayPath, hmrClientPath, refreshSetupPath, generateReactIndexFiles = async (reactPagesDirectory, reactIndexesDirectory, isDev2 = false) => {
   if (!existsSync7(reactIndexesDirectory)) {
     mkdirSync2(reactIndexesDirectory, { recursive: true });
@@ -8826,13 +8929,13 @@ var indexContentCache, resolveDevClientDir = () => {
   });
   if (staleIndexes.length > 0) {
     await Promise.all(staleIndexes.map((indexFile) => {
-      indexContentCache.delete(join8(reactIndexesDirectory, indexFile));
-      return rm(join8(reactIndexesDirectory, indexFile), {
+      indexContentCache.delete(join9(reactIndexesDirectory, indexFile));
+      return rm(join9(reactIndexesDirectory, indexFile), {
         force: true
       });
     }));
   }
-  const pagesRelPath = relative4(resolve11(reactIndexesDirectory), resolve11(reactPagesDirectory)).split(sep).join("/");
+  const pagesRelPath = relative5(resolve12(reactIndexesDirectory), resolve12(reactPagesDirectory)).split(sep).join("/");
   const promises = files.map(async (file2) => {
     const fileName = basename3(file2);
     const componentName = fileName.split(".")[0];
@@ -9106,11 +9209,11 @@ var indexContentCache, resolveDevClientDir = () => {
         `
 // Pre-warm: import the page module from the module server`,
         `// immediately so the browser caches all /@src/ URLs.`,
-        `import('/@src/${relative4(process.cwd(), resolve11(reactPagesDirectory, `${componentName}.tsx`)).replace(/\\/g, "/")}').catch(() => {});`
+        `import('/@src/${relative5(process.cwd(), resolve12(reactPagesDirectory, `${componentName}.tsx`)).replace(/\\/g, "/")}').catch(() => {});`
       ] : []
     ].join(`
 `);
-    const indexPath = join8(reactIndexesDirectory, `${componentName}.tsx`);
+    const indexPath = join9(reactIndexesDirectory, `${componentName}.tsx`);
     const hasher = new Bun.CryptoHasher("md5");
     hasher.update(content);
     const contentHash = hasher.digest("hex");
@@ -9124,7 +9227,7 @@ var indexContentCache, resolveDevClientDir = () => {
   if (!isDev2) {
     return;
   }
-  const refreshPath = join8(reactIndexesDirectory, "_refresh.tsx");
+  const refreshPath = join9(reactIndexesDirectory, "_refresh.tsx");
   if (!existsSync7(refreshPath)) {
     await writeFile(refreshPath, `import '${refreshSetupPath}';
 import 'react';
@@ -9135,9 +9238,9 @@ import 'react-dom/client';
 var init_generateReactIndexes = __esm(() => {
   indexContentCache = new Map;
   devClientDir = resolveDevClientDir();
-  errorOverlayPath = join8(devClientDir, "errorOverlay.ts").replace(/\\/g, "/");
-  hmrClientPath = join8(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
-  refreshSetupPath = join8(devClientDir, "reactRefreshSetup.ts").replace(/\\/g, "/");
+  errorOverlayPath = join9(devClientDir, "errorOverlay.ts").replace(/\\/g, "/");
+  hmrClientPath = join9(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
+  refreshSetupPath = join9(devClientDir, "reactRefreshSetup.ts").replace(/\\/g, "/");
 });
 
 // src/build/wrapHTMLScript.ts
@@ -9274,7 +9377,7 @@ var init_scanCssEntryPoints = __esm(() => {
 
 // src/utils/imageProcessing.ts
 import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
-import { join as join9, resolve as resolve12 } from "path";
+import { join as join10, resolve as resolve13 } from "path";
 var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_ENDPOINT = "/_absolute/image", BLUR_DEVIATION = 20, sharpModule = undefined, sharpLoaded = false, sharpWarned = false, snapToSize = (target, sizes) => {
   for (const size of sizes) {
     if (size >= target)
@@ -9329,7 +9432,7 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_END
   const image2 = config?.imageSizes ?? DEFAULT_IMAGE_SIZES;
   return [...device, ...image2].sort((left, right) => left - right);
 }, getCacheDir = (buildDir) => {
-  const dir = join9(buildDir, ".cache", "images");
+  const dir = join10(buildDir, ".cache", "images");
   if (!existsSync10(dir))
     mkdirSync3(dir, { recursive: true });
   return dir;
@@ -9386,8 +9489,8 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_END
       return toBuffer(buffer);
   }
 }, readFromCache = (cacheDir, cacheKey) => {
-  const metaPath = join9(cacheDir, `${cacheKey}.meta`);
-  const dataPath = join9(cacheDir, `${cacheKey}.data`);
+  const metaPath = join10(cacheDir, `${cacheKey}.meta`);
+  const dataPath = join10(cacheDir, `${cacheKey}.data`);
   if (!existsSync10(metaPath) || !existsSync10(dataPath))
     return null;
   try {
@@ -9402,7 +9505,7 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_END
     return sharpModule;
   sharpLoaded = true;
   try {
-    const sharpPath = resolve12(process.cwd(), "node_modules/sharp");
+    const sharpPath = resolve13(process.cwd(), "node_modules/sharp");
     const mod = await import(sharpPath);
     sharpModule = mod.default ?? mod;
     return sharpModule;
@@ -9414,8 +9517,8 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_END
     return null;
   }
 }, writeToCache = (cacheDir, cacheKey, buffer, meta) => {
-  const metaPath = join9(cacheDir, `${cacheKey}.meta`);
-  const dataPath = join9(cacheDir, `${cacheKey}.data`);
+  const metaPath = join10(cacheDir, `${cacheKey}.meta`);
+  const dataPath = join10(cacheDir, `${cacheKey}.data`);
   writeFileSync4(dataPath, buffer);
   writeFileSync4(metaPath, JSON.stringify(meta));
 };
@@ -9503,7 +9606,7 @@ var init_optimizeHtmlImages = __esm(() => {
 // src/cli/scripts/telemetry.ts
 import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
 import { homedir } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var configDir, configPath, getTelemetryConfig = () => {
   try {
     if (!existsSync11(configPath))
@@ -9516,14 +9619,14 @@ var configDir, configPath, getTelemetryConfig = () => {
   }
 };
 var init_telemetry = __esm(() => {
-  configDir = join10(homedir(), ".absolutejs");
-  configPath = join10(configDir, "telemetry.json");
+  configDir = join11(homedir(), ".absolutejs");
+  configPath = join11(configDir, "telemetry.json");
 });
 
 // src/cli/telemetryEvent.ts
 import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
 import { arch, platform } from "os";
-import { dirname as dirname8, join as join11, parse } from "path";
+import { dirname as dirname9, join as join12, parse } from "path";
 var checkCandidate = (candidate) => {
   if (!existsSync12(candidate)) {
     return null;
@@ -9543,12 +9646,12 @@ var checkCandidate = (candidate) => {
 }, findPackageVersion = () => {
   let { dir } = import.meta;
   while (dir !== parse(dir).root) {
-    const candidate = join11(dir, "package.json");
+    const candidate = join12(dir, "package.json");
     const version = checkCandidate(candidate);
     if (version) {
       return version;
     }
-    dir = dirname8(dir);
+    dir = dirname9(dir);
   }
   return "unknown";
 }, sendTelemetryEvent = (event, payload) => {
@@ -9634,18 +9737,18 @@ var init_updateAssetPaths = __esm(() => {
 
 // src/dev/buildHMRClient.ts
 import { existsSync as existsSync13 } from "fs";
-import { resolve as resolve13 } from "path";
+import { resolve as resolve14 } from "path";
 var {build: bunBuild } = globalThis.Bun;
 var resolveHmrClientPath = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve13(import.meta.dir, "client/hmrClient.ts");
+  const fromSource = resolve14(import.meta.dir, "client/hmrClient.ts");
   if (existsSync13(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve13(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client/hmrClient.ts");
+  const fromNodeModules = resolve14(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client/hmrClient.ts");
   if (existsSync13(fromNodeModules))
     return fromNodeModules;
-  return resolve13(import.meta.dir, "dev/client/hmrClient.ts");
+  return resolve14(import.meta.dir, "dev/client/hmrClient.ts");
 }, hmrClientPath2, buildHMRClient = async () => {
   const entryPoint = hmrClientPath2;
   const result = await bunBuild({
@@ -9675,7 +9778,7 @@ var init_buildHMRClient = __esm(() => {
 // src/build/nativeRewrite.ts
 import { dlopen, FFIType, ptr } from "bun:ffi";
 import { platform as platform2, arch as arch2 } from "os";
-import { resolve as resolve14 } from "path";
+import { resolve as resolve15 } from "path";
 var ffiDefinition, nativeLib = null, loadNative = () => {
   if (nativeLib !== null)
     return nativeLib;
@@ -9693,7 +9796,7 @@ var ffiDefinition, nativeLib = null, loadNative = () => {
   if (!libPath)
     return null;
   try {
-    const fullPath = resolve14(import.meta.dir, "../../native/packages", libPath);
+    const fullPath = resolve15(import.meta.dir, "../../native/packages", libPath);
     const lib = dlopen(fullPath, ffiDefinition);
     nativeLib = lib.symbols;
     return nativeLib;
@@ -9839,7 +9942,7 @@ var devVendorPaths = null, getDevVendorPaths = () => devVendorPaths, setDevVendo
 
 // src/build/angularLinkerPlugin.ts
 import { existsSync as existsSync14, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname9, join as join12, relative as relative5, resolve as resolve15 } from "path";
+import { dirname as dirname10, join as join13, relative as relative6, resolve as resolve16 } from "path";
 import { createHash as createHash3 } from "crypto";
 var CACHE_ROOT, createAngularLinkerPlugin = (linkerJitMode) => ({
   name: "angular-linker",
@@ -9847,7 +9950,7 @@ var CACHE_ROOT, createAngularLinkerPlugin = (linkerJitMode) => ({
     let needsLinking;
     let babelTransform;
     let linkerPlugin;
-    const cacheDir = join12(CACHE_ROOT, linkerJitMode ? "jit" : "aot");
+    const cacheDir = join13(CACHE_ROOT, linkerJitMode ? "jit" : "aot");
     bld.onLoad({ filter: /[\\/]@angular[\\/].*\.m?js$/ }, async (args) => {
       const source = await Bun.file(args.path).text();
       if (!needsLinking) {
@@ -9860,7 +9963,7 @@ var CACHE_ROOT, createAngularLinkerPlugin = (linkerJitMode) => ({
         return;
       }
       const hash = createHash3("md5").update(source).digest("hex");
-      const cachePath = join12(cacheDir, `${hash}.js`);
+      const cachePath = join13(cacheDir, `${hash}.js`);
       if (existsSync14(cachePath)) {
         return {
           contents: readFileSync11(cachePath, "utf-8"),
@@ -9877,11 +9980,11 @@ var CACHE_ROOT, createAngularLinkerPlugin = (linkerJitMode) => ({
         const mod = await import(linkerSpecifier);
         linkerPlugin = mod.createEs2015LinkerPlugin({
           fileSystem: {
-            dirname: dirname9,
+            dirname: dirname10,
             exists: existsSync14,
             readFile: readFileSync11,
-            relative: relative5,
-            resolve: resolve15
+            relative: relative6,
+            resolve: resolve16
           },
           linkerJitMode,
           logger: {
@@ -9912,7 +10015,7 @@ var CACHE_ROOT, createAngularLinkerPlugin = (linkerJitMode) => ({
   }
 }), angularLinkerPlugin;
 var init_angularLinkerPlugin = __esm(() => {
-  CACHE_ROOT = resolve15(".absolutejs", "cache", "angular-linker");
+  CACHE_ROOT = resolve16(".absolutejs", "cache", "angular-linker");
   angularLinkerPlugin = createAngularLinkerPlugin(false);
 });
 
@@ -9923,7 +10026,7 @@ __export(exports_hmrInjectionPlugin, {
   applyAngularHmrInjection: () => applyAngularHmrInjection
 });
 import { readFile as readFile5 } from "fs/promises";
-import { relative as relative6, resolve as resolve16 } from "path";
+import { relative as relative7, resolve as resolve17 } from "path";
 var ENTITY_DECORATOR_RE, IMPORT_RE, TOP_LEVEL_DECL_RE, extractAllTopLevelNames = (jsSource) => {
   const names = new Set;
   IMPORT_RE.lastIndex = 0;
@@ -10086,7 +10189,7 @@ var ENTITY_DECORATOR_RE, IMPORT_RE, TOP_LEVEL_DECL_RE, extractAllTopLevelNames =
 }
 `, applyAngularHmrInjection = (jsSource, componentJsAbsPath, params) => {
   const { generatedAngularRoot, userAngularRoot, projectRoot } = params;
-  const normalizedGenRoot = resolve16(generatedAngularRoot).replace(/\\/g, "/");
+  const normalizedGenRoot = resolve17(generatedAngularRoot).replace(/\\/g, "/");
   const normalizedPath = componentJsAbsPath.replace(/\\/g, "/");
   if (!normalizedPath.startsWith(normalizedGenRoot + "/"))
     return;
@@ -10103,9 +10206,9 @@ var ENTITY_DECORATOR_RE, IMPORT_RE, TOP_LEVEL_DECL_RE, extractAllTopLevelNames =
   }
   if (classNames.length === 0)
     return;
-  const relFromGenRoot = relative6(generatedAngularRoot, componentJsAbsPath).replace(/\\/g, "/");
-  const userTsPath = resolve16(userAngularRoot, relFromGenRoot.replace(/\.js$/, ".ts"));
-  const projectRel = relative6(projectRoot, userTsPath).replace(/\\/g, "/");
+  const relFromGenRoot = relative7(generatedAngularRoot, componentJsAbsPath).replace(/\\/g, "/");
+  const userTsPath = resolve17(userAngularRoot, relFromGenRoot.replace(/\.js$/, ".ts"));
+  const projectRel = relative7(projectRoot, userTsPath).replace(/\\/g, "/");
   const tail = classNames.map((className) => {
     const id = `${projectRel}@${className}`;
     return buildHmrTail(className, JSON.stringify(id));
@@ -10139,17 +10242,17 @@ var init_hmrInjectionPlugin = __esm(() => {
 
 // src/utils/cleanStaleOutputs.ts
 import { rm as rm2 } from "fs/promises";
-import { resolve as resolve17 } from "path";
+import { resolve as resolve18 } from "path";
 var {Glob: Glob5 } = globalThis.Bun;
 var HASHED_FILE_PATTERN, cleanStaleOutputs = async (buildPath, currentOutputPaths) => {
-  const currentPaths = new Set(currentOutputPaths.map((path) => resolve17(path)));
+  const currentPaths = new Set(currentOutputPaths.map((path) => resolve18(path)));
   const glob = new Glob5("**/*");
   const removals = [];
-  for (const relative7 of glob.scanSync({ cwd: buildPath })) {
-    const absolute = resolve17(buildPath, relative7);
+  for (const relative8 of glob.scanSync({ cwd: buildPath })) {
+    const absolute = resolve18(buildPath, relative8);
     if (currentPaths.has(absolute))
       continue;
-    if (!HASHED_FILE_PATTERN.test(relative7))
+    if (!HASHED_FILE_PATTERN.test(relative8))
       continue;
     removals.push(rm2(absolute, { force: true }));
   }
@@ -10165,20 +10268,20 @@ __export(exports_generatedDir, {
   getGeneratedRoot: () => getGeneratedRoot,
   getFrameworkGeneratedDir: () => getFrameworkGeneratedDir
 });
-import { join as join13 } from "path";
-var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getGeneratedRoot = (projectRoot = process.cwd()) => join13(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME), getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join13(getGeneratedRoot(projectRoot), framework);
+import { join as join14 } from "path";
+var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getGeneratedRoot = (projectRoot = process.cwd()) => join14(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME), getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join14(getGeneratedRoot(projectRoot), framework);
 var init_generatedDir = () => {};
 
 // src/utils/cleanup.ts
 import { rm as rm3 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var removeIfExists = (path) => rm3(path, { force: true, recursive: true }), cleanFramework = (framework, frameworkDir, skipGenerated = false) => {
   const tasks = [];
   if (!skipGenerated) {
     tasks.push(removeIfExists(getFrameworkGeneratedDir(framework)));
   }
   if (frameworkDir)
-    tasks.push(removeIfExists(join14(frameworkDir, "generated")));
+    tasks.push(removeIfExists(join15(frameworkDir, "generated")));
   return Promise.all(tasks);
 }, cleanup = async ({
   angularDir,
@@ -10217,7 +10320,7 @@ var init_commonAncestor = () => {};
 
 // src/utils/buildDirectoryLock.ts
 import { mkdirSync as mkdirSync6, unlinkSync, writeFileSync as writeFileSync7, readFileSync as readFileSync12 } from "fs";
-import { dirname as dirname10, join as join15 } from "path";
+import { dirname as dirname11, join as join16 } from "path";
 var heldLocks, HELD_LOCKS_ENV = "ABSOLUTE_HELD_BUILD_DIRECTORY_LOCKS", exitHandlersRegistered = false, registerExitHandlersOnce = () => {
   if (exitHandlersRegistered)
     return;
@@ -10243,7 +10346,7 @@ var heldLocks, HELD_LOCKS_ENV = "ABSOLUTE_HELD_BUILD_DIRECTORY_LOCKS", exitHandl
     releaseAllSync();
     throw err;
   });
-}, isAlreadyExistsError = (error) => error instanceof Error && ("code" in error) && error.code === "EEXIST", lockPathForBuildDirectory = (buildDirectory) => join15(dirname10(buildDirectory), ".absolutejs", "build.lock"), readHeldLockEnv = () => new Set((process.env[HELD_LOCKS_ENV] ?? "").split(`
+}, isAlreadyExistsError = (error) => error instanceof Error && ("code" in error) && error.code === "EEXIST", lockPathForBuildDirectory = (buildDirectory) => join16(dirname11(buildDirectory), ".absolutejs", "build.lock"), readHeldLockEnv = () => new Set((process.env[HELD_LOCKS_ENV] ?? "").split(`
 `).filter((entry) => entry.length > 0)), writeHeldLockEnv = (locks) => {
   if (locks.size === 0) {
     delete process.env[HELD_LOCKS_ENV];
@@ -10260,7 +10363,7 @@ var heldLocks, HELD_LOCKS_ENV = "ABSOLUTE_HELD_BUILD_DIRECTORY_LOCKS", exitHandl
   locks.delete(buildDirectory);
   writeHeldLockEnv(locks);
 }, writeLockFileSync = (lockPath, metadata2) => {
-  mkdirSync6(dirname10(lockPath), { recursive: true });
+  mkdirSync6(dirname11(lockPath), { recursive: true });
   writeFileSync7(lockPath, JSON.stringify(metadata2, null, 2), { flag: "wx" });
 }, readLockMetadata = (lockPath) => {
   try {
@@ -10380,11 +10483,11 @@ var init_buildDirectoryLock = __esm(() => {
 });
 
 // src/utils/validateSafePath.ts
-import { resolve as resolve18, relative as relative7 } from "path";
+import { resolve as resolve19, relative as relative8 } from "path";
 var validateSafePath = (targetPath, baseDirectory) => {
-  const absoluteBase = resolve18(baseDirectory);
-  const absoluteTarget = resolve18(baseDirectory, targetPath);
-  const relativePath = normalizePath(relative7(absoluteBase, absoluteTarget));
+  const absoluteBase = resolve19(baseDirectory);
+  const absoluteTarget = resolve19(baseDirectory, targetPath);
+  const relativePath = normalizePath(relative8(absoluteBase, absoluteTarget));
   if (relativePath.startsWith("../") || relativePath === "..") {
     throw new Error(`Unsafe path: ${targetPath}`);
   }
@@ -10455,32 +10558,32 @@ __export(exports_compileSvelte, {
   clearSvelteCompilerCache: () => clearSvelteCompilerCache
 });
 import { existsSync as existsSync15 } from "fs";
-import { mkdir as mkdir3, stat as stat2 } from "fs/promises";
+import { mkdir as mkdir4, stat as stat2 } from "fs/promises";
 import {
-  dirname as dirname11,
-  join as join16,
+  dirname as dirname12,
+  join as join17,
   basename as basename5,
   extname as extname5,
-  resolve as resolve19,
-  relative as relative8,
+  resolve as resolve20,
+  relative as relative9,
   sep as sep2
 } from "path";
 import { env as env2 } from "process";
-var {write, file: file2, Transpiler } = globalThis.Bun;
+var {write, file: file2, Transpiler: Transpiler2 } = globalThis.Bun;
 var resolveDevClientDir2 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve19(import.meta.dir, "../dev/client");
+  const fromSource = resolve20(import.meta.dir, "../dev/client");
   if (existsSync15(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve19(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve20(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync15(fromNodeModules))
     return fromNodeModules;
-  return resolve19(import.meta.dir, "./dev/client");
+  return resolve20(import.meta.dir, "./dev/client");
 }, devClientDir2, hmrClientPath3, persistentCache, sourceHashCache, clearSvelteCompilerCache = () => {
   persistentCache.clear();
   sourceHashCache.clear();
-}, transpiler2, removeUnusedRequireHelper = (code) => {
+}, transpiler3, removeUnusedRequireHelper = (code) => {
   const helperStart = code.indexOf("var __require = /* @__PURE__ */");
   if (helperStart === -1) {
     return code;
@@ -10506,7 +10609,7 @@ var resolveDevClientDir2 = () => {
 }, resolveRelativeModule2 = async (spec, from) => {
   if (!spec.startsWith("."))
     return null;
-  const basePath = resolve19(dirname11(from), spec);
+  const basePath = resolve20(dirname12(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -10517,14 +10620,14 @@ var resolveDevClientDir2 = () => {
     `${basePath}.svelte`,
     `${basePath}.svelte.ts`,
     `${basePath}.svelte.js`,
-    join16(basePath, "index.ts"),
-    join16(basePath, "index.js"),
-    join16(basePath, "index.mjs"),
-    join16(basePath, "index.cjs"),
-    join16(basePath, "index.json"),
-    join16(basePath, "index.svelte"),
-    join16(basePath, "index.svelte.ts"),
-    join16(basePath, "index.svelte.js")
+    join17(basePath, "index.ts"),
+    join17(basePath, "index.js"),
+    join17(basePath, "index.mjs"),
+    join17(basePath, "index.cjs"),
+    join17(basePath, "index.json"),
+    join17(basePath, "index.svelte"),
+    join17(basePath, "index.svelte.ts"),
+    join17(basePath, "index.svelte.js")
   ];
   const checks = await Promise.all(candidates.map(exists));
   return candidates.find((_2, index) => checks[index]) ?? null;
@@ -10533,7 +10636,7 @@ var resolveDevClientDir2 = () => {
     const resolved = resolvePackageImport(spec);
     return resolved && /\.svelte(\.(?:ts|js))?$/.test(resolved) ? resolved : null;
   }
-  const basePath = resolve19(dirname11(from), spec);
+  const basePath = resolve20(dirname12(from), spec);
   const explicit = /\.(svelte|svelte\.(?:ts|js))$/.test(basePath);
   if (!explicit) {
     const extensions = [".svelte", ".svelte.ts", ".svelte.js"];
@@ -10554,8 +10657,8 @@ var resolveDevClientDir2 = () => {
     return jsPath;
   return null;
 }, addModuleRewrite = (rewrites, rawSpec, resolvedModule, ssrOutputDir, clientOutputDir) => {
-  const toServer = relative8(ssrOutputDir, resolvedModule).replace(/\\/g, "/");
-  const toClient = relative8(clientOutputDir, resolvedModule).replace(/\\/g, "/");
+  const toServer = relative9(ssrOutputDir, resolvedModule).replace(/\\/g, "/");
+  const toClient = relative9(clientOutputDir, resolvedModule).replace(/\\/g, "/");
   rewrites.set(rawSpec, {
     client: toClient.startsWith(".") || toClient.startsWith("/") ? toClient : `./${toClient}`,
     server: toServer.startsWith(".") ? toServer : `./${toServer}`
@@ -10563,10 +10666,10 @@ var resolveDevClientDir2 = () => {
 }, compileSvelte = async (entryPoints, svelteRoot, cache = new Map, isDev2 = false, stylePreprocessors) => {
   const { compile, compileModule, preprocess } = await import("svelte/compiler");
   const generatedDir = getFrameworkGeneratedDir("svelte");
-  const clientDir = join16(generatedDir, "client");
-  const indexDir = join16(generatedDir, "indexes");
-  const serverDir = join16(generatedDir, "server");
-  await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir3(dir, { recursive: true })));
+  const clientDir = join17(generatedDir, "client");
+  const indexDir = join17(generatedDir, "indexes");
+  const serverDir = join17(generatedDir, "server");
+  await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir4(dir, { recursive: true })));
   const dev = env2.NODE_ENV !== "production";
   const build2 = async (src) => {
     const memoized = cache.get(src);
@@ -10591,10 +10694,10 @@ var resolveDevClientDir2 = () => {
     const svelteStylePreprocessor = createSvelteStylePreprocessor(stylePreprocessors);
     const preprocessedServer = isModule ? loweredServerSource.code : (await preprocess(loweredServerSource.code, svelteStylePreprocessor)).code;
     const preprocessedClient = isModule ? loweredClientSource.code : (await preprocess(loweredClientSource.code, svelteStylePreprocessor)).code;
-    const transpiledServer = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler2.transformSync(preprocessedServer) : preprocessedServer;
-    const transpiledClient = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler2.transformSync(preprocessedClient) : preprocessedClient;
-    const rawRel = dirname11(relative8(svelteRoot, src)).replace(/\\/g, "/");
-    const relDir = rawRel.startsWith("..") ? `_ext/${relative8(process.cwd(), dirname11(src)).replace(/\\/g, "/")}` : rawRel;
+    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 = dirname12(relative9(svelteRoot, src)).replace(/\\/g, "/");
+    const relDir = rawRel.startsWith("..") ? `_ext/${relative9(process.cwd(), dirname12(src)).replace(/\\/g, "/")}` : rawRel;
     const baseName = basename5(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)));
@@ -10603,8 +10706,8 @@ var resolveDevClientDir2 = () => {
     const childBuilt = await Promise.all(childSources.map((child) => build2(child)));
     const hasAwaitSlotFromChildren = childBuilt.some((child) => child.hasAwaitSlot);
     const externalRewrites = new Map;
-    const ssrOutputDir = dirname11(join16(serverDir, relDir, `${baseName}.js`));
-    const clientOutputDir = dirname11(join16(clientDir, relDir, `${baseName}.js`));
+    const ssrOutputDir = dirname12(join17(serverDir, relDir, `${baseName}.js`));
+    const clientOutputDir = dirname12(join17(clientDir, relDir, `${baseName}.js`));
     for (let idx = 0;idx < importPaths.length; idx++) {
       const rawSpec = importPaths[idx];
       if (!rawSpec)
@@ -10615,15 +10718,15 @@ var resolveDevClientDir2 = () => {
         addModuleRewrite(externalRewrites, rawSpec, resolvedModule, ssrOutputDir, clientOutputDir);
       if (!resolved)
         continue;
-      const childRel = relative8(svelteRoot, resolved).replace(/\\/g, "/");
+      const childRel = relative9(svelteRoot, resolved).replace(/\\/g, "/");
       if (!childRel.startsWith(".."))
         continue;
       const childBuilt2 = cache.get(resolved);
       if (!childBuilt2)
         continue;
       const origSpec = rawSpec.replace(/\.svelte(?:\.(?:ts|js))?$/, ".js");
-      const toServer = relative8(ssrOutputDir, childBuilt2.ssr).replace(/\\/g, "/");
-      const toClient = relative8(clientOutputDir, childBuilt2.client).replace(/\\/g, "/");
+      const toServer = relative9(ssrOutputDir, childBuilt2.ssr).replace(/\\/g, "/");
+      const toClient = relative9(clientOutputDir, childBuilt2.client).replace(/\\/g, "/");
       externalRewrites.set(origSpec, {
         client: toClient.startsWith(".") ? toClient : `./${toClient}`,
         server: toServer.startsWith(".") ? toServer : `./${toServer}`
@@ -10657,7 +10760,7 @@ var resolveDevClientDir2 = () => {
       }).js.code;
       let code = compiled.replace(/\.svelte(?:\.(?:ts|js))?(['"])/g, ".js$1");
       if (mode === "client" && isDev2) {
-        const moduleKey = `/@src/${relative8(process.cwd(), src).replace(/\\/g, "/")}`;
+        const moduleKey = `/@src/${relative9(process.cwd(), src).replace(/\\/g, "/")}`;
         code = code.replace(/if\s*\(import\.meta\.hot\)\s*\{/, `if (typeof window !== "undefined") {
   if (!window.__SVELTE_HMR_ACCEPT__) window.__SVELTE_HMR_ACCEPT__ = {};
   var __hmr_accept = function(cb) { window.__SVELTE_HMR_ACCEPT__[${JSON.stringify(moduleKey)}] = cb; };`);
@@ -10669,11 +10772,11 @@ var resolveDevClientDir2 = () => {
       code += islandMetadataExports;
       return code;
     };
-    const ssrPath = join16(serverDir, relDir, `${baseName}.js`);
-    const clientPath = join16(clientDir, relDir, `${baseName}.js`);
+    const ssrPath = join17(serverDir, relDir, `${baseName}.js`);
+    const clientPath = join17(clientDir, relDir, `${baseName}.js`);
     await Promise.all([
-      mkdir3(dirname11(ssrPath), { recursive: true }),
-      mkdir3(dirname11(clientPath), { recursive: true })
+      mkdir4(dirname12(ssrPath), { recursive: true }),
+      mkdir4(dirname12(clientPath), { recursive: true })
     ]);
     if (isModule) {
       const bundle = rewriteExternalImports(generate("client"), "client");
@@ -10700,10 +10803,10 @@ var resolveDevClientDir2 = () => {
   };
   const roots = await Promise.all(entryPoints.map(build2));
   await Promise.all(roots.map(async ({ client: client2, hasAwaitSlot }) => {
-    const relClientDir = dirname11(relative8(clientDir, client2));
+    const relClientDir = dirname12(relative9(clientDir, client2));
     const name = basename5(client2, extname5(client2));
-    const indexPath = join16(indexDir, relClientDir, `${name}.js`);
-    const importRaw = relative8(dirname11(indexPath), client2).split(sep2).join("/");
+    const indexPath = join17(indexDir, relClientDir, `${name}.js`);
+    const importRaw = relative9(dirname12(indexPath), client2).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev2 ? `window.__HMR_FRAMEWORK__ = "svelte";
 import "${hmrClientPath3}";
@@ -10774,14 +10877,14 @@ if (typeof window !== "undefined") {
     setTimeout(releaseStreamingSlots, 0);
   }
 }`;
-    await mkdir3(dirname11(indexPath), { recursive: true });
+    await mkdir4(dirname12(indexPath), { recursive: true });
     return write(indexPath, bootstrap);
   }));
   return {
     svelteClientPaths: roots.map(({ client: client2 }) => client2),
     svelteIndexPaths: roots.map(({ client: client2 }) => {
-      const rel = dirname11(relative8(clientDir, client2));
-      return join16(indexDir, rel, basename5(client2));
+      const rel = dirname12(relative9(clientDir, client2));
+      return join17(indexDir, rel, basename5(client2));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
   };
@@ -10796,10 +10899,10 @@ var init_compileSvelte = __esm(() => {
   init_lowerAwaitSlotSyntax();
   init_renderToReadableStream();
   devClientDir2 = resolveDevClientDir2();
-  hmrClientPath3 = join16(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath3 = join17(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
   persistentCache = new Map;
   sourceHashCache = new Map;
-  transpiler2 = new Transpiler({ loader: "ts", target: "browser" });
+  transpiler3 = new Transpiler2({ loader: "ts", target: "browser" });
 });
 
 // src/build/vueAutoRouterTransform.ts
@@ -10863,27 +10966,27 @@ __export(exports_compileVue, {
   clearVueHmrCaches: () => clearVueHmrCaches
 });
 import { existsSync as existsSync16 } from "fs";
-import { mkdir as mkdir4 } from "fs/promises";
+import { mkdir as mkdir5 } from "fs/promises";
 import {
   basename as basename6,
-  dirname as dirname12,
+  dirname as dirname13,
   isAbsolute as isAbsolute3,
-  join as join17,
-  relative as relative9,
-  resolve as resolve20
+  join as join18,
+  relative as relative10,
+  resolve as resolve21
 } from "path";
-var {file: file3, write: write2, Transpiler: Transpiler2 } = globalThis.Bun;
+var {file: file3, write: write2, Transpiler: Transpiler3 } = globalThis.Bun;
 var resolveDevClientDir3 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve20(import.meta.dir, "../dev/client");
+  const fromSource = resolve21(import.meta.dir, "../dev/client");
   if (existsSync16(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve20(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve21(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync16(fromNodeModules))
     return fromNodeModules;
-  return resolve20(import.meta.dir, "./dev/client");
-}, devClientDir3, hmrClientPath4, transpiler3, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, clearVueHmrCaches = () => {
+  return resolve21(import.meta.dir, "./dev/client");
+}, devClientDir3, hmrClientPath4, transpiler4, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, clearVueHmrCaches = () => {
   scriptCache.clear();
   scriptSetupCache.clear();
   templateCache.clear();
@@ -10921,19 +11024,19 @@ var resolveDevClientDir3 = () => {
     return "template-only";
   }
   return "full";
-}, generateVueHmrId = (sourceFilePath, vueRootDir) => relative9(vueRootDir, sourceFilePath).replace(/\\/g, "/").replace(/\.vue$/, ""), extractImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => importPath !== undefined), toJs = (filePath, sourceDir) => {
+}, generateVueHmrId = (sourceFilePath, vueRootDir) => relative10(vueRootDir, sourceFilePath).replace(/\\/g, "/").replace(/\.vue$/, ""), extractImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => importPath !== undefined), toJs = (filePath, sourceDir) => {
   if (filePath.endsWith(".vue"))
     return filePath.replace(/\.vue$/, ".js");
   if (filePath.endsWith(".ts"))
     return filePath.replace(/\.ts$/, ".js");
   if (isStylePath(filePath)) {
     if (sourceDir && (filePath.startsWith("./") || filePath.startsWith("../"))) {
-      return resolve20(sourceDir, filePath);
+      return resolve21(sourceDir, filePath);
     }
     return filePath;
   }
   return `${filePath}.js`;
-}, stripExports = (code) => code.replace(/export\s+default/, "const script ="), mergeVueImports = (code) => {
+}, stripExports2 = (code) => code.replace(/export\s+default/, "const script ="), mergeVueImports2 = (code) => {
   const lines = code.split(`
 `);
   const specifierSet = new Set;
@@ -10954,7 +11057,7 @@ var resolveDevClientDir3 = () => {
   const cachedResult = cacheMap.get(sourceFilePath);
   if (cachedResult)
     return cachedResult;
-  const relativeFilePath = relative9(vueRootDir, sourceFilePath).replace(/\\/g, "/");
+  const relativeFilePath = relative10(vueRootDir, sourceFilePath).replace(/\\/g, "/");
   const relativeWithoutExtension = relativeFilePath.replace(/\.vue$/, "");
   const fileBaseName = basename6(sourceFilePath, ".vue");
   const componentId = toKebab(fileBaseName);
@@ -10992,12 +11095,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(".") || isAbsolute3(path)) && isStylePath(path)).map((path) => isAbsolute3(path) ? path : resolve20(dirname12(sourceFilePath), path));
+  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute3(path)) && isStylePath(path)).map((path) => isAbsolute3(path) ? path : resolve21(dirname13(sourceFilePath), path));
   for (const stylePath of stylePathsImported) {
     addStyleImporter(sourceFilePath, stylePath);
   }
   const childBuildResults = await Promise.all([
-    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve20(dirname12(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
+    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve21(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;
@@ -11005,9 +11108,9 @@ var resolveDevClientDir3 = () => {
     id: componentId,
     inlineTemplate: false
   }) : { bindings: {}, content: "export default {};" };
-  const strippedScript = stripExports(compiledScript.content);
-  const sourceDir = dirname12(sourceFilePath);
-  const transpiledScript = transpiler3.transformSync(strippedScript).replace(/(['"])(\.{1,2}\/[^'"]+)(['"])/g, (_2, quoteStart, relativeImport, quoteEnd) => `${quoteStart}${toJs(relativeImport, sourceDir)}${quoteEnd}`);
+  const strippedScript = stripExports2(compiledScript.content);
+  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) {
     const childResult = cacheMap.get(absolutePath);
@@ -11021,6 +11124,8 @@ var resolveDevClientDir3 = () => {
   const generateRenderFunction = (ssr) => compiler.compileTemplate({
     compilerOptions: {
       bindingMetadata: compiledScript.bindings,
+      expressionPlugins: ["typescript"],
+      isCustomElement: (tag) => tag === "absolute-island",
       prefixIdentifiers: true
     },
     filename: sourceFilePath,
@@ -11043,8 +11148,8 @@ var resolveDevClientDir3 = () => {
   ];
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
-    const cssOutputFile = join17(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
-    await mkdir4(dirname12(cssOutputFile), { recursive: true });
+    const cssOutputFile = join18(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
+    await mkdir5(dirname13(cssOutputFile), { recursive: true });
     await write2(cssOutputFile, allCss.join(`
 `));
     cssOutputPaths = [cssOutputFile];
@@ -11062,7 +11167,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     window.__VUE_HMR_COMPONENTS__[script.__hmrId] = script;
   }
 }` : "";
-    return mergeVueImports([
+    return mergeVueImports2([
       transpiledScript,
       renderCode,
       `script.${renderFnName} = ${renderFnName};`,
@@ -11074,9 +11179,9 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
   const clientCode = assembleModule(generateRenderFunction(false), "render", true) + islandMetadataExports;
   const serverCode = assembleModule(generateRenderFunction(true), "ssrRender", false) + islandMetadataExports;
-  const clientOutputPath = join17(outputDirs.client, `${relativeWithoutExtension}.js`);
-  const serverOutputPath = join17(outputDirs.server, `${relativeWithoutExtension}.js`);
-  const relDir = dirname12(relativeFilePath);
+  const clientOutputPath = join18(outputDirs.client, `${relativeWithoutExtension}.js`);
+  const serverOutputPath = join18(outputDirs.server, `${relativeWithoutExtension}.js`);
+  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;
@@ -11088,15 +11193,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 = relative9(dirname12(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 mkdir4(dirname12(clientOutputPath), { recursive: true });
-  await mkdir4(dirname12(serverOutputPath), { recursive: true });
+  await mkdir5(dirname13(clientOutputPath), { recursive: true });
+  await mkdir5(dirname13(serverOutputPath), { recursive: true });
   await write2(clientOutputPath, rewritePackageImports(adjustImports(clientCode), clientOutputPath, "client"));
   await write2(serverOutputPath, rewritePackageImports(adjustImports(serverCode), serverOutputPath, "server"));
   const result = {
@@ -11106,7 +11211,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     hmrId,
     serverPath: serverOutputPath,
     tsHelperPaths: [
-      ...helperModulePaths.map((helper) => resolve20(dirname12(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
+      ...helperModulePaths.map((helper) => resolve21(dirname13(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
       ...childBuildResults.flatMap((child) => child.tsHelperPaths)
     ]
   };
@@ -11116,36 +11221,36 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
 }, compileVue = async (entryPoints, vueRootDir, isDev2 = false, stylePreprocessors) => {
   const compiler = await import("@vue/compiler-sfc");
   const generatedDir = getFrameworkGeneratedDir("vue");
-  const clientOutputDir = join17(generatedDir, "client");
-  const indexOutputDir = join17(generatedDir, "indexes");
-  const serverOutputDir = join17(generatedDir, "server");
-  const cssOutputDir = join17(generatedDir, "compiled");
+  const clientOutputDir = join18(generatedDir, "client");
+  const indexOutputDir = join18(generatedDir, "indexes");
+  const serverOutputDir = join18(generatedDir, "server");
+  const cssOutputDir = join18(generatedDir, "compiled");
   await Promise.all([
-    mkdir4(clientOutputDir, { recursive: true }),
-    mkdir4(indexOutputDir, { recursive: true }),
-    mkdir4(serverOutputDir, { recursive: true }),
-    mkdir4(cssOutputDir, { recursive: true })
+    mkdir5(clientOutputDir, { recursive: true }),
+    mkdir5(indexOutputDir, { recursive: true }),
+    mkdir5(serverOutputDir, { recursive: true }),
+    mkdir5(cssOutputDir, { recursive: true })
   ]);
   const buildCache = new Map;
   const allTsHelperPaths = new Set;
   const compiledPages = await Promise.all(entryPoints.map(async (entryPath) => {
-    const result = await compileVueFile(resolve20(entryPath), {
+    const result = await compileVueFile(resolve21(entryPath), {
       client: clientOutputDir,
       css: cssOutputDir,
       server: serverOutputDir
     }, buildCache, true, vueRootDir, compiler, stylePreprocessors);
     result.tsHelperPaths.forEach((path) => allTsHelperPaths.add(path));
     const entryBaseName = basename6(entryPath, ".vue");
-    const indexOutputFile = join17(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join17(clientOutputDir, relative9(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
-    await mkdir4(dirname12(indexOutputFile), { recursive: true });
+    const indexOutputFile = join18(indexOutputDir, `${entryBaseName}.js`);
+    const clientOutputFile = join18(clientOutputDir, relative10(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    await mkdir5(dirname13(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev2 ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
       `import "${hmrClientPath4}";`
     ] : [];
     await write2(indexOutputFile, [
       ...vueHmrImports,
-      `import Comp, * as PageModule from "${relative9(dirname12(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",
@@ -11288,12 +11393,12 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   }));
   await Promise.all(Array.from(allTsHelperPaths).map(async (tsPath) => {
     const sourceCode = await file3(tsPath).text();
-    const transpiledCode = transpiler3.transformSync(sourceCode);
-    const relativeJsPath = relative9(vueRootDir, tsPath).replace(/\.ts$/, ".js");
-    const outClientPath = join17(clientOutputDir, relativeJsPath);
-    const outServerPath = join17(serverOutputDir, relativeJsPath);
-    await mkdir4(dirname12(outClientPath), { recursive: true });
-    await mkdir4(dirname12(outServerPath), { recursive: true });
+    const transpiledCode = transpiler4.transformSync(sourceCode);
+    const relativeJsPath = relative10(vueRootDir, tsPath).replace(/\.ts$/, ".js");
+    const outClientPath = join18(clientOutputDir, relativeJsPath);
+    const outServerPath = join18(serverOutputDir, relativeJsPath);
+    await mkdir5(dirname13(outClientPath), { recursive: true });
+    await mkdir5(dirname13(outServerPath), { recursive: true });
     await write2(outClientPath, transpiledCode);
     await write2(outServerPath, transpiledCode);
   }));
@@ -11313,8 +11418,8 @@ var init_compileVue = __esm(() => {
   init_vueAutoRouterTransform();
   init_stylePreprocessor();
   devClientDir3 = resolveDevClientDir3();
-  hmrClientPath4 = join17(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
-  transpiler3 = new Transpiler2({ loader: "ts", target: "browser" });
+  hmrClientPath4 = join18(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
+  transpiler4 = new Transpiler3({ loader: "ts", target: "browser" });
   scriptCache = new Map;
   scriptSetupCache = new Map;
   templateCache = new Map;
@@ -11794,17 +11899,17 @@ __export(exports_compileAngular, {
   compileAngular: () => compileAngular
 });
 import { existsSync as existsSync17, readFileSync as readFileSync13, promises as fs } from "fs";
-import { join as join18, basename as basename7, sep as sep3, dirname as dirname13, resolve as resolve21, relative as relative10 } from "path";
+import { join as join19, basename as basename7, sep as sep3, dirname as dirname14, resolve as resolve22, relative as relative11 } from "path";
 import ts2 from "typescript";
 var traceAngularPhase = async (name, fn2, metadata2) => {
   const tracePhase = globalThis.__absoluteBuildTracePhase;
   return tracePhase ? tracePhase(`compile/angular/${name}`, fn2, metadata2) : await fn2();
 }, readTsconfigPathAliases = () => {
   try {
-    const configPath2 = resolve21(process.cwd(), "tsconfig.json");
+    const configPath2 = resolve22(process.cwd(), "tsconfig.json");
     const config = ts2.readConfigFile(configPath2, ts2.sys.readFile).config;
     const compilerOptions = config?.compilerOptions ?? {};
-    const baseUrl = resolve21(process.cwd(), compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve22(process.cwd(), compilerOptions.baseUrl ?? ".");
     const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
     return { aliases, baseUrl };
   } catch {
@@ -11824,7 +11929,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     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(resolve21(baseUrl, candidate));
+      const resolved = resolveSourceFile(resolve22(baseUrl, candidate));
       if (resolved)
         return resolved;
     }
@@ -11836,20 +11941,20 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     `${candidate}.tsx`,
     `${candidate}.js`,
     `${candidate}.jsx`,
-    join18(candidate, "index.ts"),
-    join18(candidate, "index.tsx"),
-    join18(candidate, "index.js"),
-    join18(candidate, "index.jsx")
+    join19(candidate, "index.ts"),
+    join19(candidate, "index.tsx"),
+    join19(candidate, "index.js"),
+    join19(candidate, "index.jsx")
   ];
   return candidates.find((file4) => existsSync17(file4));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
-  const baseDir = resolve21(rootDir);
+  const baseDir = resolve22(rootDir);
   const tsconfigAliases = readTsconfigPathAliases();
-  const transpiler4 = new Bun.Transpiler({ loader: "tsx" });
+  const transpiler5 = new Bun.Transpiler({ loader: "tsx" });
   const scanCache = new Map;
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile(resolve21(fromDir, specifier));
+      return resolveSourceFile(resolve22(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile);
     if (aliased)
@@ -11858,7 +11963,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve21(resolved);
+      const absolute = resolve22(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile(absolute);
@@ -11874,7 +11979,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
         usesLegacyAnimations: false
       });
     }
-    const resolved = resolve21(actualPath);
+    const resolved = resolve22(actualPath);
     const cached = scanCache.get(resolved);
     if (cached)
       return cached;
@@ -11887,7 +11992,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
       }
       let imports;
       try {
-        imports = transpiler4.scanImports(sourceCode);
+        imports = transpiler5.scanImports(sourceCode);
       } catch {
         return { imports: [], usesLegacyAnimations: false };
       }
@@ -11903,7 +12008,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     const actualPath = resolveSourceFile(filePath);
     if (!actualPath)
       return false;
-    const resolved = resolve21(actualPath);
+    const resolved = resolve22(actualPath);
     if (visited.has(resolved))
       return false;
     visited.add(resolved);
@@ -11911,7 +12016,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     if (scan.usesLegacyAnimations)
       return true;
     for (const specifier of scan.imports) {
-      const importedPath = resolveLocalImport(specifier, dirname13(resolved));
+      const importedPath = resolveLocalImport(specifier, dirname14(resolved));
       if (importedPath && await visit(importedPath, visited)) {
         return true;
       }
@@ -11921,14 +12026,14 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   return (entryPath) => visit(entryPath);
 }, resolveDevClientDir4 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve21(import.meta.dir, "../dev/client");
+  const fromSource = resolve22(import.meta.dir, "../dev/client");
   if (existsSync17(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve21(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve22(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync17(fromNodeModules))
     return fromNodeModules;
-  return resolve21(import.meta.dir, "./dev/client");
+  return resolve22(import.meta.dir, "./dev/client");
 }, devClientDir4, hmrClientPath5, formatDiagnosticMessage = (diagnostic) => {
   try {
     return ts2.flattenDiagnosticMessageText(diagnostic.messageText, `
@@ -11970,12 +12075,12 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     return `${path.replace(/\.ts$/, ".js")}${query}`;
   if (hasJsLikeExtension(path))
     return `${path}${query}`;
-  const importerDir = dirname13(importerOutputPath);
-  const fileCandidate = resolve21(importerDir, `${path}.js`);
+  const importerDir = dirname14(importerOutputPath);
+  const fileCandidate = resolve22(importerDir, `${path}.js`);
   if (outputFiles?.has(fileCandidate) || existsSync17(fileCandidate)) {
     return `${path}.js${query}`;
   }
-  const indexCandidate = resolve21(importerDir, path, "index.js");
+  const indexCandidate = resolve22(importerDir, path, "index.js");
   if (outputFiles?.has(indexCandidate) || existsSync17(indexCandidate)) {
     return `${path}/index.js${query}`;
   }
@@ -12003,18 +12108,18 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve21(dirname13(fromFile), specifier);
+  const basePath = resolve22(dirname14(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join18(basePath, "index.ts"),
-    join18(basePath, "index.tsx"),
-    join18(basePath, "index.mts"),
-    join18(basePath, "index.cts")
+    join19(basePath, "index.ts"),
+    join19(basePath, "index.tsx"),
+    join19(basePath, "index.mts"),
+    join19(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve21(candidate)).find((candidate) => existsSync17(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+  return candidates.map((candidate) => resolve22(candidate)).find((candidate) => existsSync17(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile6) => {
   const hostSource = readFile6?.(fileName);
   if (typeof hostSource === "string")
@@ -12038,18 +12143,18 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   const paths = [];
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1])
-    paths.push(join18(fileDir, templateUrlMatch[1]));
+    paths.push(join19(fileDir, templateUrlMatch[1]));
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (styleUrlMatch?.[1])
-    paths.push(join18(fileDir, styleUrlMatch[1]));
+    paths.push(join19(fileDir, styleUrlMatch[1]));
   const styleUrlsMatch = findUncommentedMatch(source, /styleUrls\s*:\s*\[([^\]]+)\]/);
   const urlMatches = styleUrlsMatch?.[1]?.match(/['"]([^'"]+)['"]/g);
   if (urlMatches) {
     for (const urlMatch of urlMatches) {
-      paths.push(join18(fileDir, urlMatch.replace(/['"]/g, "")));
+      paths.push(join19(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
-  return paths.map((path) => resolve21(path));
+  return paths.map((path) => resolve22(path));
 }, readResourceCacheFile = async (cachePath) => {
   try {
     const entry = JSON.parse(await fs.readFile(cachePath, "utf-8"));
@@ -12061,13 +12166,13 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     return null;
   }
 }, writeResourceCacheFile = async (cachePath, source) => {
-  await fs.mkdir(dirname13(cachePath), { recursive: true });
+  await fs.mkdir(dirname14(cachePath), { recursive: true });
   await fs.writeFile(cachePath, JSON.stringify({
     source,
     version: 1
   }), "utf-8");
 }, resolveResourceTransformCachePath = async (filePath, source, stylePreprocessors) => {
-  const resourcePaths = collectAngularResourcePaths(source, dirname13(filePath));
+  const resourcePaths = collectAngularResourcePaths(source, dirname14(filePath));
   const resourceContents = await Promise.all(resourcePaths.map(async (resourcePath) => {
     const content = await fs.readFile(resourcePath, "utf-8");
     return `${resourcePath}\x00${content}`;
@@ -12080,7 +12185,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     safeStableStringify(stylePreprocessors ?? null)
   ].join("\x00");
   const cacheKey2 = Bun.hash(cacheInput).toString(BASE_36_RADIX);
-  return join18(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
+  return join19(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
 }, precomputeAotResourceTransforms = async (inputPaths, readFile6, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
@@ -12091,7 +12196,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     transformedFiles: 0
   };
   const transformFile = async (filePath) => {
-    const resolvedPath = resolve21(filePath);
+    const resolvedPath = resolve22(filePath);
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
@@ -12107,7 +12212,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
       transformedSource = cached.source;
     } else {
       stats.cacheMisses += 1;
-      const transformed = await inlineResources(source, dirname13(resolvedPath), stylePreprocessors);
+      const transformed = await inlineResources(source, dirname14(resolvedPath), stylePreprocessors);
       transformedSource = transformed.source;
       await writeResourceCacheFile(cachePath, transformedSource);
     }
@@ -12126,7 +12231,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   return { stats, transformedSources };
 }, compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
   const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
-    const outputPath = resolve21(join18(outDir, relative10(process.cwd(), resolve21(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve22(join19(outDir, relative11(process.cwd(), resolve22(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
       buildIslandMetadataExports(readFileSync13(inputPath, "utf-8"))
@@ -12136,8 +12241,8 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   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 = dirname13(tsPath);
-    return tsRootDir.endsWith("lib") ? tsRootDir : resolve21(tsRootDir, "lib");
+    const tsRootDir = dirname14(tsPath);
+    return tsRootDir.endsWith("lib") ? tsRootDir : resolve22(tsRootDir, "lib");
   });
   const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
   const options = {
@@ -12173,13 +12278,13 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   const originalGetSourceFile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
     if (fileName.startsWith("lib.") && fileName.endsWith(".d.ts") && tsLibDir) {
-      const resolvedPath = join18(tsLibDir, fileName);
+      const resolvedPath = join19(tsLibDir, fileName);
       return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
     }
     return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
   };
   const emitted = {};
-  const resolvedOutDir = resolve21(outDir);
+  const resolvedOutDir = resolve22(outDir);
   host.writeFile = (fileName, text) => {
     const relativePath = resolveRelativePath(fileName, resolvedOutDir, outDir);
     emitted[relativePath] = text;
@@ -12201,12 +12306,12 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     if (!fileName.endsWith(".ts") || fileName.endsWith(".d.ts")) {
       return source;
     }
-    const resolvedPath = resolve21(fileName);
+    const resolvedPath = resolve22(fileName);
     return transformedSources.get(resolvedPath) ?? source;
   };
   const originalGetSourceFileForCompile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
-    const source = transformedSources.get(resolve21(fileName));
+    const source = transformedSources.get(resolve22(fileName));
     if (source) {
       return ts2.createSourceFile(fileName, source, languageVersion, true);
     }
@@ -12228,9 +12333,9 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   const entries = await traceAngularPhase("aot/postprocess-emitted-js", () => {
     const rawEntries = Object.entries(emitted).filter(([fileName]) => fileName.endsWith(".js")).map(([fileName, content]) => ({
       content,
-      target: join18(outDir, fileName)
+      target: join19(outDir, fileName)
     }));
-    const outputFiles = new Set(rawEntries.map(({ target }) => resolve21(target)));
+    const outputFiles = new Set(rawEntries.map(({ target }) => resolve22(target)));
     return rawEntries.map(({ content, target }) => {
       let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
         const rewritten = rewriteRelativeJsSpecifier(target, path, outputFiles);
@@ -12245,12 +12350,12 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
         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(resolve21(target)) ?? "";
+      processedContent += islandMetadataByOutputPath.get(resolve22(target)) ?? "";
       return { content: processedContent, target };
     });
   });
   await traceAngularPhase("aot/write-output", () => Promise.all(entries.map(async ({ target, content }) => {
-    await fs.mkdir(dirname13(target), { recursive: true });
+    await fs.mkdir(dirname14(target), { recursive: true });
     await fs.writeFile(target, content, "utf-8");
   })), { outputs: entries.length });
   return await traceAngularPhase("aot/collect-output-paths", () => entries.map(({ target }) => target), { outputs: entries.length });
@@ -12266,7 +12371,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   }
   return null;
 }, resolveAngularDeferImportSpecifier = () => {
-  const sourceEntry = resolve21(import.meta.dir, "../angular/components/index.ts");
+  const sourceEntry = resolve22(import.meta.dir, "../angular/components/index.ts");
   if (existsSync17(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
@@ -12403,7 +12508,7 @@ ${fields}
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join18(fileDir, templateUrlMatch[1]);
+    const templatePath = join19(fileDir, templateUrlMatch[1]);
     if (!existsSync17(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -12434,7 +12539,7 @@ ${fields}
 }, inlineTemplateAndLowerDeferSync = (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join18(fileDir, templateUrlMatch[1]);
+    const templatePath = join19(fileDir, templateUrlMatch[1]);
     if (!existsSync17(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -12471,7 +12576,7 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join18(fileDir, styleUrl), stylePreprocessors);
+    return readAndEscapeFile(join19(fileDir, styleUrl), stylePreprocessors);
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -12482,7 +12587,7 @@ ${fields}
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join18(fileDir, styleUrlMatch[1]), stylePreprocessors);
+  const escaped = await readAndEscapeFile(join19(fileDir, styleUrlMatch[1]), stylePreprocessors);
   if (!escaped)
     return source;
   return source.slice(0, styleUrlMatch.index) + `styles: [\`${escaped}\`]` + source.slice(styleUrlMatch.index + styleUrlMatch[0].length);
@@ -12496,10 +12601,10 @@ ${fields}
     source: result
   };
 }, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors, cacheBuster) => {
-  const entryPath = resolve21(inputPath);
+  const entryPath = resolve22(inputPath);
   const allOutputs = [];
   const visited = new Set;
-  const baseDir = resolve21(rootDir ?? process.cwd());
+  const baseDir = resolve22(rootDir ?? process.cwd());
   let usesLegacyAnimations = false;
   const angularTranspiler = new Bun.Transpiler({
     loader: "ts",
@@ -12517,16 +12622,16 @@ ${fields}
       `${candidate}.tsx`,
       `${candidate}.js`,
       `${candidate}.jsx`,
-      join18(candidate, "index.ts"),
-      join18(candidate, "index.tsx"),
-      join18(candidate, "index.js"),
-      join18(candidate, "index.jsx")
+      join19(candidate, "index.ts"),
+      join19(candidate, "index.tsx"),
+      join19(candidate, "index.js"),
+      join19(candidate, "index.jsx")
     ];
     return candidates.find((file4) => existsSync17(file4));
   };
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile2(resolve21(fromDir, specifier));
+      return resolveSourceFile2(resolve22(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile2);
     if (aliased)
@@ -12535,7 +12640,7 @@ ${fields}
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve21(resolved);
+      const absolute = resolve22(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile2(absolute);
@@ -12544,10 +12649,10 @@ ${fields}
     }
   };
   const toOutputPath = (sourcePath) => {
-    const inputDir = dirname13(sourcePath);
+    const inputDir = dirname14(sourcePath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename7(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    return join18(outDir, relativeDir, fileBase);
+    return join19(outDir, relativeDir, fileBase);
   };
   const withCacheBuster = (specifier) => {
     if (!cacheBuster)
@@ -12584,13 +12689,13 @@ ${fields}
         return `${prefix}${dots}`;
       return `${prefix}../${dots}`;
     });
-    if (resolve21(actualPath) === entryPath) {
+    if (resolve22(actualPath) === entryPath) {
       processedContent += buildIslandMetadataExports(sourceCode);
     }
     return processedContent;
   };
   const transpileFile = async (filePath) => {
-    const resolved = resolve21(filePath);
+    const resolved = resolve22(filePath);
     if (visited.has(resolved))
       return;
     visited.add(resolved);
@@ -12600,12 +12705,12 @@ ${fields}
     if (!existsSync17(actualPath))
       return;
     let sourceCode = await fs.readFile(actualPath, "utf-8");
-    const inlined = await inlineResources(sourceCode, dirname13(actualPath), stylePreprocessors);
-    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname13(actualPath)).source;
-    const inputDir = dirname13(actualPath);
+    const inlined = await inlineResources(sourceCode, dirname14(actualPath), stylePreprocessors);
+    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname14(actualPath)).source;
+    const inputDir = dirname14(actualPath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename7(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    const targetDir = join18(outDir, relativeDir);
+    const targetDir = join19(outDir, relativeDir);
     const targetPath = toOutputPath(actualPath);
     const localImports = [];
     const importRewrites = new Map;
@@ -12627,12 +12732,12 @@ ${fields}
       const resolved2 = resolveLocalImport(specifier, inputDir);
       if (!resolved2)
         return null;
-      const relativeImport = relative10(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
+      const relativeImport = relative11(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
       const relativeRewrite = relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`;
       importRewrites.set(specifier, relativeRewrite);
       return resolved2;
     }).filter((path) => Boolean(path));
-    const isEntry = resolve21(actualPath) === resolve21(entryPath);
+    const isEntry = resolve22(actualPath) === resolve22(entryPath);
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey2 = actualPath;
     const shouldWriteFile = cacheBuster && isEntry ? true : jitContentCache.get(cacheKey2) !== contentHash || !existsSync17(targetPath);
@@ -12666,13 +12771,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join18(compiledParent, "indexes");
+  const indexesDir = join19(compiledParent, "indexes");
   await traceAngularPhase("setup/create-indexes-dir", () => fs.mkdir(indexesDir, { recursive: true }));
-  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve21(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
+  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve22(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
   const compileTasks = entryPoints.map(async (entry) => {
-    const resolvedEntry = resolve21(entry);
-    const relativeEntry = relative10(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
+    const resolvedEntry = resolve22(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, {
       entry: resolvedEntry
@@ -12680,13 +12785,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const fileBase = basename7(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
     const compiledFallbackPaths = [
-      join18(compiledRoot, relativeEntry),
-      join18(compiledRoot, "pages", jsName),
-      join18(compiledRoot, jsName)
-    ].map((file4) => resolve21(file4));
+      join19(compiledRoot, relativeEntry),
+      join19(compiledRoot, "pages", jsName),
+      join19(compiledRoot, jsName)
+    ].map((file4) => resolve22(file4));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
-        ...candidatePaths.map((file4) => resolve21(file4)),
+        ...candidatePaths.map((file4) => resolve22(file4)),
         ...compiledFallbackPaths
       ];
       let candidate = normalizedCandidates.find((file4) => existsSync17(file4) && file4.endsWith(`${sep3}pages${sep3}${jsName}`));
@@ -12727,7 +12832,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const usesLegacyAnimations = await traceAngularPhase("wrapper/detect-legacy-animations", () => usesLegacyAngularAnimations(resolvedEntry), { entry: resolvedEntry });
     const serverContentHash = Bun.hash(original).toString(BASE_36_RADIX);
     const cachedWrapper = wrapperOutputCache.get(resolvedEntry);
-    const clientFile = join18(indexesDir, jsName);
+    const clientFile = join19(indexesDir, jsName);
     if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync17(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
       return {
         clientPath: clientFile,
@@ -12754,7 +12859,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
 `;
     }
     await traceAngularPhase("wrapper/write-server-output", () => fs.writeFile(rawServerFile, rewritten, "utf-8"), { entry: resolvedEntry });
-    const relativePath = relative10(indexesDir, rawServerFile).replace(/\\/g, "/");
+    const relativePath = relative11(indexesDir, rawServerFile).replace(/\\/g, "/");
     const normalizedImportPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
     const hmrPreamble = hmr ? `window.__HMR_FRAMEWORK__ = "angular";
 import "${hmrClientPath5}";
@@ -12958,14 +13063,14 @@ var init_compileAngular = __esm(() => {
   init_stylePreprocessor();
   init_generatedDir();
   devClientDir4 = resolveDevClientDir4();
-  hmrClientPath5 = join18(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath5 = join19(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
 });
 
 // node_modules/content-tag/pkg/node/content_tag.cjs
 var require_content_tag = __commonJS((exports, module) => {
-  var __dirname = "/tmp/absolutejs-clean/node_modules/content-tag/pkg/node";
+  var __dirname = "/home/alexkahn/abs/absolutejs/node_modules/content-tag/pkg/node";
   var imports = {};
   imports["__wbindgen_placeholder__"] = exports;
   var wasm;
@@ -13403,7 +13508,7 @@ __export(exports_compileEmber, {
   getEmberServerCompiledDir: () => getEmberServerCompiledDir,
   getEmberCompiledRoot: () => getEmberCompiledRoot,
   getEmberClientCompiledDir: () => getEmberClientCompiledDir,
-  dirname: () => dirname14,
+  dirname: () => dirname15,
   compileEmberFileSource: () => compileEmberFileSource,
   compileEmberFile: () => compileEmberFile,
   compileEmber: () => compileEmber,
@@ -13411,16 +13516,16 @@ __export(exports_compileEmber, {
   basename: () => basename8
 });
 import { existsSync as existsSync18 } from "fs";
-import { mkdir as mkdir5, rm as rm4 } from "fs/promises";
-import { basename as basename8, dirname as dirname14, extname as extname6, join as join19, resolve as resolve22 } from "path";
-var {build: bunBuild2, Transpiler: Transpiler3, write: write3, file: file4 } = globalThis.Bun;
+import { mkdir as mkdir6, rm as rm4 } from "fs/promises";
+import { basename as basename8, dirname as dirname15, extname as extname6, join as join20, resolve as resolve23 } from "path";
+var {build: bunBuild2, Transpiler: Transpiler4, write: write3, file: file4 } = globalThis.Bun;
 var cachedPreprocessor = null, getPreprocessor = async () => {
   if (cachedPreprocessor)
     return cachedPreprocessor;
   const module = await Promise.resolve().then(() => __toESM(require_node(), 1));
   cachedPreprocessor = new module.Preprocessor;
   return cachedPreprocessor;
-}, transpiler4, isTemplateTagFile = (entry) => {
+}, transpiler5, isTemplateTagFile = (entry) => {
   const ext = extname6(entry);
   return ext === ".gjs" || ext === ".gts";
 }, rewriteTemplateEvalToScope = (source) => {
@@ -13508,7 +13613,7 @@ export const importSync = (specifier) => {
         const originalImporter = stagedSourceMap.get(args.importer);
         if (!originalImporter)
           return;
-        const candidateBase = resolve22(dirname14(originalImporter), args.path);
+        const candidateBase = resolve23(dirname15(originalImporter), args.path);
         const extensionsToTry = ["", ".gts", ".gjs", ".ts", ".js"];
         for (const ext of extensionsToTry) {
           const candidate = candidateBase + ext;
@@ -13525,13 +13630,13 @@ export const importSync = (specifier) => {
         filename: args.path
       });
       const rewritten = rewriteTemplateEvalToScope(result.code);
-      const transpiled = transpiler4.transformSync(rewritten);
+      const transpiled = transpiler5.transformSync(rewritten);
       return { contents: transpiled, loader: "js" };
     });
     build2.onResolve({ filter: /^@(?:ember|glimmer|simple-dom)\// }, (args) => {
       if (standalonePackages.has(args.path))
         return;
-      const internal = join19(cwd, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      const internal = join20(cwd, "node_modules/ember-source/dist/packages", args.path, "index.js");
       if (existsSync18(internal))
         return { path: internal };
       return;
@@ -13567,7 +13672,7 @@ export const renderToHTML = (props = {}) => {
 export { PageComponent };
 export default PageComponent;
 `, compileEmberFile = async (entry, compiledRoot, cwd = process.cwd()) => {
-  const resolvedEntry = resolve22(entry);
+  const resolvedEntry = resolve23(entry);
   const source = await file4(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -13577,18 +13682,18 @@ export default PageComponent;
     });
     preprocessed = rewriteTemplateEvalToScope(result.code);
   }
-  const transpiled = transpiler4.transformSync(preprocessed);
+  const transpiled = transpiler5.transformSync(preprocessed);
   const baseName = basename8(resolvedEntry).replace(/\.(gjs|gts|ts|js)$/, "");
-  const tmpDir = join19(compiledRoot, "_tmp");
-  const serverDir = join19(compiledRoot, "server");
-  const clientDir = join19(compiledRoot, "client");
+  const tmpDir = join20(compiledRoot, "_tmp");
+  const serverDir = join20(compiledRoot, "server");
+  const clientDir = join20(compiledRoot, "client");
   await Promise.all([
-    mkdir5(tmpDir, { recursive: true }),
-    mkdir5(serverDir, { recursive: true }),
-    mkdir5(clientDir, { recursive: true })
+    mkdir6(tmpDir, { recursive: true }),
+    mkdir6(serverDir, { recursive: true }),
+    mkdir6(clientDir, { recursive: true })
   ]);
-  const tmpPagePath = resolve22(join19(tmpDir, `${baseName}.module.js`));
-  const tmpHarnessPath = resolve22(join19(tmpDir, `${baseName}.harness.js`));
+  const tmpPagePath = resolve23(join20(tmpDir, `${baseName}.module.js`));
+  const tmpHarnessPath = resolve23(join20(tmpDir, `${baseName}.harness.js`));
   await Promise.all([
     write3(tmpPagePath, transpiled),
     write3(tmpHarnessPath, generateServerHarness(tmpPagePath))
@@ -13596,7 +13701,7 @@ export default PageComponent;
   const stagedSourceMap = new Map([
     [tmpPagePath, resolvedEntry]
   ]);
-  const serverPath = join19(serverDir, `${baseName}.js`);
+  const serverPath = join20(serverDir, `${baseName}.js`);
   const buildResult = await bunBuild2({
     entrypoints: [tmpHarnessPath],
     format: "esm",
@@ -13613,7 +13718,7 @@ export default PageComponent;
     console.warn(`\u26A0\uFE0F Ember server build for ${baseName} had errors:`, buildResult.logs);
   }
   await rm4(tmpDir, { force: true, recursive: true });
-  const clientPath = join19(clientDir, `${baseName}.js`);
+  const clientPath = join20(clientDir, `${baseName}.js`);
   await write3(clientPath, transpiled);
   return { clientPath, serverPath };
 }, compileEmber = async (entries, emberDir, cwd = process.cwd(), _hmr = false) => {
@@ -13630,7 +13735,7 @@ export default PageComponent;
     serverPaths: outputs.map((o) => o.serverPath)
   };
 }, compileEmberFileSource = async (entry) => {
-  const resolvedEntry = resolve22(entry);
+  const resolvedEntry = resolve23(entry);
   const source = await file4(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -13640,11 +13745,11 @@ export default PageComponent;
     });
     preprocessed = rewriteTemplateEvalToScope(result.code);
   }
-  return transpiler4.transformSync(preprocessed);
-}, clearEmberCompilerCache = () => {}, getEmberCompiledRoot = (_emberDir) => getFrameworkGeneratedDir("ember"), getEmberServerCompiledDir = (emberDir) => join19(getEmberCompiledRoot(emberDir), "server"), getEmberClientCompiledDir = (emberDir) => join19(getEmberCompiledRoot(emberDir), "client");
+  return transpiler5.transformSync(preprocessed);
+}, clearEmberCompilerCache = () => {}, getEmberCompiledRoot = (_emberDir) => getFrameworkGeneratedDir("ember"), getEmberServerCompiledDir = (emberDir) => join20(getEmberCompiledRoot(emberDir), "server"), getEmberClientCompiledDir = (emberDir) => join20(getEmberCompiledRoot(emberDir), "client");
 var init_compileEmber = __esm(() => {
   init_generatedDir();
-  transpiler4 = new Transpiler3({
+  transpiler5 = new Transpiler4({
     loader: "ts",
     target: "browser",
     tsconfig: JSON.stringify({
@@ -13663,24 +13768,24 @@ __export(exports_buildReactVendor, {
   buildReactVendor: () => buildReactVendor
 });
 import { existsSync as existsSync19, mkdirSync as mkdirSync7 } from "fs";
-import { join as join20, resolve as resolve23 } from "path";
+import { join as join21, resolve as resolve24 } from "path";
 import { rm as rm5 } from "fs/promises";
 var {build: bunBuild3 } = globalThis.Bun;
 var resolveJsxDevRuntimeCompatPath = () => {
   const candidates = [
-    resolve23(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
-    resolve23(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve23(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve23(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve23(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve23(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 (existsSync19(candidate)) {
       return candidate.replace(/\\/g, "/");
     }
   }
-  return (candidates[0] ?? resolve23(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());
@@ -13717,14 +13822,14 @@ var resolveJsxDevRuntimeCompatPath = () => {
 `)}
 `;
 }, buildReactVendor = async (buildDir) => {
-  const vendorDir = join20(buildDir, "react", "vendor");
+  const vendorDir = join21(buildDir, "react", "vendor");
   mkdirSync7(vendorDir, { recursive: true });
-  const tmpDir = join20(buildDir, "_vendor_tmp");
+  const tmpDir = join21(buildDir, "_vendor_tmp");
   mkdirSync7(tmpDir, { recursive: true });
   const specifiers = resolveVendorSpecifiers();
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName(specifier);
-    const entryPath = join20(tmpDir, `${safeName}.ts`);
+    const entryPath = join21(tmpDir, `${safeName}.ts`);
     const source = await generateEntrySource(specifier);
     await Bun.write(entryPath, source);
     return entryPath;
@@ -13789,7 +13894,7 @@ __export(exports_buildAngularVendor, {
   buildAngularServerVendor: () => buildAngularServerVendor
 });
 import { mkdirSync as mkdirSync8 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 import { rm as rm6 } from "fs/promises";
 var {build: bunBuild4, Glob: Glob6 } = globalThis.Bun;
 var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => jitMode ? [...REQUIRED_ANGULAR_SPECIFIERS_BASE, "@angular/compiler"] : REQUIRED_ANGULAR_SPECIFIERS_BASE, SERVER_ONLY_ANGULAR_SPECIFIERS, BUILD_ONLY_ANGULAR_SPECIFIER_PREFIXES, isBuildOnlyAngularSpecifier = (spec) => BUILD_ONLY_ANGULAR_SPECIFIER_PREFIXES.some((prefix) => spec === prefix || spec.startsWith(`${prefix}/`)), SCAN_SKIP_DIRS, isResolvable2 = (specifier) => {
@@ -13802,7 +13907,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
 }, isBareSpecifier = (spec) => !spec.startsWith(".") && !spec.startsWith("/") && !spec.startsWith("@src/"), isAngularBrowserSpecifier = (spec) => spec.startsWith("@angular/") && !SERVER_ONLY_ANGULAR_SPECIFIERS.has(spec) && !isBuildOnlyAngularSpecifier(spec), scanSourceImports = async (directories) => {
   const angular = new Set;
   const transitiveRoots = new Set;
-  const transpiler5 = new Bun.Transpiler({ loader: "tsx" });
+  const transpiler6 = new Bun.Transpiler({ loader: "tsx" });
   const glob = new Glob6("**/*.{ts,tsx,js,jsx}");
   for (const dir of directories) {
     try {
@@ -13813,7 +13918,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
           continue;
         try {
           const content = await Bun.file(file5).text();
-          for (const imp of transpiler5.scanImports(content)) {
+          for (const imp of transpiler6.scanImports(content)) {
             if (isAngularBrowserSpecifier(imp.path)) {
               angular.add(imp.path);
             } else if (isBareSpecifier(imp.path)) {
@@ -13827,7 +13932,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   return { angular, transitiveRoots };
 }, PARTIAL_DECL_MARKERS, containsPartialDeclarations = (source) => PARTIAL_DECL_MARKERS.some((marker) => source.includes(marker)), collectTransitiveAngularSpecs = async (roots, angularFound) => {
   const { readFileSync: readFileSync14 } = await import("fs");
-  const transpiler5 = new Bun.Transpiler({ loader: "js" });
+  const transpiler6 = new Bun.Transpiler({ loader: "js" });
   const visited = new Set;
   const frontier = [];
   for (const r of roots)
@@ -13856,7 +13961,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
       }
       let imports;
       try {
-        imports = transpiler5.scanImports(content);
+        imports = transpiler6.scanImports(content);
       } catch {
         continue;
       }
@@ -13886,14 +13991,14 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   await collectTransitiveAngularSpecs([...angular, ...transitiveRoots], angular);
   return Array.from(angular).filter(isResolvable2);
 }, buildAngularVendor = async (buildDir, directories = [], linkerJitMode = false, depVendorSpecifiers = []) => {
-  const vendorDir = join21(buildDir, "angular", "vendor");
+  const vendorDir = join22(buildDir, "angular", "vendor");
   mkdirSync8(vendorDir, { recursive: true });
-  const tmpDir = join21(buildDir, "_angular_vendor_tmp");
+  const tmpDir = join22(buildDir, "_angular_vendor_tmp");
   mkdirSync8(tmpDir, { recursive: true });
   const specifiers = await resolveAngularSpecifiers(directories, linkerJitMode);
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
-    const entryPath = join21(tmpDir, `${safeName}.ts`);
+    const entryPath = join22(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -13924,9 +14029,9 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   const specifiers = await resolveAngularSpecifiers(directories, linkerJitMode);
   return computeAngularVendorPaths(specifiers);
 }, buildAngularServerVendor = async (buildDir, directories = [], linkerJitMode = false) => {
-  const vendorDir = join21(buildDir, "angular", "vendor", "server");
+  const vendorDir = join22(buildDir, "angular", "vendor", "server");
   mkdirSync8(vendorDir, { recursive: true });
-  const tmpDir = join21(buildDir, "_angular_server_vendor_tmp");
+  const tmpDir = join22(buildDir, "_angular_server_vendor_tmp");
   mkdirSync8(tmpDir, { recursive: true });
   const browserSpecs = await resolveAngularSpecifiers(directories, linkerJitMode);
   const allSpecs = new Set(browserSpecs);
@@ -13937,7 +14042,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   const specifiers = Array.from(allSpecs);
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
-    const entryPath = join21(tmpDir, `${safeName}.ts`);
+    const entryPath = join22(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -13959,9 +14064,9 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   return specifiers;
 }, computeAngularServerVendorPaths = (buildDir, specifiers) => {
   const paths = {};
-  const vendorDir = join21(buildDir, "angular", "vendor", "server");
+  const vendorDir = join22(buildDir, "angular", "vendor", "server");
   for (const specifier of specifiers) {
-    paths[specifier] = join21(vendorDir, `${toSafeFileName2(specifier)}.js`);
+    paths[specifier] = join22(vendorDir, `${toSafeFileName2(specifier)}.js`);
   }
   return paths;
 }, computeAngularServerVendorPathsAsync = async (buildDir, directories = [], linkerJitMode = true) => {
@@ -14017,17 +14122,17 @@ __export(exports_buildVueVendor, {
   buildVueVendor: () => buildVueVendor
 });
 import { mkdirSync as mkdirSync9 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 import { rm as rm7 } from "fs/promises";
 var {build: bunBuild5 } = globalThis.Bun;
 var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"), buildVueVendor = async (buildDir) => {
-  const vendorDir = join22(buildDir, "vue", "vendor");
+  const vendorDir = join23(buildDir, "vue", "vendor");
   mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join22(buildDir, "_vue_vendor_tmp");
+  const tmpDir = join23(buildDir, "_vue_vendor_tmp");
   mkdirSync9(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(vueSpecifiers.map(async (specifier) => {
     const safeName = toSafeFileName3(specifier);
-    const entryPath = join22(tmpDir, `${safeName}.ts`);
+    const entryPath = join23(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -14055,7 +14160,7 @@ var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"
   const { readFileSync: readFileSync14, writeFileSync: writeFileSync8, readdirSync } = await import("fs");
   const files = readdirSync(vendorDir).filter((f2) => f2.endsWith(".js"));
   for (const file5 of files) {
-    const filePath = join22(vendorDir, file5);
+    const filePath = join23(vendorDir, file5);
     const content = readFileSync14(filePath, "utf-8");
     if (!content.includes("__VUE_HMR_RUNTIME__"))
       continue;
@@ -14082,7 +14187,7 @@ __export(exports_buildSvelteVendor, {
   buildSvelteVendor: () => buildSvelteVendor
 });
 import { mkdirSync as mkdirSync10 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 import { rm as rm8 } from "fs/promises";
 var {build: bunBuild6 } = globalThis.Bun;
 var svelteSpecifiers, isResolvable3 = (specifier) => {
@@ -14096,13 +14201,13 @@ var svelteSpecifiers, isResolvable3 = (specifier) => {
   const specifiers = resolveVendorSpecifiers2();
   if (specifiers.length === 0)
     return;
-  const vendorDir = join23(buildDir, "svelte", "vendor");
+  const vendorDir = join24(buildDir, "svelte", "vendor");
   mkdirSync10(vendorDir, { recursive: true });
-  const tmpDir = join23(buildDir, "_svelte_vendor_tmp");
+  const tmpDir = join24(buildDir, "_svelte_vendor_tmp");
   mkdirSync10(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName4(specifier);
-    const entryPath = join23(tmpDir, `${safeName}.ts`);
+    const entryPath = join24(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -14152,7 +14257,7 @@ __export(exports_rewriteImportsPlugin, {
   buildWithImportRewrite: () => buildWithImportRewrite
 });
 import { readdir as readdir3 } from "fs/promises";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 var escapeRegex2 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewriteImports = (content, replacements) => {
   let result = content;
   for (const [specifier, webPath] of replacements) {
@@ -14281,7 +14386,7 @@ ${content}`;
       const entries = await readdir3(dir);
       for (const entry of entries) {
         if (entry.endsWith(".js"))
-          allFiles.push(join24(dir, entry));
+          allFiles.push(join25(dir, entry));
       }
     } catch {}
   }
@@ -14330,7 +14435,7 @@ import {
   statSync,
   writeFileSync as writeFileSync8
 } from "fs";
-import { basename as basename9, dirname as dirname15, extname as extname7, join as join25, relative as relative11, resolve as resolve24 } from "path";
+import { basename as basename9, dirname as dirname16, extname as extname7, join as join26, relative as relative12, resolve as resolve25 } from "path";
 import { cwd, env as env3, exit } from "process";
 var {build: bunBuild7, Glob: Glob7 } = globalThis.Bun;
 var isDev2, isBuildTraceEnabled = () => {
@@ -14408,8 +14513,8 @@ var isDev2, isBuildTraceEnabled = () => {
   mkdirSync11(htmxDestDir, { recursive: true });
   const glob = new Glob7("htmx*.min.js");
   for (const relPath of glob.scanSync({ cwd: htmxDir })) {
-    const src = join25(htmxDir, relPath);
-    const dest = join25(htmxDestDir, "htmx.min.js");
+    const src = join26(htmxDir, relPath);
+    const dest = join26(htmxDestDir, "htmx.min.js");
     copyFileSync(src, dest);
     return;
   }
@@ -14421,8 +14526,8 @@ var isDev2, isBuildTraceEnabled = () => {
   }
 }, resolveAbsoluteVersion = async () => {
   const candidates = [
-    resolve24(import.meta.dir, "..", "..", "package.json"),
-    resolve24(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;
@@ -14438,7 +14543,7 @@ var isDev2, isBuildTraceEnabled = () => {
   };
   await resolveCandidate(candidates);
 }, SKIP_DIRS, addWorkerPathIfExists = (file5, relPath, workerPaths) => {
-  const absPath = resolve24(file5, "..", relPath);
+  const absPath = resolve25(file5, "..", relPath);
   try {
     statSync(absPath);
     workerPaths.add(absPath);
@@ -14484,7 +14589,7 @@ var isDev2, isBuildTraceEnabled = () => {
   vuePagesPath
 }) => {
   const { readdirSync: readDir } = await import("fs");
-  const devIndexDir = join25(buildPath, "_src_indexes");
+  const devIndexDir = join26(buildPath, "_src_indexes");
   mkdirSync11(devIndexDir, { recursive: true });
   if (reactIndexesPath && reactPagesPath) {
     copyReactDevIndexes(reactIndexesPath, reactPagesPath, devIndexDir, readDir);
@@ -14500,37 +14605,37 @@ var isDev2, isBuildTraceEnabled = () => {
     return;
   }
   const indexFiles = readDir(reactIndexesPath).filter((file5) => file5.endsWith(".tsx"));
-  const pagesRel = relative11(process.cwd(), resolve24(reactPagesPath)).replace(/\\/g, "/");
+  const pagesRel = relative12(process.cwd(), resolve25(reactPagesPath)).replace(/\\/g, "/");
   for (const file5 of indexFiles) {
-    let content = readFileSync14(join25(reactIndexesPath, file5), "utf-8");
+    let content = readFileSync14(join26(reactIndexesPath, file5), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
-    writeFileSync8(join25(devIndexDir, file5), content);
+    writeFileSync8(join26(devIndexDir, file5), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
-  const svelteIndexDir = join25(getFrameworkGeneratedDir("svelte"), "indexes");
-  const sveltePageEntries = svelteEntries.filter((file5) => resolve24(file5).startsWith(resolve24(sveltePagesPath)));
+  const svelteIndexDir = join26(getFrameworkGeneratedDir("svelte"), "indexes");
+  const sveltePageEntries = svelteEntries.filter((file5) => resolve25(file5).startsWith(resolve25(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename9(entry).replace(/\.svelte(\.(ts|js))?$/, "");
-    const indexFile = join25(svelteIndexDir, "pages", `${name}.js`);
+    const indexFile = join26(svelteIndexDir, "pages", `${name}.js`);
     if (!existsSync20(indexFile))
       continue;
     let content = readFileSync14(indexFile, "utf-8");
-    const srcRel = relative11(process.cwd(), resolve24(entry)).replace(/\\/g, "/");
+    const srcRel = relative12(process.cwd(), resolve25(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
-    writeFileSync8(join25(devIndexDir, `${name}.svelte.js`), content);
+    writeFileSync8(join26(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
-  const vueIndexDir = join25(getFrameworkGeneratedDir("vue"), "indexes");
-  const vuePageEntries = vueEntries.filter((file5) => resolve24(file5).startsWith(resolve24(vuePagesPath)));
+  const vueIndexDir = join26(getFrameworkGeneratedDir("vue"), "indexes");
+  const vuePageEntries = vueEntries.filter((file5) => resolve25(file5).startsWith(resolve25(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename9(entry, ".vue");
-    const indexFile = join25(vueIndexDir, `${name}.js`);
+    const indexFile = join26(vueIndexDir, `${name}.js`);
     if (!existsSync20(indexFile))
       continue;
     let content = readFileSync14(indexFile, "utf-8");
-    const srcRel = relative11(process.cwd(), resolve24(entry)).replace(/\\/g, "/");
+    const srcRel = relative12(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(join25(devIndexDir, `${name}.vue.js`), content);
+    writeFileSync8(join26(devIndexDir, `${name}.vue.js`), content);
   }
 }, resolveVueRuntimeId = (content, firstUseName, outputPath, projectRoot) => {
   const varIdx = content.indexOf(`var ${firstUseName} =`);
@@ -14541,7 +14646,7 @@ var isDev2, isBuildTraceEnabled = () => {
   const last = allComments[allComments.length - 1];
   if (!last?.[1])
     return JSON.stringify(outputPath);
-  const srcPath = resolve24(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;
@@ -14603,7 +14708,7 @@ ${content.slice(firstUseIdx)}`;
 }, buildDevUrlFileMap = (urlReferencedFiles, projectRoot) => {
   const urlFileMap = new Map;
   for (const srcPath of urlReferencedFiles) {
-    const rel = relative11(projectRoot, srcPath).replace(/\\/g, "/");
+    const rel = relative12(projectRoot, srcPath).replace(/\\/g, "/");
     const name = basename9(srcPath);
     const mtime = Math.round(statSync(srcPath).mtimeMs);
     const url = `/@src/${rel}?v=${mtime}`;
@@ -14618,7 +14723,7 @@ ${content.slice(firstUseIdx)}`;
     const output = nonReactClientOutputs.find((artifact) => basename9(artifact.path).startsWith(`${srcBase}.`));
     if (!output)
       continue;
-    urlFileMap.set(basename9(srcPath), `/${relative11(buildPath, output.path).replace(/\\/g, "/")}`);
+    urlFileMap.set(basename9(srcPath), `/${relative12(buildPath, output.path).replace(/\\/g, "/")}`);
   }
   return urlFileMap;
 }, buildUrlFileMap = (urlReferencedFiles, hmr, projectRoot, buildPath, nonReactClientOutputs) => {
@@ -14752,10 +14857,10 @@ ${content.slice(firstUseIdx)}`;
       restoreTracePhase();
       return;
     }
-    const traceDir = join25(buildPath2, ".absolute-trace");
+    const traceDir = join26(buildPath2, ".absolute-trace");
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
     mkdirSync11(traceDir, { recursive: true });
-    writeFileSync8(join25(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
+    writeFileSync8(join26(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
       events: traceEvents,
       frameworks: traceFrameworkNames,
       generatedAt: new Date().toISOString(),
@@ -14786,15 +14891,15 @@ ${content.slice(firstUseIdx)}`;
   const stylesPath = typeof stylesConfig === "string" ? stylesConfig : stylesConfig?.path;
   const stylesIgnore = typeof stylesConfig === "object" ? stylesConfig.ignore : undefined;
   const stylesDir = stylesPath && validateSafePath(stylesPath, projectRoot);
-  const reactIndexesPath = reactDir && join25(getFrameworkGeneratedDir("react"), "indexes");
-  const reactPagesPath = reactDir && join25(reactDir, "pages");
-  const htmlPagesPath = htmlDir && join25(htmlDir, "pages");
-  const htmlScriptsPath = htmlDir && join25(htmlDir, "scripts");
-  const sveltePagesPath = svelteDir && join25(svelteDir, "pages");
-  const vuePagesPath = vueDir && join25(vueDir, "pages");
-  const htmxPagesPath = htmxDir && join25(htmxDir, "pages");
-  const angularPagesPath = angularDir && join25(angularDir, "pages");
-  const emberPagesPath = emberDir && join25(emberDir, "pages");
+  const reactIndexesPath = reactDir && join26(getFrameworkGeneratedDir("react"), "indexes");
+  const reactPagesPath = reactDir && join26(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join26(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join26(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join26(svelteDir, "pages");
+  const vuePagesPath = vueDir && join26(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join26(htmxDir, "pages");
+  const angularPagesPath = angularDir && join26(angularDir, "pages");
+  const emberPagesPath = emberDir && join26(emberDir, "pages");
   const frontends = [
     reactDir,
     htmlDir,
@@ -14825,7 +14930,7 @@ ${content.slice(firstUseIdx)}`;
   const sourceClientRoots = [
     htmlDir,
     htmxDir,
-    islandBootstrapPath && dirname15(islandBootstrapPath)
+    islandBootstrapPath && dirname16(islandBootstrapPath)
   ].filter((dir) => Boolean(dir));
   const usesGenerated = Boolean(reactDir) || Boolean(svelteDir) || Boolean(vueDir) || Boolean(angularDir);
   if (usesGenerated)
@@ -14853,8 +14958,8 @@ ${content.slice(firstUseIdx)}`;
     const [firstEntry] = serverDirMap;
     if (!firstEntry)
       throw new Error("Expected at least one server directory entry");
-    serverRoot = join25(firstEntry.dir, firstEntry.subdir);
-    serverOutDir = join25(buildPath, basename9(firstEntry.dir));
+    serverRoot = join26(firstEntry.dir, firstEntry.subdir);
+    serverOutDir = join26(buildPath, basename9(firstEntry.dir));
   } else if (serverDirMap.length > 1) {
     serverRoot = commonAncestor(serverDirMap.map((entry) => entry.dir), projectRoot);
     serverOutDir = buildPath;
@@ -14866,13 +14971,13 @@ ${content.slice(firstUseIdx)}`;
   const filterToIncrementalEntries = (entryPoints, mapToSource) => {
     if (!isIncremental || !incrementalFiles)
       return entryPoints;
-    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve24(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(resolve24(sourceFile)))
+      if (!normalizedIncremental.has(resolve25(sourceFile)))
         continue;
       matchingEntries.push(entry);
     }
@@ -14882,7 +14987,7 @@ ${content.slice(firstUseIdx)}`;
     await tracePhase("react/index-generation", () => generateReactIndexFiles(reactPagesPath, reactIndexesPath, hmr));
   }
   if (assetsPath && (!isIncremental || normalizedIncrementalFiles?.some((f2) => f2.includes("/assets/")))) {
-    await tracePhase("assets/copy", () => cpSync(assetsPath, join25(buildPath, "assets"), {
+    await tracePhase("assets/copy", () => cpSync(assetsPath, join26(buildPath, "assets"), {
       force: true,
       recursive: true
     }));
@@ -14901,6 +15006,7 @@ ${content.slice(firstUseIdx)}`;
     vueConventionResult,
     angularConventionResult,
     emberConventionResult,
+    htmlConventionResult,
     allGlobalCssEntries
   ] = await Promise.all([
     tailwindPromise,
@@ -14911,6 +15017,7 @@ ${content.slice(firstUseIdx)}`;
     vuePagesPath ? tracePhase("scan/vue-conventions", () => scanConventions(vuePagesPath, "*.vue")) : emptyConventionResult,
     angularPagesPath ? tracePhase("scan/angular-conventions", () => scanConventions(angularPagesPath, "*.ts")) : emptyConventionResult,
     emberPagesPath ? tracePhase("scan/ember-conventions", () => scanConventions(emberPagesPath, "*.{gjs,gts,ts}")) : emptyConventionResult,
+    htmlPagesPath ? tracePhase("scan/html-conventions", () => scanConventions(htmlPagesPath, "*.html")) : emptyConventionResult,
     stylesDir ? tracePhase("scan/css", () => scanCssEntryPoints(stylesDir, stylesIgnore)) : []
   ]);
   const allSvelteEntries = svelteConventionResult.pageFiles;
@@ -14928,15 +15035,37 @@ ${content.slice(firstUseIdx)}`;
     conventionsMap.angular = angularConventionResult.conventions;
   if (emberConventionResult.conventions)
     conventionsMap.ember = emberConventionResult.conventions;
-  const notFoundFrameworks = ["react", "svelte", "vue", "angular", "ember"].filter((framework) => conventionsMap[framework]?.defaults?.notFound);
+  if (htmlConventionResult.conventions && htmlDir && htmlPagesPath) {
+    const outputHtmlPages = isSingle ? join26(buildPath, "pages") : join26(buildPath, basename9(htmlDir), "pages");
+    const remap = (sourcePath) => join26(outputHtmlPages, relative12(htmlPagesPath, sourcePath));
+    const htmlConventions = htmlConventionResult.conventions;
+    if (htmlConventions.defaults) {
+      if (htmlConventions.defaults.error)
+        htmlConventions.defaults.error = remap(htmlConventions.defaults.error);
+      if (htmlConventions.defaults.notFound)
+        htmlConventions.defaults.notFound = remap(htmlConventions.defaults.notFound);
+      if (htmlConventions.defaults.loading)
+        htmlConventions.defaults.loading = remap(htmlConventions.defaults.loading);
+    }
+    if (htmlConventions.pages) {
+      for (const page of Object.values(htmlConventions.pages)) {
+        if (page.error)
+          page.error = remap(page.error);
+        if (page.loading)
+          page.loading = remap(page.loading);
+      }
+    }
+    conventionsMap.html = htmlConventions;
+  }
+  const notFoundFrameworks = ["react", "svelte", "vue", "angular", "ember", "html"].filter((framework) => conventionsMap[framework]?.defaults?.notFound);
   if (notFoundFrameworks.length > 1) {
     logWarn(`Multiple frameworks define not-found convention files: ${notFoundFrameworks.join(", ")}. Only one will be used (priority: ${notFoundFrameworks[0]}). Remove not-found files from other frameworks to avoid ambiguity.`);
   }
   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(resolve24(reactIndexesPath))) {
+    if (entry.startsWith(resolve25(reactIndexesPath))) {
       const pageName = basename9(entry, ".tsx");
-      return join25(reactPagesPath, `${pageName}.tsx`);
+      return join26(reactPagesPath, `${pageName}.tsx`);
     }
     return null;
   }) : allReactEntries;
@@ -15013,7 +15142,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandSvelteClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandSvelteClientPathMap.set(resolve24(sourcePath), clientPath);
+    islandSvelteClientPathMap.set(resolve25(sourcePath), clientPath);
   }
   const islandVueClientPathMap = new Map;
   for (let idx = 0;idx < islandVueSources.length; idx++) {
@@ -15021,7 +15150,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandVueClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandVueClientPathMap.set(resolve24(sourcePath), clientPath);
+    islandVueClientPathMap.set(resolve25(sourcePath), clientPath);
   }
   const islandAngularClientPathMap = new Map;
   for (let idx = 0;idx < islandAngularSources.length; idx++) {
@@ -15029,7 +15158,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandAngularClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandAngularClientPathMap.set(resolve24(sourcePath), clientPath);
+    islandAngularClientPathMap.set(resolve25(sourcePath), clientPath);
   }
   const reactConventionSources = collectConventionSourceFiles(conventionsMap.react);
   const svelteConventionSources = collectConventionSourceFiles(conventionsMap.svelte);
@@ -15040,7 +15169,7 @@ ${content.slice(firstUseIdx)}`;
     const compileReactConventions = async () => {
       if (reactConventionSources.length === 0)
         return emptyStringArray;
-      const destDir = join25(buildPath, "conventions", "react");
+      const destDir = join26(buildPath, "conventions", "react");
       rmSync2(destDir, { force: true, recursive: true });
       mkdirSync11(destDir, { recursive: true });
       const destPaths = [];
@@ -15056,7 +15185,7 @@ ${content.slice(firstUseIdx)}`;
           naming: `${idx}-[name].[ext]`,
           outdir: destDir,
           plugins: [stylePreprocessorPlugin2],
-          root: dirname15(source),
+          root: dirname16(source),
           target: "bun",
           throw: false,
           tsconfig: "./tsconfig.json"
@@ -15084,7 +15213,7 @@ ${content.slice(firstUseIdx)}`;
       angularConventionSources.length > 0 && angularDir ? tracePhase("compile/convention-angular", () => Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular)).then((mod) => mod.compileAngular(angularConventionSources, angularDir, hmr, styleTransformConfig))) : { serverPaths: emptyStringArray }
     ]);
     const bundleConventionFiles = async (framework, compiledPaths) => {
-      const destDir = join25(buildPath, "conventions", framework);
+      const destDir = join26(buildPath, "conventions", framework);
       rmSync2(destDir, { force: true, recursive: true });
       mkdirSync11(destDir, { recursive: true });
       const destPaths = [];
@@ -15158,7 +15287,7 @@ ${content.slice(firstUseIdx)}`;
     }
   })) : {
     entries: [],
-    generatedRoot: join25(buildPath, "_island_entries")
+    generatedRoot: join26(buildPath, "_island_entries")
   };
   const islandClientEntryPoints = islandEntryResult.entries.map((entry) => entry.entryPath);
   if (serverEntryPoints.length === 0 && reactClientEntryPoints.length === 0 && nonReactClientEntryPoints.length === 0 && islandClientEntryPoints.length === 0 && htmxDir === undefined && htmlDir === undefined) {
@@ -15194,7 +15323,7 @@ ${content.slice(firstUseIdx)}`;
     return {};
   }
   if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
-    const refreshEntry = join25(reactIndexesPath, "_refresh.tsx");
+    const refreshEntry = join26(reactIndexesPath, "_refresh.tsx");
     if (!reactClientEntryPoints.includes(refreshEntry))
       reactClientEntryPoints.push(refreshEntry);
   }
@@ -15293,19 +15422,19 @@ ${content.slice(firstUseIdx)}`;
     throw: false
   }, resolveBunBuildOverride(bunBuildConfig, "reactClient")) : undefined;
   if (reactDir && reactClientEntryPoints.length > 0) {
-    rmSync2(join25(buildPath, "react", "generated", "indexes"), {
+    rmSync2(join26(buildPath, "react", "generated", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (angularDir && angularClientPaths.length > 0) {
-    rmSync2(join25(buildPath, "angular", "indexes"), {
+    rmSync2(join26(buildPath, "angular", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (islandClientEntryPoints.length > 0) {
-    rmSync2(join25(buildPath, "islands"), {
+    rmSync2(join26(buildPath, "islands"), {
       force: true,
       recursive: true
     });
@@ -15388,7 +15517,7 @@ ${content.slice(firstUseIdx)}`;
     globalCssEntries.length > 0 ? tracePhase("bun/global-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: globalCssEntries,
       naming: `[dir]/[name].[hash].[ext]`,
-      outdir: stylesDir ? join25(buildPath, basename9(stylesDir)) : buildPath,
+      outdir: stylesDir ? join26(buildPath, basename9(stylesDir)) : buildPath,
       plugins: [stylePreprocessorPlugin2],
       root: stylesDir || clientRoot,
       target: "browser",
@@ -15397,7 +15526,7 @@ ${content.slice(firstUseIdx)}`;
     vueCssPaths.length > 0 ? tracePhase("bun/vue-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: vueCssPaths,
       naming: `[name].[hash].[ext]`,
-      outdir: join25(buildPath, assetsPath ? basename9(assetsPath) : "assets", "css"),
+      outdir: join26(buildPath, assetsPath ? basename9(assetsPath) : "assets", "css"),
       target: "browser",
       throw: false
     }, resolveBunBuildOverride(bunBuildConfig, "vueCss")))) : undefined
@@ -15464,10 +15593,10 @@ ${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 = dirname15(artifact.path);
+      const fileDir = dirname16(artifact.path);
       const relativePaths = {};
       for (const [specifier, absolute] of Object.entries(angularServerVendorPaths2)) {
-        const rel = relative11(fileDir, absolute);
+        const rel = relative12(fileDir, absolute);
         relativePaths[specifier] = rel.startsWith(".") ? rel : `./${rel}`;
       }
       return relativePaths;
@@ -15536,7 +15665,7 @@ ${content.slice(firstUseIdx)}`;
   if (skipAngularClientBundle) {
     for (const clientPath of angularClientPaths) {
       const fileBase = basename9(clientPath, ".js");
-      const relFromCwd = relative11(projectRoot, clientPath).replace(/\\/g, "/");
+      const relFromCwd = relative12(projectRoot, clientPath).replace(/\\/g, "/");
       manifest[`${toPascal(fileBase)}Index`] = `/@src/${relFromCwd}`;
     }
   }
@@ -15558,7 +15687,7 @@ ${content.slice(firstUseIdx)}`;
   const processHtmlPages = async () => {
     if (!(htmlDir && htmlPagesPath))
       return;
-    const outputHtmlPages = isSingle ? join25(buildPath, "pages") : join25(buildPath, basename9(htmlDir), "pages");
+    const outputHtmlPages = isSingle ? join26(buildPath, "pages") : join26(buildPath, basename9(htmlDir), "pages");
     mkdirSync11(outputHtmlPages, { recursive: true });
     cpSync(htmlPagesPath, outputHtmlPages, {
       force: true,
@@ -15580,14 +15709,14 @@ ${content.slice(firstUseIdx)}`;
   const processHtmxPages = async () => {
     if (!(htmxDir && htmxPagesPath))
       return;
-    const outputHtmxPages = isSingle ? join25(buildPath, "pages") : join25(buildPath, basename9(htmxDir), "pages");
+    const outputHtmxPages = isSingle ? join26(buildPath, "pages") : join26(buildPath, basename9(htmxDir), "pages");
     mkdirSync11(outputHtmxPages, { recursive: true });
     cpSync(htmxPagesPath, outputHtmxPages, {
       force: true,
       recursive: true
     });
     if (shouldCopyHtmx) {
-      const htmxDestDir = isSingle ? buildPath : join25(buildPath, basename9(htmxDir));
+      const htmxDestDir = isSingle ? buildPath : join26(buildPath, basename9(htmxDir));
       copyHtmxVendor(htmxDir, htmxDestDir);
     }
     if (shouldUpdateHtmxAssetPaths) {
@@ -15649,9 +15778,9 @@ ${content.slice(firstUseIdx)}`;
     writeBuildTrace(buildPath);
     return { conventions: conventionsMap, manifest };
   }
-  writeFileSync8(join25(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
+  writeFileSync8(join26(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
   if (Object.keys(conventionsMap).length > 0) {
-    writeFileSync8(join25(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
+    writeFileSync8(join26(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
   }
   writeBuildTrace(buildPath);
   if (tailwind && mode === "production") {
@@ -15752,7 +15881,7 @@ var init_build = __esm(() => {
 
 // src/build/buildEmberVendor.ts
 import { mkdirSync as mkdirSync12, existsSync as existsSync21 } from "fs";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 import { rm as rm9 } from "fs/promises";
 var {build: bunBuild8 } = globalThis.Bun;
 var toSafeFileName5 = (specifier) => specifier.replace(/^@/, "").replace(/\//g, "_"), generateMacrosShim = () => `// Generated shim for @embroider/macros \u2014 provides minimal runtime
@@ -15804,7 +15933,7 @@ export const importSync = (specifier) => {
   if (standaloneSpecifiers.has(specifier)) {
     return { resolveTo: specifier, specifier };
   }
-  const emberInternalPath = join26(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
+  const emberInternalPath = join27(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
   if (!existsSync21(emberInternalPath)) {
     throw new Error(`Ember vendor build: cannot find ${specifier} at ${emberInternalPath}. ` + `Is ember-source installed and at least 6.12?`);
   }
@@ -15836,7 +15965,7 @@ export const importSync = (specifier) => {
       if (standalonePackages.has(args.path)) {
         return;
       }
-      const internal = join26(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      const internal = join27(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
       if (existsSync21(internal)) {
         return { path: internal };
       }
@@ -15844,16 +15973,16 @@ export const importSync = (specifier) => {
     });
   }
 }), buildEmberVendor = async (buildDir, cwd2 = process.cwd()) => {
-  const vendorDir = join26(buildDir, "ember", "vendor");
+  const vendorDir = join27(buildDir, "ember", "vendor");
   mkdirSync12(vendorDir, { recursive: true });
-  const tmpDir = join26(buildDir, "_ember_vendor_tmp");
+  const tmpDir = join27(buildDir, "_ember_vendor_tmp");
   mkdirSync12(tmpDir, { recursive: true });
-  const macrosShimPath = join26(tmpDir, "embroider_macros_shim.js");
+  const macrosShimPath = join27(tmpDir, "embroider_macros_shim.js");
   await Bun.write(macrosShimPath, generateMacrosShim());
   const resolutions = REQUIRED_EMBER_SPECIFIERS.map((specifier) => resolveEmberSpecifier(specifier, cwd2));
   const entrypoints = await Promise.all(resolutions.map(async (resolution) => {
     const safeName = toSafeFileName5(resolution.specifier);
-    const entryPath = join26(tmpDir, `${safeName}.js`);
+    const entryPath = join27(tmpDir, `${safeName}.js`);
     const source = resolution.specifier === "@embroider/macros" ? `export * from ${JSON.stringify(macrosShimPath)};
 ` : generateVendorEntrySource2(resolution);
     await Bun.write(entryPath, source);
@@ -15899,7 +16028,7 @@ var init_buildEmberVendor = __esm(() => {
 // src/dev/dependencyGraph.ts
 import { existsSync as existsSync22, readFileSync as readFileSync15 } from "fs";
 var {Glob: Glob8 } = globalThis.Bun;
-import { resolve as resolve25 } 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"))
@@ -15913,8 +16042,8 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
     return null;
   }
-  const fromDir = resolve25(fromFile, "..");
-  const normalized = resolve25(fromDir, importPath);
+  const fromDir = resolve26(fromFile, "..");
+  const normalized = resolve26(fromDir, importPath);
   const extensions = [
     ".ts",
     ".tsx",
@@ -15944,7 +16073,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     dependents.delete(normalizedPath);
   }
 }, addFileToGraph = (graph, filePath) => {
-  const normalizedPath = resolve25(filePath);
+  const normalizedPath = resolve26(filePath);
   if (!existsSync22(normalizedPath))
     return;
   const dependencies = extractDependencies(normalizedPath);
@@ -15961,10 +16090,10 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
 }, IGNORED_SEGMENTS, buildInitialDependencyGraph = (graph, directories) => {
   const processedFiles = new Set;
   const glob = new Glob8("**/*.{ts,tsx,js,jsx,vue,svelte,html,htm}");
-  const resolvedDirs = directories.map((dir) => resolve25(dir)).filter((dir) => existsSync22(dir));
+  const resolvedDirs = directories.map((dir) => resolve26(dir)).filter((dir) => existsSync22(dir));
   const allFiles = resolvedDirs.flatMap((dir) => Array.from(glob.scanSync({ absolute: true, cwd: dir })));
   for (const file5 of allFiles) {
-    const fullPath = resolve25(file5);
+    const fullPath = resolve26(file5);
     if (IGNORED_SEGMENTS.some((seg) => fullPath.includes(seg)))
       continue;
     if (processedFiles.has(fullPath))
@@ -16019,8 +16148,8 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   resolveRegexMatches(styleUrlSingularRegex, content, filePath, dependencies);
   extractStyleUrlsDependencies(content, filePath, dependencies);
 }, extractJsDependencies = (filePath, content, loader) => {
-  const transpiler5 = loader === "tsx" ? tsTranspiler : jsTranspiler;
-  const imports = transpiler5.scanImports(content);
+  const transpiler6 = loader === "tsx" ? tsTranspiler : jsTranspiler;
+  const imports = transpiler6.scanImports(content);
   const dependencies = [];
   for (const imp of imports) {
     const resolved = resolveImportPath2(imp.path, filePath);
@@ -16077,7 +16206,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     return [];
   }
 }, getAffectedFiles = (graph, changedFile) => {
-  const normalizedPath = resolve25(changedFile);
+  const normalizedPath = resolve26(changedFile);
   const affected = new Set;
   const toProcess = [normalizedPath];
   const processNode = (current) => {
@@ -16117,7 +16246,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   }
   graph.dependents.delete(normalizedPath);
 }, removeFileFromGraph = (graph, filePath) => {
-  const normalizedPath = resolve25(filePath);
+  const normalizedPath = resolve26(filePath);
   removeDepsForFile(graph, normalizedPath);
   removeDependentsForFile(graph, normalizedPath);
 };
@@ -16160,12 +16289,12 @@ var globalVersionCounter = 0, createModuleVersionTracker = () => new Map, getNex
 };
 
 // src/dev/configResolver.ts
-import { resolve as resolve26 } 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(resolve26(cwd2, value ?? fallback));
-  const optional = (value) => value ? normalize(resolve26(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),
@@ -16218,7 +16347,7 @@ var init_clientManager = __esm(() => {
 
 // src/dev/pathUtils.ts
 import { existsSync as existsSync23, readdirSync, readFileSync as readFileSync16 } from "fs";
-import { dirname as dirname16, resolve as resolve27 } from "path";
+import { dirname as dirname17, resolve as resolve28 } from "path";
 var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   if (shouldIgnorePath(filePath, resolved)) {
     return "ignored";
@@ -16294,7 +16423,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   return "unknown";
 }, collectAngularResourceDirs = (angularDir) => {
   const out = new Set;
-  const angularRoot = resolve27(angularDir);
+  const angularRoot = resolve28(angularDir);
   const angularRootNormalized = normalizePath(angularRoot);
   const walk = (dir) => {
     let entries;
@@ -16307,7 +16436,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const full = resolve27(dir, entry.name);
+      const full = resolve28(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
         continue;
@@ -16346,10 +16475,10 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
             refs.push(strMatch[1]);
         }
       }
-      const componentDir = dirname16(full);
+      const componentDir = dirname17(full);
       for (const ref of refs) {
-        const refAbs = normalizePath(resolve27(componentDir, ref));
-        const refDir = normalizePath(dirname16(refAbs));
+        const refAbs = normalizePath(resolve28(componentDir, ref));
+        const refDir = normalizePath(dirname17(refAbs));
         if (refDir === angularRootNormalized || refDir.startsWith(angularRootNormalized + "/")) {
           continue;
         }
@@ -16365,7 +16494,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   const push = (path) => {
     if (!path)
       return;
-    const abs = normalizePath(resolve27(cwd2, path));
+    const abs = normalizePath(resolve28(cwd2, path));
     if (!roots.includes(abs))
       roots.push(abs);
   };
@@ -16390,7 +16519,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(resolve27(cwd2, candidate));
+    const abs = normalizePath(resolve28(cwd2, candidate));
     if (existsSync23(abs) && !roots.includes(abs))
       roots.push(abs);
   }
@@ -16461,7 +16590,7 @@ var init_pathUtils = __esm(() => {
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
 import { existsSync as existsSync24 } from "fs";
-import { join as join27, resolve as resolve28 } from "path";
+import { join as join28, resolve as resolve29 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -16488,7 +16617,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
     if (shouldSkipFilename(filename, isStylesDir)) {
       return;
     }
-    const fullPath = join27(absolutePath, filename).replace(/\\/g, "/");
+    const fullPath = join28(absolutePath, filename).replace(/\\/g, "/");
     if (shouldIgnorePath(fullPath, state.resolvedPaths)) {
       return;
     }
@@ -16506,7 +16635,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
 }, addFileWatchers = (state, paths, onFileChange) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
-    const absolutePath = resolve28(path).replace(/\\/g, "/");
+    const absolutePath = resolve29(path).replace(/\\/g, "/");
     if (!existsSync24(absolutePath)) {
       return;
     }
@@ -16517,7 +16646,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const watchPaths = getWatchPaths(config, state.resolvedPaths);
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
-    const absolutePath = resolve28(path).replace(/\\/g, "/");
+    const absolutePath = resolve29(path).replace(/\\/g, "/");
     if (!existsSync24(absolutePath)) {
       return;
     }
@@ -16532,13 +16661,13 @@ var init_fileWatcher = __esm(() => {
 });
 
 // src/dev/assetStore.ts
-import { resolve as resolve29 } 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 = resolve29(dir, entry.name);
+  const fullPath = resolve30(dir, entry.name);
   if (entry.isDirectory()) {
     return walkAndClean(fullPath);
   }
@@ -16554,10 +16683,10 @@ var mimeTypes, getMimeType = (filePath) => {
 }, cleanStaleAssets = async (store, manifest, buildDir) => {
   const liveByIdentity = new Map;
   for (const webPath of store.keys()) {
-    const diskPath = resolve29(buildDir, webPath.slice(1));
+    const diskPath = resolve30(buildDir, webPath.slice(1));
     liveByIdentity.set(stripHash(diskPath), diskPath);
   }
-  const absBuildDir = resolve29(buildDir);
+  const absBuildDir = resolve30(buildDir);
   Object.values(manifest).forEach((val) => {
     if (!HASHED_FILE_RE.test(val))
       return;
@@ -16575,7 +16704,7 @@ var mimeTypes, getMimeType = (filePath) => {
   } catch {}
 }, lookupAsset = (store, path) => store.get(path), processScanEntry = (entry, dir, prefix, store, scanDir) => {
   if (entry.isDirectory()) {
-    return scanDir(resolve29(dir, entry.name), `${prefix}${entry.name}/`);
+    return scanDir(resolve30(dir, entry.name), `${prefix}${entry.name}/`);
   }
   if (!entry.name.startsWith("chunk-")) {
     return null;
@@ -16584,7 +16713,7 @@ var mimeTypes, getMimeType = (filePath) => {
   if (store.has(webPath)) {
     return null;
   }
-  return Bun.file(resolve29(dir, entry.name)).bytes().then((bytes) => {
+  return Bun.file(resolve30(dir, entry.name)).bytes().then((bytes) => {
     store.set(webPath, bytes);
     return;
   }).catch(() => {});
@@ -16606,7 +16735,7 @@ var mimeTypes, getMimeType = (filePath) => {
   for (const webPath of newIdentities.values()) {
     if (store.has(webPath))
       continue;
-    loadPromises.push(Bun.file(resolve29(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(() => {}));
@@ -16732,9 +16861,9 @@ var init_transformCache = __esm(() => {
 });
 
 // src/dev/reactComponentClassifier.ts
-import { resolve as resolve30 } from "path";
+import { resolve as resolve31 } from "path";
 var classifyComponent = (filePath) => {
-  const normalizedPath = resolve30(filePath);
+  const normalizedPath = resolve31(filePath);
   if (normalizedPath.includes("/react/pages/")) {
     return "server";
   }
@@ -16746,7 +16875,7 @@ var classifyComponent = (filePath) => {
 var init_reactComponentClassifier = () => {};
 
 // src/dev/moduleMapper.ts
-import { basename as basename10, resolve as resolve31 } from "path";
+import { basename as basename10, resolve as resolve32 } from "path";
 var buildModulePaths = (moduleKeys, manifest) => {
   const modulePaths = {};
   moduleKeys.forEach((key) => {
@@ -16756,7 +16885,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return modulePaths;
 }, processChangedFile = (sourceFile, framework, manifest, resolvedPaths, processedFiles) => {
-  const normalizedFile = resolve31(sourceFile);
+  const normalizedFile = resolve32(sourceFile);
   const normalizedPath = normalizedFile.replace(/\\/g, "/");
   if (processedFiles.has(normalizedFile)) {
     return null;
@@ -16792,7 +16921,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return grouped;
 }, mapSourceFileToManifestKeys = (sourceFile, framework, resolvedPaths) => {
-  const normalizedFile = resolve31(sourceFile);
+  const normalizedFile = resolve32(sourceFile);
   const fileName = basename10(normalizedFile);
   const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|css|html)$/, "");
   const pascalName = toPascal(baseName);
@@ -16967,7 +17096,7 @@ __export(exports_moduleServer, {
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
 import { existsSync as existsSync25, readFileSync as readFileSync18, statSync as statSync2 } from "fs";
-import { basename as basename11, dirname as dirname17, extname as extname8, join as join28, resolve as resolve32, relative as relative12 } from "path";
+import { basename as basename11, dirname as dirname18, extname as extname8, join as join29, resolve as resolve33, relative as relative13 } 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 = [];
@@ -16987,7 +17116,7 @@ var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPIL
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const found = extensions.find((ext) => existsSync25(resolve32(projectRoot, srcPath + ext)));
+  const found = extensions.find((ext) => existsSync25(resolve33(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);
@@ -17002,7 +17131,7 @@ ${stubs}
   return invalidationVersion > 0 ? `${mtime}.${invalidationVersion}` : `${mtime}`;
 }, srcUrl = (relPath, projectRoot) => {
   const base = `${SRC_PREFIX}${relPath.replace(/\\/g, "/")}`;
-  const absPath = resolve32(projectRoot, relPath);
+  const absPath = resolve33(projectRoot, relPath);
   const cached = mtimeCache.get(absPath);
   if (cached !== undefined)
     return `${base}?v=${buildVersion(cached, absPath)}`;
@@ -17014,12 +17143,12 @@ ${stubs}
     return base;
   }
 }, resolveRelativeImport = (relPath, fileDir, projectRoot, extensions) => {
-  const absPath = resolve32(fileDir, relPath);
-  const rel = relative12(projectRoot, absPath);
+  const absPath = resolve33(fileDir, relPath);
+  const rel = relative13(projectRoot, absPath);
   const extension = extname8(rel);
   let srcPath = RESOLVED_MODULE_EXTENSIONS.has(extension) ? rel : resolveRelativeExtension(rel, projectRoot, extensions);
   if (extname8(srcPath) === ".svelte") {
-    srcPath = relative12(projectRoot, resolveSvelteModulePath(resolve32(projectRoot, srcPath)));
+    srcPath = relative13(projectRoot, resolveSvelteModulePath(resolve33(projectRoot, srcPath)));
   }
   return srcUrl(srcPath, projectRoot);
 }, NODE_BUILTIN_RE, resolveAbsoluteSpecifier = (specifier, projectRoot) => {
@@ -17031,27 +17160,27 @@ ${stubs}
       "import"
     ]);
     if (fromExports)
-      return relative12(projectRoot, fromExports);
+      return relative13(projectRoot, fromExports);
     try {
       const isScoped = specifier.startsWith("@");
       const parts = specifier.split("/");
       const packageName = isScoped ? `${parts[0]}/${parts[1]}` : parts[0];
       const subpath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
       if (!subpath) {
-        const pkgDir = resolve32(projectRoot, "node_modules", packageName ?? "");
-        const pkgJsonPath = join28(pkgDir, "package.json");
+        const pkgDir = resolve33(projectRoot, "node_modules", packageName ?? "");
+        const pkgJsonPath = join29(pkgDir, "package.json");
         if (existsSync25(pkgJsonPath)) {
           const pkg = JSON.parse(readFileSync18(pkgJsonPath, "utf-8"));
           const esmEntry = typeof pkg.module === "string" && pkg.module || typeof pkg.browser === "string" && pkg.browser;
           if (esmEntry) {
-            const resolved = resolve32(pkgDir, esmEntry);
+            const resolved = resolve33(pkgDir, esmEntry);
             if (existsSync25(resolved))
-              return relative12(projectRoot, resolved);
+              return relative13(projectRoot, resolved);
           }
         }
       }
     } catch {}
-    return relative12(projectRoot, Bun.resolveSync(specifier, projectRoot));
+    return relative13(projectRoot, Bun.resolveSync(specifier, projectRoot));
   } catch {
     return;
   }
@@ -17076,28 +17205,28 @@ ${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 = dirname17(filePath);
+  const fileDir = dirname18(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}`);
   const rewriteAbsoluteToSrc = (_match, prefix, absPath, _ext, suffix) => {
     if (absPath.startsWith(projectRoot)) {
-      const rel2 = relative12(projectRoot, absPath).replace(/\\/g, "/");
+      const rel2 = relative13(projectRoot, absPath).replace(/\\/g, "/");
       return `${prefix}${srcUrl(rel2, projectRoot)}${suffix}`;
     }
-    const rel = relative12(projectRoot, absPath).replace(/\\/g, "/");
+    const rel = relative13(projectRoot, absPath).replace(/\\/g, "/");
     return `${prefix}${srcUrl(rel, projectRoot)}${suffix}`;
   };
   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 = resolve32(fileDir, relPath);
-    const rel = relative12(projectRoot, absPath);
+    const absPath = resolve33(fileDir, relPath);
+    const rel = relative13(projectRoot, absPath);
     return `new URL('${srcUrl(rel, projectRoot)}', import.meta.url)`;
   });
   result = result.replace(/import\.meta\.resolve\(\s*["'](\.\.?\/[^"']+)["']\s*\)/g, (_match, relPath) => {
-    const absPath = resolve32(fileDir, relPath);
-    const rel = relative12(projectRoot, absPath);
+    const absPath = resolve33(fileDir, relPath);
+    const rel = relative13(projectRoot, absPath);
     return `'${srcUrl(rel, projectRoot)}'`;
   });
   return result;
@@ -17153,7 +17282,7 @@ ${code}`;
   transpiled = `var $RefreshReg$ = window.$RefreshReg$ || function(){};
 ` + `var $RefreshSig$ = window.$RefreshSig$ || function(){ return function(t){ return t; }; };
 ${transpiled}`;
-  const relPath = relative12(projectRoot, filePath).replace(/\\/g, "/");
+  const relPath = relative13(projectRoot, filePath).replace(/\\/g, "/");
   transpiled = transpiled.replace(/\binput\.tsx:/g, `${relPath}:`);
   transpiled += buildIslandMetadataExports(raw);
   return rewriteImports(transpiled, filePath, projectRoot, rewriter);
@@ -17162,13 +17291,13 @@ ${transpiled}`;
   const ext = extname8(filePath);
   const isTS = ext === ".ts" || ext === ".tsx";
   const isTSX = ext === ".tsx" || ext === ".jsx";
-  let transpiler5 = jsTranspiler2;
+  let transpiler6 = jsTranspiler2;
   if (isTSX)
-    transpiler5 = tsxTranspiler;
+    transpiler6 = tsxTranspiler;
   else if (isTS)
-    transpiler5 = tsTranspiler2;
-  const valueExports = isTS ? transpiler5.scan(raw).exports : [];
-  let transpiled = transpiler5.transformSync(raw);
+    transpiler6 = tsTranspiler2;
+  const valueExports = isTS ? transpiler6.scan(raw).exports : [];
+  let transpiled = transpiler6.transformSync(raw);
   if (isTS) {
     transpiled = preserveTypeExports(raw, transpiled, valueExports);
   }
@@ -17314,11 +17443,11 @@ ${code}`;
   if (compiled.css?.code) {
     const cssPath = `${filePath}.css`;
     svelteExternalCss.set(cssPath, compiled.css.code);
-    const cssUrl = srcUrl(relative12(projectRoot, cssPath), projectRoot);
+    const cssUrl = srcUrl(relative13(projectRoot, cssPath), projectRoot);
     code = `import "${cssUrl}";
 ${code}`;
   }
-  const moduleUrl = `${SRC_PREFIX}${relative12(projectRoot, filePath).replace(/\\/g, "/")}`;
+  const moduleUrl = `${SRC_PREFIX}${relative13(projectRoot, filePath).replace(/\\/g, "/")}`;
   code = code.replace(/if\s*\(import\.meta\.hot\)\s*\{/, `if (typeof window !== "undefined") {
 ` + `  if (!window.__SVELTE_HMR_ACCEPT__) window.__SVELTE_HMR_ACCEPT__ = {};
 ` + `  var __hmr_accept = function(cb) { window.__SVELTE_HMR_ACCEPT__[${JSON.stringify(moduleUrl)}] = cb; };`);
@@ -17344,6 +17473,8 @@ ${code}`;
   const templateResult = compiler.compileTemplate({
     compilerOptions: {
       bindingMetadata: compiledScript.bindings,
+      expressionPlugins: ["typescript"],
+      isCustomElement: (tag) => tag === "absolute-island",
       prefixIdentifiers: true
     },
     filename: filePath,
@@ -17407,8 +17538,8 @@ ${code}`;
   code = injectVueHmr(code, filePath, projectRoot, vueDir);
   return rewriteImports(code, filePath, projectRoot, rewriter);
 }, injectVueHmr = (code, filePath, projectRoot, vueDir) => {
-  const hmrBase = vueDir ? resolve32(vueDir) : projectRoot;
-  const hmrId = relative12(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
+  const hmrBase = vueDir ? resolve33(vueDir) : projectRoot;
+  const hmrId = relative13(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
   let result = code.replace(/export\s+default\s+/, "var __hmr_comp__ = ");
   result += [
     "",
@@ -17571,7 +17702,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 = resolve32(projectRoot, relPath);
+  const filePath = resolve33(projectRoot, relPath);
   const ext = extname8(filePath);
   if (ext === ".svelte")
     return { ext, filePath: resolveSvelteModulePath(filePath) };
@@ -17598,7 +17729,7 @@ export default {};
   if (!TRANSPILABLE.has(ext))
     return;
   const stat3 = statSync2(filePath);
-  const resolvedVueDir = vueDir ? resolve32(vueDir) : undefined;
+  const resolvedVueDir = vueDir ? resolve33(vueDir) : undefined;
   let content = REACT_EXTENSIONS.has(ext) ? transformReactFile(filePath, projectRoot, rewriter) : transformPlainFile(filePath, projectRoot, rewriter, resolvedVueDir);
   const isComponentJs = ext === ".js" && filePath.endsWith(".component.js") && filePath.replace(/\\/g, "/").includes("/.absolutejs/generated/angular/");
   if (isComponentJs) {
@@ -17657,7 +17788,7 @@ export default {};
     const relPath = pathname.slice(SRC_PREFIX.length);
     if (relPath === "bun:wrap" || relPath.startsWith("bun:wrap?"))
       return handleBunWrapRequest();
-    const virtualCssResponse = handleVirtualSvelteCss(resolve32(projectRoot, relPath));
+    const virtualCssResponse = handleVirtualSvelteCss(resolve33(projectRoot, relPath));
     if (virtualCssResponse)
       return virtualCssResponse;
     const { filePath, ext } = resolveSourcePath(relPath, projectRoot);
@@ -17673,11 +17804,11 @@ export default {};
   SRC_IMPORT_RE.lastIndex = 0;
   while ((match = SRC_IMPORT_RE.exec(content)) !== null) {
     if (match[1])
-      files.push(resolve32(projectRoot, match[1]));
+      files.push(resolve33(projectRoot, match[1]));
   }
   return files;
 }, invalidateModule = (filePath) => {
-  const resolved = resolve32(filePath);
+  const resolved = resolve33(filePath);
   invalidate(filePath);
   if (resolved !== filePath)
     invalidate(resolved);
@@ -17824,7 +17955,7 @@ __export(exports_resolveOwningComponents, {
   invalidateResourceIndex: () => invalidateResourceIndex
 });
 import { readdirSync as readdirSync2, readFileSync as readFileSync19, statSync as statSync3 } from "fs";
-import { dirname as dirname18, extname as extname9, join as join29, resolve as resolve33 } from "path";
+import { dirname as dirname19, extname as extname9, join as join30, resolve as resolve34 } from "path";
 import ts3 from "typescript";
 var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") || file5.endsWith(".tsx"), walkAngularSourceFiles = (root) => {
   const out = [];
@@ -17839,7 +17970,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const full = join29(dir, entry.name);
+      const full = join30(dir, entry.name);
       if (entry.isDirectory()) {
         visit(full);
       } else if (entry.isFile() && isAngularSourceFile(entry.name)) {
@@ -17937,7 +18068,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
   };
   visit(sourceFile);
   return out;
-}, safeNormalize = (path) => resolve33(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
+}, safeNormalize = (path) => resolve34(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
   const { changedFilePath, userAngularRoot } = params;
   const changedAbs = safeNormalize(changedFilePath);
   const out = [];
@@ -17978,7 +18109,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
     return null;
   }
   const sf = ts3.createSourceFile(childFilePath, source, ts3.ScriptTarget.ES2022, true, ts3.ScriptKind.TS);
-  const childDir = dirname18(childFilePath);
+  const childDir = dirname19(childFilePath);
   for (const stmt of sf.statements) {
     if (!ts3.isImportDeclaration(stmt))
       continue;
@@ -18006,7 +18137,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
     if (!spec.startsWith(".") && !spec.startsWith("/")) {
       return null;
     }
-    const base = resolve33(childDir, spec);
+    const base = resolve34(childDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -18035,7 +18166,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
   const parentFile = new Map;
   for (const tsPath of walkAngularSourceFiles(userAngularRoot)) {
     const classes = parseDecoratedClasses(tsPath);
-    const componentDir = dirname18(tsPath);
+    const componentDir = dirname19(tsPath);
     for (const cls of classes) {
       const entity = {
         className: cls.className,
@@ -18044,7 +18175,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
       };
       if (cls.kind === "component") {
         for (const url of [...cls.templateUrls, ...cls.styleUrls]) {
-          const abs = safeNormalize(resolve33(componentDir, url));
+          const abs = safeNormalize(resolve34(componentDir, url));
           const existing = resource.get(abs);
           if (existing)
             existing.push(entity);
@@ -18124,8 +18255,6 @@ class Context {
 }
 
 // src/dev/angular/vendor/translator/translator.ts
-import * as o from "@angular/compiler";
-
 class ExpressionTranslatorVisitor {
   factory;
   imports;
@@ -18181,7 +18310,9 @@ class ExpressionTranslatorVisitor {
     return this.setSourceMapRange(this.factory.createRegularExpressionLiteral(ast.body, ast.flags), ast.sourceSpan);
   }
   visitLocalizedString(ast, context) {
-    const elements = [createTemplateElement(ast.serializeI18nHead())];
+    const elements = [
+      createTemplateElement(ast.serializeI18nHead())
+    ];
     const expressions = [];
     for (let i = 0;i < ast.expressions.length; i++) {
       const placeholder = this.setSourceMapRange(ast.expressions[i].visitExpression(this, context), ast.getPlaceholderSourceSpan(i));
@@ -18189,7 +18320,10 @@ class ExpressionTranslatorVisitor {
       elements.push(createTemplateElement(ast.serializeI18nTemplatePart(i + 1)));
     }
     const localizeTag = this.factory.createIdentifier("$localize");
-    return this.setSourceMapRange(this.createTaggedTemplateExpression(localizeTag, { elements, expressions }), ast.sourceSpan);
+    return this.setSourceMapRange(this.createTaggedTemplateExpression(localizeTag, {
+      elements,
+      expressions
+    }), ast.sourceSpan);
   }
   visitBuiltinType(ast) {
     let builtInType;
@@ -18246,7 +18380,10 @@ class ExpressionTranslatorVisitor {
       cooked.push(this.factory.setSourceMapRange(this.factory.createLiteral(element.cooked), element.range));
       raw.push(this.factory.setSourceMapRange(this.factory.createLiteral(element.raw), element.range));
     }
-    const templateHelperCall = this.factory.createCallExpression(__makeTemplateObjectHelper, [this.factory.createArrayLiteral(cooked), this.factory.createArrayLiteral(raw)], false);
+    const templateHelperCall = this.factory.createCallExpression(__makeTemplateObjectHelper, [
+      this.factory.createArrayLiteral(cooked),
+      this.factory.createArrayLiteral(raw)
+    ], false);
     return this.factory.createCallExpression(tagHandler, [templateHelperCall, ...expressions], false);
   }
   visitExternalExpr(ast, _context) {
@@ -18276,7 +18413,9 @@ class ExpressionTranslatorVisitor {
   visitDynamicImportExpr(ast, context) {
     const urlExpression = typeof ast.url === "string" ? this.factory.createLiteral(ast.url) : ast.url.visitExpression(this, context);
     if (ast.urlComment) {
-      this.factory.attachComments(urlExpression, [o.leadingComment(ast.urlComment, true)]);
+      this.factory.attachComments(urlExpression, [
+        o.leadingComment(ast.urlComment, true)
+      ]);
     }
     return this.factory.createDynamicImport(urlExpression);
   }
@@ -18416,8 +18555,16 @@ function createRange(span) {
     end: { offset: end.offset, line: end.line, column: end.col }
   };
 }
-var UNARY_OPERATORS, BINARY_OPERATORS;
+var o, UNARY_OPERATORS, BINARY_OPERATORS;
 var init_translator = __esm(() => {
+  o = (() => {
+    try {
+      return __require("@angular/compiler");
+    } catch {
+      const stub = new Proxy(function() {}, { apply: () => stub, construct: () => stub, get: () => stub });
+      return stub;
+    }
+  })();
   UNARY_OPERATORS = /* @__PURE__ */ new Map([
     [o.UnaryOperator.Minus, "-"],
     [o.UnaryOperator.Plus, "+"]
@@ -18552,7 +18699,9 @@ class TypeScriptAstFactory {
   createElementAccess = ts6.factory.createElementAccessExpression;
   createExpressionStatement = ts6.factory.createExpressionStatement;
   createDynamicImport(url) {
-    return ts6.factory.createCallExpression(ts6.factory.createToken(ts6.SyntaxKind.ImportKeyword), undefined, [typeof url === "string" ? ts6.factory.createStringLiteral(url) : url]);
+    return ts6.factory.createCallExpression(ts6.factory.createToken(ts6.SyntaxKind.ImportKeyword), undefined, [
+      typeof url === "string" ? ts6.factory.createStringLiteral(url) : url
+    ]);
   }
   createFunctionDeclaration(functionName, parameters, body) {
     if (!ts6.isBlock(body)) {
@@ -18755,9 +18904,18 @@ var init_typescript_ast_factory = __esm(() => {
 function translateStatement(contextFile, statement, imports, options = {}) {
   return statement.visitStatement(new ExpressionTranslatorVisitor(new TypeScriptAstFactory(options.annotateForClosureCompiler === true), imports, contextFile, options), new Context(true));
 }
+var o2;
 var init_typescript_translator = __esm(() => {
   init_translator();
   init_typescript_ast_factory();
+  o2 = (() => {
+    try {
+      return __require("@angular/compiler");
+    } catch {
+      const stub = new Proxy(function() {}, { apply: () => stub, construct: () => stub, get: () => stub });
+      return stub;
+    }
+  })();
 });
 
 // src/dev/angular/fastHmrCompiler.ts
@@ -18769,7 +18927,7 @@ __export(exports_fastHmrCompiler, {
   invalidateFingerprintCache: () => invalidateFingerprintCache
 });
 import { existsSync as existsSync26, readFileSync as readFileSync20, statSync as statSync4 } from "fs";
-import { dirname as dirname19, extname as extname10, relative as relative13, resolve as resolve34 } from "path";
+import { dirname as dirname20, extname as extname10, relative as relative14, resolve as resolve35 } from "path";
 import ts7 from "typescript";
 var fail = (reason, detail, location) => ({
   ok: false,
@@ -18991,7 +19149,7 @@ var fail = (reason, detail, location) => ({
     if (!spec.startsWith(".") && !spec.startsWith("/")) {
       return true;
     }
-    const base = resolve34(componentDir, spec);
+    const base = resolve35(componentDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -19566,7 +19724,10 @@ var fail = (reason, detail, location) => ({
   try {
     source = readFileSync20(filePath, "utf-8");
   } catch {
-    childComponentInfoCache.set(cacheKey2, { info: null, mtimeMs: stat3.mtimeMs });
+    childComponentInfoCache.set(cacheKey2, {
+      info: null,
+      mtimeMs: stat3.mtimeMs
+    });
     return null;
   }
   const sf = ts7.createSourceFile(filePath, source, ts7.ScriptTarget.Latest, true);
@@ -19754,7 +19915,7 @@ var fail = (reason, detail, location) => ({
     });
     if (!names.includes(className))
       continue;
-    const nextDts = resolveDtsFromSpec(fromPath, dirname19(startDtsPath));
+    const nextDts = resolveDtsFromSpec(fromPath, dirname20(startDtsPath));
     if (!nextDts)
       continue;
     const found = findDtsContainingClass(nextDts, className, visited);
@@ -19764,7 +19925,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, dirname19(startDtsPath));
+    const nextDts = resolveDtsFromSpec(fromPath, dirname20(startDtsPath));
     if (!nextDts)
       continue;
     const found = findDtsContainingClass(nextDts, className, visited);
@@ -19774,7 +19935,7 @@ var fail = (reason, detail, location) => ({
   return null;
 }, resolveDtsFromSpec = (spec, fromDir) => {
   const stripped = spec.replace(/\.[mc]?js$/, "");
-  const base = resolve34(fromDir, stripped);
+  const base = resolve35(fromDir, stripped);
   const candidates = [
     `${base}.d.ts`,
     `${base}.d.mts`,
@@ -19798,7 +19959,7 @@ var fail = (reason, detail, location) => ({
   return null;
 }, resolveChildComponentInfo = (className, spec, componentDir, projectRoot) => {
   if (spec.startsWith(".") || spec.startsWith("/")) {
-    const base = resolve34(componentDir, spec);
+    const base = resolve35(componentDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -19968,13 +20129,13 @@ var fail = (reason, detail, location) => ({
     }
     if (!matches)
       continue;
-    const resolved = resolve34(componentDir, spec);
+    const resolved = resolve35(componentDir, spec);
     for (const ext of TS_EXTENSIONS) {
       const candidate = resolved + ext;
       if (existsSync26(candidate))
         return candidate;
     }
-    const indexCandidate = resolve34(resolved, "index.ts");
+    const indexCandidate = resolve35(resolved, "index.ts");
     if (existsSync26(indexCandidate))
       return indexCandidate;
   }
@@ -20161,7 +20322,7 @@ ${transpiled}
     }
 }${staticPatch}`;
 }, STYLE_PREPROCESSED_EXT, resolveAndReadStyleResource = (componentDir, url) => {
-  const abs = resolve34(componentDir, url);
+  const abs = resolve35(componentDir, url);
   if (!existsSync26(abs))
     return null;
   const ext = extname10(abs).toLowerCase();
@@ -20201,7 +20362,7 @@ ${block}
   const cached = projectOptionsCache.get(projectRoot);
   if (cached !== undefined)
     return cached;
-  const tsconfigPath = resolve34(projectRoot, "tsconfig.json");
+  const tsconfigPath = resolve35(projectRoot, "tsconfig.json");
   const opts = {};
   if (existsSync26(tsconfigPath)) {
     try {
@@ -20247,7 +20408,7 @@ ${block}
   }
   const kind = params.kind ?? "component";
   if (kind !== "component") {
-    const entityId = encodeURIComponent(`${relative13(projectRoot, componentFilePath).replace(/\\/g, "/")}@${className}`);
+    const entityId = encodeURIComponent(`${relative14(projectRoot, componentFilePath).replace(/\\/g, "/")}@${className}`);
     const currentEntityFingerprint = extractEntityFingerprint(classNode, className, sourceFile);
     const cachedEntityFingerprint = entityFingerprintCache.get(entityId);
     if (cachedEntityFingerprint !== undefined && !entityFingerprintsEqual(cachedEntityFingerprint, currentEntityFingerprint)) {
@@ -20265,7 +20426,7 @@ ${block}
       ok: true
     };
   }
-  if (inheritsDecoratedClass(classNode, sourceFile, dirname19(componentFilePath), projectRoot)) {
+  if (inheritsDecoratedClass(classNode, sourceFile, dirname20(componentFilePath), projectRoot)) {
     return fail("inherits-decorated-class");
   }
   const decorator = findComponentDecorator(classNode);
@@ -20277,14 +20438,14 @@ ${block}
   const projectDefaults = readProjectAngularCompilerOptions(projectRoot);
   const decoratorMeta = readDecoratorMeta(decoratorArgs, projectDefaults);
   const advancedMetadata = extractAdvancedMetadata(classNode, decoratorArgs, compiler);
-  const componentDir = dirname19(componentFilePath);
+  const componentDir = dirname20(componentFilePath);
   let templateText;
   let templatePath;
   if (decoratorMeta.template !== null) {
     templateText = decoratorMeta.template;
     templatePath = componentFilePath;
   } else if (decoratorMeta.templateUrl) {
-    const tplAbs = resolve34(componentDir, decoratorMeta.templateUrl);
+    const tplAbs = resolve35(componentDir, decoratorMeta.templateUrl);
     if (!existsSync26(tplAbs)) {
       return fail("template-resource-not-found", `Template file not found: ${tplAbs}`, { file: componentFilePath });
     }
@@ -20329,13 +20490,8 @@ ${block}
   if (!className_)
     return fail("class-not-found", "anonymous class");
   const wrappedClass = new compiler.WrappedNodeExpr(className_);
-  const {
-    inputs,
-    outputs,
-    hasDecoratorIO,
-    hasSignalIO
-  } = extractInputsAndOutputs(classNode, compiler);
-  const projectRelPath = relative13(projectRoot, componentFilePath).replace(/\\/g, "/");
+  const { inputs, outputs, hasDecoratorIO, hasSignalIO } = extractInputsAndOutputs(classNode, compiler);
+  const projectRelPath = relative14(projectRoot, componentFilePath).replace(/\\/g, "/");
   const fingerprintId = encodeURIComponent(`${projectRelPath}@${className}`);
   const currentFingerprint = extractFingerprint(classNode, className, decoratorMeta, inputs, outputs, sourceFile, componentDir);
   const cachedFingerprint = fingerprintCache.get(fingerprintId);
@@ -20538,11 +20694,7 @@ var init_fastHmrCompiler = __esm(() => {
   fingerprintCache = new Map;
   pendingModuleCache = new Map;
   entityFingerprintCache = new Map;
-  ENTITY_DECORATOR_NAMES = new Set([
-    "Pipe",
-    "Directive",
-    "Injectable"
-  ]);
+  ENTITY_DECORATOR_NAMES = new Set(["Pipe", "Directive", "Injectable"]);
   VIEW_ENCAPSULATION_VALUES = {
     Emulated: 0,
     ExperimentalIsolatedShadowDom: 4,
@@ -20589,7 +20741,7 @@ __export(exports_hmrCompiler, {
   getApplyMetadataModule: () => getApplyMetadataModule,
   encodeHmrComponentId: () => encodeHmrComponentId
 });
-import { dirname as dirname20, relative as relative14, resolve as resolve35 } from "path";
+import { dirname as dirname21, relative as relative15, resolve as resolve36 } from "path";
 import { performance as performance2 } from "perf_hooks";
 var getApplyMetadataModule = async (encodedId) => {
   const decoded = decodeURIComponent(encodedId);
@@ -20598,8 +20750,8 @@ var getApplyMetadataModule = async (encodedId) => {
     return null;
   const filePathRel = decoded.slice(0, at2);
   const className = decoded.slice(at2 + 1);
-  const componentFilePath = resolve35(process.cwd(), filePathRel);
-  const projectRelPath = relative14(process.cwd(), componentFilePath).replace(/\\/g, "/");
+  const componentFilePath = resolve36(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));
   const cached = takePendingModule2(cacheKey2);
@@ -20609,9 +20761,9 @@ var getApplyMetadataModule = async (encodedId) => {
   const { resolveOwningComponents: resolveOwningComponents2 } = await Promise.resolve().then(() => (init_resolveOwningComponents(), exports_resolveOwningComponents));
   const owners = resolveOwningComponents2({
     changedFilePath: componentFilePath,
-    userAngularRoot: dirname20(componentFilePath)
+    userAngularRoot: dirname21(componentFilePath)
   });
-  const owner = owners.find((o2) => o2.className === className);
+  const owner = owners.find((o3) => o3.className === className);
   const kind = owner?.kind ?? "component";
   const fastStart = performance2.now();
   const fast = await tryFastHmr({ className, componentFilePath, kind });
@@ -20621,7 +20773,7 @@ var getApplyMetadataModule = async (encodedId) => {
   }
   return null;
 }, encodeHmrComponentId = (absoluteFilePath, className) => {
-  const projectRel = relative14(process.cwd(), absoluteFilePath).replace(/\\/g, "/");
+  const projectRel = relative15(process.cwd(), absoluteFilePath).replace(/\\/g, "/");
   return `${projectRel}@${className}`;
 };
 var init_hmrCompiler = __esm(() => {
@@ -20760,11 +20912,11 @@ var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { resolve as resolve36 } from "path";
+import { resolve as resolve37 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve36(htmlFilePath);
+    const resolvedPath = resolve37(htmlFilePath);
     const file5 = Bun.file(resolvedPath);
     if (!await file5.exists()) {
       return null;
@@ -20790,11 +20942,11 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { resolve as resolve37 } from "path";
+import { resolve as resolve38 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve37(htmxFilePath);
+    const resolvedPath = resolve38(htmxFilePath);
     const file5 = Bun.file(resolvedPath);
     if (!await file5.exists()) {
       return null;
@@ -20817,7 +20969,7 @@ var init_simpleHTMXHMR = () => {};
 
 // src/dev/rebuildTrigger.ts
 import { existsSync as existsSync27 } from "fs";
-import { basename as basename12, dirname as dirname21, relative as relative15, resolve as resolve38, sep as sep4 } from "path";
+import { basename as basename12, dirname as dirname22, relative as relative16, resolve as resolve39, 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;
@@ -20909,7 +21061,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   state.fileHashes.delete(filePathInSet);
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, filePathInSet);
-    const deletedPathResolved = resolve38(filePathInSet);
+    const deletedPathResolved = resolve39(filePathInSet);
     affectedFiles.forEach((affectedFile) => {
       if (isValidDeletedAffectedFile(affectedFile, deletedPathResolved, processedFiles)) {
         validFiles.push(affectedFile);
@@ -20953,7 +21105,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (storedHash !== undefined && storedHash === fileHash) {
     return;
   }
-  const normalizedFilePath = resolve38(filePathInSet);
+  const normalizedFilePath = resolve39(filePathInSet);
   if (!processedFiles.has(normalizedFilePath)) {
     validFiles.push(normalizedFilePath);
     processedFiles.add(normalizedFilePath);
@@ -21057,8 +21209,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return;
   }
   if (framework === "unknown") {
-    invalidate(resolve38(filePath));
-    const relPath = relative15(process.cwd(), filePath);
+    invalidate(resolve39(filePath));
+    const relPath = relative16(process.cwd(), filePath);
     logHmrUpdate(relPath);
     return;
   }
@@ -21084,7 +21236,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const userEditedFiles = new Set;
     state.fileChangeQueue.forEach((filePaths) => {
       for (const filePath2 of filePaths) {
-        userEditedFiles.add(resolve38(filePath2));
+        userEditedFiles.add(resolve39(filePath2));
       }
     });
     state.lastUserEditedFiles = userEditedFiles;
@@ -21113,7 +21265,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   if (!graph)
     return componentFile;
-  const dependents = graph.dependents.get(resolve38(componentFile));
+  const dependents = graph.dependents.get(resolve39(componentFile));
   if (!dependents)
     return componentFile;
   for (const dep of dependents) {
@@ -21122,7 +21274,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   return componentFile;
 }, resolveAngularPageEntries = (state, angularFiles, angularPagesPath) => {
-  const pageEntries = angularFiles.filter((file5) => file5.endsWith(".ts") && resolve38(file5).startsWith(angularPagesPath));
+  const pageEntries = angularFiles.filter((file5) => file5.endsWith(".ts") && resolve39(file5).startsWith(angularPagesPath));
   if (pageEntries.length > 0 || !state.dependencyGraph) {
     return pageEntries;
   }
@@ -21131,7 +21283,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const lookupFile = resolveComponentLookupFile(componentFile, state.dependencyGraph);
     const affected = getAffectedFiles(state.dependencyGraph, lookupFile);
     affected.forEach((file5) => {
-      if (file5.endsWith(".ts") && resolve38(file5).startsWith(angularPagesPath)) {
+      if (file5.endsWith(".ts") && resolve39(file5).startsWith(angularPagesPath)) {
         resolvedPages.add(file5);
       }
     });
@@ -21403,16 +21555,16 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   };
   const fire = () => {
     ctx.debounceTimer = null;
-    const resolve39 = ctx.debouncedResolve;
+    const resolve40 = ctx.debouncedResolve;
     ctx.debouncedResolve = null;
     ctx.debouncedPromise = null;
     if (ctx.inFlight) {
       ctx.pending = true;
-      ctx.inFlight.finally(() => resolve39?.());
+      ctx.inFlight.finally(() => resolve40?.());
       return;
     }
     ctx.inFlight = drive();
-    ctx.inFlight.finally(() => resolve39?.());
+    ctx.inFlight.finally(() => resolve40?.());
   };
   return ({ immediate = false } = {}) => {
     if (!ctx.debouncedPromise) {
@@ -21439,9 +21591,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const diskRefreshPromise = (async () => {
     if (!angularDir || editedFiles.size === 0)
       return;
-    const angularDirAbs = resolve38(angularDir);
+    const angularDirAbs = resolve39(angularDir);
     const filesUnderAngular = Array.from(editedFiles).filter((file5) => {
-      const abs = resolve38(file5);
+      const abs = resolve39(file5);
       return abs === angularDirAbs || abs.startsWith(angularDirAbs + sep4);
     });
     if (filesUnderAngular.length === 0)
@@ -21463,7 +21615,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
         if (!ext)
           continue;
         if (ext === ".ts" || ext === ".tsx") {
-          tsFilesToRefresh.add(resolve38(file5));
+          tsFilesToRefresh.add(resolve39(file5));
           continue;
         }
         const owners = resolveOwningComponents2({
@@ -21471,7 +21623,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
           userAngularRoot: angularDirAbs
         });
         for (const owner of owners) {
-          tsFilesToRefresh.add(resolve38(owner.componentFilePath));
+          tsFilesToRefresh.add(resolve39(owner.componentFilePath));
         }
       }
       if (tsFilesToRefresh.size === 0)
@@ -21482,8 +21634,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
       try {
         const { invalidateModule: invalidateModule2 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
         for (const tsFile of tsFilesToRefresh) {
-          const rel = relative15(angularDirAbs, tsFile).replace(/\\/g, "/").replace(/\.[tj]sx?$/, ".js");
-          const compiledFile = resolve38(compiledRoot, rel);
+          const rel = relative16(angularDirAbs, tsFile).replace(/\\/g, "/").replace(/\.[tj]sx?$/, ".js");
+          const compiledFile = resolve39(compiledRoot, rel);
           invalidateModule2(compiledFile);
         }
       } catch {}
@@ -21512,7 +21664,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   serverPaths.forEach((serverPath, idx) => {
     const fileBase = basename12(serverPath, ".js");
     const ssrPath = ssrPaths[idx] ?? serverPath;
-    state.manifest[toPascal(fileBase)] = resolve38(ssrPath);
+    state.manifest[toPascal(fileBase)] = resolve39(ssrPath);
   });
   if (clientPaths.length > 0) {
     await bundleAngularClient(state, clientPaths, state.resolvedPaths.buildDir, angularDir);
@@ -21521,9 +21673,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const angularDir = config.angularDirectory ?? "";
   const angularFiles = filesToRebuild.filter((file5) => detectFramework(file5, state.resolvedPaths) === "angular");
   for (const file5 of angularFiles) {
-    state.fileHashes.set(resolve38(file5), computeFileHash(file5));
+    state.fileHashes.set(resolve39(file5), computeFileHash(file5));
   }
-  const angularPagesPath = resolve38(angularDir, "pages");
+  const angularPagesPath = resolve39(angularDir, "pages");
   const pageEntries = resolveAngularPageEntries(state, angularFiles, angularPagesPath);
   const tierStart = performance.now();
   const verdict = await decideAngularTier(state, angularDir);
@@ -21553,7 +21705,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
 }, getModuleUrl = async (pageFile) => {
   const { invalidateModule: invalidateModule2, warmCache: warmCache2, SRC_URL_PREFIX: SRC_URL_PREFIX2 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
   invalidateModule2(pageFile);
-  const rel = relative15(process.cwd(), pageFile).replace(/\\/g, "/");
+  const rel = relative16(process.cwd(), pageFile).replace(/\\/g, "/");
   const url = `${SRC_URL_PREFIX2}${rel}`;
   warmCache2(url);
   return url;
@@ -21562,11 +21714,11 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (isComponentFile2)
     return primaryFile;
   const { findNearestComponent: findNearestComponent2 } = await Promise.resolve().then(() => (init_transformCache(), exports_transformCache));
-  const nearest = findNearestComponent2(resolve38(primaryFile));
+  const nearest = findNearestComponent2(resolve39(primaryFile));
   return nearest ?? primaryFile;
 }, handleReactModuleServerPath = async (state, reactFiles, startTime, onRebuildComplete) => {
   for (const file5 of reactFiles) {
-    state.fileHashes.set(resolve38(file5), computeFileHash(file5));
+    state.fileHashes.set(resolve39(file5), computeFileHash(file5));
   }
   markSsrCacheDirty("react");
   const primaryFile = reactFiles.find((file5) => !file5.replace(/\\/g, "/").includes("/pages/")) ?? reactFiles[0];
@@ -21585,7 +21737,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const pageModuleUrl = await getReactModuleUrl(broadcastTarget);
   if (pageModuleUrl) {
     const serverDuration = Date.now() - startTime;
-    state.lastHmrPath = relative15(process.cwd(), primaryFile).replace(/\\/g, "/");
+    state.lastHmrPath = relative16(process.cwd(), primaryFile).replace(/\\/g, "/");
     state.lastHmrFramework = "react";
     broadcastToClients(state, {
       data: {
@@ -21648,7 +21800,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, handleSvelteModuleServerPath = async (state, svelteFiles, startTime, onRebuildComplete) => {
   for (const file5 of svelteFiles) {
-    state.fileHashes.set(resolve38(file5), computeFileHash(file5));
+    state.fileHashes.set(resolve39(file5), computeFileHash(file5));
   }
   markSsrCacheDirty("svelte");
   const serverDuration = Date.now() - startTime;
@@ -21673,8 +21825,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const serverEntries = [...svelteServerPaths];
     const clientEntries = [...svelteIndexPaths, ...svelteClientPaths];
     const { getFrameworkGeneratedDir: getFrameworkGeneratedDir2 } = await Promise.resolve().then(() => (init_generatedDir(), exports_generatedDir));
-    const serverRoot = resolve38(getFrameworkGeneratedDir2("svelte"), "server");
-    const serverOutDir = resolve38(buildDir, basename12(svelteDir));
+    const serverRoot = resolve39(getFrameworkGeneratedDir2("svelte"), "server");
+    const serverOutDir = resolve39(buildDir, basename12(svelteDir));
     const [serverResult, clientResult] = await Promise.all([
       serverEntries.length > 0 ? bunBuild9({
         entrypoints: serverEntries,
@@ -21771,7 +21923,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, handleVueModuleServerPath = async (state, vueFiles, nonVueFiles, startTime, onRebuildComplete) => {
   for (const file5 of [...vueFiles, ...nonVueFiles]) {
-    state.fileHashes.set(resolve38(file5), computeFileHash(file5));
+    state.fileHashes.set(resolve39(file5), computeFileHash(file5));
   }
   markSsrCacheDirty("vue");
   await invalidateNonVueModules(nonVueFiles);
@@ -21799,7 +21951,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) => resolve38(emberPagesPath, entry.name));
+    return entries.filter((entry) => entry.isFile() && EMBER_PAGE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))).map((entry) => resolve39(emberPagesPath, entry.name));
   } catch {
     return [];
   }
@@ -21811,10 +21963,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return state.manifest;
   }
   for (const file5 of emberFiles) {
-    state.fileHashes.set(resolve38(file5), computeFileHash(file5));
+    state.fileHashes.set(resolve39(file5), computeFileHash(file5));
   }
-  const emberPagesPath = resolve38(emberDir, "pages");
-  const directPageEntries = emberFiles.filter((file5) => resolve38(file5).startsWith(emberPagesPath));
+  const emberPagesPath = resolve39(emberDir, "pages");
+  const directPageEntries = emberFiles.filter((file5) => resolve39(file5).startsWith(emberPagesPath));
   const allPageEntries = directPageEntries.length > 0 ? directPageEntries : await collectAllEmberPages(emberPagesPath);
   if (allPageEntries.length === 0) {
     onRebuildComplete({ hmrState: state, manifest: state.manifest });
@@ -21824,14 +21976,14 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const { serverPaths } = await compileEmber2(allPageEntries, emberDir, process.cwd(), true);
   for (const serverPath of serverPaths) {
     const fileBase = basename12(serverPath, ".js");
-    state.manifest[toPascal(fileBase)] = resolve38(serverPath);
+    state.manifest[toPascal(fileBase)] = resolve39(serverPath);
   }
   const { invalidateEmberSsrCache: invalidateEmberSsrCache2 } = await Promise.resolve().then(() => (init_ember(), exports_ember));
   invalidateEmberSsrCache2();
   const duration = Date.now() - startTime;
   const [primary] = emberFiles;
   if (primary) {
-    state.lastHmrPath = relative15(process.cwd(), primary).replace(/\\/g, "/");
+    state.lastHmrPath = relative16(process.cwd(), primary).replace(/\\/g, "/");
     state.lastHmrFramework = "ember";
     logHmrUpdate(primary, "ember", duration);
   }
@@ -21916,8 +22068,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!buildReference?.source) {
     return;
   }
-  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve38(dirname21(buildInfo.resolvedRegistryPath), buildReference.source);
-  islandFiles.add(resolve38(sourcePath));
+  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve39(dirname22(buildInfo.resolvedRegistryPath), buildReference.source);
+  islandFiles.add(resolve39(sourcePath));
 }, resolveIslandSourceFiles = async (config) => {
   const registryPath = config.islands?.registry;
   if (!registryPath) {
@@ -21925,7 +22077,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   const buildInfo = await loadIslandRegistryBuildInfo(registryPath);
   const islandFiles = new Set([
-    resolve38(buildInfo.resolvedRegistryPath)
+    resolve39(buildInfo.resolvedRegistryPath)
   ]);
   for (const definition of buildInfo.definitions) {
     resolveIslandDefinitionSource(definition, buildInfo, islandFiles);
@@ -21936,7 +22088,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (islandFiles.size === 0) {
     return false;
   }
-  return filesToRebuild.some((file5) => islandFiles.has(resolve38(file5)));
+  return filesToRebuild.some((file5) => islandFiles.has(resolve39(file5)));
 }, handleIslandSourceReload = async (state, config, filesToRebuild, manifest) => {
   const shouldReload = await didStaticPagesNeedIslandRefresh(config, filesToRebuild);
   if (!shouldReload) {
@@ -21971,10 +22123,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 resolve38(state.resolvedPaths.buildDir, "pages");
+    return resolve39(state.resolvedPaths.buildDir, "pages");
   }
   const dirName = framework === "html" ? basename12(config.htmlDirectory ?? "html") : basename12(config.htmxDirectory ?? "htmx");
-  return resolve38(state.resolvedPaths.buildDir, dirName, "pages");
+  return resolve39(state.resolvedPaths.buildDir, dirName, "pages");
 }, processHtmlPageUpdate = async (state, pageFile, builtHtmlPagePath, manifest, duration) => {
   try {
     const { handleHTMLUpdate: handleHTMLUpdate2 } = await Promise.resolve().then(() => (init_simpleHTMLHMR(), exports_simpleHTMLHMR));
@@ -22013,7 +22165,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmlPages, "*.html") : htmlPageFiles;
   await runSequentially(pageFilesToUpdate, async (pageFile) => {
     const htmlPageName = basename12(pageFile);
-    const builtHtmlPagePath = resolve38(outputHtmlPages, htmlPageName);
+    const builtHtmlPagePath = resolve39(outputHtmlPages, htmlPageName);
     await processHtmlPageUpdate(state, pageFile, builtHtmlPagePath, manifest, duration);
   });
 }, handleVueCssOnlyUpdate = (state, vueCssFiles, manifest, duration) => {
@@ -22074,11 +22226,11 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const baseName = fileName.replace(/\.vue$/, "");
   const pascalName = toPascal(baseName);
   const vueRoot = config.vueDirectory;
-  const hmrId = vueRoot ? relative15(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
+  const hmrId = vueRoot ? relative16(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
   const cssKey = `${pascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
   const { vueHmrMetadata: vueHmrMetadata2 } = await Promise.resolve().then(() => (init_compileVue(), exports_compileVue));
-  const hmrMeta = vueHmrMetadata2.get(resolve38(vuePagePath));
+  const hmrMeta = vueHmrMetadata2.get(resolve39(vuePagePath));
   const changeType = hmrMeta?.changeType ?? "full";
   if (changeType === "style-only") {
     broadcastVueStyleOnly(state, vuePagePath, baseName, cssUrl, hmrId, manifest, duration);
@@ -22263,7 +22415,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmxPages, "*.html") : htmxPageFiles;
   await runSequentially(pageFilesToUpdate, async (htmxPageFile) => {
     const htmxPageName = basename12(htmxPageFile);
-    const builtHtmxPagePath = resolve38(outputHtmxPages, htmxPageName);
+    const builtHtmxPagePath = resolve39(outputHtmxPages, htmxPageName);
     await processHtmxPageUpdate(state, htmxPageFile, builtHtmxPagePath, manifest, duration);
   });
 }, collectUpdatedModulePaths = (allModuleUpdates) => {
@@ -22372,7 +22524,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 = resolve38(outputDir, basename12(sourceFile));
+  const destPath = resolve39(outputDir, basename12(sourceFile));
   const hmrScript = extractHmrScript(destPath, readFs);
   const source = await Bun.file(sourceFile).text();
   await Bun.write(destPath, source);
@@ -22662,7 +22814,7 @@ __export(exports_buildDepVendor, {
   buildDepVendor: () => buildDepVendor
 });
 import { mkdirSync as mkdirSync13 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 import { rm as rm10 } from "fs/promises";
 var {build: bunBuild9, Glob: Glob9 } = globalThis.Bun;
 var toSafeFileName6 = (specifier) => {
@@ -22675,12 +22827,12 @@ var toSafeFileName6 = (specifier) => {
   } catch {
     return false;
   }
-}, isBareSpecifier2 = (spec) => !spec.startsWith(".") && !spec.startsWith("/") && !spec.startsWith("@src/"), isAbsolutePackageSpecifier = (spec) => spec === "@absolutejs/absolute" || spec.startsWith("@absolutejs/absolute/"), FRAMEWORK_SPECIFIERS, FRAMEWORK_NAMESPACE_PREFIXES, isFrameworkSpecifier = (spec) => FRAMEWORK_SPECIFIERS.has(spec) || FRAMEWORK_NAMESPACE_PREFIXES.some((prefix) => spec.startsWith(prefix)), FRAMEWORK_EXTERNALS, isSkippedFile = (file5) => file5.includes("node_modules") || file5.includes("/build/") || file5.includes("/dist/") || file5.includes("/indexes/"), isDepSpecifier = (path) => isBareSpecifier2(path) && !isFrameworkSpecifier(path) && !isAbsolutePackageSpecifier(path), isFrameworkRootCandidate = (path) => isBareSpecifier2(path) && isFrameworkSpecifier(path) && !isAbsolutePackageSpecifier(path), readFileSpecifiers = async (file5, transpiler5) => {
+}, isBareSpecifier2 = (spec) => !spec.startsWith(".") && !spec.startsWith("/") && !spec.startsWith("@src/"), isAbsolutePackageSpecifier = (spec) => spec === "@absolutejs/absolute" || spec.startsWith("@absolutejs/absolute/"), FRAMEWORK_SPECIFIERS, FRAMEWORK_NAMESPACE_PREFIXES, isFrameworkSpecifier = (spec) => FRAMEWORK_SPECIFIERS.has(spec) || FRAMEWORK_NAMESPACE_PREFIXES.some((prefix) => spec.startsWith(prefix)), FRAMEWORK_EXTERNALS, isSkippedFile = (file5) => file5.includes("node_modules") || file5.includes("/build/") || file5.includes("/dist/") || file5.includes("/indexes/"), isDepSpecifier = (path) => isBareSpecifier2(path) && !isFrameworkSpecifier(path) && !isAbsolutePackageSpecifier(path), isFrameworkRootCandidate = (path) => isBareSpecifier2(path) && isFrameworkSpecifier(path) && !isAbsolutePackageSpecifier(path), readFileSpecifiers = async (file5, transpiler6) => {
   const dep = [];
   const framework = [];
   try {
     const content = await Bun.file(file5).text();
-    for (const imp of transpiler5.scanImports(content)) {
+    for (const imp of transpiler6.scanImports(content)) {
       if (isDepSpecifier(imp.path))
         dep.push(imp.path);
       else if (isFrameworkRootCandidate(imp.path))
@@ -22697,9 +22849,9 @@ var toSafeFileName6 = (specifier) => {
   } catch {
     return empty;
   }
-}, collectDirSpecifiers = async (dir, transpiler5, dep, framework) => {
+}, collectDirSpecifiers = async (dir, transpiler6, dep, framework) => {
   const files = await scanDirFiles(dir);
-  const results = await Promise.all(files.map((file5) => readFileSpecifiers(file5, transpiler5)));
+  const results = await Promise.all(files.map((file5) => readFileSpecifiers(file5, transpiler6)));
   for (const result of results) {
     for (const spec of result.dep)
       dep.add(spec);
@@ -22709,15 +22861,15 @@ var toSafeFileName6 = (specifier) => {
 }, scanBareImports = async (directories) => {
   const dep = new Set;
   const framework = new Set;
-  const transpiler5 = new Bun.Transpiler({ loader: "tsx" });
-  await Promise.all(directories.map((dir) => collectDirSpecifiers(dir, transpiler5, dep, framework)));
+  const transpiler6 = new Bun.Transpiler({ loader: "tsx" });
+  await Promise.all(directories.map((dir) => collectDirSpecifiers(dir, transpiler6, dep, framework)));
   return {
     dep: Array.from(dep).filter(isResolvable4),
     framework: Array.from(framework).filter(isResolvable4)
   };
 }, collectTransitiveImports = async (specs, alreadyVendored, alreadyScanned) => {
   const { readFileSync: readFileSync21 } = await import("fs");
-  const transpiler5 = new Bun.Transpiler({ loader: "js" });
+  const transpiler6 = new Bun.Transpiler({ loader: "js" });
   const newSpecs = new Set;
   for (const spec of specs) {
     if (alreadyScanned.has(spec))
@@ -22737,7 +22889,7 @@ var toSafeFileName6 = (specifier) => {
     }
     let imports;
     try {
-      imports = transpiler5.scanImports(content);
+      imports = transpiler6.scanImports(content);
     } catch {
       continue;
     }
@@ -22773,7 +22925,7 @@ var toSafeFileName6 = (specifier) => {
 }), buildDepVendorPass = async (specifiers, vendorDir, tmpDir) => {
   const entries = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName6(specifier);
-    const entryPath = join30(tmpDir, `${safeName}.ts`);
+    const entryPath = join31(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return { entryPath, specifier };
   }));
@@ -22834,9 +22986,9 @@ var toSafeFileName6 = (specifier) => {
   const { dep: initialSpecs, framework: frameworkRoots } = await scanBareImports(directories);
   if (initialSpecs.length === 0 && frameworkRoots.length === 0)
     return {};
-  const vendorDir = join30(buildDir, "vendor");
+  const vendorDir = join31(buildDir, "vendor");
   mkdirSync13(vendorDir, { recursive: true });
-  const tmpDir = join30(buildDir, "_dep_vendor_tmp");
+  const tmpDir = join31(buildDir, "_dep_vendor_tmp");
   mkdirSync13(tmpDir, { recursive: true });
   const allSpecs = new Set(initialSpecs);
   const alreadyScanned = new Set;
@@ -22919,7 +23071,7 @@ __export(exports_devBuild, {
 });
 import { readdir as readdir5 } from "fs/promises";
 import { statSync as statSync5 } from "fs";
-import { resolve as resolve39 } from "path";
+import { resolve as resolve40 } from "path";
 var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const configuredDirs = [
     config.reactDirectory,
@@ -22942,7 +23094,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return Object.keys(config).length > 0 ? config : null;
 }, reloadConfig = async () => {
   try {
-    const configPath2 = resolve39(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+    const configPath2 = resolve40(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
     const source = await Bun.file(configPath2).text();
     return parseDirectoryConfig(source);
   } catch {
@@ -23027,7 +23179,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     state.fileChangeQueue.clear();
   }
 }, handleCachedReload = async () => {
-  const serverMtime = statSync5(resolve39(Bun.main)).mtimeMs;
+  const serverMtime = statSync5(resolve40(Bun.main)).mtimeMs;
   const lastMtime = globalThis.__hmrServerMtime;
   globalThis.__hmrServerMtime = serverMtime;
   const cached = globalThis.__hmrDevResult;
@@ -23064,8 +23216,8 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return true;
 }, resolveAbsoluteVersion2 = async () => {
   const candidates = [
-    resolve39(import.meta.dir, "..", "..", "package.json"),
-    resolve39(import.meta.dir, "..", "package.json")
+    resolve40(import.meta.dir, "..", "..", "package.json"),
+    resolve40(import.meta.dir, "..", "package.json")
   ];
   const [candidate, ...remaining] = candidates;
   if (!candidate) {
@@ -23091,7 +23243,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(resolve39(vendorDir, entry)).bytes();
+    const bytes = await Bun.file(resolve40(vendorDir, entry)).bytes();
     assetStore.set(webPath, bytes);
   }));
 }, devBuild = async (config) => {
@@ -23159,11 +23311,11 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   cleanStaleAssets(state.assetStore, manifest, state.resolvedPaths.buildDir);
   recordStep("populate asset store", stepStartedAt);
   stepStartedAt = performance.now();
-  const reactVendorDir = resolve39(state.resolvedPaths.buildDir, "react", "vendor");
-  const angularVendorDir = resolve39(state.resolvedPaths.buildDir, "angular", "vendor");
-  const svelteVendorDir = resolve39(state.resolvedPaths.buildDir, "svelte", "vendor");
-  const vueVendorDir = resolve39(state.resolvedPaths.buildDir, "vue", "vendor");
-  const depVendorDir = resolve39(state.resolvedPaths.buildDir, "vendor");
+  const reactVendorDir = resolve40(state.resolvedPaths.buildDir, "react", "vendor");
+  const angularVendorDir = resolve40(state.resolvedPaths.buildDir, "angular", "vendor");
+  const svelteVendorDir = resolve40(state.resolvedPaths.buildDir, "svelte", "vendor");
+  const vueVendorDir = resolve40(state.resolvedPaths.buildDir, "vue", "vendor");
+  const depVendorDir = resolve40(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),
@@ -23241,7 +23393,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     manifest
   };
   globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync5(resolve39(Bun.main)).mtimeMs;
+  globalThis.__hmrServerMtime = statSync5(resolve40(Bun.main)).mtimeMs;
   return result;
 };
 var init_devBuild = __esm(() => {
@@ -23386,8 +23538,8 @@ var STORE_KEY = "__elysiaStore", getGlobalValue = (key) => Reflect.get(globalThi
     return null;
   if (!pathname.startsWith("/"))
     return null;
-  const { resolve: resolve40, normalize } = await import("path");
-  const candidate = resolve40(buildDir, pathname.slice(1));
+  const { resolve: resolve41, normalize } = await import("path");
+  const candidate = resolve41(buildDir, pathname.slice(1));
   const normalizedBuild = normalize(buildDir);
   if (!candidate.startsWith(normalizedBuild))
     return null;
@@ -23471,12 +23623,12 @@ __export(exports_devtoolsJson, {
   devtoolsJson: () => devtoolsJson
 });
 import { existsSync as existsSync28, mkdirSync as mkdirSync14, readFileSync as readFileSync21, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname22, join as join31, resolve as resolve40 } from "path";
+import { dirname as dirname23, join as join32, resolve as resolve41 } from "path";
 import { Elysia as Elysia3 } from "elysia";
 var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_KEY = "__absoluteDevtoolsWorkspaceUuid", getGlobalUuid = () => Reflect.get(globalThis, UUID_CACHE_KEY), setGlobalUuid = (uuid) => {
   Reflect.set(globalThis, UUID_CACHE_KEY, uuid);
   return uuid;
-}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve40(uuidCachePath ?? join31(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
+}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve41(uuidCachePath ?? join32(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
   if (!existsSync28(cachePath))
     return null;
   try {
@@ -23498,11 +23650,11 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   if (cachedUuid)
     return setGlobalUuid(cachedUuid);
   const uuid = crypto.randomUUID();
-  mkdirSync14(dirname22(cachePath), { recursive: true });
+  mkdirSync14(dirname23(cachePath), { recursive: true });
   writeFileSync9(cachePath, uuid, "utf-8");
   return setGlobalUuid(uuid);
 }, devtoolsJson = (buildDir, options = {}) => {
-  const rootPath = resolve40(options.projectRoot ?? process.cwd());
+  const rootPath = resolve41(options.projectRoot ?? process.cwd());
   const root = options.normalizeForWindowsContainer === false ? rootPath : normalizeDevtoolsWorkspaceRoot(rootPath);
   const uuid = getOrCreateUuid(buildDir, options);
   return new Elysia3({ name: "absolute-devtools-json" }).get(ENDPOINT, () => ({
@@ -23515,11 +23667,11 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   if (process.env.WSL_DISTRO_NAME) {
     const distro = process.env.WSL_DISTRO_NAME;
     const withoutLeadingSlash = root.replace(/^\//, "");
-    return join31("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
+    return join32("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
   }
   if (process.env.DOCKER_DESKTOP && !root.startsWith("\\\\")) {
     const withoutLeadingSlash = root.replace(/^\//, "");
-    return join31("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
+    return join32("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
   }
   return root;
 };
@@ -23531,7 +23683,7 @@ __export(exports_imageOptimizer, {
   imageOptimizer: () => imageOptimizer
 });
 import { existsSync as existsSync29 } from "fs";
-import { resolve as resolve41 } from "path";
+import { resolve as resolve42 } from "path";
 import { Elysia as Elysia4 } from "elysia";
 var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avifInProgress, safeResolve = (path, baseDir) => {
   try {
@@ -23544,7 +23696,7 @@ var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avi
   }
 }, resolveLocalImage = (url, buildDir) => {
   const cleanPath = url.startsWith("/") ? url.slice(1) : url;
-  return safeResolve(cleanPath, buildDir) ?? safeResolve(cleanPath, resolve41(process.cwd()));
+  return safeResolve(cleanPath, buildDir) ?? safeResolve(cleanPath, resolve42(process.cwd()));
 }, parseQueryParams = (query, allowedSizes, defaultQuality) => {
   const url = typeof query["url"] === "string" ? query["url"] : undefined;
   const wParam = typeof query["w"] === "string" ? query["w"] : undefined;
@@ -23836,7 +23988,7 @@ __export(exports_prerender, {
   PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER
 });
 import { mkdirSync as mkdirSync15, readFileSync as readFileSync22 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_TIMEOUT_MS = 30000, PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass", routeToFilename = (route) => route === "/" ? "index.html" : `${route.slice(1).replace(/\//g, "-")}.html`, writeTimestamp = async (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   await Bun.write(metaPath, String(Date.now()));
@@ -23902,7 +24054,7 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
       return false;
     const html = await res.text();
     const fileName = routeToFilename(route);
-    const filePath = join32(prerenderDir, fileName);
+    const filePath = join33(prerenderDir, fileName);
     await Bun.write(filePath, html);
     await writeTimestamp(filePath);
     return true;
@@ -23928,13 +24080,13 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
   }
   const html = await res.text();
   const fileName = routeToFilename(route);
-  const filePath = join32(prerenderDir, fileName);
+  const filePath = join33(prerenderDir, fileName);
   await Bun.write(filePath, html);
   await writeTimestamp(filePath);
   result.routes.set(route, filePath);
   log2?.(`  Pre-rendered ${route} \u2192 ${fileName} (${html.length} bytes)`);
 }, prerender = async (port, outDir, staticConfig, log2) => {
-  const prerenderDir = join32(outDir, "_prerendered");
+  const prerenderDir = join33(outDir, "_prerendered");
   mkdirSync15(prerenderDir, { recursive: true });
   const baseUrl = `http://localhost:${port}`;
   let routes;
@@ -24533,11 +24685,11 @@ var handleHTMXPageRequest = async (pagePath) => {
 };
 // src/core/prepare.ts
 import { existsSync as existsSync30, readdirSync as readdirSync3, readFileSync as readFileSync23 } from "fs";
-import { basename as basename13, join as join33, relative as relative16, resolve as resolve42 } from "path";
+import { basename as basename13, join as join34, relative as relative17, resolve as resolve43 } from "path";
 import { Elysia as Elysia5 } from "elysia";
 
 // src/utils/loadConfig.ts
-import { resolve as resolve7 } from "path";
+import { resolve as resolve8 } from "path";
 var RESERVED_TOP_LEVEL_KEYS = new Set([
   "assetsDirectory",
   "astroDirectory",
@@ -24630,7 +24782,7 @@ var loadConfig = async (configPath) => {
   return config;
 };
 var loadRawConfig = async (configPath) => {
-  const resolved = resolve7(configPath ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+  const resolved = resolve8(configPath ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
   const mod = await import(resolved);
   const config = mod.default ?? mod.config;
   if (!config) {
@@ -24645,7 +24797,7 @@ Expected: export default defineConfig({ ... })`);
 
 // src/core/loadIslandRegistry.ts
 init_islandEntries();
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 var isRecord6 = (value) => typeof value === "object" && value !== null;
 var resolveRegistryExport2 = (mod) => {
   if (isRecord6(mod.islandRegistry))
@@ -24657,7 +24809,7 @@ var resolveRegistryExport2 = (mod) => {
 var isRegistryModuleExport = (value) => isRecord6(value);
 var isIslandRegistryInput = (value) => isRecord6(value);
 var loadIslandRegistry = async (registryPath) => {
-  const resolvedRegistryPath = resolve8(registryPath);
+  const resolvedRegistryPath = resolve9(registryPath);
   const buildInfo = await loadIslandRegistryBuildInfo(resolvedRegistryPath);
   if (buildInfo.definitions.length > 0) {
     return buildInfo.registry;
@@ -24723,16 +24875,22 @@ var setConventions = (map) => {
 };
 var isDev = () => true;
 var buildErrorProps = (error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  const stack = isDev() && error instanceof Error ? error.stack : undefined;
-  return { error: { message, stack } };
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      ...isDev() && error.stack ? { stack: error.stack } : {}
+    };
+  }
+  return { name: "Error", message: String(error) };
 };
 var renderReactError = async (conventionPath, errorProps) => {
   const { createElement } = await import("react");
   const { renderToReadableStream } = await import("react-dom/server");
   const mod = await import(conventionPath);
-  const [firstKey] = Object.keys(mod);
-  const ErrorComponent = mod.default ?? (firstKey ? mod[firstKey] : undefined);
+  const ErrorComponent = mod.default;
+  if (typeof ErrorComponent !== "function")
+    return null;
   const element = createElement(ErrorComponent, errorProps);
   const stream = await renderToReadableStream(element);
   return new Response(stream, {
@@ -24744,6 +24902,8 @@ var renderSvelteError = async (conventionPath, errorProps) => {
   const { render } = await import("svelte/server");
   const mod = await import(conventionPath);
   const ErrorComponent = mod.default;
+  if (!ErrorComponent)
+    return null;
   const { head, body } = render(ErrorComponent, {
     props: errorProps
   });
@@ -24766,6 +24926,8 @@ var renderVueError = async (conventionPath, errorProps) => {
   const { renderToString } = await import("vue/server-renderer");
   const mod = await import(conventionPath);
   const ErrorComponent = mod.default;
+  if (!ErrorComponent)
+    return null;
   const app = createSSRApp({
     render: () => h2(ErrorComponent, errorProps)
   });
@@ -24779,10 +24941,20 @@ var renderVueError = async (conventionPath, errorProps) => {
 };
 var renderAngularError = async (conventionPath, errorProps) => {
   const mod = await import(conventionPath);
-  const renderError = mod.default ?? mod.renderError;
-  if (typeof renderError !== "function")
+  const renderFn = mod.default;
+  if (typeof renderFn !== "function")
     return null;
-  const html = renderError(errorProps);
+  const html = renderFn(errorProps);
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" },
+    status: 500
+  });
+};
+var escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+var replaceErrorTokens = (template, errorProps) => template.replace(/\{\{\s*name\s*\}\}/g, escapeHtml(errorProps.name)).replace(/\{\{\s*message\s*\}\}/g, escapeHtml(errorProps.message)).replace(/\{\{\s*stack\s*\}\}/g, errorProps.stack ? escapeHtml(errorProps.stack) : "");
+var renderHtmlError = async (conventionPath, errorProps) => {
+  const template = await Bun.file(conventionPath).text();
+  const html = replaceErrorTokens(template, errorProps);
   return new Response(html, {
     headers: { "Content-Type": "text/html" },
     status: 500
@@ -24801,11 +24973,12 @@ var renderEmberNotFound = async () => null;
 var ERROR_RENDERERS = {
   angular: renderAngularError,
   ember: renderEmberError,
+  html: renderHtmlError,
   react: renderReactError,
   svelte: renderSvelteError,
   vue: renderVueError
 };
-var renderConventionError = async (framework, pageName, error) => {
+var tryFrameworkErrorConvention = async (framework, pageName, errorProps, error) => {
   let conventionPath = resolveErrorConventionPath(framework, pageName);
   if (!conventionPath && error instanceof Error && error.stack) {
     for (const match of error.stack.matchAll(/^\s*at\s+([A-Za-z_$][\w$]*)/gm)) {
@@ -24819,7 +24992,6 @@ var renderConventionError = async (framework, pageName, error) => {
   }
   if (!conventionPath)
     return null;
-  const errorProps = buildErrorProps(error);
   const renderer = ERROR_RENDERERS[framework];
   if (!renderer)
     return null;
@@ -24830,12 +25002,25 @@ var renderConventionError = async (framework, pageName, error) => {
   }
   return null;
 };
+var renderConventionError = async (framework, pageName, error) => {
+  const errorProps = buildErrorProps(error);
+  const frameworkResponse = await tryFrameworkErrorConvention(framework, pageName, errorProps, error);
+  if (frameworkResponse)
+    return frameworkResponse;
+  if (framework !== "html") {
+    const htmlResponse = await tryFrameworkErrorConvention("html", pageName, errorProps, error);
+    if (htmlResponse)
+      return htmlResponse;
+  }
+  return null;
+};
 var renderReactNotFound = async (conventionPath) => {
   const { createElement } = await import("react");
   const { renderToReadableStream } = await import("react-dom/server");
   const mod = await import(conventionPath);
-  const [nfKey] = Object.keys(mod);
-  const NotFoundComponent = mod.default ?? (nfKey ? mod[nfKey] : undefined);
+  const NotFoundComponent = mod.default;
+  if (typeof NotFoundComponent !== "function")
+    return null;
   const element = createElement(NotFoundComponent);
   const stream = await renderToReadableStream(element);
   return new Response(stream, {
@@ -24847,6 +25032,8 @@ var renderSvelteNotFound = async (conventionPath) => {
   const { render } = await import("svelte/server");
   const mod = await import(conventionPath);
   const NotFoundComponent = mod.default;
+  if (!NotFoundComponent)
+    return null;
   const { head, body } = render(NotFoundComponent);
   const html = `<!DOCTYPE html><html><head>${head}</head><body>${body}</body></html>`;
   return new Response(html, {
@@ -24859,6 +25046,8 @@ var renderVueNotFound = async (conventionPath) => {
   const { renderToString } = await import("vue/server-renderer");
   const mod = await import(conventionPath);
   const NotFoundComponent = mod.default;
+  if (!NotFoundComponent)
+    return null;
   const app = createSSRApp({
     render: () => h2(NotFoundComponent)
   });
@@ -24872,10 +25061,17 @@ var renderVueNotFound = async (conventionPath) => {
 };
 var renderAngularNotFound = async (conventionPath) => {
   const mod = await import(conventionPath);
-  const renderNotFound = mod.default ?? mod.renderNotFound;
-  if (typeof renderNotFound !== "function")
+  const renderFn = mod.default;
+  if (typeof renderFn !== "function")
     return null;
-  const html = renderNotFound();
+  const html = renderFn();
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" },
+    status: 404
+  });
+};
+var renderHtmlNotFound = async (conventionPath) => {
+  const html = await Bun.file(conventionPath).text();
   return new Response(html, {
     headers: { "Content-Type": "text/html" },
     status: 404
@@ -24884,6 +25080,7 @@ var renderAngularNotFound = async (conventionPath) => {
 var NOT_FOUND_RENDERERS = {
   angular: renderAngularNotFound,
   ember: renderEmberNotFound,
+  html: renderHtmlNotFound,
   react: renderReactNotFound,
   svelte: renderSvelteNotFound,
   vue: renderVueNotFound
@@ -24906,7 +25103,8 @@ var NOT_FOUND_PRIORITY = [
   "react",
   "svelte",
   "vue",
-  "angular"
+  "angular",
+  "html"
 ];
 var renderFirstNotFound = async () => {
   const renderNext = async (frameworks2) => {
@@ -24956,7 +25154,7 @@ var collectPrewarmFiles = async (prewarmDirs) => {
   for (const { dir, pattern } of prewarmDirs) {
     const glob = new Glob10(pattern);
     const matches = [
-      ...glob.scanSync({ absolute: true, cwd: resolve42(dir) })
+      ...glob.scanSync({ absolute: true, cwd: resolve43(dir) })
     ];
     files.push(...matches);
   }
@@ -24967,7 +25165,7 @@ var warmPrewarmDirs = async (prewarmDirs, warmCache2, SRC_URL_PREFIX2) => {
   for (const file5 of files) {
     if (file5.includes("/node_modules/"))
       continue;
-    const rel = relative16(process.cwd(), file5).replace(/\\/g, "/");
+    const rel = relative17(process.cwd(), file5).replace(/\\/g, "/");
     warmCache2(`${SRC_URL_PREFIX2}${rel}`);
   }
 };
@@ -24992,10 +25190,10 @@ var patchManifestIndexes = (manifest, devIndexDir, SRC_URL_PREFIX2) => {
     const fileName = resolveDevIndexFileName(manifest[key], baseName);
     if (!fileName)
       continue;
-    const srcPath = resolve42(devIndexDir, fileName);
+    const srcPath = resolve43(devIndexDir, fileName);
     if (!existsSync30(srcPath))
       continue;
-    const rel = relative16(process.cwd(), srcPath).replace(/\\/g, "/");
+    const rel = relative17(process.cwd(), srcPath).replace(/\\/g, "/");
     manifest[key] = `${SRC_URL_PREFIX2}${rel}`;
   }
 };
@@ -25065,7 +25263,7 @@ var prepareDev = async (config, buildDir) => {
   stepStartedAt = performance.now();
   const hmrPlugin = hmr2(result.hmrState, result.manifest, moduleHandler);
   const { devtoolsJson: devtoolsJson2 } = await Promise.resolve().then(() => (init_devtoolsJson(), exports_devtoolsJson));
-  const devIndexDir = resolve42(buildDir, "_src_indexes");
+  const devIndexDir = resolve43(buildDir, "_src_indexes");
   patchManifestIndexes(result.manifest, devIndexDir, SRC_URL_PREFIX2);
   recordStep("configure dev plugins", stepStartedAt);
   stepStartedAt = performance.now();
@@ -25114,7 +25312,7 @@ var loadPrerenderMap = (prerenderDir) => {
       continue;
     const name = basename13(entry, ".html");
     const route = name === "index" ? "/" : `/${name}`;
-    map.set(route, join33(prerenderDir, entry));
+    map.set(route, join34(prerenderDir, entry));
   }
   return map;
 };
@@ -25146,7 +25344,7 @@ var prepare = async (configOrPath) => {
   recordStep("load config", stepStartedAt);
   const nodeEnv = process.env["NODE_ENV"];
   const isDev3 = nodeEnv === "development";
-  const buildDir = resolve42(process.env.ABSOLUTE_BUILD_DIR ?? config.buildDirectory ?? "build");
+  const buildDir = resolve43(process.env.ABSOLUTE_BUILD_DIR ?? config.buildDirectory ?? "build");
   if (isDev3) {
     stepStartedAt = performance.now();
     const result = await prepareDev(config, buildDir);
@@ -25163,7 +25361,7 @@ var prepare = async (configOrPath) => {
   setCurrentPageIslandMetadata(await loadPageIslandMetadata(config));
   recordStep("load production manifest and island metadata", stepStartedAt);
   stepStartedAt = performance.now();
-  const conventionsPath = join33(buildDir, "conventions.json");
+  const conventionsPath = join34(buildDir, "conventions.json");
   if (existsSync30(conventionsPath)) {
     const conventions2 = JSON.parse(readFileSync23(conventionsPath, "utf-8"));
     setConventions(conventions2);
@@ -25179,7 +25377,7 @@ var prepare = async (configOrPath) => {
   });
   recordStep("create static plugin", stepStartedAt);
   stepStartedAt = performance.now();
-  const prerenderDir = join33(buildDir, "_prerendered");
+  const prerenderDir = join34(buildDir, "_prerendered");
   const prerenderMap = loadPrerenderMap(prerenderDir);
   recordStep("load prerender map", stepStartedAt);
   if (prerenderMap.size > 0) {
@@ -25238,10 +25436,10 @@ var {env: env4 } = globalThis.Bun;
 
 // src/dev/devCert.ts
 import { existsSync as existsSync31, mkdirSync as mkdirSync16, readFileSync as readFileSync24, rmSync as rmSync3 } from "fs";
-import { join as join34 } from "path";
-var CERT_DIR = join34(process.cwd(), ".absolutejs");
-var CERT_PATH = join34(CERT_DIR, "cert.pem");
-var KEY_PATH = join34(CERT_DIR, "key.pem");
+import { join as join35 } from "path";
+var CERT_DIR = join35(process.cwd(), ".absolutejs");
+var CERT_PATH = join35(CERT_DIR, "cert.pem");
+var KEY_PATH = join35(CERT_DIR, "key.pem");
 var CERT_VALIDITY_DAYS = 365;
 var devLog = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[36m[dev]\x1B[0m ${msg}`);
 var devWarn = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[33m[dev]\x1B[0m \x1B[33m${msg}\x1B[0m`);
@@ -25436,6 +25634,9 @@ var pageRouterPlugin = () => {
 init_devtoolsJson();
 // src/utils/defineConfig.ts
 var defineConfig = (config) => config;
+// src/utils/defineConvention.ts
+var defineRenderErrorPage = (fn2) => fn2;
+var defineRenderNotFoundPage = (fn2) => fn2;
 // src/utils/generateHeadElement.ts
 var renderRobotsContent = (robots) => {
   const directives = [];
@@ -25574,7 +25775,7 @@ var jsonLd2 = (schema) => {
 // src/utils/defineEnv.ts
 var {env: bunEnv } = globalThis.Bun;
 import { existsSync as existsSync32, readFileSync as readFileSync25 } from "fs";
-import { resolve as resolve43 } from "path";
+import { resolve as resolve44 } from "path";
 
 // node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
 var exports_value = {};
@@ -31609,7 +31810,7 @@ ${lines.join(`
 };
 var checkEnvFileSecurity = (properties) => {
   const cwd2 = process.cwd();
-  const envPath = resolve43(cwd2, ".env");
+  const envPath = resolve44(cwd2, ".env");
   if (!existsSync32(envPath))
     return;
   const sensitiveKeys = Object.keys(properties).filter(isSensitive);
@@ -31619,7 +31820,7 @@ var checkEnvFileSecurity = (properties) => {
   const presentKeys = sensitiveKeys.filter((key) => envContent.includes(`${key}=`));
   if (presentKeys.length === 0)
     return;
-  const gitignorePath = resolve43(cwd2, ".gitignore");
+  const gitignorePath = resolve44(cwd2, ".gitignore");
   if (existsSync32(gitignorePath)) {
     const gitignore = readFileSync25(gitignorePath, "utf-8");
     if (gitignore.split(`
@@ -31766,6 +31967,8 @@ export {
   enhanceHtmlResponseWithStreamingSlots,
   disposeTailwindCompiler,
   devtoolsJson,
+  defineRenderNotFoundPage,
+  defineRenderErrorPage,
   defineIslandRegistry,
   defineIslandComponent,
   defineEnv,
@@ -31859,5 +32062,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=01ED83B435DEDF0664756E2164756E21
+//# debugId=1D5D4C42226608CC64756E2164756E21
 //# sourceMappingURL=index.js.map