@absolutejs/absolute 0.19.0-beta.1023 → 0.19.0-beta.1025

package/dist/index.js

@@ -6839,9 +6839,12 @@ var initDominoAdapter = (platformServer) => {
   return {
     APP_BASE_HREF: common.APP_BASE_HREF,
     bootstrapApplication: platformBrowser.bootstrapApplication,
+    Component: core.Component,
     DomSanitizer: platformBrowser.DomSanitizer,
     ENVIRONMENT_INITIALIZER: core.ENVIRONMENT_INITIALIZER,
     inject: core.inject,
+    InjectionToken: core.InjectionToken,
+    NgComponentOutlet: common.NgComponentOutlet,
     provideClientHydration: platformBrowser.provideClientHydration,
     provideServerRendering: platformServer.provideServerRendering,
     provideZonelessChangeDetection: core.provideZonelessChangeDetection,
@@ -7097,9 +7100,8 @@ var angularIslandSelector = "abs-angular-island", isAngularComponent = (value) =
   const componentName = typeof component.name === "string" && component.name.length > 0 ? component.name : "AngularIsland";
   return `${componentName}:${JSON.stringify(props)}`;
 }, buildAngularIslandWrapperMetadata = async (component, islandId, wrapperKey) => {
-  const { Component, InjectionToken, inject } = await import("@angular/core");
-  const { NgComponentOutlet } = await import("@angular/common");
   const deps = await getAngularDeps();
+  const { Component, InjectionToken, NgComponentOutlet, inject } = deps;
   const selector = getAngularIslandSelector(islandId);
   const propsToken = new InjectionToken(`${wrapperKey}:props`);
 
@@ -7205,7 +7207,15 @@ var init_islands2 = __esm(() => {
 var renderAngularIslandToHtmlInternal = async (component, props, islandId) => {
   const { renderAngularIslandToHtml: renderAngularIslandToHtml2 } = await Promise.resolve().then(() => (init_islands2(), exports_islands));
   return renderAngularIslandToHtml2(component, props, islandId);
-}, renderAngularIslandToHtml2, renderReactIslandToHtml = (component, props) => import("react").then(({ createElement }) => import("react-dom/server").then(({ renderToStaticMarkup }) => renderToStaticMarkup(createElement(component, props)))), renderSvelteIslandToHtml = (component, props) => import("svelte/server").then(({ render }) => {
+}, renderAngularIslandToHtml2, LEADING_HOISTED_RESOURCE_RE, stripLeadingHoistedResources = (html) => {
+  let result = html;
+  let match = LEADING_HOISTED_RESOURCE_RE.exec(result);
+  while (match) {
+    result = result.slice(match[0].length);
+    match = LEADING_HOISTED_RESOURCE_RE.exec(result);
+  }
+  return result.trimStart();
+}, renderReactIslandToHtml = (component, props) => import("react").then(({ createElement }) => import("react-dom/server").then(({ renderToString }) => stripLeadingHoistedResources(renderToString(createElement(component, props))))), renderSvelteIslandToHtml = (component, props) => import("svelte/server").then(({ render }) => {
   const { body } = render(component, { props });
   return body;
 }), renderVueIslandToHtml = (component, props) => import("vue").then(({ createSSRApp, h: createVueVNode }) => {
@@ -7216,10 +7226,311 @@ var renderAngularIslandToHtmlInternal = async (component, props, islandId) => {
 });
 var init_islandSsr = __esm(() => {
   renderAngularIslandToHtml2 = renderAngularIslandToHtmlInternal;
+  LEADING_HOISTED_RESOURCE_RE = /^\s*(?:<link\b[^>]*\/?>|<meta\b[^>]*\/?>|<title\b[^>]*>[\s\S]*?<\/title>|<style\b[^>]*>[\s\S]*?<\/style>|<script\b[^>]*>[\s\S]*?<\/script>)/i;
+});
+
+// src/build/nativeRewrite.ts
+import { dlopen, FFIType, ptr } from "bun:ffi";
+import { platform, arch } from "os";
+import { resolve as resolve5 } from "path";
+var ffiDefinition, nativeLib = null, loadNative = () => {
+  if (nativeLib !== null)
+    return nativeLib;
+  const osPlatform = platform();
+  const cpu = arch();
+  const platformMap = {
+    "darwin-arm64": "darwin-arm64/fast_ops.dylib",
+    "darwin-x64": "darwin-x64/fast_ops.dylib",
+    "linux-arm64": "linux-arm64/fast_ops.so",
+    "linux-x64": "linux-x64/fast_ops.so",
+    "win32-arm64": "windows-arm64/fast_ops.dll",
+    "win32-x64": "windows-x64/fast_ops.dll"
+  };
+  const libPath = platformMap[`${osPlatform}-${cpu}`];
+  if (!libPath)
+    return null;
+  try {
+    const fullPath = resolve5(import.meta.dir, "../../native/packages", libPath);
+    const lib = dlopen(fullPath, ffiDefinition);
+    nativeLib = lib.symbols;
+    return nativeLib;
+  } catch {
+    return null;
+  }
+}, nativeRewriteImports = (content, replacements) => {
+  const lib = loadNative();
+  if (!lib)
+    return null;
+  const jsonStr = JSON.stringify(replacements);
+  const contentBuf = Buffer.from(content);
+  const jsonBuf = Buffer.from(jsonStr);
+  const outBuf = Buffer.alloc(content.length * 2);
+  const outLenBuf = new BigUint64Array([BigInt(outBuf.length)]);
+  const result = lib.rewrite_imports(ptr(contentBuf), contentBuf.length, ptr(jsonBuf), jsonBuf.length, ptr(outBuf), ptr(new Uint8Array(outLenBuf.buffer)));
+  if (result < 0)
+    return null;
+  if (result === 0)
+    return content;
+  const outLen = Number(outLenBuf[0]);
+  return outBuf.subarray(0, outLen).toString("utf-8");
+};
+var init_nativeRewrite = __esm(() => {
+  ffiDefinition = {
+    rewrite_imports: {
+      args: [
+        FFIType.ptr,
+        FFIType.u64,
+        FFIType.ptr,
+        FFIType.u64,
+        FFIType.ptr,
+        FFIType.ptr
+      ],
+      returns: FFIType.i32
+    }
+  };
+});
+
+// src/build/rewriteImportsPlugin.ts
+var exports_rewriteImportsPlugin = {};
+__export(exports_rewriteImportsPlugin, {
+  rewriteVendorDirectories: () => rewriteVendorDirectories,
+  rewriteImportsInContent: () => rewriteImportsInContent,
+  rewriteBuildOutputsWith: () => rewriteBuildOutputsWith,
+  rewriteBuildOutputs: () => rewriteBuildOutputs,
+  jsRewriteImports: () => jsRewriteImports,
+  fixMissingReExportNamespacesInContent: () => fixMissingReExportNamespacesInContent,
+  buildWithImportRewrite: () => buildWithImportRewrite
+});
+import { readdir } from "fs/promises";
+import { join as join5 } from "path";
+var escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewriteImports = (content, replacements) => {
+  let result = content;
+  for (const [specifier, webPath] of replacements) {
+    const escaped = escapeRegex(specifier);
+    const fromRegex = new RegExp(`(from\\s*["'])${escaped}(["'])`, "g");
+    const sideEffectRegex = new RegExp(`(import\\s*["'])${escaped}(["'])`, "g");
+    const dynamicRegex = new RegExp(`(import\\s*\\(\\s*["'])${escaped}(["']\\s*\\))`, "g");
+    result = result.replace(fromRegex, `$1${webPath}$2`);
+    result = result.replace(sideEffectRegex, `$1${webPath}$2`);
+    result = result.replace(dynamicRegex, `$1${webPath}$2`);
+  }
+  return result;
+}, rewriteImportsInContent = (content, vendorPaths) => {
+  if (Object.keys(vendorPaths).length === 0)
+    return content;
+  const replacements = Object.entries(vendorPaths).sort(([keyA], [keyB]) => keyB.length - keyA.length);
+  const native = nativeRewriteImports(content, replacements);
+  return native ?? jsRewriteImports(content, replacements);
+}, fixMissingReExportNamespacesInContent = (content) => {
+  const REEXPORT_PATTERN = /__reExport\(\s*[A-Za-z_$][\w$]*\s*,\s*([A-Za-z_$][\w$]*)\s*\)/g;
+  REEXPORT_PATTERN.lastIndex = 0;
+  const missing = [];
+  let match;
+  while ((match = REEXPORT_PATTERN.exec(content)) !== null) {
+    const ident = match[1];
+    if (!ident)
+      continue;
+    const nsImportRe = new RegExp(`\\bimport\\s*\\*\\s*as\\s+${ident}\\s+from\\b`);
+    if (nsImportRe.test(content))
+      continue;
+    const declRe = new RegExp(`\\b(?:const|let|var|function|class)\\s+${ident}\\b`);
+    if (declRe.test(content))
+      continue;
+    const namedImportRe = new RegExp(`\\bimport\\s*\\{[^}]*\\b${ident}\\b[^}]*\\}\\s*from\\b`);
+    if (namedImportRe.test(content))
+      continue;
+    const importPathRe = /(?:from\s+|import\s*)["']([^"']+)["']/g;
+    let pathMatch;
+    let sourcePath;
+    while ((pathMatch = importPathRe.exec(content)) !== null) {
+      const p2 = pathMatch[1];
+      if (!p2)
+        continue;
+      const base = p2.split("/").pop()?.replace(/\.[mc]?js$/, "");
+      if (!base)
+        continue;
+      const normalized = base.startsWith("_") ? base.slice(1) : base;
+      if (normalized === ident || normalized.endsWith(`_${ident}`)) {
+        sourcePath = p2;
+        break;
+      }
+    }
+    if (sourcePath)
+      missing.push({ ident, path: sourcePath });
+  }
+  if (missing.length === 0)
+    return content;
+  const seen = new Set;
+  const unique = missing.filter((entry) => {
+    if (seen.has(entry.ident))
+      return false;
+    seen.add(entry.ident);
+    return true;
+  });
+  const inserts = unique.map((entry) => `import * as ${entry.ident} from "${entry.path}";`).join(`
+`);
+  return `${inserts}
+${content}`;
+}, isReadableArtifact = (artifact) => artifact.path.endsWith(".js"), rewriteBuildOutputs = async (outputs, vendorPaths) => {
+  if (Object.keys(vendorPaths).length === 0)
+    return;
+  await Promise.all(outputs.filter(isReadableArtifact).map(async (artifact) => {
+    let original;
+    try {
+      original = await artifact.text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+    const rewritten = rewriteImportsInContent(original, vendorPaths);
+    if (rewritten === original)
+      return;
+    try {
+      await Bun.write(artifact.path, rewritten);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+  }));
+}, rewriteBuildOutputsWith = async (outputs, resolveVendorPaths) => {
+  await Promise.all(outputs.filter(isReadableArtifact).map(async (artifact) => {
+    const vendorPaths = resolveVendorPaths(artifact);
+    if (Object.keys(vendorPaths).length === 0)
+      return;
+    let original;
+    try {
+      original = await artifact.text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+    const rewritten = rewriteImportsInContent(original, vendorPaths);
+    if (rewritten === original)
+      return;
+    try {
+      await Bun.write(artifact.path, rewritten);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+  }));
+}, rewriteVendorDirectories = async (vendorDirs, vendorPaths) => {
+  if (Object.keys(vendorPaths).length === 0)
+    return;
+  const allFiles = [];
+  for (const dir of vendorDirs) {
+    try {
+      const entries = await readdir(dir);
+      for (const entry of entries) {
+        if (entry.endsWith(".js"))
+          allFiles.push(join5(dir, entry));
+      }
+    } catch {}
+  }
+  await Promise.all(allFiles.map(async (filePath) => {
+    let original;
+    try {
+      original = await Bun.file(filePath).text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+    let next = rewriteImportsInContent(original, vendorPaths);
+    next = fixMissingReExportNamespacesInContent(next);
+    if (next === original)
+      return;
+    try {
+      await Bun.write(filePath, next);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+  }));
+}, buildWithImportRewrite = async (pendingBuild, vendorPaths) => {
+  const result = await pendingBuild;
+  if (result.outputs.length > 0) {
+    await rewriteBuildOutputs(result.outputs, vendorPaths);
+  }
+  return result;
+};
+var init_rewriteImportsPlugin = __esm(() => {
+  init_nativeRewrite();
+});
+
+// src/core/angularServerModule.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { dirname as dirname5, join as join6, relative as relative2 } from "path";
+var serverCacheRoot, compiledModuleCache, ANGULAR_SPECIFIER_RE, getCachedModulePath = (sourcePath) => {
+  const relativeSourcePath = relative2(process.cwd(), sourcePath).replace(/\\/g, "/");
+  const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
+  return join6(serverCacheRoot, `${normalizedSourcePath}.server.js`);
+}, collectVendorPaths = (code) => {
+  const vendorPaths = {};
+  if (!isProductionRuntime()) {
+    return vendorPaths;
+  }
+  const specifiers = new Set([...code.matchAll(ANGULAR_SPECIFIER_RE)].map((match) => match[1]));
+  specifiers.forEach((specifier) => {
+    if (!specifier)
+      return;
+    const resolved = resolveAngularRuntimePath(specifier);
+    if (resolved === specifier)
+      return;
+    vendorPaths[specifier] = resolved;
+  });
+  return vendorPaths;
+}, buildAngularServerModule = async (sourcePath) => {
+  const result = await Bun.build({
+    entrypoints: [sourcePath],
+    format: "esm",
+    packages: "external",
+    target: "bun",
+    throw: false
+  });
+  const entry = result.outputs.find((output) => output.kind === "entry-point");
+  if (!result.success || !entry) {
+    const message = result.logs.map((log) => String(log)).join(`
+`);
+    throw new Error(`Failed to compile Angular island server module for "${sourcePath}":
+${message}`);
+  }
+  const code = await entry.text();
+  const rewritten = rewriteImportsInContent(code, collectVendorPaths(code));
+  const modulePath = getCachedModulePath(sourcePath);
+  await mkdir2(dirname5(modulePath), { recursive: true });
+  await Bun.write(modulePath, rewritten);
+  return modulePath;
+}, compileAngularServerModule = (sourcePath) => {
+  const cached = compiledModuleCache.get(sourcePath);
+  if (cached) {
+    return cached;
+  }
+  const compiledModulePromise = buildAngularServerModule(sourcePath);
+  compiledModuleCache.set(sourcePath, compiledModulePromise);
+  return compiledModulePromise;
+};
+var init_angularServerModule = __esm(() => {
+  init_resolveAngularPackage();
+  init_rewriteImportsPlugin();
+  serverCacheRoot = join6(process.cwd(), ".absolutejs", "islands", "angular");
+  compiledModuleCache = new Map;
+  ANGULAR_SPECIFIER_RE = /["'](@angular\/[^"']+)["']/g;
 });
 
 // src/build/resolvePackageImport.ts
-import { resolve as resolve5, join as join5 } from "path";
+import { resolve as resolve6, join as join7 } from "path";
 import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 var resolveExportPath = (entry, conditions) => {
   if (typeof entry === "string")
@@ -7241,11 +7552,11 @@ var resolveExportPath = (entry, conditions) => {
   const packageName = isScoped ? `${parts[0]}/${parts[1]}` : parts[0];
   const subpath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
   const exportKey = subpath ? `./${subpath}` : ".";
-  const currentPackageJsonPath = resolve5(process.cwd(), "package.json");
+  const currentPackageJsonPath = resolve6(process.cwd(), "package.json");
   const currentPackageJson = existsSync5(currentPackageJsonPath) ? JSON.parse(readFileSync5(currentPackageJsonPath, "utf-8")) : null;
   const currentPackageDir = currentPackageJson?.name === packageName ? process.cwd() : null;
-  const packageDir = currentPackageDir ?? resolve5(process.cwd(), "node_modules", packageName ?? "");
-  const packageJsonPath = join5(packageDir, "package.json");
+  const packageDir = currentPackageDir ?? resolve6(process.cwd(), "node_modules", packageName ?? "");
+  const packageJsonPath = join7(packageDir, "package.json");
   if (!existsSync5(packageJsonPath))
     return null;
   try {
@@ -7260,12 +7571,12 @@ var resolveExportPath = (entry, conditions) => {
     if (!importPath)
       return null;
     if (currentPackageDir && importPath.startsWith("./dist/")) {
-      const sourceCandidate = resolve5(packageDir, importPath.replace(/^\.\/dist\//, "./src/"));
+      const sourceCandidate = resolve6(packageDir, importPath.replace(/^\.\/dist\//, "./src/"));
       if (existsSync5(sourceCandidate)) {
         return sourceCandidate;
       }
     }
-    const resolved = resolve5(packageDir, importPath);
+    const resolved = resolve6(packageDir, importPath);
     return existsSync5(resolved) ? resolved : null;
   } catch {
     return null;
@@ -7398,14 +7709,14 @@ var init_lowerAwaitSlotSyntax = __esm(() => {
 });
 
 // src/core/svelteServerModule.ts
-import { mkdir as mkdir2, readdir } from "fs/promises";
-import { basename, dirname as dirname5, extname as extname2, join as join6, relative as relative2, resolve as resolve6 } from "path";
-var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
-  const importPath = relative2(dirname5(from), target).replace(/\\/g, "/");
+import { mkdir as mkdir3, readdir as readdir2 } from "fs/promises";
+import { basename, dirname as dirname6, extname as extname2, join as join8, relative as relative3, resolve as resolve7 } from "path";
+var serverCacheRoot2, compiledModuleCache2, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
+  const importPath = relative3(dirname6(from), target).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
 }, processDirectoryEntries = (entries, dir, targetFileName, stack) => {
   for (const entry of entries) {
-    const entryPath = join6(dir, entry.name);
+    const entryPath = join8(dir, entry.name);
     if (entry.isDirectory())
       stack.push(entryPath);
     if (entry.isFile() && entry.name === targetFileName) {
@@ -7419,7 +7730,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   const nextStack = [];
   const dirEntries = await Promise.all(dirs.map(async (dir) => ({
     dir,
-    entries: await readdir(dir, {
+    entries: await readdir2(dir, {
       encoding: "utf-8",
       withFileTypes: true
     })
@@ -7435,11 +7746,11 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (cachedPath !== undefined) {
     return cachedPath;
   }
-  if (!sourcePath.includes(`${join6(process.cwd(), "build")}${process.platform === "win32" ? "" : "/"}`) && !sourcePath.includes("/build/")) {
+  if (!sourcePath.includes(`${join8(process.cwd(), "build")}${process.platform === "win32" ? "" : "/"}`) && !sourcePath.includes("/build/")) {
     originalSourcePathCache.set(sourcePath, sourcePath);
     return sourcePath;
   }
-  const resolvedSourcePath = await findSourceFileByBasename(join6(process.cwd(), "src"), normalizeBuiltSvelteFileName(sourcePath));
+  const resolvedSourcePath = await findSourceFileByBasename(join8(process.cwd(), "src"), normalizeBuiltSvelteFileName(sourcePath));
   const nextPath = resolvedSourcePath ?? sourcePath;
   originalSourcePathCache.set(sourcePath, nextPath);
   return nextPath;
@@ -7447,7 +7758,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (!spec.startsWith(".")) {
     return null;
   }
-  const basePath = resolve6(dirname5(from), spec);
+  const basePath = resolve7(dirname6(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -7455,19 +7766,19 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
     `${basePath}.mjs`,
     `${basePath}.cjs`,
     `${basePath}.json`,
-    join6(basePath, "index.ts"),
-    join6(basePath, "index.js"),
-    join6(basePath, "index.mjs"),
-    join6(basePath, "index.cjs"),
-    join6(basePath, "index.json")
+    join8(basePath, "index.ts"),
+    join8(basePath, "index.js"),
+    join8(basePath, "index.mjs"),
+    join8(basePath, "index.cjs"),
+    join8(basePath, "index.json")
   ];
   const existResults = await Promise.all(candidates.map((candidate) => Bun.file(candidate).exists()));
   const foundIndex = existResults.indexOf(true);
   return foundIndex >= 0 ? candidates[foundIndex] ?? null : null;
-}, getCachedModulePath = (sourcePath) => {
-  const relativeSourcePath = relative2(process.cwd(), sourcePath).replace(/\\/g, "/");
+}, getCachedModulePath2 = (sourcePath) => {
+  const relativeSourcePath = relative3(process.cwd(), sourcePath).replace(/\\/g, "/");
   const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
-  return join6(serverCacheRoot, `${normalizedSourcePath}.server.js`);
+  return join8(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
 }, resolveSvelteImport = async (spec, from) => {
   if (!spec.startsWith(".") && !spec.startsWith("/")) {
     const resolved = resolvePackageImport(spec);
@@ -7479,7 +7790,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (!spec.startsWith(".")) {
     return null;
   }
-  const explicitPath = resolve6(dirname5(from), spec);
+  const explicitPath = resolve7(dirname6(from), spec);
   if (extname2(explicitPath) === ".svelte") {
     return explicitPath;
   }
@@ -7499,7 +7810,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   }
   await Bun.write(path, content);
 }, compileSvelteServerModule = async (sourcePath) => {
-  const cachedModulePath = compiledModuleCache.get(sourcePath);
+  const cachedModulePath = compiledModuleCache2.get(sourcePath);
   if (cachedModulePath) {
     return cachedModulePath;
   }
@@ -7538,7 +7849,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
       continue;
     if (resolvedChildModules[index])
       continue;
-    rewrittenModulePaths.set(spec, ensureRelativeImportPath(getCachedModulePath(sourcePath), resolvedModuleImport));
+    rewrittenModulePaths.set(spec, ensureRelativeImportPath(getCachedModulePath2(sourcePath), resolvedModuleImport));
   }
   for (const [spec, resolvedModuleImport] of rewrittenModulePaths) {
     transpiled = transpiled.replaceAll(spec, resolvedModuleImport);
@@ -7552,15 +7863,15 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
     generate: "server"
   }).js.code;
   for (const [spec, compiledChildPath] of childModulePaths) {
-    compiledCode = compiledCode.replaceAll(spec, ensureRelativeImportPath(getCachedModulePath(sourcePath), compiledChildPath));
+    compiledCode = compiledCode.replaceAll(spec, ensureRelativeImportPath(getCachedModulePath2(sourcePath), compiledChildPath));
   }
   for (const [spec, resolvedModuleImport] of rewrittenModulePaths) {
     compiledCode = compiledCode.replaceAll(spec, resolvedModuleImport);
   }
-  const compiledModulePath = getCachedModulePath(sourcePath);
-  await mkdir2(dirname5(compiledModulePath), { recursive: true });
+  const compiledModulePath = getCachedModulePath2(sourcePath);
+  await mkdir3(dirname6(compiledModulePath), { recursive: true });
   await writeIfChanged(compiledModulePath, compiledCode);
-  compiledModuleCache.set(sourcePath, compiledModulePath);
+  compiledModuleCache2.set(sourcePath, compiledModulePath);
   return compiledModulePath;
 };
 var init_svelteServerModule = __esm(() => {
@@ -7568,8 +7879,8 @@ var init_svelteServerModule = __esm(() => {
   init_lowerIslandSyntax();
   init_lowerAwaitSlotSyntax();
   init_stylePreprocessor();
-  serverCacheRoot = join6(process.cwd(), ".absolutejs", "islands", "svelte");
-  compiledModuleCache = new Map;
+  serverCacheRoot2 = join8(process.cwd(), ".absolutejs", "islands", "svelte");
+  compiledModuleCache2 = new Map;
   originalSourcePathCache = new Map;
   transpiler = new Bun.Transpiler({
     loader: "ts",
@@ -7579,16 +7890,16 @@ var init_svelteServerModule = __esm(() => {
 
 // src/core/vueServerModule.ts
 import { existsSync as existsSync6, readFileSync as readFileSync6, realpathSync } from "fs";
-import { mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname6, join as join7, relative as relative3, resolve as resolve7 } from "path";
+import { mkdir as mkdir4 } from "fs/promises";
+import { dirname as dirname7, join as join9, relative as relative4, resolve as resolve8 } 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, "/");
+var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot3, compiledModuleCache3, transpiler2, ensureRelativeImportPath2 = (from, target) => {
+  const importPath = relative4(dirname7(from), target).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
-}, getCachedModulePath2 = (sourcePath) => {
-  const relativeSourcePath = relative3(process.cwd(), sourcePath).replace(/\\/g, "/");
+}, getCachedModulePath3 = (sourcePath) => {
+  const relativeSourcePath = relative4(process.cwd(), sourcePath).replace(/\\/g, "/");
   const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
-  return join7(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
+  return join9(serverCacheRoot3, `${normalizedSourcePath}.server.js`);
 }, writeIfChanged2 = async (path, content) => {
   const targetFile = Bun.file(path);
   if (await targetFile.exists()) {
@@ -7615,7 +7926,7 @@ var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, tran
 `) : 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);
+  const cachedModulePath = compiledModuleCache3.get(sourcePath);
   if (cachedModulePath)
     return cachedModulePath;
   const compiler = await import("@vue/compiler-sfc");
@@ -7648,7 +7959,7 @@ var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, tran
   }).code : "const ssrRender = () => {};";
   const childImportPaths = extractRelativeVueImports(compiledScript.content);
   const compiledChildren = await Promise.all(childImportPaths.map(async (relativeImport) => ({
-    compiledPath: await compileVueServerModule(resolve7(dirname6(sourcePath), relativeImport)),
+    compiledPath: await compileVueServerModule(resolve8(dirname7(sourcePath), relativeImport)),
     spec: relativeImport
   })));
   const strippedScript = stripExports(compiledScript.content);
@@ -7660,20 +7971,20 @@ var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, tran
     "export default script;"
   ].join(`
 `));
-  const compiledModulePath = getCachedModulePath2(sourcePath);
+  const compiledModulePath = getCachedModulePath3(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 mkdir4(dirname7(compiledModulePath), { recursive: true });
   await writeIfChanged2(compiledModulePath, rewritten);
-  compiledModuleCache2.set(sourcePath, compiledModulePath);
+  compiledModuleCache3.set(sourcePath, compiledModulePath);
   return compiledModulePath;
 };
 var init_vueServerModule = __esm(() => {
   init_constants();
-  serverCacheRoot2 = join7(process.cwd(), ".absolutejs", "islands", "vue");
-  compiledModuleCache2 = new Map;
+  serverCacheRoot3 = join9(process.cwd(), ".absolutejs", "islands", "vue");
+  compiledModuleCache3 = new Map;
   transpiler2 = new Transpiler({ loader: "ts", target: "browser" });
 });
 
@@ -7768,8 +8079,17 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
     throw new Error("Resolved Vue island is not a valid Vue component.");
   }
   return resolvedComponent;
+}, loadAngularServerBuildComponent = async (buildReferencePath, exportName) => {
+  const serverModulePath = await compileAngularServerModule(buildReferencePath);
+  const loadedModule = await import(serverModulePath);
+  if (exportName && exportName !== "default" && exportName in loadedModule) {
+    return loadedModule[exportName];
+  }
+  return "default" in loadedModule ? loadedModule.default : loadedModule;
 }, resolveAngularServerIslandComponent = async (component) => {
-  const resolvedComponent = await resolveServerIslandComponent(component);
+  const buildReference = getIslandBuildReference(component);
+  const buildReferencePath = buildReference?.source ? resolveBuildReferencePath(buildReference.source, import.meta.url) : null;
+  const resolvedComponent = buildReferencePath ? await loadAngularServerBuildComponent(buildReferencePath, buildReference?.export) : await resolveServerIslandComponent(component);
   if (!isAngularServerIslandComponent(resolvedComponent)) {
     throw new Error("Resolved Angular island is not a valid Angular component.");
   }
@@ -7825,6 +8145,7 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
 };
 var init_renderIslandMarkup = __esm(() => {
   init_islandSsr();
+  init_angularServerModule();
   init_svelteServerModule();
   init_vueServerModule();
   init_islandMarkupAttributes();
@@ -7835,7 +8156,7 @@ var init_renderIslandMarkup = __esm(() => {
 
 // src/build/islandEntries.ts
 import { mkdirSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname7, extname as extname3, join as join8, relative as relative4, resolve as resolve8 } from "path";
+import { dirname as dirname8, extname as extname3, join as join10, relative as relative5, resolve as resolve9 } from "path";
 import ts from "typescript";
 var frameworks, isRecord4 = (value) => typeof value === "object" && value !== null, resolveRegistryExport = (mod) => {
   if (isRecord4(mod.islandRegistry))
@@ -7844,13 +8165,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 = relative4(dirname7(wrapperPath), targetPath).replace(/\\/g, "/");
+  const importPath = relative5(dirname8(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 resolve8(dirname7(registryPath), sourcePath);
+  return resolve9(dirname8(registryPath), sourcePath);
 }, getObjectPropertyName = (name) => {
   if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
     return name.text;
@@ -8068,16 +8389,16 @@ export default component;
   buildPath,
   clientPathMaps = {}
 }) => {
-  const generatedRoot = join8(buildPath, "_island_entries");
+  const generatedRoot = join10(buildPath, "_island_entries");
   rmSync(generatedRoot, { force: true, recursive: true });
   const entries = [];
   for (const definition of buildInfo.definitions) {
-    const entryPath = join8(generatedRoot, "islands", definition.framework, `${definition.component}.ts`);
+    const entryPath = join10(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(dirname7(entryPath), { recursive: true });
+    mkdirSync(dirname8(entryPath), { recursive: true });
     writeFileSync2(entryPath, entrySource);
     entries.push({
       component: definition.component,
@@ -8090,7 +8411,7 @@ export default component;
     generatedRoot
   };
 }, loadIslandRegistryBuildInfo = async (registryPath) => {
-  const resolvedRegistryPath = resolve8(registryPath);
+  const resolvedRegistryPath = resolve9(registryPath);
   const registrySource = Bun.file(resolvedRegistryPath);
   const registrySourceText = await registrySource.text();
   const parsedInfo = parseIslandRegistryBuildInfo(registrySourceText, resolvedRegistryPath);
@@ -8357,7 +8678,7 @@ __export(exports_loadConfig, {
   isWorkspaceConfig: () => isWorkspaceConfig,
   getWorkspaceServices: () => getWorkspaceServices
 });
-import { resolve as resolve9 } from "path";
+import { resolve as resolve10 } from "path";
 var RESERVED_TOP_LEVEL_KEYS, isObject = (value) => typeof value === "object" && value !== null, isCommandService = (service) => service.kind === "command" || Array.isArray(service.command), isServiceCandidate = (value) => isObject(value) && (typeof value.entry === "string" || Array.isArray(value.command)), isWorkspaceConfig = (config) => {
   if (!isObject(config)) {
     return false;
@@ -8408,7 +8729,7 @@ var RESERVED_TOP_LEVEL_KEYS, isObject = (value) => typeof value === "object" &&
   }
   return config;
 }, loadRawConfig = async (configPath) => {
-  const resolved = resolve9(configPath ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+  const resolved = resolve10(configPath ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
   const mod = await import(resolved);
   const config = mod.default ?? mod.config;
   if (!config) {
@@ -8551,7 +8872,7 @@ var init_sourceMetadata = __esm(() => {
 
 // src/islands/pageMetadata.ts
 import { readFileSync as readFileSync8 } from "fs";
-import { dirname as dirname8, resolve as resolve11 } from "path";
+import { dirname as dirname9, resolve as resolve12 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
   { dir: config.emberDirectory, framework: "ember" },
@@ -8571,15 +8892,15 @@ var pagePatterns, getPageDirs = (config) => [
     const source = definition.buildReference?.source;
     if (!source)
       continue;
-    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve11(dirname8(buildInfo.resolvedRegistryPath), source);
-    lookup.set(`${definition.framework}:${definition.component}`, resolve11(resolvedSource));
+    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve12(dirname9(buildInfo.resolvedRegistryPath), source);
+    lookup.set(`${definition.framework}:${definition.component}`, resolve12(resolvedSource));
   }
   return lookup;
 }, getCurrentPageIslandMetadata = () => globalThis.__absolutePageIslandMetadata ?? new Map, metadataUsesSource = (metadata2, target) => metadata2.islands.some((usage) => {
   const candidate = usage.source;
-  return candidate ? resolve11(candidate) === target : false;
+  return candidate ? resolve12(candidate) === target : false;
 }), getPagesUsingIslandSource = (sourcePath) => {
-  const target = resolve11(sourcePath);
+  const target = resolve12(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}`);
@@ -8591,13 +8912,13 @@ var pagePatterns, getPageDirs = (config) => [
   const pattern = pagePatterns[entry.framework];
   if (!pattern)
     return;
-  const files = await scanEntryPoints(resolve11(entry.dir), pattern);
+  const files = await scanEntryPoints(resolve12(entry.dir), pattern);
   for (const filePath of files) {
     const source = readFileSync8(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
-    pageMetadata.set(resolve11(filePath), {
+    pageMetadata.set(resolve12(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
-      pagePath: resolve11(filePath)
+      pagePath: resolve12(filePath)
     });
   }
 }, loadPageIslandMetadata = async (config) => {
@@ -8839,12 +9160,12 @@ var init_startupBanner = __esm(() => {
 // src/utils/logger.ts
 var colors2, frameworkColors, formatPath = (filePath) => {
   const cwd = process.cwd();
-  let relative5 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
-  relative5 = relative5.replace(/\\/g, "/");
-  if (!relative5.startsWith("/")) {
-    relative5 = `/${relative5}`;
+  let relative6 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+  relative6 = relative6.replace(/\\/g, "/");
+  if (!relative6.startsWith("/")) {
+    relative6 = `/${relative6}`;
   }
-  return relative5;
+  return relative6;
 }, getFrameworkColor = (framework) => frameworkColors[framework] || colors2.white, log = (action, options) => {
   const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
   const tag = `${colors2.cyan}[hmr]${colors2.reset}`;
@@ -8947,9 +9268,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 relative5 = normalizedArtifactPath.startsWith(normalizedBuildPath) ? normalizedArtifactPath.slice(normalizedBuildPath.length) : normalizedArtifactPath;
-  relative5 = relative5.replace(/^\/+/, "");
-  const segments = relative5.split("/");
+  let relative6 = normalizedArtifactPath.startsWith(normalizedBuildPath) ? normalizedArtifactPath.slice(normalizedBuildPath.length) : normalizedArtifactPath;
+  relative6 = relative6.replace(/^\/+/, "");
+  const segments = relative6.split("/");
   const fileWithHash = segments.pop();
   if (!fileWithHash)
     return manifest;
@@ -8963,15 +9284,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] !== `/${relative5}`)
-      logWarn(`Duplicate manifest key "${cssKey}" \u2014 "${manifest[cssKey]}" will be overwritten by "/${relative5}". Use unique page names across frameworks.`);
-    manifest[cssKey] = `/${relative5}`;
+    if (manifest[cssKey] && manifest[cssKey] !== `/${relative6}`)
+      logWarn(`Duplicate manifest key "${cssKey}" \u2014 "${manifest[cssKey]}" will be overwritten by "/${relative6}". Use unique page names across frameworks.`);
+    manifest[cssKey] = `/${relative6}`;
     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] = `/${relative5}`;
+    manifest[manifestKey2] = `/${relative6}`;
     return manifest;
   }
   const idx = segments.findIndex((seg) => seg === "indexes" || seg === "pages" || seg === "client");
@@ -8982,10 +9303,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] !== `/${relative5}`) {
-    logWarn(`Duplicate manifest key "${manifestKey}" \u2014 "${manifest[manifestKey]}" will be overwritten by "/${relative5}". Use unique page names across frameworks.`);
+  if (manifest[manifestKey] && manifest[manifestKey] !== `/${relative6}`) {
+    logWarn(`Duplicate manifest key "${manifestKey}" \u2014 "${manifest[manifestKey]}" will be overwritten by "/${relative6}". Use unique page names across frameworks.`);
   }
-  manifest[manifestKey] = `/${relative5}`;
+  manifest[manifestKey] = `/${relative6}`;
   return manifest;
 }, {});
 var init_generateManifest = __esm(() => {
@@ -8994,7 +9315,7 @@ var init_generateManifest = __esm(() => {
 });
 
 // src/build/verifyAngularCoreUniqueness.ts
-import { resolve as resolve12 } from "path";
+import { resolve as resolve13 } from "path";
 var ANGULAR_CORE_IMPORT_RE, ANGULAR_CORE_PACKAGE_RE, classifySpecifier = (specifier, artifactPath, serverOutDir) => {
   if (!ANGULAR_CORE_PACKAGE_RE.test(specifier))
     return null;
@@ -9004,9 +9325,9 @@ var ANGULAR_CORE_IMPORT_RE, ANGULAR_CORE_PACKAGE_RE, classifySpecifier = (specif
   if (specifier.startsWith("/")) {
     absolute = specifier;
   } else if (specifier.startsWith(".")) {
-    absolute = resolve12(artifactPath, "..", specifier);
+    absolute = resolve13(artifactPath, "..", specifier);
   } else {
-    absolute = serverOutDir ? resolve12(serverOutDir, specifier) : resolve12(artifactPath, "..", specifier);
+    absolute = serverOutDir ? resolve13(serverOutDir, specifier) : resolve13(artifactPath, "..", specifier);
   }
   return {
     kind: "resolved",
@@ -9070,19 +9391,19 @@ var init_verifyAngularCoreUniqueness = __esm(() => {
 
 // src/build/generateReactIndexes.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync2 } from "fs";
-import { readdir as readdir2, rm, writeFile } from "fs/promises";
-import { basename as basename3, join as join9, relative as relative5, resolve as resolve13, sep } from "path";
+import { readdir as readdir3, rm, writeFile } from "fs/promises";
+import { basename as basename3, join as join11, relative as relative6, resolve as resolve14, sep } from "path";
 var {Glob: Glob2 } = globalThis.Bun;
 var indexContentCache, resolveDevClientDir = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve13(import.meta.dir, "../dev/client");
+  const fromSource = resolve14(import.meta.dir, "../dev/client");
   if (existsSync8(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve13(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve14(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync8(fromNodeModules))
     return fromNodeModules;
-  return resolve13(import.meta.dir, "./dev/client");
+  return resolve14(import.meta.dir, "./dev/client");
 }, devClientDir, errorOverlayPath, hmrClientPath, refreshSetupPath, reactRefreshRuntimePath, generateReactIndexFiles = async (reactPagesDirectory, reactIndexesDirectory, isDev2 = false) => {
   if (!existsSync8(reactIndexesDirectory)) {
     mkdirSync2(reactIndexesDirectory, { recursive: true });
@@ -9097,20 +9418,20 @@ var indexContentCache, resolveDevClientDir = () => {
   }
   const currentPageNames = new Set(files.map((file2) => basename3(file2).split(".")[0]));
   const emptyStringArray = [];
-  const existingIndexes = await readdir2(reactIndexesDirectory).catch(() => emptyStringArray);
+  const existingIndexes = await readdir3(reactIndexesDirectory).catch(() => emptyStringArray);
   const staleIndexes = existingIndexes.filter((indexFile) => {
     const indexName = indexFile.replace(/\.tsx$/, "");
     return indexName !== "_refresh" && !currentPageNames.has(indexName);
   });
   if (staleIndexes.length > 0) {
     await Promise.all(staleIndexes.map((indexFile) => {
-      indexContentCache.delete(join9(reactIndexesDirectory, indexFile));
-      return rm(join9(reactIndexesDirectory, indexFile), {
+      indexContentCache.delete(join11(reactIndexesDirectory, indexFile));
+      return rm(join11(reactIndexesDirectory, indexFile), {
         force: true
       });
     }));
   }
-  const pagesRelPath = relative5(resolve13(reactIndexesDirectory), resolve13(reactPagesDirectory)).split(sep).join("/");
+  const pagesRelPath = relative6(resolve14(reactIndexesDirectory), resolve14(reactPagesDirectory)).split(sep).join("/");
   const promises = files.map(async (file2) => {
     const fileName = basename3(file2);
     const componentName = fileName.split(".")[0];
@@ -9384,11 +9705,11 @@ var indexContentCache, resolveDevClientDir = () => {
         `
 // Pre-warm: import the page module from the module server`,
         `// immediately so the browser caches all /@src/ URLs.`,
-        `import('/@src/${relative5(process.cwd(), resolve13(reactPagesDirectory, `${componentName}.tsx`)).replace(/\\/g, "/")}').catch(() => {});`
+        `import('/@src/${relative6(process.cwd(), resolve14(reactPagesDirectory, `${componentName}.tsx`)).replace(/\\/g, "/")}').catch(() => {});`
       ] : []
     ].join(`
 `);
-    const indexPath = join9(reactIndexesDirectory, `${componentName}.tsx`);
+    const indexPath = join11(reactIndexesDirectory, `${componentName}.tsx`);
     const hasher = new Bun.CryptoHasher("md5");
     hasher.update(content);
     const contentHash = hasher.digest("hex");
@@ -9402,7 +9723,7 @@ var indexContentCache, resolveDevClientDir = () => {
   if (!isDev2) {
     return;
   }
-  const refreshPath = join9(reactIndexesDirectory, "_refresh.tsx");
+  const refreshPath = join11(reactIndexesDirectory, "_refresh.tsx");
   if (!existsSync8(refreshPath)) {
     await writeFile(refreshPath, `import '${refreshSetupPath}';
 import 'react';
@@ -9413,10 +9734,10 @@ import 'react-dom/client';
 var init_generateReactIndexes = __esm(() => {
   indexContentCache = new Map;
   devClientDir = resolveDevClientDir();
-  errorOverlayPath = join9(devClientDir, "errorOverlay.ts").replace(/\\/g, "/");
-  hmrClientPath = join9(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
-  refreshSetupPath = join9(devClientDir, "reactRefreshSetup.ts").replace(/\\/g, "/");
-  reactRefreshRuntimePath = join9(devClientDir, "vendor", "reactRefreshRuntime.js").replace(/\\/g, "/");
+  errorOverlayPath = join11(devClientDir, "errorOverlay.ts").replace(/\\/g, "/");
+  hmrClientPath = join11(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
+  refreshSetupPath = join11(devClientDir, "reactRefreshSetup.ts").replace(/\\/g, "/");
+  reactRefreshRuntimePath = join11(devClientDir, "vendor", "reactRefreshRuntime.js").replace(/\\/g, "/");
 });
 
 // src/build/wrapHTMLScript.ts
@@ -9533,7 +9854,7 @@ var init_scanConventions = __esm(() => {
 
 // src/build/scanRouteRegistrations.ts
 import { readdirSync, readFileSync as readFileSync9 } from "fs";
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 import ts2 from "typescript";
 var ELYSIA_ROUTE_METHODS, SKIP_DIRS, SOURCE_EXTENSIONS, getScriptKind = (filePath) => {
   if (filePath.endsWith(".tsx"))
@@ -9570,9 +9891,9 @@ var ELYSIA_ROUTE_METHODS, SKIP_DIRS, SOURCE_EXTENSIONS, getScriptKind = (filePat
           continue;
         if (entry.name.startsWith("."))
           continue;
-        stack.push(join10(dir, entry.name));
+        stack.push(join12(dir, entry.name));
       } else if (entry.isFile() && hasSourceExtension(entry.name)) {
-        out.push(join10(dir, entry.name));
+        out.push(join12(dir, entry.name));
       }
     }
   }
@@ -9656,7 +9977,7 @@ var init_scanRouteRegistrations = __esm(() => {
 
 // src/angular/staticAnalyzeSpaRoutes.ts
 import { existsSync as existsSync10, promises as fs } from "fs";
-import { join as join11 } from "path";
+import { join as join13 } from "path";
 import ts3 from "typescript";
 var DYNAMIC_SEGMENT_PATTERN, pathHasDynamic = (path) => path.split("/").some((seg) => DYNAMIC_SEGMENT_PATTERN.test(seg) || seg === "**"), importsSymbolFrom = (sf, localName, moduleSpecifier) => {
   for (const statement of sf.statements) {
@@ -9854,7 +10175,7 @@ var DYNAMIC_SEGMENT_PATTERN, pathHasDynamic = (path) => path.split("/").some((se
       continue;
     if (item.name.startsWith("."))
       continue;
-    const full = join11(dir, item.name);
+    const full = join13(dir, item.name);
     if (item.isDirectory()) {
       await walkTsFiles(full, out);
     } else if (item.isFile() && item.name.endsWith(".ts") && !item.name.endsWith(".d.ts")) {
@@ -9884,7 +10205,7 @@ var init_staticAnalyzeSpaRoutes = __esm(() => {
 
 // src/react/staticAnalyzeSpaRoutes.ts
 import { existsSync as existsSync11, promises as fs2 } from "fs";
-import { join as join12 } from "path";
+import { join as join14 } from "path";
 import ts4 from "typescript";
 var DYNAMIC_SEGMENT_PATTERN2, pathHasDynamic2 = (path) => path.split("/").some((seg) => DYNAMIC_SEGMENT_PATTERN2.test(seg) || seg === "**"), readStringLiteral2 = (expression) => {
   if (ts4.isStringLiteral(expression) || ts4.isNoSubstitutionTemplateLiteral(expression)) {
@@ -10064,7 +10385,7 @@ var DYNAMIC_SEGMENT_PATTERN2, pathHasDynamic2 = (path) => path.split("/").some((
   for (const item of items) {
     if (item.name === "node_modules" || item.name.startsWith("."))
       continue;
-    const full = join12(dir, item.name);
+    const full = join14(dir, item.name);
     if (item.isDirectory()) {
       await walkSourceFiles(full, out);
     } else if (item.isFile() && (item.name.endsWith(".tsx") || item.name.endsWith(".ts") || item.name.endsWith(".jsx") || item.name.endsWith(".js")) && !item.name.endsWith(".d.ts")) {
@@ -10094,7 +10415,7 @@ var init_staticAnalyzeSpaRoutes2 = __esm(() => {
 
 // src/svelte/staticAnalyzeSpaRoutes.ts
 import { existsSync as existsSync12, promises as fs3 } from "fs";
-import { join as join13 } from "path";
+import { join as join15 } from "path";
 var DYNAMIC_SEGMENT_PATTERN3, pathHasDynamic3 = (path) => path.split("/").some((seg) => DYNAMIC_SEGMENT_PATTERN3.test(seg) || seg === "**"), joinSegments3 = (parent, child) => {
   if (!child)
     return parent;
@@ -10166,7 +10487,7 @@ var DYNAMIC_SEGMENT_PATTERN3, pathHasDynamic3 = (path) => path.split("/").some((
   for (const item of items) {
     if (item.name === "node_modules" || item.name.startsWith("."))
       continue;
-    const full = join13(dir, item.name);
+    const full = join15(dir, item.name);
     if (item.isDirectory()) {
       await walkSvelteFiles(full, out);
     } else if (item.isFile() && item.name.endsWith(".svelte")) {
@@ -10198,7 +10519,7 @@ var init_staticAnalyzeSpaRoutes3 = __esm(() => {
 
 // src/vue/staticAnalyzeSpaRoutes.ts
 import { existsSync as existsSync13, promises as fs4 } from "fs";
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 import ts5 from "typescript";
 var DYNAMIC_SEGMENT_PATTERN4, pathHasDynamic4 = (path) => path.split("/").some((seg) => DYNAMIC_SEGMENT_PATTERN4.test(seg) || seg === "**"), readStringLiteral3 = (expression) => {
   if (ts5.isStringLiteral(expression) || ts5.isNoSubstitutionTemplateLiteral(expression)) {
@@ -10404,7 +10725,7 @@ var DYNAMIC_SEGMENT_PATTERN4, pathHasDynamic4 = (path) => path.split("/").some((
   for (const item of items) {
     if (item.name === "node_modules" || item.name.startsWith("."))
       continue;
-    const full = join14(dir, item.name);
+    const full = join16(dir, item.name);
     if (item.isDirectory()) {
       await walkSourceFiles2(full, out);
     } else if (item.isFile() && (item.name.endsWith(".ts") || item.name.endsWith(".js") || item.name.endsWith(".vue")) && !item.name.endsWith(".d.ts")) {
@@ -10686,7 +11007,7 @@ var init_scanCssEntryPoints = __esm(() => {
 
 // src/utils/imageProcessing.ts
 import { existsSync as existsSync15, mkdirSync as mkdirSync3, readFileSync as readFileSync10, writeFileSync as writeFileSync4 } from "fs";
-import { join as join15, resolve as resolve14 } from "path";
+import { join as join17, resolve as resolve15 } 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)
@@ -10736,7 +11057,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 = join15(buildDir, ".cache", "images");
+  const dir = join17(buildDir, ".cache", "images");
   if (!existsSync15(dir))
     mkdirSync3(dir, { recursive: true });
   return dir;
@@ -10817,8 +11138,8 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_END
     throw err;
   }
 }, readFromCache = (cacheDir, cacheKey) => {
-  const metaPath = join15(cacheDir, `${cacheKey}.meta`);
-  const dataPath = join15(cacheDir, `${cacheKey}.data`);
+  const metaPath = join17(cacheDir, `${cacheKey}.meta`);
+  const dataPath = join17(cacheDir, `${cacheKey}.data`);
   if (!existsSync15(metaPath) || !existsSync15(dataPath))
     return null;
   try {
@@ -10833,7 +11154,7 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_END
     return sharpModule;
   sharpLoaded = true;
   try {
-    const sharpPath = resolve14(process.cwd(), "node_modules/sharp");
+    const sharpPath = resolve15(process.cwd(), "node_modules/sharp");
     const mod = await import(sharpPath);
     sharpModule = mod.default ?? mod;
     return sharpModule;
@@ -10845,8 +11166,8 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_END
     return null;
   }
 }, writeToCache = (cacheDir, cacheKey, buffer, meta) => {
-  const metaPath = join15(cacheDir, `${cacheKey}.meta`);
-  const dataPath = join15(cacheDir, `${cacheKey}.data`);
+  const metaPath = join17(cacheDir, `${cacheKey}.meta`);
+  const dataPath = join17(cacheDir, `${cacheKey}.data`);
   writeFileSync4(dataPath, buffer);
   writeFileSync4(metaPath, JSON.stringify(meta));
 };
@@ -10934,7 +11255,7 @@ var init_optimizeHtmlImages = __esm(() => {
 // src/cli/scripts/telemetry.ts
 import { existsSync as existsSync16, mkdirSync as mkdirSync4, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
 import { homedir } from "os";
-import { join as join16 } from "path";
+import { join as join18 } from "path";
 var configDir, configPath, getTelemetryConfig = () => {
   try {
     if (!existsSync16(configPath))
@@ -10947,14 +11268,14 @@ var configDir, configPath, getTelemetryConfig = () => {
   }
 };
 var init_telemetry = __esm(() => {
-  configDir = join16(homedir(), ".absolutejs");
-  configPath = join16(configDir, "telemetry.json");
+  configDir = join18(homedir(), ".absolutejs");
+  configPath = join18(configDir, "telemetry.json");
 });
 
 // src/cli/telemetryEvent.ts
 import { existsSync as existsSync17, readFileSync as readFileSync12 } from "fs";
-import { arch, platform } from "os";
-import { dirname as dirname9, join as join17, parse } from "path";
+import { arch as arch2, platform as platform2 } from "os";
+import { dirname as dirname10, join as join19, parse } from "path";
 var checkCandidate = (candidate) => {
   if (!existsSync17(candidate)) {
     return null;
@@ -10974,12 +11295,12 @@ var checkCandidate = (candidate) => {
 }, findPackageVersion = () => {
   let { dir } = import.meta;
   while (dir !== parse(dir).root) {
-    const candidate = join17(dir, "package.json");
+    const candidate = join19(dir, "package.json");
     const version = checkCandidate(candidate);
     if (version) {
       return version;
     }
-    dir = dirname9(dir);
+    dir = dirname10(dir);
   }
   return "unknown";
 }, sendTelemetryEvent = (event, payload) => {
@@ -10991,10 +11312,10 @@ var checkCandidate = (candidate) => {
       return;
     const body = {
       anonymousId: config.anonymousId,
-      arch: arch(),
+      arch: arch2(),
       bunVersion: Bun.version,
       event,
-      os: platform(),
+      os: platform2(),
       payload,
       timestamp: new Date().toISOString(),
       version: getVersion()
@@ -11072,18 +11393,18 @@ __export(exports_buildHMRClient, {
   buildHMRClient: () => buildHMRClient
 });
 import { existsSync as existsSync18 } from "fs";
-import { resolve as resolve15 } from "path";
+import { resolve as resolve16 } from "path";
 var {build: bunBuild } = globalThis.Bun;
 var resolveHmrClientPath = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve15(import.meta.dir, "client/hmrClient.ts");
+  const fromSource = resolve16(import.meta.dir, "client/hmrClient.ts");
   if (existsSync18(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve15(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client/hmrClient.ts");
+  const fromNodeModules = resolve16(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client/hmrClient.ts");
   if (existsSync18(fromNodeModules))
     return fromNodeModules;
-  return resolve15(import.meta.dir, "dev/client/hmrClient.ts");
+  return resolve16(import.meta.dir, "dev/client/hmrClient.ts");
 }, hmrClientPath2, buildHMRClient = async () => {
   const entryPoint = hmrClientPath2;
   const result = await bunBuild({
@@ -11100,79 +11421,18 @@ var resolveHmrClientPath = () => {
     });
     return "// HMR client build failed";
   }
-  const [firstOutput] = result.outputs;
-  if (!firstOutput)
-    return "// HMR client build failed";
-  return firstOutput.text();
-};
-var init_buildHMRClient = __esm(() => {
-  init_telemetryEvent();
-  hmrClientPath2 = resolveHmrClientPath();
-});
-
-// src/build/nativeRewrite.ts
-import { dlopen, FFIType, ptr } from "bun:ffi";
-import { platform as platform2, arch as arch2 } from "os";
-import { resolve as resolve16 } from "path";
-var ffiDefinition, nativeLib = null, loadNative = () => {
-  if (nativeLib !== null)
-    return nativeLib;
-  const osPlatform = platform2();
-  const cpu = arch2();
-  const platformMap = {
-    "darwin-arm64": "darwin-arm64/fast_ops.dylib",
-    "darwin-x64": "darwin-x64/fast_ops.dylib",
-    "linux-arm64": "linux-arm64/fast_ops.so",
-    "linux-x64": "linux-x64/fast_ops.so",
-    "win32-arm64": "windows-arm64/fast_ops.dll",
-    "win32-x64": "windows-x64/fast_ops.dll"
-  };
-  const libPath = platformMap[`${osPlatform}-${cpu}`];
-  if (!libPath)
-    return null;
-  try {
-    const fullPath = resolve16(import.meta.dir, "../../native/packages", libPath);
-    const lib = dlopen(fullPath, ffiDefinition);
-    nativeLib = lib.symbols;
-    return nativeLib;
-  } catch {
-    return null;
-  }
-}, nativeRewriteImports = (content, replacements) => {
-  const lib = loadNative();
-  if (!lib)
-    return null;
-  const jsonStr = JSON.stringify(replacements);
-  const contentBuf = Buffer.from(content);
-  const jsonBuf = Buffer.from(jsonStr);
-  const outBuf = Buffer.alloc(content.length * 2);
-  const outLenBuf = new BigUint64Array([BigInt(outBuf.length)]);
-  const result = lib.rewrite_imports(ptr(contentBuf), contentBuf.length, ptr(jsonBuf), jsonBuf.length, ptr(outBuf), ptr(new Uint8Array(outLenBuf.buffer)));
-  if (result < 0)
-    return null;
-  if (result === 0)
-    return content;
-  const outLen = Number(outLenBuf[0]);
-  return outBuf.subarray(0, outLen).toString("utf-8");
+  const [firstOutput] = result.outputs;
+  if (!firstOutput)
+    return "// HMR client build failed";
+  return firstOutput.text();
 };
-var init_nativeRewrite = __esm(() => {
-  ffiDefinition = {
-    rewrite_imports: {
-      args: [
-        FFIType.ptr,
-        FFIType.u64,
-        FFIType.ptr,
-        FFIType.u64,
-        FFIType.ptr,
-        FFIType.ptr
-      ],
-      returns: FFIType.i32
-    }
-  };
+var init_buildHMRClient = __esm(() => {
+  init_telemetryEvent();
+  hmrClientPath2 = resolveHmrClientPath();
 });
 
 // src/build/rewriteReactImports.ts
-var escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), rewriterCache, cacheKey = (vendorPaths) => {
+var escapeRegex2 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), rewriterCache, cacheKey = (vendorPaths) => {
   const entries = Object.entries(vendorPaths).sort(([left], [right]) => left.localeCompare(right));
   let key = "";
   for (const [k2, v2] of entries) {
@@ -11186,7 +11446,7 @@ var escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), rewriterC
     return cached;
   const replacements = Object.entries(vendorPaths).sort(([keyA], [keyB]) => keyB.length - keyA.length);
   const lookup = new Map(replacements);
-  const alt = replacements.map(([spec]) => escapeRegex(spec)).join("|");
+  const alt = replacements.map(([spec]) => escapeRegex2(spec)).join("|");
   const fromRegex = new RegExp(`(from\\s*["'])(${alt})(["'])`, "g");
   const sideEffectRegex = new RegExp(`(import\\s*["'])(${alt})(["']\\s*;?)`, "g");
   const dynamicRegex = new RegExp(`(import\\s*\\(\\s*["'])(${alt})(["']\\s*\\))`, "g");
@@ -11277,7 +11537,7 @@ var devVendorPaths = null, getDevVendorPaths = () => devVendorPaths, setDevVendo
 
 // src/build/angularLinkerPlugin.ts
 import { existsSync as existsSync19, mkdirSync as mkdirSync5, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname10, join as join18, relative as relative6, resolve as resolve17 } from "path";
+import { dirname as dirname11, join as join20, relative as relative7, resolve as resolve17 } from "path";
 import { createHash as createHash3 } from "crypto";
 var CACHE_ROOT, ANGULAR_LINKER_CANDIDATE_RE, createAngularLinkerPlugin = (linkerJitMode) => ({
   name: "angular-linker",
@@ -11285,7 +11545,7 @@ var CACHE_ROOT, ANGULAR_LINKER_CANDIDATE_RE, createAngularLinkerPlugin = (linker
     let needsLinking;
     let babelTransform;
     let linkerPlugin;
-    const cacheDir = join18(CACHE_ROOT, linkerJitMode ? "jit" : "aot");
+    const cacheDir = join20(CACHE_ROOT, linkerJitMode ? "jit" : "aot");
     bld.onLoad({ filter: ANGULAR_LINKER_CANDIDATE_RE }, async (args) => {
       const source = await Bun.file(args.path).text();
       if (!needsLinking) {
@@ -11298,7 +11558,7 @@ var CACHE_ROOT, ANGULAR_LINKER_CANDIDATE_RE, createAngularLinkerPlugin = (linker
         return;
       }
       const hash = createHash3("md5").update(source).digest("hex");
-      const cachePath = join18(cacheDir, `${hash}.js`);
+      const cachePath = join20(cacheDir, `${hash}.js`);
       if (existsSync19(cachePath)) {
         return {
           contents: readFileSync13(cachePath, "utf-8"),
@@ -11315,10 +11575,10 @@ var CACHE_ROOT, ANGULAR_LINKER_CANDIDATE_RE, createAngularLinkerPlugin = (linker
         const mod = await import(linkerSpecifier);
         linkerPlugin = mod.createEs2015LinkerPlugin({
           fileSystem: {
-            dirname: dirname10,
+            dirname: dirname11,
             exists: existsSync19,
             readFile: readFileSync13,
-            relative: relative6,
+            relative: relative7,
             resolve: resolve17
           },
           linkerJitMode,
@@ -11357,7 +11617,7 @@ var init_angularLinkerPlugin = __esm(() => {
 
 // src/build/externalAssetPlugin.ts
 import { copyFileSync, existsSync as existsSync20, mkdirSync as mkdirSync6, statSync } from "fs";
-import { basename as basename5, dirname as dirname11, join as join19, resolve as resolve18 } from "path";
+import { basename as basename5, dirname as dirname12, join as join21, resolve as resolve18 } from "path";
 var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
   name: "absolute-external-asset",
   setup(bld) {
@@ -11372,7 +11632,7 @@ var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
         return;
       urlPattern.lastIndex = 0;
       let match;
-      const sourceDir = dirname11(args.path);
+      const sourceDir = dirname12(args.path);
       while ((match = urlPattern.exec(source)) !== null) {
         const relPath = match[1];
         if (!relPath)
@@ -11382,10 +11642,10 @@ var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
           continue;
         if (!statSync(assetPath).isFile())
           continue;
-        const targetPath = join19(outDir, basename5(assetPath));
+        const targetPath = join21(outDir, basename5(assetPath));
         if (existsSync20(targetPath))
           continue;
-        mkdirSync6(dirname11(targetPath), { recursive: true });
+        mkdirSync6(dirname12(targetPath), { recursive: true });
         copyFileSync(assetPath, targetPath);
       }
       return;
@@ -11593,7 +11853,7 @@ __export(exports_hmrInjectionPlugin, {
   applyAngularHmrInjection: () => applyAngularHmrInjection
 });
 import { readFile as readFile5 } from "fs/promises";
-import { relative as relative7, resolve as resolve19 } from "path";
+import { relative as relative8, resolve as resolve19 } from "path";
 var ENTITY_DECORATOR_RE, IMPORT_RE, TOP_LEVEL_DECL_RE, extractAllTopLevelNames = (jsSource) => {
   const names = new Set;
   IMPORT_RE.lastIndex = 0;
@@ -11773,9 +12033,9 @@ var ENTITY_DECORATOR_RE, IMPORT_RE, TOP_LEVEL_DECL_RE, extractAllTopLevelNames =
   }
   if (classNames.length === 0)
     return;
-  const relFromGenRoot = relative7(generatedAngularRoot, componentJsAbsPath).replace(/\\/g, "/");
+  const relFromGenRoot = relative8(generatedAngularRoot, componentJsAbsPath).replace(/\\/g, "/");
   const userTsPath = resolve19(userAngularRoot, relFromGenRoot.replace(/\.js$/, ".ts"));
-  const projectRel = relative7(projectRoot, userTsPath).replace(/\\/g, "/");
+  const projectRel = relative8(projectRoot, userTsPath).replace(/\\/g, "/");
   const tail = classNames.map((className) => {
     const id = `${projectRel}@${className}`;
     return buildHmrTail(className, JSON.stringify(id));
@@ -11815,11 +12075,11 @@ var HASHED_FILE_PATTERN, cleanStaleOutputs = async (buildPath, currentOutputPath
   const currentPaths = new Set(currentOutputPaths.map((path) => resolve20(path)));
   const glob = new Glob5("**/*");
   const removals = [];
-  for (const relative8 of glob.scanSync({ cwd: buildPath })) {
-    const absolute = resolve20(buildPath, relative8);
+  for (const relative9 of glob.scanSync({ cwd: buildPath })) {
+    const absolute = resolve20(buildPath, relative9);
     if (currentPaths.has(absolute))
       continue;
-    if (!HASHED_FILE_PATTERN.test(relative8))
+    if (!HASHED_FILE_PATTERN.test(relative9))
       continue;
     removals.push(rm2(absolute, { force: true }));
   }
@@ -11835,20 +12095,20 @@ __export(exports_generatedDir, {
   getGeneratedRoot: () => getGeneratedRoot,
   getFrameworkGeneratedDir: () => getFrameworkGeneratedDir
 });
-import { join as join20 } from "path";
-var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getGeneratedRoot = (projectRoot = process.cwd()) => join20(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME), getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join20(getGeneratedRoot(projectRoot), framework);
+import { join as join22 } from "path";
+var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getGeneratedRoot = (projectRoot = process.cwd()) => join22(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME), getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join22(getGeneratedRoot(projectRoot), framework);
 var init_generatedDir = () => {};
 
 // src/utils/cleanup.ts
 import { rm as rm3 } from "fs/promises";
-import { join as join21 } from "path";
+import { join as join23 } 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(join21(frameworkDir, "generated")));
+    tasks.push(removeIfExists(join23(frameworkDir, "generated")));
   return Promise.all(tasks);
 }, cleanup = async ({
   angularDir,
@@ -11887,7 +12147,7 @@ var init_commonAncestor = () => {};
 
 // src/utils/buildDirectoryLock.ts
 import { mkdirSync as mkdirSync7, unlinkSync, writeFileSync as writeFileSync7, readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname12, join as join22 } from "path";
+import { dirname as dirname13, join as join24 } from "path";
 var heldLocks, HELD_LOCKS_ENV = "ABSOLUTE_HELD_BUILD_DIRECTORY_LOCKS", exitHandlersRegistered = false, registerExitHandlersOnce = () => {
   if (exitHandlersRegistered)
     return;
@@ -11913,7 +12173,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) => join22(dirname12(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) => join24(dirname13(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];
@@ -11930,7 +12190,7 @@ var heldLocks, HELD_LOCKS_ENV = "ABSOLUTE_HELD_BUILD_DIRECTORY_LOCKS", exitHandl
   locks.delete(buildDirectory);
   writeHeldLockEnv(locks);
 }, writeLockFileSync = (lockPath, metadata2) => {
-  mkdirSync7(dirname12(lockPath), { recursive: true });
+  mkdirSync7(dirname13(lockPath), { recursive: true });
   writeFileSync7(lockPath, JSON.stringify(metadata2, null, 2), { flag: "wx" });
 }, readLockMetadata = (lockPath) => {
   try {
@@ -12050,11 +12310,11 @@ var init_buildDirectoryLock = __esm(() => {
 });
 
 // src/utils/validateSafePath.ts
-import { resolve as resolve21, relative as relative8 } from "path";
+import { resolve as resolve21, relative as relative9 } from "path";
 var validateSafePath = (targetPath, baseDirectory) => {
   const absoluteBase = resolve21(baseDirectory);
   const absoluteTarget = resolve21(baseDirectory, targetPath);
-  const relativePath = normalizePath(relative8(absoluteBase, absoluteTarget));
+  const relativePath = normalizePath(relative9(absoluteBase, absoluteTarget));
   if (relativePath.startsWith("../") || relativePath === "..") {
     throw new Error(`Unsafe path: ${targetPath}`);
   }
@@ -12068,7 +12328,7 @@ __export(exports_scanVueSsrOnlyPages, {
   scanVueSsrOnlyPages: () => scanVueSsrOnlyPages
 });
 import { readdirSync as readdirSync2, readFileSync as readFileSync15 } from "fs";
-import { join as join23 } from "path";
+import { join as join25 } from "path";
 import ts7 from "typescript";
 var SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind2 = (filePath) => {
   if (filePath.endsWith(".tsx"))
@@ -12101,9 +12361,9 @@ var SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind2 = (filePath) => {
           continue;
         if (entry.name.startsWith("."))
           continue;
-        stack.push(join23(dir, entry.name));
+        stack.push(join25(dir, entry.name));
       } else if (entry.isFile() && hasSourceExtension2(entry.name)) {
-        out.push(join23(dir, entry.name));
+        out.push(join25(dir, entry.name));
       }
     }
   }
@@ -12215,7 +12475,7 @@ var init_scanVueSsrOnlyPages = __esm(() => {
 
 // src/build/scanAngularHandlerCalls.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync16 } from "fs";
-import { join as join24 } from "path";
+import { join as join26 } from "path";
 import ts8 from "typescript";
 var ELYSIA_ROUTE_METHODS2, SKIP_DIRS3, SOURCE_EXTENSIONS3, getScriptKind3 = (filePath) => {
   if (filePath.endsWith(".tsx"))
@@ -12248,9 +12508,9 @@ var ELYSIA_ROUTE_METHODS2, SKIP_DIRS3, SOURCE_EXTENSIONS3, getScriptKind3 = (fil
           continue;
         if (entry.name.startsWith("."))
           continue;
-        stack.push(join24(dir, entry.name));
+        stack.push(join26(dir, entry.name));
       } else if (entry.isFile() && hasSourceExtension3(entry.name)) {
-        out.push(join24(dir, entry.name));
+        out.push(join26(dir, entry.name));
       }
     }
   }
@@ -12365,7 +12625,7 @@ var init_scanAngularHandlerCalls = __esm(() => {
 
 // src/build/scanAngularPageRoutes.ts
 import { readdirSync as readdirSync4, readFileSync as readFileSync17 } from "fs";
-import { basename as basename7, join as join25 } from "path";
+import { basename as basename7, join as join27 } from "path";
 import ts9 from "typescript";
 var SOURCE_EXTENSIONS4, SKIP_DIRS4, hasSourceExtension4 = (filePath) => {
   const idx = filePath.lastIndexOf(".");
@@ -12405,9 +12665,9 @@ var SOURCE_EXTENSIONS4, SKIP_DIRS4, hasSourceExtension4 = (filePath) => {
           continue;
         if (entry.name.startsWith("."))
           continue;
-        stack.push(join25(dir, entry.name));
+        stack.push(join27(dir, entry.name));
       } else if (entry.isFile() && isPageFile(entry.name)) {
-        out.push(join25(dir, entry.name));
+        out.push(join27(dir, entry.name));
       }
     }
   }
@@ -12484,7 +12744,7 @@ __export(exports_parseAngularConfigImports, {
   parseAngularProvidersImport: () => parseAngularProvidersImport
 });
 import { existsSync as existsSync21, readFileSync as readFileSync18 } from "fs";
-import { dirname as dirname13, isAbsolute as isAbsolute3, join as join26 } from "path";
+import { dirname as dirname14, isAbsolute as isAbsolute3, join as join28 } from "path";
 import ts10 from "typescript";
 var findDefineConfigCall = (sf) => {
   let result = null;
@@ -12539,15 +12799,15 @@ var findDefineConfigCall = (sf) => {
 }, resolveConfigPath = (projectRoot) => {
   const envOverride = process.env.ABSOLUTE_CONFIG;
   if (envOverride) {
-    const resolved = isAbsolute3(envOverride) ? envOverride : join26(projectRoot, envOverride);
+    const resolved = isAbsolute3(envOverride) ? envOverride : join28(projectRoot, envOverride);
     if (existsSync21(resolved))
       return resolved;
   }
   const candidates = [
-    join26(projectRoot, "absolute.config.ts"),
-    join26(projectRoot, "absolute.config.mts"),
-    join26(projectRoot, "absolute.config.js"),
-    join26(projectRoot, "absolute.config.mjs")
+    join28(projectRoot, "absolute.config.ts"),
+    join28(projectRoot, "absolute.config.mts"),
+    join28(projectRoot, "absolute.config.js"),
+    join28(projectRoot, "absolute.config.mjs")
   ];
   for (const candidate of candidates) {
     if (existsSync21(candidate))
@@ -12579,8 +12839,8 @@ var findDefineConfigCall = (sf) => {
   const importInfo = findImportForBinding(sf, binding);
   if (!importInfo)
     return null;
-  const configDir2 = dirname13(configPath2);
-  const absolutePath = importInfo.source.startsWith(".") ? join26(configDir2, importInfo.source).replace(/\.[cm]?[tj]sx?$/, "") : isAbsolute3(importInfo.source) ? importInfo.source.replace(/\.[cm]?[tj]sx?$/, "") : importInfo.source;
+  const configDir2 = dirname14(configPath2);
+  const absolutePath = importInfo.source.startsWith(".") ? join28(configDir2, importInfo.source).replace(/\.[cm]?[tj]sx?$/, "") : isAbsolute3(importInfo.source) ? importInfo.source.replace(/\.[cm]?[tj]sx?$/, "") : importInfo.source;
   return {
     absolutePath,
     bindingName: binding,
@@ -12652,14 +12912,14 @@ __export(exports_compileSvelte, {
   clearSvelteCompilerCache: () => clearSvelteCompilerCache
 });
 import { existsSync as existsSync22 } from "fs";
-import { mkdir as mkdir4, stat as stat2 } from "fs/promises";
+import { mkdir as mkdir5, stat as stat2 } from "fs/promises";
 import {
-  dirname as dirname14,
-  join as join27,
+  dirname as dirname15,
+  join as join29,
   basename as basename8,
   extname as extname5,
   resolve as resolve22,
-  relative as relative9,
+  relative as relative10,
   sep as sep2
 } from "path";
 import { env as env2 } from "process";
@@ -12703,7 +12963,7 @@ var resolveDevClientDir2 = () => {
 }, resolveRelativeModule2 = async (spec, from) => {
   if (!spec.startsWith("."))
     return null;
-  const basePath = resolve22(dirname14(from), spec);
+  const basePath = resolve22(dirname15(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -12714,14 +12974,14 @@ var resolveDevClientDir2 = () => {
     `${basePath}.svelte`,
     `${basePath}.svelte.ts`,
     `${basePath}.svelte.js`,
-    join27(basePath, "index.ts"),
-    join27(basePath, "index.js"),
-    join27(basePath, "index.mjs"),
-    join27(basePath, "index.cjs"),
-    join27(basePath, "index.json"),
-    join27(basePath, "index.svelte"),
-    join27(basePath, "index.svelte.ts"),
-    join27(basePath, "index.svelte.js")
+    join29(basePath, "index.ts"),
+    join29(basePath, "index.js"),
+    join29(basePath, "index.mjs"),
+    join29(basePath, "index.cjs"),
+    join29(basePath, "index.json"),
+    join29(basePath, "index.svelte"),
+    join29(basePath, "index.svelte.ts"),
+    join29(basePath, "index.svelte.js")
   ];
   const checks = await Promise.all(candidates.map(exists));
   return candidates.find((_2, index) => checks[index]) ?? null;
@@ -12730,7 +12990,7 @@ var resolveDevClientDir2 = () => {
     const resolved = resolvePackageImport(spec);
     return resolved && /\.svelte(\.(?:ts|js))?$/.test(resolved) ? resolved : null;
   }
-  const basePath = resolve22(dirname14(from), spec);
+  const basePath = resolve22(dirname15(from), spec);
   const explicit = /\.(svelte|svelte\.(?:ts|js))$/.test(basePath);
   if (!explicit) {
     const extensions = [".svelte", ".svelte.ts", ".svelte.js"];
@@ -12751,8 +13011,8 @@ var resolveDevClientDir2 = () => {
     return jsPath;
   return null;
 }, addModuleRewrite = (rewrites, rawSpec, resolvedModule, ssrOutputDir, clientOutputDir) => {
-  const toServer = relative9(ssrOutputDir, resolvedModule).replace(/\\/g, "/");
-  const toClient = relative9(clientOutputDir, resolvedModule).replace(/\\/g, "/");
+  const toServer = relative10(ssrOutputDir, resolvedModule).replace(/\\/g, "/");
+  const toClient = relative10(clientOutputDir, resolvedModule).replace(/\\/g, "/");
   rewrites.set(rawSpec, {
     client: toClient.startsWith(".") || toClient.startsWith("/") ? toClient : `./${toClient}`,
     server: toServer.startsWith(".") ? toServer : `./${toServer}`
@@ -12760,10 +13020,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 = join27(generatedDir, "client");
-  const indexDir = join27(generatedDir, "indexes");
-  const serverDir = join27(generatedDir, "server");
-  await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir4(dir, { recursive: true })));
+  const clientDir = join29(generatedDir, "client");
+  const indexDir = join29(generatedDir, "indexes");
+  const serverDir = join29(generatedDir, "server");
+  await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir5(dir, { recursive: true })));
   const dev = env2.NODE_ENV !== "production";
   const build2 = async (src) => {
     const memoized = cache.get(src);
@@ -12790,8 +13050,8 @@ var resolveDevClientDir2 = () => {
     const preprocessedClient = isModule ? loweredClientSource.code : (await preprocess(loweredClientSource.code, svelteStylePreprocessor)).code;
     const transpiledServer = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler3.transformSync(preprocessedServer) : preprocessedServer;
     const transpiledClient = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler3.transformSync(preprocessedClient) : preprocessedClient;
-    const rawRel = dirname14(relative9(svelteRoot, src)).replace(/\\/g, "/");
-    const relDir = rawRel.startsWith("..") ? `_ext/${relative9(process.cwd(), dirname14(src)).replace(/\\/g, "/")}` : rawRel;
+    const rawRel = dirname15(relative10(svelteRoot, src)).replace(/\\/g, "/");
+    const relDir = rawRel.startsWith("..") ? `_ext/${relative10(process.cwd(), dirname15(src)).replace(/\\/g, "/")}` : rawRel;
     const baseName = basename8(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)));
@@ -12800,8 +13060,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 = dirname14(join27(serverDir, relDir, `${baseName}.js`));
-    const clientOutputDir = dirname14(join27(clientDir, relDir, `${baseName}.js`));
+    const ssrOutputDir = dirname15(join29(serverDir, relDir, `${baseName}.js`));
+    const clientOutputDir = dirname15(join29(clientDir, relDir, `${baseName}.js`));
     for (let idx = 0;idx < importPaths.length; idx++) {
       const rawSpec = importPaths[idx];
       if (!rawSpec)
@@ -12812,15 +13072,15 @@ var resolveDevClientDir2 = () => {
         addModuleRewrite(externalRewrites, rawSpec, resolvedModule, ssrOutputDir, clientOutputDir);
       if (!resolved)
         continue;
-      const childRel = relative9(svelteRoot, resolved).replace(/\\/g, "/");
+      const childRel = relative10(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 = relative9(ssrOutputDir, childBuilt2.ssr).replace(/\\/g, "/");
-      const toClient = relative9(clientOutputDir, childBuilt2.client).replace(/\\/g, "/");
+      const toServer = relative10(ssrOutputDir, childBuilt2.ssr).replace(/\\/g, "/");
+      const toClient = relative10(clientOutputDir, childBuilt2.client).replace(/\\/g, "/");
       externalRewrites.set(origSpec, {
         client: toClient.startsWith(".") ? toClient : `./${toClient}`,
         server: toServer.startsWith(".") ? toServer : `./${toServer}`
@@ -12854,7 +13114,7 @@ var resolveDevClientDir2 = () => {
       }).js;
       let code = compiledJs.code.replace(/\.svelte(?:\.(?:ts|js))?(['"])/g, ".js$1");
       if (mode === "client" && isDev2) {
-        const moduleKey = `/@src/${relative9(process.cwd(), src).replace(/\\/g, "/")}`;
+        const moduleKey = `/@src/${relative10(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; };`);
@@ -12866,11 +13126,11 @@ var resolveDevClientDir2 = () => {
       code += islandMetadataExports;
       return { code, map: compiledJs.map };
     };
-    const ssrPath = join27(serverDir, relDir, `${baseName}.js`);
-    const clientPath = join27(clientDir, relDir, `${baseName}.js`);
+    const ssrPath = join29(serverDir, relDir, `${baseName}.js`);
+    const clientPath = join29(clientDir, relDir, `${baseName}.js`);
     await Promise.all([
-      mkdir4(dirname14(ssrPath), { recursive: true }),
-      mkdir4(dirname14(clientPath), { recursive: true })
+      mkdir5(dirname15(ssrPath), { recursive: true }),
+      mkdir5(dirname15(clientPath), { recursive: true })
     ]);
     const inlineMap = (map) => map ? `
 //# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(map)).toString("base64")}
@@ -12903,10 +13163,10 @@ var resolveDevClientDir2 = () => {
   };
   const roots = await Promise.all(entryPoints.map(build2));
   await Promise.all(roots.map(async ({ client: client2, hasAwaitSlot }) => {
-    const relClientDir = dirname14(relative9(clientDir, client2));
+    const relClientDir = dirname15(relative10(clientDir, client2));
     const name = basename8(client2, extname5(client2));
-    const indexPath = join27(indexDir, relClientDir, `${name}.js`);
-    const importRaw = relative9(dirname14(indexPath), client2).split(sep2).join("/");
+    const indexPath = join29(indexDir, relClientDir, `${name}.js`);
+    const importRaw = relative10(dirname15(indexPath), client2).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev2 ? `window.__HMR_FRAMEWORK__ = "svelte";
 import "${hmrClientPath3}";
@@ -12977,14 +13237,14 @@ if (typeof window !== "undefined") {
     setTimeout(releaseStreamingSlots, 0);
   }
 }`;
-    await mkdir4(dirname14(indexPath), { recursive: true });
+    await mkdir5(dirname15(indexPath), { recursive: true });
     return write2(indexPath, bootstrap);
   }));
   return {
     svelteClientPaths: roots.map(({ client: client2 }) => client2),
     svelteIndexPaths: roots.map(({ client: client2 }) => {
-      const rel = dirname14(relative9(clientDir, client2));
-      return join27(indexDir, rel, basename8(client2));
+      const rel = dirname15(relative10(clientDir, client2));
+      return join29(indexDir, rel, basename8(client2));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
   };
@@ -12999,7 +13259,7 @@ var init_compileSvelte = __esm(() => {
   init_lowerAwaitSlotSyntax();
   init_renderToReadableStream();
   devClientDir2 = resolveDevClientDir2();
-  hmrClientPath3 = join27(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath3 = join29(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
   persistentCache = new Map;
   sourceHashCache = new Map;
   transpiler3 = new Transpiler2({ loader: "ts", target: "browser" });
@@ -13411,13 +13671,13 @@ __export(exports_compileVue, {
   clearVueHmrCaches: () => clearVueHmrCaches
 });
 import { existsSync as existsSync23, readFileSync as readFileSync20, realpathSync as realpathSync2 } from "fs";
-import { mkdir as mkdir5 } from "fs/promises";
+import { mkdir as mkdir6 } from "fs/promises";
 import {
   basename as basename9,
-  dirname as dirname15,
+  dirname as dirname16,
   isAbsolute as isAbsolute4,
-  join as join28,
-  relative as relative10,
+  join as join30,
+  relative as relative11,
   resolve as resolve23
 } from "path";
 var {file: file3, write: write3, Transpiler: Transpiler3 } = globalThis.Bun;
@@ -13469,14 +13729,14 @@ var resolveDevClientDir3 = () => {
     return "template-only";
   }
   return "full";
-}, 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), inlineCssImports = (cssContent, cssFilePath, visited = new Set) => {
+}, generateVueHmrId = (sourceFilePath, vueRootDir) => relative11(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), inlineCssImports = (cssContent, cssFilePath, visited = new Set) => {
   const resolved = realpathSync2(cssFilePath);
   if (visited.has(resolved))
     return "";
   visited.add(resolved);
   const importRegex = /@import\s+(?:url\(\s*)?(['"])(\.{1,2}\/[^'"]+)\1\s*\)?\s*;?/g;
   return cssContent.replace(importRegex, (match, _quote, relPath) => {
-    const importedPath = resolve23(dirname15(cssFilePath), relPath);
+    const importedPath = resolve23(dirname16(cssFilePath), relPath);
     if (!existsSync23(importedPath))
       return match;
     const importedContent = readFileSync20(importedPath, "utf-8");
@@ -13533,7 +13793,7 @@ var resolveDevClientDir3 = () => {
   const cachedResult = cacheMap.get(sourceFilePath);
   if (cachedResult)
     return cachedResult;
-  const relativeFilePath = relative10(vueRootDir, sourceFilePath).replace(/\\/g, "/");
+  const relativeFilePath = relative11(vueRootDir, sourceFilePath).replace(/\\/g, "/");
   const relativeWithoutExtension = relativeFilePath.replace(/\.vue$/, "");
   const fileBaseName = basename9(sourceFilePath, ".vue");
   const componentId = toKebab(fileBaseName);
@@ -13572,12 +13832,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(".") || isAbsolute4(path)) && isStylePath(path)).map((path) => isAbsolute4(path) ? path : resolve23(dirname15(sourceFilePath), path));
+  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute4(path)) && isStylePath(path)).map((path) => isAbsolute4(path) ? path : resolve23(dirname16(sourceFilePath), path));
   for (const stylePath of stylePathsImported) {
     addStyleImporter(sourceFilePath, stylePath);
   }
   const childBuildResults = await Promise.all([
-    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve23(dirname15(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
+    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve23(dirname16(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;
@@ -13592,7 +13852,7 @@ var resolveDevClientDir3 = () => {
     sourceMap: true
   }) : { bindings: {}, content: "export default {};", map: undefined };
   const strippedScript = stripExports2(compiledScript.content);
-  const sourceDir = dirname15(sourceFilePath);
+  const sourceDir = dirname16(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) {
@@ -13637,8 +13897,8 @@ var resolveDevClientDir3 = () => {
   ];
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
-    const cssOutputFile = join28(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
-    await mkdir5(dirname15(cssOutputFile), { recursive: true });
+    const cssOutputFile = join30(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
+    await mkdir6(dirname16(cssOutputFile), { recursive: true });
     await write3(cssOutputFile, allCss.join(`
 `));
     cssOutputPaths = [cssOutputFile];
@@ -13668,21 +13928,21 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
   const clientCode = assembleModule(generateRenderFunction(false), "render", true) + islandMetadataExports;
   const serverCode = assembleModule(generateRenderFunction(true), "ssrRender", false) + islandMetadataExports;
-  const clientOutputPath = join28(outputDirs.client, `${relativeWithoutExtension}.js`);
-  const serverOutputPath = join28(outputDirs.server, `${relativeWithoutExtension}.js`);
+  const clientOutputPath = join30(outputDirs.client, `${relativeWithoutExtension}.js`);
+  const serverOutputPath = join30(outputDirs.server, `${relativeWithoutExtension}.js`);
   const rewritePackageImports = (code, outputPath, mode) => {
     let result2 = code;
     for (const [bareImport, paths] of packageImportRewrites) {
       const targetPath = mode === "server" ? paths.server : paths.client;
-      let rel = relative10(dirname15(outputPath), targetPath).replace(/\\/g, "/");
+      let rel = relative11(dirname16(outputPath), targetPath).replace(/\\/g, "/");
       if (!rel.startsWith("."))
         rel = `./${rel}`;
       result2 = result2.replaceAll(bareImport, rel);
     }
     return result2;
   };
-  await mkdir5(dirname15(clientOutputPath), { recursive: true });
-  await mkdir5(dirname15(serverOutputPath), { recursive: true });
+  await mkdir6(dirname16(clientOutputPath), { recursive: true });
+  await mkdir6(dirname16(serverOutputPath), { recursive: true });
   const clientFinal = rewritePackageImports(clientCode, clientOutputPath, "client");
   const serverFinal = rewritePackageImports(serverCode, serverOutputPath, "server");
   const inlineSourceMapFor = (finalContent) => {
@@ -13705,7 +13965,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     serverPath: serverOutputPath,
     spaRoutes: spaRoutes.length > 0 ? spaRoutes : undefined,
     tsHelperPaths: [
-      ...helperModulePaths.map((helper) => resolveHelperTsPath(dirname15(sourceFilePath), helper)),
+      ...helperModulePaths.map((helper) => resolveHelperTsPath(dirname16(sourceFilePath), helper)),
       ...childBuildResults.flatMap((child) => child.tsHelperPaths)
     ]
   };
@@ -13715,15 +13975,15 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
 }, compileVue = async (entryPoints, vueRootDir, isDev2 = false, stylePreprocessors, ssrOnlyEntries) => {
   const compiler = await import("@vue/compiler-sfc");
   const generatedDir = getFrameworkGeneratedDir("vue");
-  const clientOutputDir = join28(generatedDir, "client");
-  const indexOutputDir = join28(generatedDir, "indexes");
-  const serverOutputDir = join28(generatedDir, "server");
-  const cssOutputDir = join28(generatedDir, "compiled");
+  const clientOutputDir = join30(generatedDir, "client");
+  const indexOutputDir = join30(generatedDir, "indexes");
+  const serverOutputDir = join30(generatedDir, "server");
+  const cssOutputDir = join30(generatedDir, "compiled");
   await Promise.all([
-    mkdir5(clientOutputDir, { recursive: true }),
-    mkdir5(indexOutputDir, { recursive: true }),
-    mkdir5(serverOutputDir, { recursive: true }),
-    mkdir5(cssOutputDir, { recursive: true })
+    mkdir6(clientOutputDir, { recursive: true }),
+    mkdir6(indexOutputDir, { recursive: true }),
+    mkdir6(serverOutputDir, { recursive: true }),
+    mkdir6(cssOutputDir, { recursive: true })
   ]);
   const buildCache = new Map;
   const allTsHelperPaths = new Set;
@@ -13746,16 +14006,16 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
       };
     }
     const entryBaseName = basename9(entryPath, ".vue");
-    const indexOutputFile = join28(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join28(clientOutputDir, relative10(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
-    await mkdir5(dirname15(indexOutputFile), { recursive: true });
+    const indexOutputFile = join30(indexOutputDir, `${entryBaseName}.js`);
+    const clientOutputFile = join30(clientOutputDir, relative11(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    await mkdir6(dirname16(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev2 ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
       `import "${hmrClientPath4}";`
     ] : [];
     await write3(indexOutputFile, [
       ...vueHmrImports,
-      `import Comp, * as PageModule from "${relative10(dirname15(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
+      `import Comp, * as PageModule from "${relative11(dirname16(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
       'import { createSSRApp, createApp } from "vue";',
       "",
       "// HMR State Preservation: Check for preserved state from HMR",
@@ -13904,7 +14164,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     if (!tsPath)
       continue;
     const sourceCode = await file3(tsPath).text();
-    const helperDir = dirname15(tsPath);
+    const helperDir = dirname16(tsPath);
     for (const dep of extractImports(sourceCode)) {
       if (!dep.startsWith(".") || isStylePath(dep) || dep.endsWith(".vue")) {
         continue;
@@ -13921,11 +14181,11 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   await Promise.all(Array.from(allTsHelperPaths).map(async (tsPath) => {
     const sourceCode = await file3(tsPath).text();
     const transpiledCode = transpiler4.transformSync(sourceCode);
-    const relativeJsPath = relative10(vueRootDir, tsPath).replace(/\.ts$/, ".js");
-    const outClientPath = join28(clientOutputDir, relativeJsPath);
-    const outServerPath = join28(serverOutputDir, relativeJsPath);
-    await mkdir5(dirname15(outClientPath), { recursive: true });
-    await mkdir5(dirname15(outServerPath), { recursive: true });
+    const relativeJsPath = relative11(vueRootDir, tsPath).replace(/\.ts$/, ".js");
+    const outClientPath = join30(clientOutputDir, relativeJsPath);
+    const outServerPath = join30(serverOutputDir, relativeJsPath);
+    await mkdir6(dirname16(outClientPath), { recursive: true });
+    await mkdir6(dirname16(outServerPath), { recursive: true });
     await write3(outClientPath, transpiledCode);
     await write3(outServerPath, transpiledCode);
   }));
@@ -13955,7 +14215,7 @@ var init_compileVue = __esm(() => {
   init_vueAutoRouterTransform();
   init_stylePreprocessor();
   devClientDir3 = resolveDevClientDir3();
-  hmrClientPath4 = join28(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath4 = join30(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
   transpiler4 = new Transpiler3({ loader: "ts", target: "browser" });
   scriptCache = new Map;
   scriptSetupCache = new Map;
@@ -14437,7 +14697,7 @@ __export(exports_compileAngular, {
   compileAngular: () => compileAngular
 });
 import { existsSync as existsSync24, readFileSync as readFileSync21, promises as fs5 } from "fs";
-import { join as join29, basename as basename10, sep as sep3, dirname as dirname16, resolve as resolve24, relative as relative11 } from "path";
+import { join as join31, basename as basename10, sep as sep3, dirname as dirname17, resolve as resolve24, relative as relative12 } from "path";
 var {Glob: Glob6 } = globalThis.Bun;
 import ts11 from "typescript";
 var traceAngularPhase = async (name, fn2, metadata2) => {
@@ -14480,10 +14740,10 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     `${candidate}.tsx`,
     `${candidate}.js`,
     `${candidate}.jsx`,
-    join29(candidate, "index.ts"),
-    join29(candidate, "index.tsx"),
-    join29(candidate, "index.js"),
-    join29(candidate, "index.jsx")
+    join31(candidate, "index.ts"),
+    join31(candidate, "index.tsx"),
+    join31(candidate, "index.js"),
+    join31(candidate, "index.jsx")
   ];
   return candidates.find((file4) => existsSync24(file4));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
@@ -14555,7 +14815,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     if (scan.usesLegacyAnimations)
       return true;
     for (const specifier of scan.imports) {
-      const importedPath = resolveLocalImport(specifier, dirname16(resolved));
+      const importedPath = resolveLocalImport(specifier, dirname17(resolved));
       if (importedPath && await visit(importedPath, visited)) {
         return true;
       }
@@ -14614,7 +14874,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     return `${path.replace(/\.ts$/, ".js")}${query}`;
   if (hasJsLikeExtension(path))
     return `${path}${query}`;
-  const importerDir = dirname16(importerOutputPath);
+  const importerDir = dirname17(importerOutputPath);
   const fileCandidate = resolve24(importerDir, `${path}.js`);
   if (outputFiles?.has(fileCandidate) || existsSync24(fileCandidate)) {
     return `${path}.js${query}`;
@@ -14647,16 +14907,16 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve24(dirname16(fromFile), specifier);
+  const basePath = resolve24(dirname17(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join29(basePath, "index.ts"),
-    join29(basePath, "index.tsx"),
-    join29(basePath, "index.mts"),
-    join29(basePath, "index.cts")
+    join31(basePath, "index.ts"),
+    join31(basePath, "index.tsx"),
+    join31(basePath, "index.mts"),
+    join31(basePath, "index.cts")
   ];
   return candidates.map((candidate) => resolve24(candidate)).find((candidate) => existsSync24(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile6) => {
@@ -14682,15 +14942,15 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   const paths = [];
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1])
-    paths.push(join29(fileDir, templateUrlMatch[1]));
+    paths.push(join31(fileDir, templateUrlMatch[1]));
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (styleUrlMatch?.[1])
-    paths.push(join29(fileDir, styleUrlMatch[1]));
+    paths.push(join31(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(join29(fileDir, urlMatch.replace(/['"]/g, "")));
+      paths.push(join31(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
   return paths.map((path) => resolve24(path));
@@ -14705,13 +14965,13 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     return null;
   }
 }, writeResourceCacheFile = async (cachePath, source) => {
-  await fs5.mkdir(dirname16(cachePath), { recursive: true });
+  await fs5.mkdir(dirname17(cachePath), { recursive: true });
   await fs5.writeFile(cachePath, JSON.stringify({
     source,
     version: 1
   }), "utf-8");
 }, resolveResourceTransformCachePath = async (filePath, source, stylePreprocessors) => {
-  const resourcePaths = collectAngularResourcePaths(source, dirname16(filePath));
+  const resourcePaths = collectAngularResourcePaths(source, dirname17(filePath));
   const resourceContents = await Promise.all(resourcePaths.map(async (resourcePath) => {
     const content = await fs5.readFile(resourcePath, "utf-8");
     return `${resourcePath}\x00${content}`;
@@ -14724,7 +14984,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     safeStableStringify(stylePreprocessors ?? null)
   ].join("\x00");
   const cacheKey2 = Bun.hash(cacheInput).toString(BASE_36_RADIX);
-  return join29(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
+  return join31(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
 }, precomputeAotResourceTransforms = async (inputPaths, readFile6, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
@@ -14751,7 +15011,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
       transformedSource = cached.source;
     } else {
       stats.cacheMisses += 1;
-      const transformed = await inlineResources(source, dirname16(resolvedPath), stylePreprocessors);
+      const transformed = await inlineResources(source, dirname17(resolvedPath), stylePreprocessors);
       transformedSource = transformed.source;
       await writeResourceCacheFile(cachePath, transformedSource);
     }
@@ -14770,7 +15030,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 = resolve24(join29(outDir, relative11(process.cwd(), resolve24(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve24(join31(outDir, relative12(process.cwd(), resolve24(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
       buildIslandMetadataExports(readFileSync21(inputPath, "utf-8"))
@@ -14780,7 +15040,7 @@ 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 = dirname16(tsPath);
+    const tsRootDir = dirname17(tsPath);
     return tsRootDir.endsWith("lib") ? tsRootDir : resolve24(tsRootDir, "lib");
   });
   const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
@@ -14817,7 +15077,7 @@ 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 = join29(tsLibDir, fileName);
+      const resolvedPath = join31(tsLibDir, fileName);
       return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
     }
     return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
@@ -14872,7 +15132,7 @@ 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: join29(outDir, fileName)
+      target: join31(outDir, fileName)
     }));
     const outputFiles = new Set(rawEntries.map(({ target }) => resolve24(target)));
     return rawEntries.map(({ content, target }) => {
@@ -14894,7 +15154,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     });
   });
   await traceAngularPhase("aot/write-output", () => Promise.all(entries.map(async ({ target, content }) => {
-    await fs5.mkdir(dirname16(target), { recursive: true });
+    await fs5.mkdir(dirname17(target), { recursive: true });
     await fs5.writeFile(target, content, "utf-8");
   })), { outputs: entries.length });
   return await traceAngularPhase("aot/collect-output-paths", () => entries.map(({ target }) => target), { outputs: entries.length });
@@ -15049,7 +15309,7 @@ ${fields}
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join29(fileDir, templateUrlMatch[1]);
+    const templatePath = join31(fileDir, templateUrlMatch[1]);
     if (!existsSync24(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -15080,7 +15340,7 @@ ${fields}
 }, inlineTemplateAndLowerDeferSync = (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join29(fileDir, templateUrlMatch[1]);
+    const templatePath = join31(fileDir, templateUrlMatch[1]);
     if (!existsSync24(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -15117,7 +15377,7 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join29(fileDir, styleUrl), stylePreprocessors);
+    return readAndEscapeFile(join31(fileDir, styleUrl), stylePreprocessors);
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -15128,7 +15388,7 @@ ${fields}
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join29(fileDir, styleUrlMatch[1]), stylePreprocessors);
+  const escaped = await readAndEscapeFile(join31(fileDir, styleUrlMatch[1]), stylePreprocessors);
   if (!escaped)
     return source;
   return source.slice(0, styleUrlMatch.index) + `styles: [\`${escaped}\`]` + source.slice(styleUrlMatch.index + styleUrlMatch[0].length);
@@ -15164,10 +15424,10 @@ ${fields}
       `${candidate}.js`,
       `${candidate}.jsx`,
       `${candidate}.json`,
-      join29(candidate, "index.ts"),
-      join29(candidate, "index.tsx"),
-      join29(candidate, "index.js"),
-      join29(candidate, "index.jsx")
+      join31(candidate, "index.ts"),
+      join31(candidate, "index.tsx"),
+      join31(candidate, "index.js"),
+      join31(candidate, "index.jsx")
     ];
     return candidates.find((file4) => existsSync24(file4));
   };
@@ -15191,13 +15451,13 @@ ${fields}
     }
   };
   const toOutputPath = (sourcePath) => {
-    const inputDir = dirname16(sourcePath);
+    const inputDir = dirname17(sourcePath);
     const fileBase = basename10(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
     if (inputDir === outDir || inputDir.startsWith(`${outDir}${sep3}`)) {
-      return join29(inputDir, fileBase);
+      return join31(inputDir, fileBase);
     }
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
-    return join29(outDir, relativeDir, fileBase);
+    return join31(outDir, relativeDir, fileBase);
   };
   const withCacheBuster = (specifier) => {
     if (!cacheBuster)
@@ -15245,10 +15505,10 @@ ${fields}
       return;
     visited.add(resolved);
     if (resolved.endsWith(".json") && existsSync24(resolved)) {
-      const inputDir2 = dirname16(resolved);
+      const inputDir2 = dirname17(resolved);
       const relativeDir2 = inputDir2.startsWith(baseDir) ? inputDir2.substring(baseDir.length + 1) : inputDir2;
-      const targetDir2 = join29(outDir, relativeDir2);
-      const targetPath2 = join29(targetDir2, basename10(resolved));
+      const targetDir2 = join31(outDir, relativeDir2);
+      const targetPath2 = join31(targetDir2, basename10(resolved));
       await fs5.mkdir(targetDir2, { recursive: true });
       await fs5.copyFile(resolved, targetPath2);
       allOutputs.push(targetPath2);
@@ -15260,13 +15520,13 @@ ${fields}
     if (!existsSync24(actualPath))
       return;
     let sourceCode = await fs5.readFile(actualPath, "utf-8");
-    const inlined = await inlineResources(sourceCode, dirname16(actualPath), stylePreprocessors);
-    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname16(actualPath)).source;
-    const inputDir = dirname16(actualPath);
+    const inlined = await inlineResources(sourceCode, dirname17(actualPath), stylePreprocessors);
+    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname17(actualPath)).source;
+    const inputDir = dirname17(actualPath);
     const fileBase = basename10(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
     const targetPath = toOutputPath(actualPath);
-    const targetDir = dirname16(targetPath);
-    const relativeDir = relative11(outDir, targetDir).replace(/\\/g, "/");
+    const targetDir = dirname17(targetPath);
+    const relativeDir = relative12(outDir, targetDir).replace(/\\/g, "/");
     const localImports = [];
     const importRewrites = new Map;
     const fromRegex = /(?:from|import)\s+['"]([^'".][^'"]*|\.\.?\/[^'"]+)['"]/g;
@@ -15287,7 +15547,7 @@ ${fields}
       const resolved2 = resolveLocalImport(specifier, inputDir);
       if (!resolved2)
         return null;
-      const relativeImport = relative11(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
+      const relativeImport = relative12(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
       const relativeRewrite = relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`;
       importRewrites.set(specifier, relativeRewrite);
       return resolved2;
@@ -15326,7 +15586,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join29(compiledParent, "indexes");
+  const indexesDir = join31(compiledParent, "indexes");
   await traceAngularPhase("setup/create-indexes-dir", () => fs5.mkdir(indexesDir, { recursive: true }));
   const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve24(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   if (!hmr) {
@@ -15340,10 +15600,10 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
         absolute: false,
         cwd: angularSrcDir
       })) {
-        const sourcePath = join29(angularSrcDir, rel);
-        const cwdRel = relative11(cwd, sourcePath);
-        const targetPath = join29(compiledRoot, cwdRel);
-        await fs5.mkdir(dirname16(targetPath), { recursive: true });
+        const sourcePath = join31(angularSrcDir, rel);
+        const cwdRel = relative12(cwd, sourcePath);
+        const targetPath = join31(compiledRoot, cwdRel);
+        await fs5.mkdir(dirname17(targetPath), { recursive: true });
         await fs5.copyFile(sourcePath, targetPath);
       }
     });
@@ -15351,7 +15611,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
   const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
   const compileTasks = entryPoints.map(async (entry) => {
     const resolvedEntry = resolve24(entry);
-    const relativeEntry = relative11(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
+    const relativeEntry = relative12(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
     const compileEntry = () => compileAngularFileJIT(resolvedEntry, compiledRoot, outRoot, stylePreprocessors);
     let outputs = hmr ? await traceAngularPhase("jit/compile-entry", compileEntry, {
       entry: resolvedEntry
@@ -15359,9 +15619,9 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const fileBase = basename10(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
     const compiledFallbackPaths = [
-      join29(compiledRoot, relativeEntry),
-      join29(compiledRoot, "pages", jsName),
-      join29(compiledRoot, jsName)
+      join31(compiledRoot, relativeEntry),
+      join31(compiledRoot, "pages", jsName),
+      join31(compiledRoot, jsName)
     ].map((file4) => resolve24(file4));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
@@ -15423,7 +15683,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     })() : "no-providers";
     const serverContentHash = `${Bun.hash(original).toString(BASE_36_RADIX)}.${Bun.hash(providersHashInput).toString(BASE_36_RADIX)}`;
     const cachedWrapper = wrapperOutputCache.get(resolvedEntry);
-    const clientFile = join29(indexesDir, jsName);
+    const clientFile = join31(indexesDir, jsName);
     if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync24(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
       return {
         clientPath: clientFile,
@@ -15457,11 +15717,11 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
         const compiledAppProvidersPath = (() => {
           const angularDirAbs = resolve24(outRoot);
           const appSourceAbs = resolve24(providersInjection.appProvidersSource);
-          const rel = relative11(angularDirAbs, appSourceAbs).replace(/\\/g, "/");
-          return join29(compiledParent, rel).replace(/\.[cm]?[tj]sx?$/, ".js");
+          const rel = relative12(angularDirAbs, appSourceAbs).replace(/\\/g, "/");
+          return join31(compiledParent, rel).replace(/\.[cm]?[tj]sx?$/, ".js");
         })();
         const appProvidersSpec = (() => {
-          const rel = relative11(dirname16(rawServerFile), compiledAppProvidersPath).replace(/\\/g, "/");
+          const rel = relative12(dirname17(rawServerFile), compiledAppProvidersPath).replace(/\\/g, "/");
           return rel.startsWith(".") ? rel : `./${rel}`;
         })();
         importLines.push(`import { appProviders as __abs_globalProviders } from "${appProvidersSpec}";`);
@@ -15486,7 +15746,7 @@ export const providers = [${fragments.join(", ")}];
       }
     }
     await traceAngularPhase("wrapper/write-server-output", () => fs5.writeFile(rawServerFile, rewritten, "utf-8"), { entry: resolvedEntry });
-    const relativePath = relative11(indexesDir, rawServerFile).replace(/\\/g, "/");
+    const relativePath = relative12(indexesDir, rawServerFile).replace(/\\/g, "/");
     const normalizedImportPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
     const hmrPreamble = hmr ? `window.__HMR_FRAMEWORK__ = "angular";
 import "${hmrClientPath5}";
@@ -15682,7 +15942,7 @@ var init_compileAngular = __esm(() => {
   init_stylePreprocessor();
   init_generatedDir();
   devClientDir4 = resolveDevClientDir4();
-  hmrClientPath5 = join29(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath5 = join31(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
 });
@@ -16406,7 +16666,7 @@ __export(exports_fastHmrCompiler, {
   invalidateFingerprintCache: () => invalidateFingerprintCache
 });
 import { existsSync as existsSync25, readFileSync as readFileSync22, statSync as statSync2 } from "fs";
-import { dirname as dirname17, extname as extname6, relative as relative12, resolve as resolve25 } from "path";
+import { dirname as dirname18, extname as extname6, relative as relative13, resolve as resolve25 } from "path";
 import ts15 from "typescript";
 var fail = (reason, detail, location) => ({
   ok: false,
@@ -16517,7 +16777,7 @@ var fail = (reason, detail, location) => ({
     })();
     if (!decoratorName)
       continue;
-    const projectRel = relative12(process.cwd(), componentFilePath).replace(/\\/g, "/");
+    const projectRel = relative13(process.cwd(), componentFilePath).replace(/\\/g, "/");
     const id = encodeURIComponent(`${projectRel}@${className}`);
     if (decoratorName === "Component") {
       const componentDecorator = decorators.find((d2) => {
@@ -16534,7 +16794,7 @@ var fail = (reason, detail, location) => ({
         continue;
       const decoratorMeta = readDecoratorMeta(args);
       const { inputs, outputs } = extractInputsAndOutputs(stmt, null);
-      const componentDir = dirname17(componentFilePath);
+      const componentDir = dirname18(componentFilePath);
       const fingerprint = extractFingerprint(stmt, className, decoratorMeta, inputs, outputs, sourceFile, componentDir);
       fingerprintCache.set(id, fingerprint);
     } else {
@@ -17494,7 +17754,7 @@ var fail = (reason, detail, location) => ({
     });
     if (!names.includes(className))
       continue;
-    const nextDts = resolveDtsFromSpec(fromPath, dirname17(startDtsPath));
+    const nextDts = resolveDtsFromSpec(fromPath, dirname18(startDtsPath));
     if (!nextDts)
       continue;
     const found = findDtsContainingClass(nextDts, className, visited);
@@ -17504,7 +17764,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, dirname17(startDtsPath));
+    const nextDts = resolveDtsFromSpec(fromPath, dirname18(startDtsPath));
     if (!nextDts)
       continue;
     const found = findDtsContainingClass(nextDts, className, visited);
@@ -18082,7 +18342,7 @@ ${block}
   }
   const kind = params.kind ?? "component";
   if (kind !== "component") {
-    const entityId = encodeURIComponent(`${relative12(projectRoot, componentFilePath).replace(/\\/g, "/")}@${className}`);
+    const entityId = encodeURIComponent(`${relative13(projectRoot, componentFilePath).replace(/\\/g, "/")}@${className}`);
     const currentEntityFingerprint = extractEntityFingerprint(classNode, className, sourceFile);
     const cachedEntityFingerprint = entityFingerprintCache.get(entityId);
     if (cachedEntityFingerprint !== undefined && !entityFingerprintsEqual(cachedEntityFingerprint, currentEntityFingerprint)) {
@@ -18101,7 +18361,7 @@ ${block}
       rebootstrapRequired: false
     };
   }
-  if (inheritsDecoratedClass(classNode, sourceFile, dirname17(componentFilePath), projectRoot)) {
+  if (inheritsDecoratedClass(classNode, sourceFile, dirname18(componentFilePath), projectRoot)) {
     return fail("inherits-decorated-class");
   }
   const decorator = findComponentDecorator(classNode);
@@ -18113,7 +18373,7 @@ ${block}
   const projectDefaults = readProjectAngularCompilerOptions(projectRoot);
   const decoratorMeta = readDecoratorMeta(decoratorArgs, projectDefaults);
   const advancedMetadata = extractAdvancedMetadata(classNode, decoratorArgs, compiler);
-  const componentDir = dirname17(componentFilePath);
+  const componentDir = dirname18(componentFilePath);
   let templateText;
   let templatePath;
   if (decoratorMeta.template !== null) {
@@ -18166,7 +18426,7 @@ ${block}
     return fail("class-not-found", "anonymous class");
   const wrappedClass = new compiler.WrappedNodeExpr(className_);
   const { inputs, outputs, hasDecoratorIO, hasSignalIO } = extractInputsAndOutputs(classNode, compiler);
-  const projectRelPath = relative12(projectRoot, componentFilePath).replace(/\\/g, "/");
+  const projectRelPath = relative13(projectRoot, componentFilePath).replace(/\\/g, "/");
   const fingerprintId = encodeURIComponent(`${projectRelPath}@${className}`);
   const currentFingerprint = extractFingerprint(classNode, className, decoratorMeta, inputs, outputs, sourceFile, componentDir);
   const cachedFingerprint = fingerprintCache.get(fingerprintId);
@@ -18874,7 +19134,7 @@ __export(exports_compileEmber, {
   getEmberServerCompiledDir: () => getEmberServerCompiledDir,
   getEmberCompiledRoot: () => getEmberCompiledRoot,
   getEmberClientCompiledDir: () => getEmberClientCompiledDir,
-  dirname: () => dirname18,
+  dirname: () => dirname19,
   compileEmberFileSource: () => compileEmberFileSource,
   compileEmberFile: () => compileEmberFile,
   compileEmber: () => compileEmber,
@@ -18882,8 +19142,8 @@ __export(exports_compileEmber, {
   basename: () => basename11
 });
 import { existsSync as existsSync26 } from "fs";
-import { mkdir as mkdir6, rm as rm4 } from "fs/promises";
-import { basename as basename11, dirname as dirname18, extname as extname7, join as join30, resolve as resolve26 } from "path";
+import { mkdir as mkdir7, rm as rm4 } from "fs/promises";
+import { basename as basename11, dirname as dirname19, extname as extname7, join as join32, resolve as resolve26 } from "path";
 var {build: bunBuild2, Transpiler: Transpiler4, write: write4, file: file4 } = globalThis.Bun;
 var cachedPreprocessor = null, getPreprocessor = async () => {
   if (cachedPreprocessor)
@@ -18979,7 +19239,7 @@ export const importSync = (specifier) => {
         const originalImporter = stagedSourceMap.get(args.importer);
         if (!originalImporter)
           return;
-        const candidateBase = resolve26(dirname18(originalImporter), args.path);
+        const candidateBase = resolve26(dirname19(originalImporter), args.path);
         const extensionsToTry = ["", ".gts", ".gjs", ".ts", ".js"];
         for (const ext of extensionsToTry) {
           const candidate = candidateBase + ext;
@@ -19002,7 +19262,7 @@ export const importSync = (specifier) => {
     build2.onResolve({ filter: /^@(?:ember|glimmer|simple-dom)\// }, (args) => {
       if (standalonePackages.has(args.path))
         return;
-      const internal = join30(cwd, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      const internal = join32(cwd, "node_modules/ember-source/dist/packages", args.path, "index.js");
       if (existsSync26(internal))
         return { path: internal };
       return;
@@ -19050,16 +19310,16 @@ export default PageComponent;
   }
   const transpiled = transpiler5.transformSync(preprocessed);
   const baseName = basename11(resolvedEntry).replace(/\.(gjs|gts|ts|js)$/, "");
-  const tmpDir = join30(compiledRoot, "_tmp");
-  const serverDir = join30(compiledRoot, "server");
-  const clientDir = join30(compiledRoot, "client");
+  const tmpDir = join32(compiledRoot, "_tmp");
+  const serverDir = join32(compiledRoot, "server");
+  const clientDir = join32(compiledRoot, "client");
   await Promise.all([
-    mkdir6(tmpDir, { recursive: true }),
-    mkdir6(serverDir, { recursive: true }),
-    mkdir6(clientDir, { recursive: true })
+    mkdir7(tmpDir, { recursive: true }),
+    mkdir7(serverDir, { recursive: true }),
+    mkdir7(clientDir, { recursive: true })
   ]);
-  const tmpPagePath = resolve26(join30(tmpDir, `${baseName}.module.js`));
-  const tmpHarnessPath = resolve26(join30(tmpDir, `${baseName}.harness.js`));
+  const tmpPagePath = resolve26(join32(tmpDir, `${baseName}.module.js`));
+  const tmpHarnessPath = resolve26(join32(tmpDir, `${baseName}.harness.js`));
   await Promise.all([
     write4(tmpPagePath, transpiled),
     write4(tmpHarnessPath, generateServerHarness(tmpPagePath))
@@ -19067,7 +19327,7 @@ export default PageComponent;
   const stagedSourceMap = new Map([
     [tmpPagePath, resolvedEntry]
   ]);
-  const serverPath = join30(serverDir, `${baseName}.js`);
+  const serverPath = join32(serverDir, `${baseName}.js`);
   const buildResult = await bunBuild2({
     entrypoints: [tmpHarnessPath],
     format: "esm",
@@ -19084,7 +19344,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 = join30(clientDir, `${baseName}.js`);
+  const clientPath = join32(clientDir, `${baseName}.js`);
   await write4(clientPath, transpiled);
   return { clientPath, serverPath };
 }, compileEmber = async (entries, emberDir, cwd = process.cwd(), _hmr = false) => {
@@ -19112,7 +19372,7 @@ export default PageComponent;
     preprocessed = rewriteTemplateEvalToScope(result.code);
   }
   return transpiler5.transformSync(preprocessed);
-}, clearEmberCompilerCache = () => {}, getEmberCompiledRoot = (_emberDir) => getFrameworkGeneratedDir("ember"), getEmberServerCompiledDir = (emberDir) => join30(getEmberCompiledRoot(emberDir), "server"), getEmberClientCompiledDir = (emberDir) => join30(getEmberCompiledRoot(emberDir), "client");
+}, clearEmberCompilerCache = () => {}, getEmberCompiledRoot = (_emberDir) => getFrameworkGeneratedDir("ember"), getEmberServerCompiledDir = (emberDir) => join32(getEmberCompiledRoot(emberDir), "server"), getEmberClientCompiledDir = (emberDir) => join32(getEmberCompiledRoot(emberDir), "client");
 var init_compileEmber = __esm(() => {
   init_generatedDir();
   transpiler5 = new Transpiler4({
@@ -19134,7 +19394,7 @@ __export(exports_buildReactVendor, {
   buildReactVendor: () => buildReactVendor
 });
 import { existsSync as existsSync27, mkdirSync as mkdirSync8 } from "fs";
-import { join as join31, resolve as resolve27 } from "path";
+import { join as join33, resolve as resolve27 } from "path";
 import { rm as rm5 } from "fs/promises";
 var {build: bunBuild3 } = globalThis.Bun;
 var resolveJsxDevRuntimeCompatPath = () => {
@@ -19176,14 +19436,14 @@ var resolveJsxDevRuntimeCompatPath = () => {
 `)}
 `;
 }, buildReactVendor = async (buildDir) => {
-  const vendorDir = join31(buildDir, "react", "vendor");
+  const vendorDir = join33(buildDir, "react", "vendor");
   mkdirSync8(vendorDir, { recursive: true });
-  const tmpDir = join31(buildDir, "_vendor_tmp");
+  const tmpDir = join33(buildDir, "_vendor_tmp");
   mkdirSync8(tmpDir, { recursive: true });
   const specifiers = reactSpecifiers;
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName(specifier);
-    const entryPath = join31(tmpDir, `${safeName}.ts`);
+    const entryPath = join33(tmpDir, `${safeName}.ts`);
     const source = await generateEntrySource(specifier);
     await Bun.write(entryPath, source);
     return entryPath;
@@ -19248,7 +19508,7 @@ __export(exports_buildAngularVendor, {
   buildAngularServerVendor: () => buildAngularServerVendor
 });
 import { mkdirSync as mkdirSync9 } from "fs";
-import { join as join32 } from "path";
+import { join as join34 } from "path";
 import { rm as rm6 } from "fs/promises";
 var {build: bunBuild4, Glob: Glob7 } = 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, isResolvable = (specifier) => {
@@ -19345,14 +19605,14 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   await collectTransitiveAngularSpecs([...angular, ...transitiveRoots], angular);
   return Array.from(angular).filter(isResolvable);
 }, buildAngularVendor = async (buildDir, directories = [], linkerJitMode = false, depVendorSpecifiers = []) => {
-  const vendorDir = join32(buildDir, "angular", "vendor");
+  const vendorDir = join34(buildDir, "angular", "vendor");
   mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join32(buildDir, "_angular_vendor_tmp");
+  const tmpDir = join34(buildDir, "_angular_vendor_tmp");
   mkdirSync9(tmpDir, { recursive: true });
   const specifiers = await resolveAngularSpecifiers(directories, linkerJitMode);
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
-    const entryPath = join32(tmpDir, `${safeName}.ts`);
+    const entryPath = join34(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -19383,9 +19643,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 = join32(buildDir, "angular", "vendor", "server");
+  const vendorDir = join34(buildDir, "angular", "vendor", "server");
   mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join32(buildDir, "_angular_server_vendor_tmp");
+  const tmpDir = join34(buildDir, "_angular_server_vendor_tmp");
   mkdirSync9(tmpDir, { recursive: true });
   const browserSpecs = await resolveAngularSpecifiers(directories, linkerJitMode);
   const allSpecs = new Set(browserSpecs);
@@ -19396,7 +19656,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 = join32(tmpDir, `${safeName}.ts`);
+    const entryPath = join34(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -19418,9 +19678,9 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   return specifiers;
 }, computeAngularServerVendorPaths = (buildDir, specifiers) => {
   const paths = {};
-  const vendorDir = join32(buildDir, "angular", "vendor", "server");
+  const vendorDir = join34(buildDir, "angular", "vendor", "server");
   for (const specifier of specifiers) {
-    paths[specifier] = join32(vendorDir, `${toSafeFileName2(specifier)}.js`);
+    paths[specifier] = join34(vendorDir, `${toSafeFileName2(specifier)}.js`);
   }
   return paths;
 }, computeAngularServerVendorPathsAsync = async (buildDir, directories = [], linkerJitMode = true) => {
@@ -19476,17 +19736,17 @@ __export(exports_buildVueVendor, {
   buildVueVendor: () => buildVueVendor
 });
 import { mkdirSync as mkdirSync10 } from "fs";
-import { join as join33 } from "path";
+import { join as join35 } 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 = join33(buildDir, "vue", "vendor");
+  const vendorDir = join35(buildDir, "vue", "vendor");
   mkdirSync10(vendorDir, { recursive: true });
-  const tmpDir = join33(buildDir, "_vue_vendor_tmp");
+  const tmpDir = join35(buildDir, "_vue_vendor_tmp");
   mkdirSync10(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(vueSpecifiers.map(async (specifier) => {
     const safeName = toSafeFileName3(specifier);
-    const entryPath = join33(tmpDir, `${safeName}.ts`);
+    const entryPath = join35(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -19514,7 +19774,7 @@ var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"
   const { readFileSync: readFileSync23, writeFileSync: writeFileSync9, readdirSync: readdirSync5 } = await import("fs");
   const files = readdirSync5(vendorDir).filter((f2) => f2.endsWith(".js"));
   for (const file5 of files) {
-    const filePath = join33(vendorDir, file5);
+    const filePath = join35(vendorDir, file5);
     const content = readFileSync23(filePath, "utf-8");
     if (!content.includes("__VUE_HMR_RUNTIME__"))
       continue;
@@ -19541,7 +19801,7 @@ __export(exports_buildSvelteVendor, {
   buildSvelteVendor: () => buildSvelteVendor
 });
 import { mkdirSync as mkdirSync11 } from "fs";
-import { join as join34 } from "path";
+import { join as join36 } from "path";
 import { rm as rm8 } from "fs/promises";
 var {build: bunBuild6 } = globalThis.Bun;
 var svelteSpecifiers, isResolvable2 = (specifier) => {
@@ -19555,13 +19815,13 @@ var svelteSpecifiers, isResolvable2 = (specifier) => {
   const specifiers = resolveVendorSpecifiers();
   if (specifiers.length === 0)
     return;
-  const vendorDir = join34(buildDir, "svelte", "vendor");
+  const vendorDir = join36(buildDir, "svelte", "vendor");
   mkdirSync11(vendorDir, { recursive: true });
-  const tmpDir = join34(buildDir, "_svelte_vendor_tmp");
+  const tmpDir = join36(buildDir, "_svelte_vendor_tmp");
   mkdirSync11(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName4(specifier);
-    const entryPath = join34(tmpDir, `${safeName}.ts`);
+    const entryPath = join36(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -19599,185 +19859,6 @@ var init_buildSvelteVendor = __esm(() => {
   ];
 });
 
-// src/build/rewriteImportsPlugin.ts
-var exports_rewriteImportsPlugin = {};
-__export(exports_rewriteImportsPlugin, {
-  rewriteVendorDirectories: () => rewriteVendorDirectories,
-  rewriteImportsInContent: () => rewriteImportsInContent,
-  rewriteBuildOutputsWith: () => rewriteBuildOutputsWith,
-  rewriteBuildOutputs: () => rewriteBuildOutputs,
-  jsRewriteImports: () => jsRewriteImports,
-  fixMissingReExportNamespacesInContent: () => fixMissingReExportNamespacesInContent,
-  buildWithImportRewrite: () => buildWithImportRewrite
-});
-import { readdir as readdir3 } from "fs/promises";
-import { join as join35 } from "path";
-var escapeRegex2 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewriteImports = (content, replacements) => {
-  let result = content;
-  for (const [specifier, webPath] of replacements) {
-    const escaped = escapeRegex2(specifier);
-    const fromRegex = new RegExp(`(from\\s*["'])${escaped}(["'])`, "g");
-    const sideEffectRegex = new RegExp(`(import\\s*["'])${escaped}(["'])`, "g");
-    const dynamicRegex = new RegExp(`(import\\s*\\(\\s*["'])${escaped}(["']\\s*\\))`, "g");
-    result = result.replace(fromRegex, `$1${webPath}$2`);
-    result = result.replace(sideEffectRegex, `$1${webPath}$2`);
-    result = result.replace(dynamicRegex, `$1${webPath}$2`);
-  }
-  return result;
-}, rewriteImportsInContent = (content, vendorPaths) => {
-  if (Object.keys(vendorPaths).length === 0)
-    return content;
-  const replacements = Object.entries(vendorPaths).sort(([keyA], [keyB]) => keyB.length - keyA.length);
-  const native = nativeRewriteImports(content, replacements);
-  return native ?? jsRewriteImports(content, replacements);
-}, fixMissingReExportNamespacesInContent = (content) => {
-  const REEXPORT_PATTERN = /__reExport\(\s*[A-Za-z_$][\w$]*\s*,\s*([A-Za-z_$][\w$]*)\s*\)/g;
-  REEXPORT_PATTERN.lastIndex = 0;
-  const missing = [];
-  let match;
-  while ((match = REEXPORT_PATTERN.exec(content)) !== null) {
-    const ident = match[1];
-    if (!ident)
-      continue;
-    const nsImportRe = new RegExp(`\\bimport\\s*\\*\\s*as\\s+${ident}\\s+from\\b`);
-    if (nsImportRe.test(content))
-      continue;
-    const declRe = new RegExp(`\\b(?:const|let|var|function|class)\\s+${ident}\\b`);
-    if (declRe.test(content))
-      continue;
-    const namedImportRe = new RegExp(`\\bimport\\s*\\{[^}]*\\b${ident}\\b[^}]*\\}\\s*from\\b`);
-    if (namedImportRe.test(content))
-      continue;
-    const importPathRe = /(?:from\s+|import\s*)["']([^"']+)["']/g;
-    let pathMatch;
-    let sourcePath;
-    while ((pathMatch = importPathRe.exec(content)) !== null) {
-      const p2 = pathMatch[1];
-      if (!p2)
-        continue;
-      const base = p2.split("/").pop()?.replace(/\.[mc]?js$/, "");
-      if (!base)
-        continue;
-      const normalized = base.startsWith("_") ? base.slice(1) : base;
-      if (normalized === ident || normalized.endsWith(`_${ident}`)) {
-        sourcePath = p2;
-        break;
-      }
-    }
-    if (sourcePath)
-      missing.push({ ident, path: sourcePath });
-  }
-  if (missing.length === 0)
-    return content;
-  const seen = new Set;
-  const unique = missing.filter((entry) => {
-    if (seen.has(entry.ident))
-      return false;
-    seen.add(entry.ident);
-    return true;
-  });
-  const inserts = unique.map((entry) => `import * as ${entry.ident} from "${entry.path}";`).join(`
-`);
-  return `${inserts}
-${content}`;
-}, isReadableArtifact = (artifact) => artifact.path.endsWith(".js"), rewriteBuildOutputs = async (outputs, vendorPaths) => {
-  if (Object.keys(vendorPaths).length === 0)
-    return;
-  await Promise.all(outputs.filter(isReadableArtifact).map(async (artifact) => {
-    let original;
-    try {
-      original = await artifact.text();
-    } catch (err) {
-      const code = err.code;
-      if (code === "ENOENT")
-        return;
-      throw err;
-    }
-    const rewritten = rewriteImportsInContent(original, vendorPaths);
-    if (rewritten === original)
-      return;
-    try {
-      await Bun.write(artifact.path, rewritten);
-    } catch (err) {
-      const code = err.code;
-      if (code === "ENOENT")
-        return;
-      throw err;
-    }
-  }));
-}, rewriteBuildOutputsWith = async (outputs, resolveVendorPaths) => {
-  await Promise.all(outputs.filter(isReadableArtifact).map(async (artifact) => {
-    const vendorPaths = resolveVendorPaths(artifact);
-    if (Object.keys(vendorPaths).length === 0)
-      return;
-    let original;
-    try {
-      original = await artifact.text();
-    } catch (err) {
-      const code = err.code;
-      if (code === "ENOENT")
-        return;
-      throw err;
-    }
-    const rewritten = rewriteImportsInContent(original, vendorPaths);
-    if (rewritten === original)
-      return;
-    try {
-      await Bun.write(artifact.path, rewritten);
-    } catch (err) {
-      const code = err.code;
-      if (code === "ENOENT")
-        return;
-      throw err;
-    }
-  }));
-}, rewriteVendorDirectories = async (vendorDirs, vendorPaths) => {
-  if (Object.keys(vendorPaths).length === 0)
-    return;
-  const allFiles = [];
-  for (const dir of vendorDirs) {
-    try {
-      const entries = await readdir3(dir);
-      for (const entry of entries) {
-        if (entry.endsWith(".js"))
-          allFiles.push(join35(dir, entry));
-      }
-    } catch {}
-  }
-  await Promise.all(allFiles.map(async (filePath) => {
-    let original;
-    try {
-      original = await Bun.file(filePath).text();
-    } catch (err) {
-      const code = err.code;
-      if (code === "ENOENT")
-        return;
-      throw err;
-    }
-    let next = rewriteImportsInContent(original, vendorPaths);
-    next = fixMissingReExportNamespacesInContent(next);
-    if (next === original)
-      return;
-    try {
-      await Bun.write(filePath, next);
-    } catch (err) {
-      const code = err.code;
-      if (code === "ENOENT")
-        return;
-      throw err;
-    }
-  }));
-}, buildWithImportRewrite = async (pendingBuild, vendorPaths) => {
-  const result = await pendingBuild;
-  if (result.outputs.length > 0) {
-    await rewriteBuildOutputs(result.outputs, vendorPaths);
-  }
-  return result;
-};
-var init_rewriteImportsPlugin = __esm(() => {
-  init_nativeRewrite();
-});
-
 // src/core/build.ts
 import {
   copyFileSync as copyFileSync2,
@@ -19789,7 +19870,7 @@ import {
   statSync as statSync3,
   writeFileSync as writeFileSync9
 } from "fs";
-import { basename as basename12, dirname as dirname19, extname as extname8, join as join36, relative as relative13, resolve as resolve28 } from "path";
+import { basename as basename12, dirname as dirname20, extname as extname8, join as join37, relative as relative14, resolve as resolve28 } from "path";
 import { cwd, env as env3, exit } from "process";
 var {
   build: bunBuild7, 
@@ -19870,8 +19951,8 @@ var isDev2, isBuildTraceEnabled = () => {
   mkdirSync12(htmxDestDir, { recursive: true });
   const glob = new Glob8("htmx*.min.js");
   for (const relPath of glob.scanSync({ cwd: htmxDir })) {
-    const src = join36(htmxDir, relPath);
-    const dest = join36(htmxDestDir, "htmx.min.js");
+    const src = join37(htmxDir, relPath);
+    const dest = join37(htmxDestDir, "htmx.min.js");
     copyFileSync2(src, dest);
     return;
   }
@@ -19946,7 +20027,7 @@ var isDev2, isBuildTraceEnabled = () => {
   vuePagesPath
 }) => {
   const { readdirSync: readDir } = await import("fs");
-  const devIndexDir = join36(buildPath, "_src_indexes");
+  const devIndexDir = join37(buildPath, "_src_indexes");
   mkdirSync12(devIndexDir, { recursive: true });
   if (reactIndexesPath && reactPagesPath) {
     copyReactDevIndexes(reactIndexesPath, reactPagesPath, devIndexDir, readDir);
@@ -19962,37 +20043,37 @@ var isDev2, isBuildTraceEnabled = () => {
     return;
   }
   const indexFiles = readDir(reactIndexesPath).filter((file5) => file5.endsWith(".tsx"));
-  const pagesRel = relative13(process.cwd(), resolve28(reactPagesPath)).replace(/\\/g, "/");
+  const pagesRel = relative14(process.cwd(), resolve28(reactPagesPath)).replace(/\\/g, "/");
   for (const file5 of indexFiles) {
-    let content = readFileSync23(join36(reactIndexesPath, file5), "utf-8");
+    let content = readFileSync23(join37(reactIndexesPath, file5), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
-    writeFileSync9(join36(devIndexDir, file5), content);
+    writeFileSync9(join37(devIndexDir, file5), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
-  const svelteIndexDir = join36(getFrameworkGeneratedDir("svelte"), "indexes");
+  const svelteIndexDir = join37(getFrameworkGeneratedDir("svelte"), "indexes");
   const sveltePageEntries = svelteEntries.filter((file5) => resolve28(file5).startsWith(resolve28(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename12(entry).replace(/\.svelte(\.(ts|js))?$/, "");
-    const indexFile = join36(svelteIndexDir, "pages", `${name}.js`);
+    const indexFile = join37(svelteIndexDir, "pages", `${name}.js`);
     if (!existsSync28(indexFile))
       continue;
     let content = readFileSync23(indexFile, "utf-8");
-    const srcRel = relative13(process.cwd(), resolve28(entry)).replace(/\\/g, "/");
+    const srcRel = relative14(process.cwd(), resolve28(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
-    writeFileSync9(join36(devIndexDir, `${name}.svelte.js`), content);
+    writeFileSync9(join37(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
-  const vueIndexDir = join36(getFrameworkGeneratedDir("vue"), "indexes");
+  const vueIndexDir = join37(getFrameworkGeneratedDir("vue"), "indexes");
   const vuePageEntries = vueEntries.filter((file5) => resolve28(file5).startsWith(resolve28(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename12(entry, ".vue");
-    const indexFile = join36(vueIndexDir, `${name}.js`);
+    const indexFile = join37(vueIndexDir, `${name}.js`);
     if (!existsSync28(indexFile))
       continue;
     let content = readFileSync23(indexFile, "utf-8");
-    const srcRel = relative13(process.cwd(), resolve28(entry)).replace(/\\/g, "/");
+    const srcRel = relative14(process.cwd(), resolve28(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Comp(?:\s*,\s*\*\s+as\s+\w+)?\s+from\s+['"]([^'"]+)['"]/, (match) => match.replace(/from\s+['"][^'"]+['"]/, `from "/@src/${srcRel}"`));
-    writeFileSync9(join36(devIndexDir, `${name}.vue.js`), content);
+    writeFileSync9(join37(devIndexDir, `${name}.vue.js`), content);
   }
 }, resolveVueRuntimeId = (content, firstUseName, outputPath, projectRoot) => {
   const varIdx = content.indexOf(`var ${firstUseName} =`);
@@ -20065,7 +20146,7 @@ ${content.slice(firstUseIdx)}`;
 }, buildDevUrlFileMap = (urlReferencedFiles, projectRoot) => {
   const urlFileMap = new Map;
   for (const srcPath of urlReferencedFiles) {
-    const rel = relative13(projectRoot, srcPath).replace(/\\/g, "/");
+    const rel = relative14(projectRoot, srcPath).replace(/\\/g, "/");
     const name = basename12(srcPath);
     const mtime = Math.round(statSync3(srcPath).mtimeMs);
     const url = `/@src/${rel}?v=${mtime}`;
@@ -20080,7 +20161,7 @@ ${content.slice(firstUseIdx)}`;
     const output = nonReactClientOutputs.find((artifact) => basename12(artifact.path).startsWith(`${srcBase}.`));
     if (!output)
       continue;
-    urlFileMap.set(basename12(srcPath), `/${relative13(buildPath, output.path).replace(/\\/g, "/")}`);
+    urlFileMap.set(basename12(srcPath), `/${relative14(buildPath, output.path).replace(/\\/g, "/")}`);
   }
   return urlFileMap;
 }, buildUrlFileMap = (urlReferencedFiles, hmr, projectRoot, buildPath, nonReactClientOutputs) => {
@@ -20215,10 +20296,10 @@ ${content.slice(firstUseIdx)}`;
       restoreTracePhase();
       return;
     }
-    const traceDir = join36(buildPath2, ".absolute-trace");
+    const traceDir = join37(buildPath2, ".absolute-trace");
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
     mkdirSync12(traceDir, { recursive: true });
-    writeFileSync9(join36(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
+    writeFileSync9(join37(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
       events: traceEvents,
       frameworks: traceFrameworkNames,
       generatedAt: new Date().toISOString(),
@@ -20249,15 +20330,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 && join36(getFrameworkGeneratedDir("react"), "indexes");
-  const reactPagesPath = reactDir && join36(reactDir, "pages");
-  const htmlPagesPath = htmlDir && join36(htmlDir, "pages");
-  const htmlScriptsPath = htmlDir && join36(htmlDir, "scripts");
-  const sveltePagesPath = svelteDir && join36(svelteDir, "pages");
-  const vuePagesPath = vueDir && join36(vueDir, "pages");
-  const htmxPagesPath = htmxDir && join36(htmxDir, "pages");
-  const angularPagesPath = angularDir && join36(angularDir, "pages");
-  const emberPagesPath = emberDir && join36(emberDir, "pages");
+  const reactIndexesPath = reactDir && join37(getFrameworkGeneratedDir("react"), "indexes");
+  const reactPagesPath = reactDir && join37(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join37(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join37(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join37(svelteDir, "pages");
+  const vuePagesPath = vueDir && join37(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join37(htmxDir, "pages");
+  const angularPagesPath = angularDir && join37(angularDir, "pages");
+  const emberPagesPath = emberDir && join37(emberDir, "pages");
   const frontends = [
     reactDir,
     htmlDir,
@@ -20288,7 +20369,7 @@ ${content.slice(firstUseIdx)}`;
   const sourceClientRoots = [
     htmlDir,
     htmxDir,
-    islandBootstrapPath && dirname19(islandBootstrapPath)
+    islandBootstrapPath && dirname20(islandBootstrapPath)
   ].filter((dir) => Boolean(dir));
   const usesGenerated = Boolean(reactDir) || Boolean(svelteDir) || Boolean(vueDir) || Boolean(angularDir);
   if (usesGenerated)
@@ -20316,8 +20397,8 @@ ${content.slice(firstUseIdx)}`;
     const [firstEntry] = serverDirMap;
     if (!firstEntry)
       throw new Error("Expected at least one server directory entry");
-    serverRoot = join36(firstEntry.dir, firstEntry.subdir);
-    serverOutDir = join36(buildPath, basename12(firstEntry.dir));
+    serverRoot = join37(firstEntry.dir, firstEntry.subdir);
+    serverOutDir = join37(buildPath, basename12(firstEntry.dir));
   } else if (serverDirMap.length > 1) {
     serverRoot = commonAncestor(serverDirMap.map((entry) => entry.dir), projectRoot);
     serverOutDir = buildPath;
@@ -20345,7 +20426,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, join36(buildPath, "assets"), {
+    await tracePhase("assets/copy", () => cpSync(assetsPath, join37(buildPath, "assets"), {
       force: true,
       recursive: true
     }));
@@ -20455,11 +20536,11 @@ ${content.slice(firstUseIdx)}`;
     }
   }
   if (htmlDefaults.error || htmlDefaults.notFound || htmlDefaults.loading || Object.keys(htmlPages).length > 0) {
-    const htmlConventionsOutDir = join36(buildPath, "conventions", "html");
+    const htmlConventionsOutDir = join37(buildPath, "conventions", "html");
     mkdirSync12(htmlConventionsOutDir, { recursive: true });
     const htmlPathRemap = new Map;
     for (const sourcePath of htmlConventionSources) {
-      const dest = join36(htmlConventionsOutDir, basename12(sourcePath));
+      const dest = join37(htmlConventionsOutDir, basename12(sourcePath));
       cpSync(sourcePath, dest, { force: true });
       htmlPathRemap.set(sourcePath, dest);
     }
@@ -20502,7 +20583,7 @@ ${content.slice(firstUseIdx)}`;
   const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
     if (entry.startsWith(resolve28(reactIndexesPath))) {
       const pageName = basename12(entry, ".tsx");
-      return join36(reactPagesPath, `${pageName}.tsx`);
+      return join37(reactPagesPath, `${pageName}.tsx`);
     }
     return null;
   }) : allReactEntries;
@@ -20621,14 +20702,14 @@ ${content.slice(firstUseIdx)}`;
         try {
           const { primeComponentFingerprint: primeComponentFingerprint2 } = await Promise.resolve().then(() => (init_fastHmrCompiler(), exports_fastHmrCompiler));
           const { readdir: readdir4 } = await import("fs/promises");
-          const { join: join37 } = await import("path");
+          const { join: join38 } = await import("path");
           const walk = async (dir) => {
             const entries = await readdir4(dir, {
               withFileTypes: true
             });
             const out = [];
             for (const entry of entries) {
-              const full = join37(dir, entry.name);
+              const full = join38(dir, entry.name);
               if (entry.isDirectory()) {
                 out.push(...await walk(full));
               } else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
@@ -20693,7 +20774,7 @@ ${content.slice(firstUseIdx)}`;
     const compileReactConventions = async () => {
       if (reactConventionSources.length === 0)
         return emptyStringArray;
-      const destDir = join36(buildPath, "conventions", "react");
+      const destDir = join37(buildPath, "conventions", "react");
       rmSync2(destDir, { force: true, recursive: true });
       mkdirSync12(destDir, { recursive: true });
       const destPaths = [];
@@ -20709,7 +20790,7 @@ ${content.slice(firstUseIdx)}`;
           naming: `${idx}-[name].[ext]`,
           outdir: destDir,
           plugins: [stylePreprocessorPlugin2],
-          root: dirname19(source),
+          root: dirname20(source),
           target: "bun",
           throw: false,
           tsconfig: "./tsconfig.json"
@@ -20737,7 +20818,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 = join36(buildPath, "conventions", framework);
+      const destDir = join37(buildPath, "conventions", framework);
       rmSync2(destDir, { force: true, recursive: true });
       mkdirSync12(destDir, { recursive: true });
       const destPaths = [];
@@ -20811,7 +20892,7 @@ ${content.slice(firstUseIdx)}`;
     }
   })) : {
     entries: [],
-    generatedRoot: join36(buildPath, "_island_entries")
+    generatedRoot: join37(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) {
@@ -20847,7 +20928,7 @@ ${content.slice(firstUseIdx)}`;
     return {};
   }
   if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
-    const refreshEntry = join36(reactIndexesPath, "_refresh.tsx");
+    const refreshEntry = join37(reactIndexesPath, "_refresh.tsx");
     if (!reactClientEntryPoints.includes(refreshEntry))
       reactClientEntryPoints.push(refreshEntry);
   }
@@ -20983,19 +21064,19 @@ ${content.slice(firstUseIdx)}`;
     throw: false
   }, resolveBunBuildOverride(bunBuildConfig, "reactClient")) : undefined;
   if (reactDir && reactClientEntryPoints.length > 0) {
-    rmSync2(join36(buildPath, "react", "generated", "indexes"), {
+    rmSync2(join37(buildPath, "react", "generated", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (angularDir && angularClientPaths.length > 0) {
-    rmSync2(join36(buildPath, "angular", "indexes"), {
+    rmSync2(join37(buildPath, "angular", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (islandClientEntryPoints.length > 0) {
-    rmSync2(join36(buildPath, "islands"), {
+    rmSync2(join37(buildPath, "islands"), {
       force: true,
       recursive: true
     });
@@ -21087,7 +21168,7 @@ ${content.slice(firstUseIdx)}`;
     globalCssEntries.length > 0 ? tracePhase("bun/global-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: globalCssEntries,
       naming: `[dir]/[name].[hash].[ext]`,
-      outdir: stylesDir ? join36(buildPath, basename12(stylesDir)) : buildPath,
+      outdir: stylesDir ? join37(buildPath, basename12(stylesDir)) : buildPath,
       plugins: [stylePreprocessorPlugin2],
       root: stylesDir || clientRoot,
       target: "browser",
@@ -21096,7 +21177,7 @@ ${content.slice(firstUseIdx)}`;
     vueCssPaths.length > 0 ? tracePhase("bun/vue-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: vueCssPaths,
       naming: `[name].[hash].[ext]`,
-      outdir: join36(buildPath, assetsPath ? basename12(assetsPath) : "assets", "css"),
+      outdir: join37(buildPath, assetsPath ? basename12(assetsPath) : "assets", "css"),
       target: "browser",
       throw: false
     }, resolveBunBuildOverride(bunBuildConfig, "vueCss")))) : undefined
@@ -21170,10 +21251,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 = dirname19(artifact.path);
+      const fileDir = dirname20(artifact.path);
       const relativePaths = {};
       for (const [specifier, absolute] of Object.entries(angularServerVendorPaths2)) {
-        const rel = relative13(fileDir, absolute);
+        const rel = relative14(fileDir, absolute);
         relativePaths[specifier] = rel.startsWith(".") ? rel : `./${rel}`;
       }
       return relativePaths;
@@ -21278,7 +21359,7 @@ ${content.slice(firstUseIdx)}`;
       const parentArtifact = serverJsByPascalName.get(parentName);
       if (!parentArtifact)
         return;
-      const sourceDir = dirname19(source);
+      const sourceDir = dirname20(source);
       const entries = routes.flatMap(({ path, importPath }) => {
         const childSourcePath = resolve28(sourceDir, importPath);
         const childName = basename12(childSourcePath, ".vue");
@@ -21303,7 +21384,7 @@ ${content.slice(firstUseIdx)}`;
   if (skipAngularClientBundle) {
     for (const clientPath of angularClientPaths) {
       const fileBase = basename12(clientPath, ".js");
-      const relFromCwd = relative13(projectRoot, clientPath).replace(/\\/g, "/");
+      const relFromCwd = relative14(projectRoot, clientPath).replace(/\\/g, "/");
       manifest[`${toPascal(fileBase)}Index`] = `/@src/${relFromCwd}`;
     }
   }
@@ -21328,7 +21409,7 @@ ${content.slice(firstUseIdx)}`;
   const processHtmlPages = async () => {
     if (!(htmlDir && htmlPagesPath))
       return;
-    const outputHtmlPages = isSingle ? join36(buildPath, "pages") : join36(buildPath, basename12(htmlDir), "pages");
+    const outputHtmlPages = isSingle ? join37(buildPath, "pages") : join37(buildPath, basename12(htmlDir), "pages");
     mkdirSync12(outputHtmlPages, { recursive: true });
     cpSync(htmlPagesPath, outputHtmlPages, {
       force: true,
@@ -21353,14 +21434,14 @@ ${content.slice(firstUseIdx)}`;
   const processHtmxPages = async () => {
     if (!(htmxDir && htmxPagesPath))
       return;
-    const outputHtmxPages = isSingle ? join36(buildPath, "pages") : join36(buildPath, basename12(htmxDir), "pages");
+    const outputHtmxPages = isSingle ? join37(buildPath, "pages") : join37(buildPath, basename12(htmxDir), "pages");
     mkdirSync12(outputHtmxPages, { recursive: true });
     cpSync(htmxPagesPath, outputHtmxPages, {
       force: true,
       recursive: true
     });
     if (shouldCopyHtmx) {
-      const htmxDestDir = isSingle ? buildPath : join36(buildPath, basename12(htmxDir));
+      const htmxDestDir = isSingle ? buildPath : join37(buildPath, basename12(htmxDir));
       copyHtmxVendor(htmxDir, htmxDestDir);
     }
     if (shouldUpdateHtmxAssetPaths) {
@@ -21427,9 +21508,9 @@ ${content.slice(firstUseIdx)}`;
     writeBuildTrace(buildPath);
     return { conventions: conventionsMap, manifest };
   }
-  writeFileSync9(join36(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
+  writeFileSync9(join37(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
   if (Object.keys(conventionsMap).length > 0) {
-    writeFileSync9(join36(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
+    writeFileSync9(join37(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
   }
   writeBuildTrace(buildPath);
   if (mode === "production") {
@@ -21552,7 +21633,7 @@ var init_build = __esm(() => {
 
 // src/build/buildEmberVendor.ts
 import { mkdirSync as mkdirSync13, existsSync as existsSync29 } from "fs";
-import { join as join37 } from "path";
+import { join as join38 } 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
@@ -21604,7 +21685,7 @@ export const importSync = (specifier) => {
   if (standaloneSpecifiers.has(specifier)) {
     return { resolveTo: specifier, specifier };
   }
-  const emberInternalPath = join37(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
+  const emberInternalPath = join38(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
   if (!existsSync29(emberInternalPath)) {
     throw new Error(`Ember vendor build: cannot find ${specifier} at ${emberInternalPath}. ` + `Is ember-source installed and at least 6.12?`);
   }
@@ -21636,7 +21717,7 @@ export const importSync = (specifier) => {
       if (standalonePackages.has(args.path)) {
         return;
       }
-      const internal = join37(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      const internal = join38(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
       if (existsSync29(internal)) {
         return { path: internal };
       }
@@ -21644,16 +21725,16 @@ export const importSync = (specifier) => {
     });
   }
 }), buildEmberVendor = async (buildDir, cwd2 = process.cwd()) => {
-  const vendorDir = join37(buildDir, "ember", "vendor");
+  const vendorDir = join38(buildDir, "ember", "vendor");
   mkdirSync13(vendorDir, { recursive: true });
-  const tmpDir = join37(buildDir, "_ember_vendor_tmp");
+  const tmpDir = join38(buildDir, "_ember_vendor_tmp");
   mkdirSync13(tmpDir, { recursive: true });
-  const macrosShimPath = join37(tmpDir, "embroider_macros_shim.js");
+  const macrosShimPath = join38(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 = join37(tmpDir, `${safeName}.js`);
+    const entryPath = join38(tmpDir, `${safeName}.js`);
     const source = resolution.specifier === "@embroider/macros" ? `export * from ${JSON.stringify(macrosShimPath)};
 ` : generateVendorEntrySource2(resolution);
     await Bun.write(entryPath, source);
@@ -22029,7 +22110,7 @@ var init_clientManager = __esm(() => {
 
 // src/dev/pathUtils.ts
 import { existsSync as existsSync31, readdirSync as readdirSync5, readFileSync as readFileSync25 } from "fs";
-import { dirname as dirname20, resolve as resolve31 } from "path";
+import { dirname as dirname21, resolve as resolve31 } from "path";
 var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   if (shouldIgnorePath(filePath, resolved)) {
     return "ignored";
@@ -22157,10 +22238,10 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
             refs.push(strMatch[1]);
         }
       }
-      const componentDir = dirname20(full);
+      const componentDir = dirname21(full);
       for (const ref of refs) {
         const refAbs = normalizePath(resolve31(componentDir, ref));
-        const refDir = normalizePath(dirname20(refAbs));
+        const refDir = normalizePath(dirname21(refAbs));
         if (refDir === angularRootNormalized || refDir.startsWith(angularRootNormalized + "/")) {
           continue;
         }
@@ -22288,7 +22369,7 @@ var init_pathUtils = __esm(() => {
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
 import { existsSync as existsSync32, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
-import { dirname as dirname21, join as join38, resolve as resolve32 } from "path";
+import { dirname as dirname22, join as join39, resolve as resolve32 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -22321,7 +22402,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
     for (const name of entries) {
       if (shouldSkipFilename(name, isStylesDir))
         continue;
-      const child = join38(eventDir, name).replace(/\\/g, "/");
+      const child = join39(eventDir, name).replace(/\\/g, "/");
       let st2;
       try {
         st2 = statSync4(child);
@@ -22346,12 +22427,12 @@ var safeRemoveFromGraph = (graph, fullPath) => {
       return;
     if (shouldSkipFilename(filename, isStylesDir)) {
       if (event === "rename") {
-        const eventDir = dirname21(join38(absolutePath, filename)).replace(/\\/g, "/");
+        const eventDir = dirname22(join39(absolutePath, filename)).replace(/\\/g, "/");
         atomicRecoveryScan(eventDir);
       }
       return;
     }
-    const fullPath = join38(absolutePath, filename).replace(/\\/g, "/");
+    const fullPath = join39(absolutePath, filename).replace(/\\/g, "/");
     if (shouldIgnorePath(fullPath, state.resolvedPaths)) {
       return;
     }
@@ -22721,7 +22802,7 @@ __export(exports_resolveOwningComponents, {
   invalidateResourceIndex: () => invalidateResourceIndex
 });
 import { readdirSync as readdirSync7, readFileSync as readFileSync27, statSync as statSync5 } from "fs";
-import { dirname as dirname22, extname as extname9, join as join39, resolve as resolve36 } from "path";
+import { dirname as dirname23, extname as extname9, join as join40, resolve as resolve36 } from "path";
 import ts16 from "typescript";
 var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") || file5.endsWith(".tsx"), walkAngularSourceFiles = (root) => {
   const out = [];
@@ -22736,7 +22817,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const full = join39(dir, entry.name);
+      const full = join40(dir, entry.name);
       if (entry.isDirectory()) {
         visit(full);
       } else if (entry.isFile() && isAngularSourceFile(entry.name)) {
@@ -22875,7 +22956,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
     return null;
   }
   const sf = ts16.createSourceFile(childFilePath, source, ts16.ScriptTarget.ES2022, true, ts16.ScriptKind.TS);
-  const childDir = dirname22(childFilePath);
+  const childDir = dirname23(childFilePath);
   for (const stmt of sf.statements) {
     if (!ts16.isImportDeclaration(stmt))
       continue;
@@ -22932,7 +23013,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 = dirname22(tsPath);
+    const componentDir = dirname23(tsPath);
     for (const cls of classes) {
       const entity = {
         className: cls.className,
@@ -23109,8 +23190,8 @@ __export(exports_moduleServer, {
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
 import { existsSync as existsSync33, readFileSync as readFileSync28, realpathSync as realpathSync3, statSync as statSync6 } from "fs";
-import { basename as basename14, dirname as dirname23, extname as extname10, join as join40, resolve as resolve37, relative as relative14 } from "path";
-var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPILABLE, ALL_EXPORTS_RE, STRING_CONTENTS_RE, preserveTypeExports = (originalSource, transpiled, valueExports) => {
+import { basename as basename14, dirname as dirname24, extname as extname10, join as join41, resolve as resolve37, relative as relative15 } from "path";
+var SRC_PREFIX = "/@src/", jsTranspiler2, legacyDecoratorTsconfig, tsTranspiler2, tsxTranspiler, TRANSPILABLE, ALL_EXPORTS_RE, STRING_CONTENTS_RE, preserveTypeExports = (originalSource, transpiled, valueExports) => {
   const codeOnly = originalSource.replace(STRING_CONTENTS_RE, '""');
   const allExports = [];
   let match;
@@ -23162,11 +23243,11 @@ ${stubs}
   }
 }, resolveRelativeImport = (relPath, fileDir, projectRoot, extensions) => {
   const absPath = resolve37(fileDir, relPath);
-  const rel = relative14(projectRoot, absPath);
+  const rel = relative15(projectRoot, absPath);
   const extension = extname10(rel);
   let srcPath = RESOLVED_MODULE_EXTENSIONS.has(extension) ? rel : resolveRelativeExtension(rel, projectRoot, extensions);
   if (extname10(srcPath) === ".svelte") {
-    srcPath = relative14(projectRoot, resolveSvelteModulePath(resolve37(projectRoot, srcPath)));
+    srcPath = relative15(projectRoot, resolveSvelteModulePath(resolve37(projectRoot, srcPath)));
   }
   return srcUrl(srcPath, projectRoot);
 }, NODE_BUILTIN_RE, resolveAbsoluteSpecifier = (specifier, projectRoot) => {
@@ -23178,7 +23259,7 @@ ${stubs}
       "import"
     ]);
     if (fromExports)
-      return relative14(projectRoot, fromExports);
+      return relative15(projectRoot, fromExports);
     try {
       const isScoped = specifier.startsWith("@");
       const parts = specifier.split("/");
@@ -23186,19 +23267,19 @@ ${stubs}
       const subpath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
       if (!subpath) {
         const pkgDir = resolve37(projectRoot, "node_modules", packageName ?? "");
-        const pkgJsonPath = join40(pkgDir, "package.json");
+        const pkgJsonPath = join41(pkgDir, "package.json");
         if (existsSync33(pkgJsonPath)) {
           const pkg = JSON.parse(readFileSync28(pkgJsonPath, "utf-8"));
           const esmEntry = typeof pkg.module === "string" && pkg.module || typeof pkg.browser === "string" && pkg.browser;
           if (esmEntry) {
             const resolved = resolve37(pkgDir, esmEntry);
             if (existsSync33(resolved))
-              return relative14(projectRoot, resolved);
+              return relative15(projectRoot, resolved);
           }
         }
       }
     } catch {}
-    return relative14(projectRoot, Bun.resolveSync(specifier, projectRoot));
+    return relative15(projectRoot, Bun.resolveSync(specifier, projectRoot));
   } catch {
     return;
   }
@@ -23223,28 +23304,28 @@ ${stubs}
   };
   result = result.replace(/^((?:import\s+[^"'`;]+?\s+from|export\s+[^"'`;]+?\s+from|import)\s*["'])([^"'./][^"']*)(["'])/gm, stubReplace);
   result = result.replace(/(import\s*\(\s*["'])([^"'./][^"']*)(["']\s*\))/g, stubReplace);
-  const fileDir = dirname23(filePath);
+  const fileDir = dirname24(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 = relative14(projectRoot, absPath).replace(/\\/g, "/");
+      const rel2 = relative15(projectRoot, absPath).replace(/\\/g, "/");
       return `${prefix}${srcUrl(rel2, projectRoot)}${suffix}`;
     }
-    const rel = relative14(projectRoot, absPath).replace(/\\/g, "/");
+    const rel = relative15(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 = resolve37(fileDir, relPath);
-    const rel = relative14(projectRoot, absPath);
+    const rel = relative15(projectRoot, absPath);
     return `new URL('${srcUrl(rel, projectRoot)}', import.meta.url)`;
   });
   result = result.replace(/import\.meta\.resolve\(\s*["'](\.\.?\/[^"']+)["']\s*\)/g, (_match, relPath) => {
     const absPath = resolve37(fileDir, relPath);
-    const rel = relative14(projectRoot, absPath);
+    const rel = relative15(projectRoot, absPath);
     return `'${srcUrl(rel, projectRoot)}'`;
   });
   return result;
@@ -23300,7 +23381,7 @@ ${code}`;
   transpiled = `var $RefreshReg$ = window.$RefreshReg$ || function(){};
 ` + `var $RefreshSig$ = window.$RefreshSig$ || function(){ return function(t){ return t; }; };
 ${transpiled}`;
-  const relPath = relative14(projectRoot, filePath).replace(/\\/g, "/");
+  const relPath = relative15(projectRoot, filePath).replace(/\\/g, "/");
   transpiled = transpiled.replace(/\binput\.tsx:/g, `${relPath}:`);
   transpiled += buildIslandMetadataExports(raw);
   return rewriteImports(transpiled, filePath, projectRoot, rewriter);
@@ -23461,11 +23542,11 @@ ${code}`;
   if (compiled.css?.code) {
     const cssPath = `${filePath}.css`;
     svelteExternalCss.set(cssPath, compiled.css.code);
-    const cssUrl = srcUrl(relative14(projectRoot, cssPath), projectRoot);
+    const cssUrl = srcUrl(relative15(projectRoot, cssPath), projectRoot);
     code = `import "${cssUrl}";
 ${code}`;
   }
-  const moduleUrl = `${SRC_PREFIX}${relative14(projectRoot, filePath).replace(/\\/g, "/")}`;
+  const moduleUrl = `${SRC_PREFIX}${relative15(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; };`);
@@ -23566,7 +23647,7 @@ ${code}`;
   return rewriteImports(code, filePath, projectRoot, rewriter);
 }, injectVueHmr = (code, filePath, projectRoot, vueDir) => {
   const hmrBase = vueDir ? resolve37(vueDir) : projectRoot;
-  const hmrId = relative14(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
+  const hmrId = relative15(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
   let result = code.replace(/export\s+default\s+/, "var __hmr_comp__ = ");
   result += [
     "",
@@ -23912,13 +23993,21 @@ var init_moduleServer = __esm(() => {
     loader: "js",
     trimUnusedImports: true
   });
+  legacyDecoratorTsconfig = JSON.stringify({
+    compilerOptions: {
+      emitDecoratorMetadata: true,
+      experimentalDecorators: true
+    }
+  });
   tsTranspiler2 = new Bun.Transpiler({
     loader: "ts",
-    trimUnusedImports: true
+    trimUnusedImports: true,
+    tsconfig: legacyDecoratorTsconfig
   });
   tsxTranspiler = new Bun.Transpiler({
     loader: "tsx",
-    trimUnusedImports: true
+    trimUnusedImports: true,
+    tsconfig: legacyDecoratorTsconfig
   });
   TRANSPILABLE = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs"]);
   ALL_EXPORTS_RE = /export\s+(?:type|interface|const|let|var|function|class|enum|abstract\s+class)\s+(\w+)/g;
@@ -23977,6 +24066,9 @@ export function __legacyMetadataTS(k, v) {
 		return Reflect.metadata(k, v);
 	}
 }
+export function __legacyDecorateParamTS(paramIndex, decorator) {
+	return function (target, key) { decorator(target, key, paramIndex); };
+}
 `.trim();
   SRC_IMPORT_RE = /\/@src\/([^"'?\s]+)/g;
   SRC_URL_PREFIX = SRC_PREFIX;
@@ -24028,7 +24120,7 @@ __export(exports_hmrCompiler, {
   getApplyMetadataModule: () => getApplyMetadataModule,
   encodeHmrComponentId: () => encodeHmrComponentId
 });
-import { dirname as dirname24, relative as relative15, resolve as resolve38 } from "path";
+import { dirname as dirname25, relative as relative16, resolve as resolve38 } from "path";
 import { performance as performance2 } from "perf_hooks";
 var getApplyMetadataModule = async (encodedId) => {
   const decoded = decodeURIComponent(encodedId);
@@ -24038,7 +24130,7 @@ var getApplyMetadataModule = async (encodedId) => {
   const filePathRel = decoded.slice(0, at2);
   const className = decoded.slice(at2 + 1);
   const componentFilePath = resolve38(process.cwd(), filePathRel);
-  const projectRelPath = relative15(process.cwd(), componentFilePath).replace(/\\/g, "/");
+  const projectRelPath = relative16(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);
@@ -24048,7 +24140,7 @@ var getApplyMetadataModule = async (encodedId) => {
   const { resolveOwningComponents: resolveOwningComponents2 } = await Promise.resolve().then(() => (init_resolveOwningComponents(), exports_resolveOwningComponents));
   const owners = resolveOwningComponents2({
     changedFilePath: componentFilePath,
-    userAngularRoot: dirname24(componentFilePath)
+    userAngularRoot: dirname25(componentFilePath)
   });
   const owner = owners.find((o3) => o3.className === className);
   const kind = owner?.kind ?? "component";
@@ -24060,7 +24152,7 @@ var getApplyMetadataModule = async (encodedId) => {
   }
   return null;
 }, encodeHmrComponentId = (absoluteFilePath, className) => {
-  const projectRel = relative15(process.cwd(), absoluteFilePath).replace(/\\/g, "/");
+  const projectRel = relative16(process.cwd(), absoluteFilePath).replace(/\\/g, "/");
   return `${projectRel}@${className}`;
 };
 var init_hmrCompiler = __esm(() => {
@@ -24256,7 +24348,7 @@ var init_simpleHTMXHMR = () => {};
 
 // src/dev/rebuildTrigger.ts
 import { existsSync as existsSync34, rmSync as rmSync3 } from "fs";
-import { basename as basename15, dirname as dirname25, join as join41, relative as relative16, resolve as resolve41, sep as sep4 } from "path";
+import { basename as basename15, dirname as dirname26, join as join42, relative as relative17, resolve as resolve41, 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;
@@ -24373,8 +24465,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const relJs = `${rel.slice(0, -ext[0].length)}.js`;
     const generatedDir = getFrameworkGeneratedDir(framework, cwd2);
     for (const candidate of [
-      join41(generatedDir, relJs),
-      `${join41(generatedDir, relJs)}.map`
+      join42(generatedDir, relJs),
+      `${join42(generatedDir, relJs)}.map`
     ]) {
       try {
         rmSync3(candidate, { force: true });
@@ -24578,15 +24670,15 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
       const relFromDir = normalizedSource.slice(normalizedDir.length + 1);
       const buildDir = state.resolvedPaths.buildDir;
       const destPath = resolve41(buildDir, urlPrefix ? `${urlPrefix}/${relFromDir}` : relFromDir);
-      const { mkdir: mkdir7, copyFile, readFile: readFile6 } = await import("fs/promises");
-      const { dirname: dirname26 } = await import("path");
-      await mkdir7(dirname26(destPath), { recursive: true });
+      const { mkdir: mkdir8, copyFile, readFile: readFile6 } = await import("fs/promises");
+      const { dirname: dirname27 } = await import("path");
+      await mkdir8(dirname27(destPath), { recursive: true });
       await copyFile(absSource, destPath);
       const bytes = await readFile6(destPath);
       const webPath = urlPrefix ? `/${urlPrefix}/${relFromDir}` : `/${relFromDir}`;
       state.assetStore.set(webPath, new Uint8Array(bytes));
       state.fileHashes.set(absSource, currentHash);
-      logHmrUpdate(relative16(process.cwd(), filePath));
+      logHmrUpdate(relative17(process.cwd(), filePath));
       broadcastToClients(state, {
         data: {
           framework: urlPrefix || "public",
@@ -24604,7 +24696,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return;
   if (framework === "unknown") {
     invalidate(resolve41(filePath));
-    const relPath = relative16(process.cwd(), filePath);
+    const relPath = relative17(process.cwd(), filePath);
     logHmrUpdate(relPath);
     const angularDir = state.resolvedPaths.angularDir;
     let hasAngularDependent = false;
@@ -24779,7 +24871,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const keepByDir = new Map;
   const prefixByDir = new Map;
   for (const artifact of freshOutputs) {
-    const dir = dirname25(artifact.path);
+    const dir = dirname26(artifact.path);
     const name = basename15(artifact.path);
     const [prefix] = name.split(".");
     if (!prefix)
@@ -25192,7 +25284,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
       try {
         const { invalidateModule: invalidateModule2 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
         for (const tsFile of tsFilesToRefresh) {
-          const rel = relative16(angularDirAbs, tsFile).replace(/\\/g, "/").replace(/\.[tj]sx?$/, ".js");
+          const rel = relative17(angularDirAbs, tsFile).replace(/\\/g, "/").replace(/\.[tj]sx?$/, ".js");
           const compiledFile = resolve41(compiledRoot, rel);
           invalidateModule2(compiledFile);
         }
@@ -25233,12 +25325,12 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     try {
       const { primeComponentFingerprint: primeComponentFingerprint2 } = await Promise.resolve().then(() => (init_fastHmrCompiler(), exports_fastHmrCompiler));
       const { readdir: readdir5 } = await import("fs/promises");
-      const { join: join42 } = await import("path");
+      const { join: join43 } = await import("path");
       const walk = async (dir) => {
         const entries = await readdir5(dir, { withFileTypes: true });
         const files = [];
         for (const entry of entries) {
-          const full = join42(dir, entry.name);
+          const full = join43(dir, entry.name);
           if (entry.isDirectory()) {
             files.push(...await walk(full));
           } else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
@@ -25338,7 +25430,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 = relative16(process.cwd(), pageFile).replace(/\\/g, "/");
+  const rel = relative17(process.cwd(), pageFile).replace(/\\/g, "/");
   const url = `${SRC_URL_PREFIX2}${rel}`;
   warmCache2(url);
   return url;
@@ -25369,7 +25461,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const pageModuleUrl = await getReactModuleUrl(broadcastTarget);
   if (pageModuleUrl) {
     const serverDuration = Date.now() - startTime;
-    state.lastHmrPath = relative16(process.cwd(), primaryFile).replace(/\\/g, "/");
+    state.lastHmrPath = relative17(process.cwd(), primaryFile).replace(/\\/g, "/");
     state.lastHmrFramework = "react";
     broadcastToClients(state, {
       data: {
@@ -25704,7 +25796,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const { vueServerPaths, vueIndexPaths, vueClientPaths, vueCssPaths } = await compileVue2(vueFiles, vueDir, true, getStyleTransformConfig(state.config));
   const serverEntries = [...vueServerPaths];
   const clientEntries = [...vueIndexPaths, ...vueClientPaths];
-  const cssOutDir = join41(buildDir, state.resolvedPaths.assetsDir ? basename15(state.resolvedPaths.assetsDir) : "assets", "css");
+  const cssOutDir = join42(buildDir, state.resolvedPaths.assetsDir ? basename15(state.resolvedPaths.assetsDir) : "assets", "css");
   const { serverRoot, serverOutDir } = await computeServerOutPaths(state.resolvedPaths, "vue");
   const [serverResult, clientResult, cssResult] = await Promise.all([
     serverEntries.length > 0 ? bunBuild9({
@@ -25860,7 +25952,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const duration = Date.now() - startTime;
   const [primary] = emberFiles;
   if (primary) {
-    state.lastHmrPath = relative16(process.cwd(), primary).replace(/\\/g, "/");
+    state.lastHmrPath = relative17(process.cwd(), primary).replace(/\\/g, "/");
     state.lastHmrFramework = "ember";
     logHmrUpdate(primary, "ember", duration);
   }
@@ -25945,7 +26037,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!buildReference?.source) {
     return;
   }
-  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve41(dirname25(buildInfo.resolvedRegistryPath), buildReference.source);
+  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve41(dirname26(buildInfo.resolvedRegistryPath), buildReference.source);
   islandFiles.add(resolve41(sourcePath));
 }, resolveIslandSourceFiles = async (config) => {
   const registryPath = config.islands?.registry;
@@ -26103,7 +26195,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const baseName = fileName.replace(/\.vue$/, "");
   const pascalName = toPascal(baseName);
   const vueRoot = config.vueDirectory;
-  const hmrId = vueRoot ? relative16(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
+  const hmrId = vueRoot ? relative17(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));
@@ -26699,7 +26791,7 @@ __export(exports_buildDepVendor, {
   buildDepVendor: () => buildDepVendor
 });
 import { mkdirSync as mkdirSync14 } from "fs";
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 import { rm as rm10 } from "fs/promises";
 var {build: bunBuild9, Glob: Glob10 } = globalThis.Bun;
 var toSafeFileName6 = (specifier) => {
@@ -26810,7 +26902,7 @@ var toSafeFileName6 = (specifier) => {
 }), buildDepVendorPass = async (specifiers, vendorDir, tmpDir) => {
   const entries = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName6(specifier);
-    const entryPath = join42(tmpDir, `${safeName}.ts`);
+    const entryPath = join43(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return { entryPath, specifier };
   }));
@@ -26871,9 +26963,9 @@ var toSafeFileName6 = (specifier) => {
   const { dep: initialSpecs, framework: frameworkRoots } = await scanBareImports(directories);
   if (initialSpecs.length === 0 && frameworkRoots.length === 0)
     return {};
-  const vendorDir = join42(buildDir, "vendor");
+  const vendorDir = join43(buildDir, "vendor");
   mkdirSync14(vendorDir, { recursive: true });
-  const tmpDir = join42(buildDir, "_dep_vendor_tmp");
+  const tmpDir = join43(buildDir, "_dep_vendor_tmp");
   mkdirSync14(tmpDir, { recursive: true });
   const allSpecs = new Set(initialSpecs);
   const alreadyScanned = new Set;
@@ -27574,12 +27666,12 @@ __export(exports_devtoolsJson, {
   devtoolsJson: () => devtoolsJson
 });
 import { existsSync as existsSync35, mkdirSync as mkdirSync15, readFileSync as readFileSync29, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname26, join as join43, resolve as resolve43 } from "path";
+import { dirname as dirname27, join as join44, resolve as resolve43 } 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) => resolve43(uuidCachePath ?? join43(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) => resolve43(uuidCachePath ?? join44(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
   if (!existsSync35(cachePath))
     return null;
   try {
@@ -27601,7 +27693,7 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   if (cachedUuid)
     return setGlobalUuid(cachedUuid);
   const uuid = crypto.randomUUID();
-  mkdirSync15(dirname26(cachePath), { recursive: true });
+  mkdirSync15(dirname27(cachePath), { recursive: true });
   writeFileSync10(cachePath, uuid, "utf-8");
   return setGlobalUuid(uuid);
 }, devtoolsJson = (buildDir, options = {}) => {
@@ -27618,11 +27710,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 join43("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
+    return join44("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
   }
   if (process.env.DOCKER_DESKTOP && !root.startsWith("\\\\")) {
     const withoutLeadingSlash = root.replace(/^\//, "");
-    return join43("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
+    return join44("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
   }
   return root;
 };
@@ -27854,7 +27946,7 @@ __export(exports_prerender, {
   PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER
 });
 import { mkdirSync as mkdirSync16, readFileSync as readFileSync30 } from "fs";
-import { join as join44 } from "path";
+import { join as join45 } 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()));
@@ -27920,7 +28012,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 = join44(prerenderDir, fileName);
+    const filePath = join45(prerenderDir, fileName);
     await Bun.write(filePath, html);
     await writeTimestamp(filePath);
     return true;
@@ -27946,13 +28038,13 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
   }
   const html = await res.text();
   const fileName = routeToFilename(route);
-  const filePath = join44(prerenderDir, fileName);
+  const filePath = join45(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 = join44(outDir, "_prerendered");
+  const prerenderDir = join45(outDir, "_prerendered");
   mkdirSync16(prerenderDir, { recursive: true });
   const baseUrl = `http://localhost:${port}`;
   let routes;
@@ -28054,7 +28146,7 @@ __export(exports_serverEntryWatcher, {
 });
 import { existsSync as existsSync39, statSync as statSync8, watch as watch2 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { dirname as dirname27, join as join48, resolve as resolve46 } from "path";
+import { dirname as dirname28, join as join49, resolve as resolve46 } from "path";
 var ATOMIC_RECOVERY_WINDOW_MS = 1000, RELOAD_DEBOUNCE_MS = 80, ATOMIC_WRITE_TEMP_PATTERNS2, isAtomicWriteTemp = (filename) => filename.endsWith(".tmp") || filename.includes(".tmp.") || filename.endsWith("~") || filename.startsWith(".#") || ATOMIC_WRITE_TEMP_PATTERNS2.some((re2) => re2.test(filename)), startServerEntryWatcher = () => {
   if (globalThis.__absoluteEntryWatcherStarted)
     return;
@@ -28063,10 +28155,10 @@ var ATOMIC_RECOVERY_WINDOW_MS = 1000, RELOAD_DEBOUNCE_MS = 80, ATOMIC_WRITE_TEMP
     return;
   globalThis.__absoluteEntryWatcherStarted = true;
   const entryPath = resolve46(main);
-  const entryDir = dirname27(entryPath);
+  const entryDir = dirname28(entryPath);
   const entryBase = entryPath.slice(entryDir.length + 1);
   const configPath2 = resolve46(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
-  const configDir2 = dirname27(configPath2);
+  const configDir2 = dirname28(configPath2);
   const configBase = configPath2.slice(configDir2.length + 1);
   const recentlyHandled = new Map;
   let entryReloadTimer = null;
@@ -28157,7 +28249,7 @@ var ATOMIC_RECOVERY_WINDOW_MS = 1000, RELOAD_DEBOUNCE_MS = 80, ATOMIC_WRITE_TEMP
         continue;
       let st2;
       try {
-        st2 = statSync8(join48(dir, entry.name));
+        st2 = statSync8(join49(dir, entry.name));
       } catch {
         continue;
       }
@@ -28415,7 +28507,6 @@ init_staticIslandPages();
 var {file } = globalThis.Bun;
 
 // src/core/islandPageContext.ts
-init_constants();
 var BOOTSTRAP_MANIFEST_KEY = "BootstrapClient";
 var ISLAND_MARKER = 'data-island="true"';
 var MANIFEST_MARKER = "__ABSOLUTE_MANIFEST__";
@@ -28536,61 +28627,69 @@ var pipeStreamWithHeadInjection = (stream, markup) => {
 var pipeStreamWithIslandMarkerDetection = (stream, markup) => {
   const encoder = new TextEncoder;
   const decoder = new TextDecoder;
-  const lookbehind = Math.max(ISLAND_MARKER.length, BYTES_PER_KILOBYTE);
-  const processPending = (controller, pending, injected) => {
-    if (injected) {
-      controller.enqueue(encoder.encode(pending));
-      return { injected, pending: "" };
+  const headLookbehind = CLOSING_HEAD_TAG2.length - 1;
+  const enqueue = (controller, text) => {
+    if (text.length > 0) {
+      controller.enqueue(encoder.encode(text));
     }
-    const markerIndex = pending.indexOf(ISLAND_MARKER);
-    if (markerIndex >= 0) {
-      const tagStart = pending.lastIndexOf("<", markerIndex);
-      const injectAt = tagStart >= 0 ? tagStart : markerIndex;
-      const next = `${pending.slice(0, injectAt)}${markup}${pending.slice(injectAt)}`;
-      controller.enqueue(encoder.encode(next));
-      return { injected: true, pending: "" };
+  };
+  const processHolding = (controller, held) => {
+    if (!held.includes(ISLAND_MARKER)) {
+      return { held, injected: false, pending: "", sawHead: true };
     }
-    return {
-      injected,
-      pending: flushSafePendingText(controller, encoder, pending, lookbehind)
-    };
+    enqueue(controller, `${markup}${held}`);
+    return { held: "", injected: true, pending: "", sawHead: true };
   };
-  const finishIslandMarkerStream = (controller, pending) => {
-    const finalPending = pending + decoder.decode();
-    if (finalPending.length > 0) {
-      controller.enqueue(encoder.encode(finalPending));
+  const processHead = (controller, pending) => {
+    const headIndex = pending.indexOf(CLOSING_HEAD_TAG2);
+    if (headIndex < 0) {
+      return {
+        held: "",
+        injected: false,
+        pending: flushSafePendingText(controller, encoder, pending, headLookbehind),
+        sawHead: false
+      };
     }
-    controller.close();
+    enqueue(controller, pending.slice(0, headIndex));
+    return processHolding(controller, pending.slice(headIndex));
   };
-  const consumeIslandChunk = async (controller, reader, pending, injected) => {
-    const { done, value } = await readStreamChunk(reader);
-    if (done || !value) {
-      return { done, injected, pending };
+  const processChunk = (controller, state, chunk) => {
+    if (state.injected) {
+      enqueue(controller, chunk);
+      return state;
     }
-    const processed = processPending(controller, pending + streamChunkToString2(value, decoder), injected);
-    return {
-      done,
-      injected: processed.injected,
-      pending: processed.pending
-    };
+    if (!state.sawHead) {
+      return processHead(controller, state.pending + chunk);
+    }
+    return processHolding(controller, state.held + chunk);
   };
-  const runIslandMarkerLoop = async (controller, reader) => {
-    const consumeNextIslandChunk = async (injected, pending) => {
-      const consumed = await consumeIslandChunk(controller, reader, pending, injected);
-      const nextState = updateInjectedState(consumed, injected, pending);
-      if (nextState.done) {
-        return { injected, pending };
+  const finishMarkerStream = (controller, state) => {
+    const tail = decoder.decode();
+    const remainder = state.injected ? tail : (state.sawHead ? state.held : state.pending) + tail;
+    enqueue(controller, remainder);
+    controller.close();
+  };
+  const runMarkerLoop = (controller, reader) => {
+    const consumeNext = async (state) => {
+      const { done, value } = await readStreamChunk(reader);
+      if (done || !value) {
+        return state;
       }
-      return consumeNextIslandChunk(nextState.injected, nextState.pending);
+      return consumeNext(processChunk(controller, state, streamChunkToString2(value, decoder)));
     };
-    return consumeNextIslandChunk(false, "");
+    return consumeNext({
+      held: "",
+      injected: false,
+      pending: "",
+      sawHead: false
+    });
   };
   return new ReadableStream({
     async start(controller) {
       const reader = stream.getReader();
       try {
-        const { pending } = await runIslandMarkerLoop(controller, reader);
-        finishIslandMarkerStream(controller, pending);
+        const finalState = await runMarkerLoop(controller, reader);
+        finishMarkerStream(controller, finalState);
       } catch (error) {
         controller.error(error);
       }
@@ -28713,12 +28812,12 @@ var handleHTMXPageRequest = async (pagePath) => {
 // src/core/prepare.ts
 init_loadConfig();
 import { existsSync as existsSync37, readdirSync as readdirSync8, readFileSync as readFileSync31 } from "fs";
-import { basename as basename16, join as join45, relative as relative17, resolve as resolve45 } from "path";
+import { basename as basename16, join as join46, relative as relative18, resolve as resolve45 } from "path";
 import { Elysia as Elysia5 } from "elysia";
 
 // src/core/loadIslandRegistry.ts
 init_islandEntries();
-import { resolve as resolve10 } from "path";
+import { resolve as resolve11 } from "path";
 var isRecord6 = (value) => typeof value === "object" && value !== null;
 var resolveRegistryExport2 = (mod) => {
   if (isRecord6(mod.islandRegistry))
@@ -28730,7 +28829,7 @@ var resolveRegistryExport2 = (mod) => {
 var isRegistryModuleExport = (value) => isRecord6(value);
 var isIslandRegistryInput = (value) => isRecord6(value);
 var loadIslandRegistry = async (registryPath) => {
-  const resolvedRegistryPath = resolve10(registryPath);
+  const resolvedRegistryPath = resolve11(registryPath);
   const buildInfo = await loadIslandRegistryBuildInfo(resolvedRegistryPath);
   if (buildInfo.definitions.length > 0) {
     return buildInfo.registry;
@@ -29086,7 +29185,7 @@ var warmPrewarmDirs = async (prewarmDirs, warmCache2, SRC_URL_PREFIX2) => {
   for (const file5 of files) {
     if (file5.includes("/node_modules/"))
       continue;
-    const rel = relative17(process.cwd(), file5).replace(/\\/g, "/");
+    const rel = relative18(process.cwd(), file5).replace(/\\/g, "/");
     warmCache2(`${SRC_URL_PREFIX2}${rel}`);
   }
 };
@@ -29114,7 +29213,7 @@ var patchManifestIndexes = (manifest, devIndexDir, SRC_URL_PREFIX2) => {
     const srcPath = resolve45(devIndexDir, fileName);
     if (!existsSync37(srcPath))
       continue;
-    const rel = relative17(process.cwd(), srcPath).replace(/\\/g, "/");
+    const rel = relative18(process.cwd(), srcPath).replace(/\\/g, "/");
     manifest[key] = `${SRC_URL_PREFIX2}${rel}`;
   }
 };
@@ -29233,7 +29332,7 @@ var loadPrerenderMap = (prerenderDir) => {
       continue;
     const name = basename16(entry, ".html");
     const route = name === "index" ? "/" : `/${name}`;
-    map.set(route, join45(prerenderDir, entry));
+    map.set(route, join46(prerenderDir, entry));
   }
   return map;
 };
@@ -29293,7 +29392,7 @@ var prepare = async (configOrPath) => {
   setCurrentPageIslandMetadata(await loadPageIslandMetadata(config));
   recordStep("load production manifest and island metadata", stepStartedAt);
   stepStartedAt = performance.now();
-  const conventionsPath = join45(buildDir, "conventions.json");
+  const conventionsPath = join46(buildDir, "conventions.json");
   if (existsSync37(conventionsPath)) {
     const conventions2 = JSON.parse(readFileSync31(conventionsPath, "utf-8"));
     setConventions(conventions2);
@@ -29307,12 +29406,12 @@ var prepare = async (configOrPath) => {
     prefix: "",
     staticLimit: MAX_STATIC_ROUTE_COUNT
   });
-  const generatedAssetsRoot = join45(buildDir, ".absolutejs");
+  const generatedAssetsRoot = join46(buildDir, ".absolutejs");
   const generatedAssetsPlugin = new Elysia5({
     name: "absolutejs-generated-assets"
   }).get("/.absolutejs/*", async ({ params, set }) => {
     const requestedPath = resolve45(generatedAssetsRoot, params["*"]);
-    if (relative17(generatedAssetsRoot, requestedPath).startsWith("..")) {
+    if (relative18(generatedAssetsRoot, requestedPath).startsWith("..")) {
       set.status = 404;
       return "Not Found";
     }
@@ -29326,7 +29425,7 @@ var prepare = async (configOrPath) => {
   });
   recordStep("create static plugin", stepStartedAt);
   stepStartedAt = performance.now();
-  const prerenderDir = join45(buildDir, "_prerendered");
+  const prerenderDir = join46(buildDir, "_prerendered");
   const prerenderMap = loadPrerenderMap(prerenderDir);
   recordStep("load prerender map", stepStartedAt);
   if (prerenderMap.size > 0) {
@@ -29391,10 +29490,10 @@ import {
   readFileSync as readFileSync32,
   rmSync as rmSync4
 } from "fs";
-import { join as join46 } from "path";
-var CERT_DIR = join46(process.cwd(), ".absolutejs");
-var CERT_PATH = join46(CERT_DIR, "cert.pem");
-var KEY_PATH = join46(CERT_DIR, "key.pem");
+import { join as join47 } from "path";
+var CERT_DIR = join47(process.cwd(), ".absolutejs");
+var CERT_PATH = join47(CERT_DIR, "cert.pem");
+var KEY_PATH = join47(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`);
@@ -29514,12 +29613,12 @@ import {
   writeFileSync as writeFileSync11
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename as basename17, join as join47 } from "path";
+import { basename as basename17, join as join48 } from "path";
 var registeredPids = new Set;
 var exitHandlerRegistered = false;
-var instanceFilePath = (pid) => join47(instanceRegistryDir(), `${pid}.json`);
-var instanceLogPath = (pid) => join47(instanceRegistryDir(), `${pid}.log`);
-var instanceRegistryDir = () => join47(homedir2(), ".absolutejs", "instances");
+var instanceFilePath = (pid) => join48(instanceRegistryDir(), `${pid}.json`);
+var instanceLogPath = (pid) => join48(instanceRegistryDir(), `${pid}.log`);
+var instanceRegistryDir = () => join48(homedir2(), ".absolutejs", "instances");
 var removeInstanceFilesSync = (pid) => {
   try {
     unlinkSync2(instanceFilePath(pid));
@@ -29554,7 +29653,7 @@ var registerInstance = (record) => {
   return record;
 };
 var resolveProjectName = (cwd2) => {
-  const parsed = readJsonFile(join47(cwd2, "package.json"));
+  const parsed = readJsonFile(join48(cwd2, "package.json"));
   if (parsed !== null && typeof parsed === "object" && typeof parsed.name === "string" && parsed.name.trim().length > 0) {
     return parsed.name;
   }
@@ -35931,7 +36030,7 @@ var getEnv = (key) => {
 };
 // src/utils/projectRoot.ts
 import { existsSync as existsSync41 } from "fs";
-import { dirname as dirname28, resolve as resolve48 } from "path";
+import { dirname as dirname29, resolve as resolve48 } from "path";
 var CONFIG_CANDIDATES = [
   "absolute.config.ts",
   "absolute.config.js",
@@ -35951,7 +36050,7 @@ var findProjectRoot = () => {
     if (packageRoot === null && existsSync41(resolve48(dir, "package.json"))) {
       packageRoot = dir;
     }
-    const parent = dirname28(dir);
+    const parent = dirname29(dir);
     if (parent === dir) {
       return packageRoot ?? start;
     }
@@ -36187,5 +36286,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=C6C2AA79E0B6938D64756E2164756E21
+//# debugId=C5D7127FA2204C7B64756E2164756E21
 //# sourceMappingURL=index.js.map