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

package/dist/angular/server.js

@@ -468,9 +468,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,
@@ -643,9 +646,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: InjectionToken2, inject } = await import("@angular/core");
-  const { NgComponentOutlet } = await import("@angular/common");
   const deps = await getAngularDeps();
+  const { Component, InjectionToken: InjectionToken2, NgComponentOutlet, inject } = deps;
   const selector = getAngularIslandSelector(islandId);
   const propsToken = new InjectionToken2(`${wrapperKey}:props`);
 
@@ -751,7 +753,15 @@ var init_islands = __esm(() => {
 var renderAngularIslandToHtmlInternal = async (component, props, islandId) => {
   const { renderAngularIslandToHtml: renderAngularIslandToHtml2 } = await Promise.resolve().then(() => (init_islands(), 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 }) => {
@@ -762,10 +772,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 resolve2 } 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 = resolve2(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 join2 } 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 p = pathMatch[1];
+      if (!p)
+        continue;
+      const base = p.split("/").pop()?.replace(/\.[mc]?js$/, "");
+      if (!base)
+        continue;
+      const normalized = base.startsWith("_") ? base.slice(1) : base;
+      if (normalized === ident || normalized.endsWith(`_${ident}`)) {
+        sourcePath = p;
+        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(join2(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 } from "fs/promises";
+import { dirname, join as join3, relative } from "path";
+var serverCacheRoot, compiledModuleCache, ANGULAR_SPECIFIER_RE, getCachedModulePath = (sourcePath) => {
+  const relativeSourcePath = relative(process.cwd(), sourcePath).replace(/\\/g, "/");
+  const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
+  return join3(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 mkdir(dirname(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 = join3(process.cwd(), ".absolutejs", "islands", "angular");
+  compiledModuleCache = new Map;
+  ANGULAR_SPECIFIER_RE = /["'](@angular\/[^"']+)["']/g;
 });
 
 // src/build/resolvePackageImport.ts
-import { resolve as resolve2, join as join2 } from "path";
+import { resolve as resolve3, join as join4 } from "path";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 var resolveExportPath = (entry, conditions) => {
   if (typeof entry === "string")
@@ -787,11 +1098,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 = resolve2(process.cwd(), "package.json");
+  const currentPackageJsonPath = resolve3(process.cwd(), "package.json");
   const currentPackageJson = existsSync2(currentPackageJsonPath) ? JSON.parse(readFileSync2(currentPackageJsonPath, "utf-8")) : null;
   const currentPackageDir = currentPackageJson?.name === packageName ? process.cwd() : null;
-  const packageDir = currentPackageDir ?? resolve2(process.cwd(), "node_modules", packageName ?? "");
-  const packageJsonPath = join2(packageDir, "package.json");
+  const packageDir = currentPackageDir ?? resolve3(process.cwd(), "node_modules", packageName ?? "");
+  const packageJsonPath = join4(packageDir, "package.json");
   if (!existsSync2(packageJsonPath))
     return null;
   try {
@@ -806,12 +1117,12 @@ var resolveExportPath = (entry, conditions) => {
     if (!importPath)
       return null;
     if (currentPackageDir && importPath.startsWith("./dist/")) {
-      const sourceCandidate = resolve2(packageDir, importPath.replace(/^\.\/dist\//, "./src/"));
+      const sourceCandidate = resolve3(packageDir, importPath.replace(/^\.\/dist\//, "./src/"));
       if (existsSync2(sourceCandidate)) {
         return sourceCandidate;
       }
     }
-    const resolved = resolve2(packageDir, importPath);
+    const resolved = resolve3(packageDir, importPath);
     return existsSync2(resolved) ? resolved : null;
   } catch {
     return null;
@@ -968,12 +1279,12 @@ import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
 import {
-  dirname,
+  dirname as dirname2,
   extname,
   isAbsolute,
-  join as join3,
-  relative,
-  resolve as resolve3
+  join as join5,
+  relative as relative2,
+  resolve as resolve4
 } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 var CSS_EXTENSION_PATTERN, STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATTERN, importOptionalPeer, requireOptionalPeer, requireFromCwd, isPreprocessableStylePath = (filePath) => STYLE_EXTENSION_PATTERN.test(filePath), isStyleModulePath = (filePath) => STYLE_MODULE_EXTENSION_PATTERN.test(filePath), isStylePath = (filePath) => /\.(css|s[ac]ss|less|styl(?:us)?)$/i.test(filePath), getStyleBaseName = (filePath) => filePath.replace(/\.(css|s[ac]ss|less|styl(?:us)?)$/i, ""), getStyleLanguage = (filePathOrLanguage) => {
@@ -1009,9 +1320,9 @@ ${message}`);
     return requireOptionalPeer(specifier);
   }
 }, normalizeLoadPaths = (filePath, paths = []) => [
-  dirname(filePath),
+  dirname2(filePath),
   process.cwd(),
-  ...paths.map((path) => resolve3(process.cwd(), path))
+  ...paths.map((path) => resolve4(process.cwd(), path))
 ], tsconfigAliasCache, stripJsonComments = (source) => source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1"), normalizeAliasEntries = (aliases) => Object.entries(aliases ?? {}).map(([pattern, value]) => ({
   pattern,
   replacements: Array.isArray(value) ? value : [value]
@@ -1019,7 +1330,7 @@ ${message}`);
   const cwd = process.cwd();
   if (tsconfigAliasCache?.cwd === cwd)
     return tsconfigAliasCache;
-  const tsconfigPath = resolve3(cwd, "tsconfig.json");
+  const tsconfigPath = resolve4(cwd, "tsconfig.json");
   const empty = { aliases: [], baseUrl: cwd, cwd };
   if (!existsSync3(tsconfigPath)) {
     tsconfigAliasCache = empty;
@@ -1028,7 +1339,7 @@ ${message}`);
   try {
     const parsed = JSON.parse(stripJsonComments(readFileSync3(tsconfigPath, "utf-8")));
     const compilerOptions = parsed.compilerOptions ?? {};
-    const baseUrl = resolve3(cwd, compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve4(cwd, compilerOptions.baseUrl ?? ".");
     tsconfigAliasCache = {
       aliases: normalizeAliasEntries(compilerOptions.paths),
       baseUrl,
@@ -1056,7 +1367,7 @@ ${message}`);
       continue;
     const wildcard = match[1] ?? "";
     for (const replacement of alias.replacements) {
-      targets.push(resolve3(baseUrl, replacement.replace("*", wildcard)));
+      targets.push(resolve4(baseUrl, replacement.replace("*", wildcard)));
     }
   }
   return targets;
@@ -1070,21 +1381,21 @@ ${message}`);
   const ext = extname(basePath);
   const paths = ext ? [basePath] : getLanguageExtensions(language).flatMap((extension) => [
     `${basePath}${extension}`,
-    join3(basePath, `index${extension}`)
+    join5(basePath, `index${extension}`)
   ]);
   if (language === "scss" || language === "sass") {
     return paths.flatMap((path) => {
-      const dir = dirname(path);
+      const dir = dirname2(path);
       const base = path.slice(dir.length + 1);
-      return [path, join3(dir, `_${base}`)];
+      return [path, join5(dir, `_${base}`)];
     });
   }
   return paths;
 }, resolveImportPath = (specifier, fromDirectory, loadPaths, language, config) => {
   const rawCandidates = [
     ...resolveAliasTargets(specifier, config),
-    isAbsolute(specifier) ? specifier : resolve3(fromDirectory, specifier),
-    ...loadPaths.map((path) => resolve3(path, specifier))
+    isAbsolute(specifier) ? specifier : resolve4(fromDirectory, specifier),
+    ...loadPaths.map((path) => resolve4(path, specifier))
   ];
   for (const candidate of rawCandidates.flatMap((path) => getCandidatePaths(path, language))) {
     if (existsSync3(candidate))
@@ -1100,8 +1411,8 @@ ${message}`);
     path: url.slice(0, markerIndex)
   };
 }, rebaseCssUrls = (contents, sourceFile, entryFile) => {
-  const sourceDir = dirname(sourceFile);
-  const entryDir = dirname(entryFile);
+  const sourceDir = dirname2(sourceFile);
+  const entryDir = dirname2(entryFile);
   if (sourceDir === entryDir)
     return contents;
   return contents.replace(/url\(\s*(['"]?)([^'")]+)\1\s*\)/gi, (match, quote, rawUrl) => {
@@ -1109,7 +1420,7 @@ ${message}`);
     if (!trimmedUrl || isExternalCssUrl(trimmedUrl))
       return match;
     const { marker, path } = splitCssUrl(trimmedUrl);
-    const rebased = relative(entryDir, resolve3(sourceDir, path)).replace(/\\/g, "/");
+    const rebased = relative2(entryDir, resolve4(sourceDir, path)).replace(/\\/g, "/");
     const normalized = rebased.startsWith(".") ? rebased : `./${rebased}`;
     const nextQuote = quote || '"';
     return `url(${nextQuote}${normalized}${marker}${nextQuote})`;
@@ -1117,7 +1428,7 @@ ${message}`);
 }, rewriteAliasedStyleImports = (contents, sourceFile, loadPaths, language, config) => contents.replace(/(@(?:use|forward|import|require)\s+)(["'])([^"']+)\2/g, (match, prefix, quote, specifier) => {
   if (specifier.startsWith(".") || isAbsolute(specifier) || isExternalCssUrl(specifier))
     return match;
-  const resolved = resolveImportPath(specifier, dirname(sourceFile), loadPaths, language, config);
+  const resolved = resolveImportPath(specifier, dirname2(sourceFile), loadPaths, language, config);
   return resolved ? `${prefix}${quote}${resolved}${quote}` : match;
 }), preprocessLoadedStyle = (contents, sourceFile, entryFile, loadPaths = [], language, config) => {
   const rebased = rebaseCssUrls(contents, sourceFile, entryFile);
@@ -1147,7 +1458,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   }
   return mod;
 }, loadPostcssConfigFile = async (configPath) => {
-  const resolved = resolve3(process.cwd(), configPath);
+  const resolved = resolve4(process.cwd(), configPath);
   const loaded = resolved.endsWith(".cjs") || resolved.endsWith(".cts") ? requireOptionalPeerSync(resolved) : await importOptionalPeer(`${new URL(`file://${resolved}`).href}?t=${Date.now()}`);
   const config = normalizePostcssModule(loaded);
   const value = typeof config === "function" ? await config({
@@ -1207,9 +1518,9 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   return result.css;
 }, createSassImporter = (entryFile, loadPaths, language, config, deps) => ({
   canonicalize(specifier, options) {
-    const fromDirectory = options.containingUrl ? dirname(fileURLToPath(options.containingUrl)) : dirname(entryFile);
+    const fromDirectory = options.containingUrl ? dirname2(fileURLToPath(options.containingUrl)) : dirname2(entryFile);
     const resolved = resolveImportPath(specifier, fromDirectory, loadPaths, language, config);
-    return resolved ? new URL(pathToFileURL(resolve3(resolved)).href) : null;
+    return resolved ? new URL(pathToFileURL(resolve4(resolved)).href) : null;
   },
   load(canonicalUrl) {
     const filePath = fileURLToPath(canonicalUrl);
@@ -1226,9 +1537,9 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   install(less, pluginManager) {
     const baseManager = new less.FileManager;
     const manager = Object.create(baseManager);
-    manager.supports = (filename, currentDirectory) => Boolean(resolveImportPath(filename, resolve3(currentDirectory), loadPaths, "less", config));
+    manager.supports = (filename, currentDirectory) => Boolean(resolveImportPath(filename, resolve4(currentDirectory), loadPaths, "less", config));
     manager.loadFile = async (filename, currentDirectory) => {
-      const resolved = resolveImportPath(filename, resolve3(currentDirectory), loadPaths, "less", config);
+      const resolved = resolveImportPath(filename, resolve4(currentDirectory), loadPaths, "less", config);
       if (!resolved) {
         throw new Error(`Unable to resolve Less import "${filename}"`);
       }
@@ -1265,29 +1576,29 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
         const stylusDeps = renderer.deps?.();
         if (Array.isArray(stylusDeps)) {
           for (const dep of stylusDeps)
-            deps.add(resolve3(dep));
+            deps.add(resolve4(dep));
         }
       }
       resolveCss(css ?? "");
     });
   });
 }, styleDependencyGraph, styleOutputHashes, recordStyleDeps = (entry, deps) => {
-  const key = resolve3(entry);
+  const key = resolve4(entry);
   const stripped = new Set;
   for (const dep of deps) {
-    const resolved = resolve3(dep);
+    const resolved = resolve4(dep);
     if (resolved !== key)
       stripped.add(resolved);
   }
   styleDependencyGraph.set(key, stripped);
 }, addStyleImporter = (importerPath, stylePath) => {
-  const key = resolve3(importerPath);
-  const target = resolve3(stylePath);
+  const key = resolve4(importerPath);
+  const target = resolve4(stylePath);
   const deps = styleDependencyGraph.get(key) ?? new Set;
   deps.add(target);
   styleDependencyGraph.set(key, deps);
 }, findStyleEntriesImporting = (changedPath) => {
-  const target = resolve3(changedPath);
+  const target = resolve4(changedPath);
   const importers = [];
   for (const [entry, deps] of styleDependencyGraph) {
     if (deps.has(target))
@@ -1295,13 +1606,13 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   }
   return importers;
 }, recordStyleOutput = (entry, css) => {
-  const key = resolve3(entry);
+  const key = resolve4(entry);
   const hash = createHash("sha1").update(css).digest("hex");
   const previous = styleOutputHashes.get(key);
   styleOutputHashes.set(key, hash);
   return previous !== hash;
 }, forgetStyleEntry = (entry) => {
-  const key = resolve3(entry);
+  const key = resolve4(entry);
   styleDependencyGraph.delete(key);
   styleOutputHashes.delete(key);
 }, compileStyleSource = async (filePath, source, languageHint, config) => {
@@ -1327,7 +1638,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
         loadPaths,
         style: "expanded",
         syntax: language === "sass" ? "indented" : "scss",
-        url: new URL(pathToFileURL(resolve3(filePath)).href)
+        url: new URL(pathToFileURL(resolve4(filePath)).href)
       });
       const css = await runPostcss(result.css, filePath, config);
       const loadedUrls = result.loadedUrls ?? [];
@@ -1335,7 +1646,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
         if (url.protocol !== "file:")
           continue;
         const dep = fileURLToPath(url);
-        if (resolve3(dep) === resolve3(filePath))
+        if (resolve4(dep) === resolve4(filePath))
           continue;
         deps.add(dep);
       }
@@ -1456,7 +1767,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
     const start = match.index ?? 0;
     const end = start + match[0].length;
     parts.push(content.slice(cursor, start));
-    const fullPath = isAbsolute(importPath) ? importPath : resolve3(baseDir, importPath);
+    const fullPath = isAbsolute(importPath) ? importPath : resolve4(baseDir, importPath);
     if (visited.has(fullPath) || !existsSync3(fullPath)) {
       parts.push(visited.has(fullPath) ? "" : match[0]);
       cursor = end;
@@ -1465,7 +1776,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
     const nextVisited = new Set(visited);
     nextVisited.add(fullPath);
     const imported = await readFile(fullPath, "utf-8");
-    parts.push(await resolveCssImportsAsync(imported, dirname(fullPath), nextVisited));
+    parts.push(await resolveCssImportsAsync(imported, dirname2(fullPath), nextVisited));
     cursor = end;
   }
   parts.push(content.slice(cursor));
@@ -1474,13 +1785,13 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   if (!isPreprocessableStylePath(filePath)) {
     const raw = await readFile(filePath, "utf-8");
     const processed = await runPostcss(raw, filePath, config);
-    return resolveCssImportsAsync(processed, dirname(filePath), new Set([filePath]));
+    return resolveCssImportsAsync(processed, dirname2(filePath), new Set([filePath]));
   }
   const compiled = await compileStyleSource(filePath, undefined, undefined, config);
-  return resolveCssImportsAsync(compiled, dirname(filePath), new Set([filePath]));
+  return resolveCssImportsAsync(compiled, dirname2(filePath), new Set([filePath]));
 }, resolveCssImportsSync = (content, baseDir, visited) => {
   return content.replace(CSS_IMPORT_PATTERN, (match, importPath) => {
-    const fullPath = isAbsolute(importPath) ? importPath : resolve3(baseDir, importPath);
+    const fullPath = isAbsolute(importPath) ? importPath : resolve4(baseDir, importPath);
     if (visited.has(fullPath))
       return "";
     if (!existsSync3(fullPath))
@@ -1488,7 +1799,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
     const nextVisited = new Set(visited);
     nextVisited.add(fullPath);
     const imported = readFileSync3(fullPath, "utf-8");
-    return resolveCssImportsSync(imported, dirname(fullPath), nextVisited);
+    return resolveCssImportsSync(imported, dirname2(fullPath), nextVisited);
   });
 }, compileStyleFileIfNeededSync = (filePath, config) => {
   const rawContents = readFileSync3(filePath, "utf-8");
@@ -1514,18 +1825,18 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
       loadPaths,
       style: "expanded",
       syntax: language === "sass" ? "indented" : "scss",
-      url: new URL(pathToFileURL(resolve3(filePath)).href)
+      url: new URL(pathToFileURL(resolve4(filePath)).href)
     });
     const loadedUrls = result.loadedUrls ?? [];
     for (const url of loadedUrls) {
       if (url.protocol !== "file:")
         continue;
       const dep = fileURLToPath(url);
-      if (resolve3(dep) === resolve3(filePath))
+      if (resolve4(dep) === resolve4(filePath))
         continue;
       addStyleImporter(filePath, dep);
     }
-    return resolveCssImportsSync(result.css, dirname(filePath), new Set([filePath]));
+    return resolveCssImportsSync(result.css, dirname2(filePath), new Set([filePath]));
   }
   if (language === "less") {
     throw new Error(`Unable to compile ${filePath}: Less styleUrl preprocessing is async-only. Import the Less file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
@@ -1533,7 +1844,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   if (language === "stylus") {
     throw new Error(`Unable to compile ${filePath}: Stylus styleUrl preprocessing is async-only. Import the Stylus file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
   }
-  return resolveCssImportsSync(rawContents, dirname(filePath), new Set([filePath]));
+  return resolveCssImportsSync(rawContents, dirname2(filePath), new Set([filePath]));
 }, getCssOutputExtension = (filePath) => isPreprocessableStylePath(filePath) ? ".css" : extname(filePath);
 var init_stylePreprocessor = __esm(() => {
   CSS_EXTENSION_PATTERN = /\.css$/i;
@@ -1542,7 +1853,7 @@ var init_stylePreprocessor = __esm(() => {
   STYLE_LANGUAGE_PATTERN = /^(s[ac]ss|less|styl(?:us)?)$/i;
   importOptionalPeer = new Function("specifier", "return import(specifier)");
   requireOptionalPeer = new Function("specifier", "return require(specifier)");
-  requireFromCwd = createRequire(join3(process.cwd(), "package.json"));
+  requireFromCwd = createRequire(join5(process.cwd(), "package.json"));
   styleDependencyGraph = new Map;
   styleOutputHashes = new Map;
   stylePreprocessorPlugin = createStylePreprocessorPlugin();
@@ -1550,14 +1861,14 @@ var init_stylePreprocessor = __esm(() => {
 });
 
 // src/core/svelteServerModule.ts
-import { mkdir, readdir } from "fs/promises";
-import { basename as basename2, dirname as dirname2, extname as extname2, join as join4, relative as relative2, resolve as resolve4 } from "path";
-var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
-  const importPath = relative2(dirname2(from), target).replace(/\\/g, "/");
+import { mkdir as mkdir2, readdir as readdir2 } from "fs/promises";
+import { basename as basename2, dirname as dirname3, extname as extname2, join as join6, relative as relative3, resolve as resolve5 } from "path";
+var serverCacheRoot2, compiledModuleCache2, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
+  const importPath = relative3(dirname3(from), target).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
 }, processDirectoryEntries = (entries, dir, targetFileName, stack) => {
   for (const entry of entries) {
-    const entryPath = join4(dir, entry.name);
+    const entryPath = join6(dir, entry.name);
     if (entry.isDirectory())
       stack.push(entryPath);
     if (entry.isFile() && entry.name === targetFileName) {
@@ -1571,7 +1882,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
     })
@@ -1587,11 +1898,11 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (cachedPath !== undefined) {
     return cachedPath;
   }
-  if (!sourcePath.includes(`${join4(process.cwd(), "build")}${process.platform === "win32" ? "" : "/"}`) && !sourcePath.includes("/build/")) {
+  if (!sourcePath.includes(`${join6(process.cwd(), "build")}${process.platform === "win32" ? "" : "/"}`) && !sourcePath.includes("/build/")) {
     originalSourcePathCache.set(sourcePath, sourcePath);
     return sourcePath;
   }
-  const resolvedSourcePath = await findSourceFileByBasename(join4(process.cwd(), "src"), normalizeBuiltSvelteFileName(sourcePath));
+  const resolvedSourcePath = await findSourceFileByBasename(join6(process.cwd(), "src"), normalizeBuiltSvelteFileName(sourcePath));
   const nextPath = resolvedSourcePath ?? sourcePath;
   originalSourcePathCache.set(sourcePath, nextPath);
   return nextPath;
@@ -1599,7 +1910,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (!spec.startsWith(".")) {
     return null;
   }
-  const basePath = resolve4(dirname2(from), spec);
+  const basePath = resolve5(dirname3(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -1607,19 +1918,19 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
     `${basePath}.mjs`,
     `${basePath}.cjs`,
     `${basePath}.json`,
-    join4(basePath, "index.ts"),
-    join4(basePath, "index.js"),
-    join4(basePath, "index.mjs"),
-    join4(basePath, "index.cjs"),
-    join4(basePath, "index.json")
+    join6(basePath, "index.ts"),
+    join6(basePath, "index.js"),
+    join6(basePath, "index.mjs"),
+    join6(basePath, "index.cjs"),
+    join6(basePath, "index.json")
   ];
   const existResults = await Promise.all(candidates.map((candidate) => Bun.file(candidate).exists()));
   const foundIndex = existResults.indexOf(true);
   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 join4(serverCacheRoot, `${normalizedSourcePath}.server.js`);
+  return join6(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
 }, resolveSvelteImport = async (spec, from) => {
   if (!spec.startsWith(".") && !spec.startsWith("/")) {
     const resolved = resolvePackageImport(spec);
@@ -1631,7 +1942,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (!spec.startsWith(".")) {
     return null;
   }
-  const explicitPath = resolve4(dirname2(from), spec);
+  const explicitPath = resolve5(dirname3(from), spec);
   if (extname2(explicitPath) === ".svelte") {
     return explicitPath;
   }
@@ -1651,7 +1962,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;
   }
@@ -1690,7 +2001,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);
@@ -1704,15 +2015,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 mkdir(dirname2(compiledModulePath), { recursive: true });
+  const compiledModulePath = getCachedModulePath2(sourcePath);
+  await mkdir2(dirname3(compiledModulePath), { recursive: true });
   await writeIfChanged(compiledModulePath, compiledCode);
-  compiledModuleCache.set(sourcePath, compiledModulePath);
+  compiledModuleCache2.set(sourcePath, compiledModulePath);
   return compiledModulePath;
 };
 var init_svelteServerModule = __esm(() => {
@@ -1720,8 +2031,8 @@ var init_svelteServerModule = __esm(() => {
   init_lowerIslandSyntax();
   init_lowerAwaitSlotSyntax();
   init_stylePreprocessor();
-  serverCacheRoot = join4(process.cwd(), ".absolutejs", "islands", "svelte");
-  compiledModuleCache = new Map;
+  serverCacheRoot2 = join6(process.cwd(), ".absolutejs", "islands", "svelte");
+  compiledModuleCache2 = new Map;
   originalSourcePathCache = new Map;
   transpiler = new Bun.Transpiler({
     loader: "ts",
@@ -1731,16 +2042,16 @@ var init_svelteServerModule = __esm(() => {
 
 // src/core/vueServerModule.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4, realpathSync } from "fs";
-import { mkdir as mkdir2 } from "fs/promises";
-import { dirname as dirname3, join as join5, relative as relative3, resolve as resolve5 } from "path";
+import { mkdir as mkdir3 } from "fs/promises";
+import { dirname as dirname4, join as join7, relative as relative4, resolve as resolve6 } from "path";
 var {Transpiler } = globalThis.Bun;
-var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, transpiler2, ensureRelativeImportPath2 = (from, target) => {
-  const importPath = relative3(dirname3(from), target).replace(/\\/g, "/");
+var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot3, compiledModuleCache3, transpiler2, ensureRelativeImportPath2 = (from, target) => {
+  const importPath = relative4(dirname4(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 join5(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
+  return join7(serverCacheRoot3, `${normalizedSourcePath}.server.js`);
 }, writeIfChanged2 = async (path, content) => {
   const targetFile = Bun.file(path);
   if (await targetFile.exists()) {
@@ -1767,7 +2078,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");
@@ -1800,7 +2111,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(resolve5(dirname3(sourcePath), relativeImport)),
+    compiledPath: await compileVueServerModule(resolve6(dirname4(sourcePath), relativeImport)),
     spec: relativeImport
   })));
   const strippedScript = stripExports(compiledScript.content);
@@ -1812,20 +2123,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 mkdir2(dirname3(compiledModulePath), { recursive: true });
+  await mkdir3(dirname4(compiledModulePath), { recursive: true });
   await writeIfChanged2(compiledModulePath, rewritten);
-  compiledModuleCache2.set(sourcePath, compiledModulePath);
+  compiledModuleCache3.set(sourcePath, compiledModulePath);
   return compiledModulePath;
 };
 var init_vueServerModule = __esm(() => {
   init_constants();
-  serverCacheRoot2 = join5(process.cwd(), ".absolutejs", "islands", "vue");
-  compiledModuleCache2 = new Map;
+  serverCacheRoot3 = join7(process.cwd(), ".absolutejs", "islands", "vue");
+  compiledModuleCache3 = new Map;
   transpiler2 = new Transpiler({ loader: "ts", target: "browser" });
 });
 
@@ -1971,8 +2282,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.");
   }
@@ -2028,6 +2348,7 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
 };
 var init_renderIslandMarkup = __esm(() => {
   init_islandSsr();
+  init_angularServerModule();
   init_svelteServerModule();
   init_vueServerModule();
   init_islandMarkupAttributes();
@@ -2901,12 +3222,12 @@ var init_startupBanner = __esm(() => {
 // src/utils/logger.ts
 var colors2, frameworkColors, formatPath = (filePath) => {
   const cwd = process.cwd();
-  let relative4 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
-  relative4 = relative4.replace(/\\/g, "/");
-  if (!relative4.startsWith("/")) {
-    relative4 = `/${relative4}`;
+  let relative5 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+  relative5 = relative5.replace(/\\/g, "/");
+  if (!relative5.startsWith("/")) {
+    relative5 = `/${relative5}`;
   }
-  return relative4;
+  return relative5;
 }, getFrameworkColor = (framework) => frameworkColors[framework] || colors2.white, log = (action, options) => {
   const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
   const tag = `${colors2.cyan}[hmr]${colors2.reset}`;
@@ -3510,8 +3831,8 @@ __export(exports_generatedDir, {
   getGeneratedRoot: () => getGeneratedRoot,
   getFrameworkGeneratedDir: () => getFrameworkGeneratedDir
 });
-import { join as join6 } from "path";
-var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getGeneratedRoot = (projectRoot = process.cwd()) => join6(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME), getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join6(getGeneratedRoot(projectRoot), framework);
+import { join as join8 } from "path";
+var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getGeneratedRoot = (projectRoot = process.cwd()) => join8(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME), getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join8(getGeneratedRoot(projectRoot), framework);
 var init_generatedDir = () => {};
 
 // src/build/compileAngular.ts
@@ -3524,7 +3845,7 @@ __export(exports_compileAngular, {
   compileAngular: () => compileAngular
 });
 import { existsSync as existsSync5, readFileSync as readFileSync5, promises as fs } from "fs";
-import { join as join7, basename as basename3, sep, dirname as dirname4, resolve as resolve6, relative as relative4 } from "path";
+import { join as join9, basename as basename3, sep, dirname as dirname5, resolve as resolve7, relative as relative5 } from "path";
 var {Glob } = globalThis.Bun;
 import ts from "typescript";
 var traceAngularPhase = async (name, fn, metadata) => {
@@ -3532,10 +3853,10 @@ var traceAngularPhase = async (name, fn, metadata) => {
   return tracePhase ? tracePhase(`compile/angular/${name}`, fn, metadata) : await fn();
 }, readTsconfigPathAliases = () => {
   try {
-    const configPath = resolve6(process.cwd(), "tsconfig.json");
+    const configPath = resolve7(process.cwd(), "tsconfig.json");
     const config = ts.readConfigFile(configPath, ts.sys.readFile).config;
     const compilerOptions = config?.compilerOptions ?? {};
-    const baseUrl = resolve6(process.cwd(), compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve7(process.cwd(), compilerOptions.baseUrl ?? ".");
     const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
     return { aliases, baseUrl };
   } catch {
@@ -3555,7 +3876,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     const wildcardValue = exactMatch ? "" : specifier.slice(prefix.length, specifier.length - suffix.length);
     for (const replacement of alias.replacements) {
       const candidate = replacement.replace("*", wildcardValue);
-      const resolved = resolveSourceFile(resolve6(baseUrl, candidate));
+      const resolved = resolveSourceFile(resolve7(baseUrl, candidate));
       if (resolved)
         return resolved;
     }
@@ -3567,20 +3888,20 @@ var traceAngularPhase = async (name, fn, metadata) => {
     `${candidate}.tsx`,
     `${candidate}.js`,
     `${candidate}.jsx`,
-    join7(candidate, "index.ts"),
-    join7(candidate, "index.tsx"),
-    join7(candidate, "index.js"),
-    join7(candidate, "index.jsx")
+    join9(candidate, "index.ts"),
+    join9(candidate, "index.tsx"),
+    join9(candidate, "index.js"),
+    join9(candidate, "index.jsx")
   ];
   return candidates.find((file) => existsSync5(file));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
-  const baseDir = resolve6(rootDir);
+  const baseDir = resolve7(rootDir);
   const tsconfigAliases = readTsconfigPathAliases();
   const transpiler3 = new Bun.Transpiler({ loader: "tsx" });
   const scanCache = new Map;
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile(resolve6(fromDir, specifier));
+      return resolveSourceFile(resolve7(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile);
     if (aliased)
@@ -3589,7 +3910,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve6(resolved);
+      const absolute = resolve7(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile(absolute);
@@ -3605,7 +3926,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
         usesLegacyAnimations: false
       });
     }
-    const resolved = resolve6(actualPath);
+    const resolved = resolve7(actualPath);
     const cached = scanCache.get(resolved);
     if (cached)
       return cached;
@@ -3634,7 +3955,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     const actualPath = resolveSourceFile(filePath);
     if (!actualPath)
       return false;
-    const resolved = resolve6(actualPath);
+    const resolved = resolve7(actualPath);
     if (visited.has(resolved))
       return false;
     visited.add(resolved);
@@ -3642,7 +3963,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     if (scan.usesLegacyAnimations)
       return true;
     for (const specifier of scan.imports) {
-      const importedPath = resolveLocalImport(specifier, dirname4(resolved));
+      const importedPath = resolveLocalImport(specifier, dirname5(resolved));
       if (importedPath && await visit(importedPath, visited)) {
         return true;
       }
@@ -3652,14 +3973,14 @@ var traceAngularPhase = async (name, fn, metadata) => {
   return (entryPath) => visit(entryPath);
 }, resolveDevClientDir = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve6(import.meta.dir, "../dev/client");
+  const fromSource = resolve7(import.meta.dir, "../dev/client");
   if (existsSync5(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve6(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve7(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync5(fromNodeModules))
     return fromNodeModules;
-  return resolve6(import.meta.dir, "./dev/client");
+  return resolve7(import.meta.dir, "./dev/client");
 }, devClientDir, hmrClientPath, formatDiagnosticMessage = (diagnostic) => {
   try {
     return ts.flattenDiagnosticMessageText(diagnostic.messageText, `
@@ -3701,12 +4022,12 @@ var traceAngularPhase = async (name, fn, metadata) => {
     return `${path.replace(/\.ts$/, ".js")}${query}`;
   if (hasJsLikeExtension(path))
     return `${path}${query}`;
-  const importerDir = dirname4(importerOutputPath);
-  const fileCandidate = resolve6(importerDir, `${path}.js`);
+  const importerDir = dirname5(importerOutputPath);
+  const fileCandidate = resolve7(importerDir, `${path}.js`);
   if (outputFiles?.has(fileCandidate) || existsSync5(fileCandidate)) {
     return `${path}.js${query}`;
   }
-  const indexCandidate = resolve6(importerDir, path, "index.js");
+  const indexCandidate = resolve7(importerDir, path, "index.js");
   if (outputFiles?.has(indexCandidate) || existsSync5(indexCandidate)) {
     return `${path}/index.js${query}`;
   }
@@ -3734,18 +4055,18 @@ var traceAngularPhase = async (name, fn, metadata) => {
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve6(dirname4(fromFile), specifier);
+  const basePath = resolve7(dirname5(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join7(basePath, "index.ts"),
-    join7(basePath, "index.tsx"),
-    join7(basePath, "index.mts"),
-    join7(basePath, "index.cts")
+    join9(basePath, "index.ts"),
+    join9(basePath, "index.tsx"),
+    join9(basePath, "index.mts"),
+    join9(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve6(candidate)).find((candidate) => existsSync5(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+  return candidates.map((candidate) => resolve7(candidate)).find((candidate) => existsSync5(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile2) => {
   const hostSource = readFile2?.(fileName);
   if (typeof hostSource === "string")
@@ -3769,18 +4090,18 @@ var traceAngularPhase = async (name, fn, metadata) => {
   const paths = [];
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1])
-    paths.push(join7(fileDir, templateUrlMatch[1]));
+    paths.push(join9(fileDir, templateUrlMatch[1]));
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (styleUrlMatch?.[1])
-    paths.push(join7(fileDir, styleUrlMatch[1]));
+    paths.push(join9(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(join7(fileDir, urlMatch.replace(/['"]/g, "")));
+      paths.push(join9(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
-  return paths.map((path) => resolve6(path));
+  return paths.map((path) => resolve7(path));
 }, readResourceCacheFile = async (cachePath) => {
   try {
     const entry = JSON.parse(await fs.readFile(cachePath, "utf-8"));
@@ -3792,13 +4113,13 @@ var traceAngularPhase = async (name, fn, metadata) => {
     return null;
   }
 }, writeResourceCacheFile = async (cachePath, source) => {
-  await fs.mkdir(dirname4(cachePath), { recursive: true });
+  await fs.mkdir(dirname5(cachePath), { recursive: true });
   await fs.writeFile(cachePath, JSON.stringify({
     source,
     version: 1
   }), "utf-8");
 }, resolveResourceTransformCachePath = async (filePath, source, stylePreprocessors) => {
-  const resourcePaths = collectAngularResourcePaths(source, dirname4(filePath));
+  const resourcePaths = collectAngularResourcePaths(source, dirname5(filePath));
   const resourceContents = await Promise.all(resourcePaths.map(async (resourcePath) => {
     const content = await fs.readFile(resourcePath, "utf-8");
     return `${resourcePath}\x00${content}`;
@@ -3811,7 +4132,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     safeStableStringify(stylePreprocessors ?? null)
   ].join("\x00");
   const cacheKey = Bun.hash(cacheInput).toString(BASE_36_RADIX);
-  return join7(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey}.json`);
+  return join9(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey}.json`);
 }, precomputeAotResourceTransforms = async (inputPaths, readFile2, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
@@ -3822,7 +4143,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     transformedFiles: 0
   };
   const transformFile = async (filePath) => {
-    const resolvedPath = resolve6(filePath);
+    const resolvedPath = resolve7(filePath);
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
@@ -3838,7 +4159,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
       transformedSource = cached.source;
     } else {
       stats.cacheMisses += 1;
-      const transformed = await inlineResources(source, dirname4(resolvedPath), stylePreprocessors);
+      const transformed = await inlineResources(source, dirname5(resolvedPath), stylePreprocessors);
       transformedSource = transformed.source;
       await writeResourceCacheFile(cachePath, transformedSource);
     }
@@ -3857,7 +4178,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
   return { stats, transformedSources };
 }, compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
   const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
-    const outputPath = resolve6(join7(outDir, relative4(process.cwd(), resolve6(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve7(join9(outDir, relative5(process.cwd(), resolve7(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
       buildIslandMetadataExports(readFileSync5(inputPath, "utf-8"))
@@ -3867,8 +4188,8 @@ var traceAngularPhase = async (name, fn, metadata) => {
   const { readConfiguration, performCompilation, EmitFlags } = await traceAngularPhase("aot/import-compiler-cli", () => import("@angular/compiler-cli"));
   const tsLibDir = await traceAngularPhase("aot/resolve-typescript-lib", () => {
     const tsPath = __require.resolve("typescript");
-    const tsRootDir = dirname4(tsPath);
-    return tsRootDir.endsWith("lib") ? tsRootDir : resolve6(tsRootDir, "lib");
+    const tsRootDir = dirname5(tsPath);
+    return tsRootDir.endsWith("lib") ? tsRootDir : resolve7(tsRootDir, "lib");
   });
   const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
   const options = {
@@ -3904,13 +4225,13 @@ var traceAngularPhase = async (name, fn, metadata) => {
   const originalGetSourceFile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
     if (fileName.startsWith("lib.") && fileName.endsWith(".d.ts") && tsLibDir) {
-      const resolvedPath = join7(tsLibDir, fileName);
+      const resolvedPath = join9(tsLibDir, fileName);
       return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
     }
     return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
   };
   const emitted = {};
-  const resolvedOutDir = resolve6(outDir);
+  const resolvedOutDir = resolve7(outDir);
   host.writeFile = (fileName, text) => {
     const relativePath = resolveRelativePath(fileName, resolvedOutDir, outDir);
     emitted[relativePath] = text;
@@ -3932,12 +4253,12 @@ var traceAngularPhase = async (name, fn, metadata) => {
     if (!fileName.endsWith(".ts") || fileName.endsWith(".d.ts")) {
       return source;
     }
-    const resolvedPath = resolve6(fileName);
+    const resolvedPath = resolve7(fileName);
     return transformedSources.get(resolvedPath) ?? source;
   };
   const originalGetSourceFileForCompile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
-    const source = transformedSources.get(resolve6(fileName));
+    const source = transformedSources.get(resolve7(fileName));
     if (source) {
       return ts.createSourceFile(fileName, source, languageVersion, true);
     }
@@ -3959,9 +4280,9 @@ var traceAngularPhase = async (name, fn, metadata) => {
   const entries = await traceAngularPhase("aot/postprocess-emitted-js", () => {
     const rawEntries = Object.entries(emitted).filter(([fileName]) => fileName.endsWith(".js")).map(([fileName, content]) => ({
       content,
-      target: join7(outDir, fileName)
+      target: join9(outDir, fileName)
     }));
-    const outputFiles = new Set(rawEntries.map(({ target }) => resolve6(target)));
+    const outputFiles = new Set(rawEntries.map(({ target }) => resolve7(target)));
     return rawEntries.map(({ content, target }) => {
       let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
         const rewritten = rewriteRelativeJsSpecifier(target, path, outputFiles);
@@ -3976,17 +4297,17 @@ var traceAngularPhase = async (name, fn, metadata) => {
         return cleaned ? `import { ${cleaned}, InternalInjectFlags } from '@angular/core'` : `import { InternalInjectFlags } from '@angular/core'`;
       });
       processedContent = processedContent.replace(/\b(?<!Internal)InjectFlags\b/g, "InternalInjectFlags");
-      processedContent += islandMetadataByOutputPath.get(resolve6(target)) ?? "";
+      processedContent += islandMetadataByOutputPath.get(resolve7(target)) ?? "";
       return { content: processedContent, target };
     });
   });
   await traceAngularPhase("aot/write-output", () => Promise.all(entries.map(async ({ target, content }) => {
-    await fs.mkdir(dirname4(target), { recursive: true });
+    await fs.mkdir(dirname5(target), { recursive: true });
     await fs.writeFile(target, content, "utf-8");
   })), { outputs: entries.length });
   return await traceAngularPhase("aot/collect-output-paths", () => entries.map(({ target }) => target), { outputs: entries.length });
 }, compileAngularFile = async (inputPath, outDir, stylePreprocessors) => compileAngularFiles([inputPath], outDir, stylePreprocessors), jitContentCache, invalidateAngularJitCache = (filePath) => {
-  jitContentCache.delete(resolve6(filePath));
+  jitContentCache.delete(resolve7(filePath));
 }, wrapperOutputCache, escapeTemplateContent = (content) => content.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${"), findUncommentedMatch = (source, pattern) => {
   const re = new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g");
   let match;
@@ -3999,7 +4320,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
   }
   return null;
 }, resolveAngularDeferImportSpecifier = () => {
-  const sourceEntry = resolve6(import.meta.dir, "../angular/components/index.ts");
+  const sourceEntry = resolve7(import.meta.dir, "../angular/components/index.ts");
   if (existsSync5(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
@@ -4136,7 +4457,7 @@ ${fields}
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join7(fileDir, templateUrlMatch[1]);
+    const templatePath = join9(fileDir, templateUrlMatch[1]);
     if (!existsSync5(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -4167,7 +4488,7 @@ ${fields}
 }, inlineTemplateAndLowerDeferSync = (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join7(fileDir, templateUrlMatch[1]);
+    const templatePath = join9(fileDir, templateUrlMatch[1]);
     if (!existsSync5(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -4204,7 +4525,7 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join7(fileDir, styleUrl), stylePreprocessors);
+    return readAndEscapeFile(join9(fileDir, styleUrl), stylePreprocessors);
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -4215,7 +4536,7 @@ ${fields}
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join7(fileDir, styleUrlMatch[1]), stylePreprocessors);
+  const escaped = await readAndEscapeFile(join9(fileDir, styleUrlMatch[1]), stylePreprocessors);
   if (!escaped)
     return source;
   return source.slice(0, styleUrlMatch.index) + `styles: [\`${escaped}\`]` + source.slice(styleUrlMatch.index + styleUrlMatch[0].length);
@@ -4229,10 +4550,10 @@ ${fields}
     source: result
   };
 }, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors, cacheBuster) => {
-  const entryPath = resolve6(inputPath);
+  const entryPath = resolve7(inputPath);
   const allOutputs = [];
   const visited = new Set;
-  const baseDir = resolve6(rootDir ?? process.cwd());
+  const baseDir = resolve7(rootDir ?? process.cwd());
   let usesLegacyAnimations = false;
   const angularTranspiler = new Bun.Transpiler({
     loader: "ts",
@@ -4251,16 +4572,16 @@ ${fields}
       `${candidate}.js`,
       `${candidate}.jsx`,
       `${candidate}.json`,
-      join7(candidate, "index.ts"),
-      join7(candidate, "index.tsx"),
-      join7(candidate, "index.js"),
-      join7(candidate, "index.jsx")
+      join9(candidate, "index.ts"),
+      join9(candidate, "index.tsx"),
+      join9(candidate, "index.js"),
+      join9(candidate, "index.jsx")
     ];
     return candidates.find((file) => existsSync5(file));
   };
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile2(resolve6(fromDir, specifier));
+      return resolveSourceFile2(resolve7(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile2);
     if (aliased)
@@ -4269,7 +4590,7 @@ ${fields}
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve6(resolved);
+      const absolute = resolve7(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile2(absolute);
@@ -4278,13 +4599,13 @@ ${fields}
     }
   };
   const toOutputPath = (sourcePath) => {
-    const inputDir = dirname4(sourcePath);
+    const inputDir = dirname5(sourcePath);
     const fileBase = basename3(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
     if (inputDir === outDir || inputDir.startsWith(`${outDir}${sep}`)) {
-      return join7(inputDir, fileBase);
+      return join9(inputDir, fileBase);
     }
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
-    return join7(outDir, relativeDir, fileBase);
+    return join9(outDir, relativeDir, fileBase);
   };
   const withCacheBuster = (specifier) => {
     if (!cacheBuster)
@@ -4321,21 +4642,21 @@ ${fields}
         return `${prefix}${dots}`;
       return `${prefix}../${dots}`;
     });
-    if (resolve6(actualPath) === entryPath) {
+    if (resolve7(actualPath) === entryPath) {
       processedContent += buildIslandMetadataExports(sourceCode);
     }
     return processedContent;
   };
   const transpileFile = async (filePath) => {
-    const resolved = resolve6(filePath);
+    const resolved = resolve7(filePath);
     if (visited.has(resolved))
       return;
     visited.add(resolved);
     if (resolved.endsWith(".json") && existsSync5(resolved)) {
-      const inputDir2 = dirname4(resolved);
+      const inputDir2 = dirname5(resolved);
       const relativeDir2 = inputDir2.startsWith(baseDir) ? inputDir2.substring(baseDir.length + 1) : inputDir2;
-      const targetDir2 = join7(outDir, relativeDir2);
-      const targetPath2 = join7(targetDir2, basename3(resolved));
+      const targetDir2 = join9(outDir, relativeDir2);
+      const targetPath2 = join9(targetDir2, basename3(resolved));
       await fs.mkdir(targetDir2, { recursive: true });
       await fs.copyFile(resolved, targetPath2);
       allOutputs.push(targetPath2);
@@ -4347,13 +4668,13 @@ ${fields}
     if (!existsSync5(actualPath))
       return;
     let sourceCode = await fs.readFile(actualPath, "utf-8");
-    const inlined = await inlineResources(sourceCode, dirname4(actualPath), stylePreprocessors);
-    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname4(actualPath)).source;
-    const inputDir = dirname4(actualPath);
+    const inlined = await inlineResources(sourceCode, dirname5(actualPath), stylePreprocessors);
+    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname5(actualPath)).source;
+    const inputDir = dirname5(actualPath);
     const fileBase = basename3(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
     const targetPath = toOutputPath(actualPath);
-    const targetDir = dirname4(targetPath);
-    const relativeDir = relative4(outDir, targetDir).replace(/\\/g, "/");
+    const targetDir = dirname5(targetPath);
+    const relativeDir = relative5(outDir, targetDir).replace(/\\/g, "/");
     const localImports = [];
     const importRewrites = new Map;
     const fromRegex = /(?:from|import)\s+['"]([^'".][^'"]*|\.\.?\/[^'"]+)['"]/g;
@@ -4374,12 +4695,12 @@ ${fields}
       const resolved2 = resolveLocalImport(specifier, inputDir);
       if (!resolved2)
         return null;
-      const relativeImport = relative4(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
+      const relativeImport = relative5(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
       const relativeRewrite = relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`;
       importRewrites.set(specifier, relativeRewrite);
       return resolved2;
     }).filter((path) => Boolean(path));
-    const isEntry = resolve6(actualPath) === resolve6(entryPath);
+    const isEntry = resolve7(actualPath) === resolve7(entryPath);
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey = actualPath;
     const shouldWriteFile = cacheBuster && isEntry ? true : jitContentCache.get(cacheKey) !== contentHash || !existsSync5(targetPath);
@@ -4413,13 +4734,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join7(compiledParent, "indexes");
+  const indexesDir = join9(compiledParent, "indexes");
   await traceAngularPhase("setup/create-indexes-dir", () => fs.mkdir(indexesDir, { recursive: true }));
-  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve6(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
+  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve7(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   if (!hmr) {
     await traceAngularPhase("aot/copy-json-resources", async () => {
       const cwd = process.cwd();
-      const angularSrcDir = resolve6(outRoot);
+      const angularSrcDir = resolve7(outRoot);
       if (!existsSync5(angularSrcDir))
         return;
       const jsonGlob = new Glob("**/*.json");
@@ -4427,18 +4748,18 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
         absolute: false,
         cwd: angularSrcDir
       })) {
-        const sourcePath = join7(angularSrcDir, rel);
-        const cwdRel = relative4(cwd, sourcePath);
-        const targetPath = join7(compiledRoot, cwdRel);
-        await fs.mkdir(dirname4(targetPath), { recursive: true });
+        const sourcePath = join9(angularSrcDir, rel);
+        const cwdRel = relative5(cwd, sourcePath);
+        const targetPath = join9(compiledRoot, cwdRel);
+        await fs.mkdir(dirname5(targetPath), { recursive: true });
         await fs.copyFile(sourcePath, targetPath);
       }
     });
   }
   const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
   const compileTasks = entryPoints.map(async (entry) => {
-    const resolvedEntry = resolve6(entry);
-    const relativeEntry = relative4(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
+    const resolvedEntry = resolve7(entry);
+    const relativeEntry = relative5(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
     const compileEntry = () => compileAngularFileJIT(resolvedEntry, compiledRoot, outRoot, stylePreprocessors);
     let outputs = hmr ? await traceAngularPhase("jit/compile-entry", compileEntry, {
       entry: resolvedEntry
@@ -4446,13 +4767,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const fileBase = basename3(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
     const compiledFallbackPaths = [
-      join7(compiledRoot, relativeEntry),
-      join7(compiledRoot, "pages", jsName),
-      join7(compiledRoot, jsName)
-    ].map((file) => resolve6(file));
+      join9(compiledRoot, relativeEntry),
+      join9(compiledRoot, "pages", jsName),
+      join9(compiledRoot, jsName)
+    ].map((file) => resolve7(file));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
-        ...candidatePaths.map((file) => resolve6(file)),
+        ...candidatePaths.map((file) => resolve7(file)),
         ...compiledFallbackPaths
       ];
       let candidate = normalizedCandidates.find((file) => existsSync5(file) && file.endsWith(`${sep}${relativeEntry}`));
@@ -4510,7 +4831,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 = join7(indexesDir, jsName);
+    const clientFile = join9(indexesDir, jsName);
     if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync5(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
       return {
         clientPath: clientFile,
@@ -4542,13 +4863,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
       const fragments = [];
       if (providersInjection.appProvidersSource) {
         const compiledAppProvidersPath = (() => {
-          const angularDirAbs = resolve6(outRoot);
-          const appSourceAbs = resolve6(providersInjection.appProvidersSource);
-          const rel = relative4(angularDirAbs, appSourceAbs).replace(/\\/g, "/");
-          return join7(compiledParent, rel).replace(/\.[cm]?[tj]sx?$/, ".js");
+          const angularDirAbs = resolve7(outRoot);
+          const appSourceAbs = resolve7(providersInjection.appProvidersSource);
+          const rel = relative5(angularDirAbs, appSourceAbs).replace(/\\/g, "/");
+          return join9(compiledParent, rel).replace(/\.[cm]?[tj]sx?$/, ".js");
         })();
         const appProvidersSpec = (() => {
-          const rel = relative4(dirname4(rawServerFile), compiledAppProvidersPath).replace(/\\/g, "/");
+          const rel = relative5(dirname5(rawServerFile), compiledAppProvidersPath).replace(/\\/g, "/");
           return rel.startsWith(".") ? rel : `./${rel}`;
         })();
         importLines.push(`import { appProviders as __abs_globalProviders } from "${appProvidersSpec}";`);
@@ -4573,7 +4894,7 @@ export const providers = [${fragments.join(", ")}];
       }
     }
     await traceAngularPhase("wrapper/write-server-output", () => fs.writeFile(rawServerFile, rewritten, "utf-8"), { entry: resolvedEntry });
-    const relativePath = relative4(indexesDir, rawServerFile).replace(/\\/g, "/");
+    const relativePath = relative5(indexesDir, rawServerFile).replace(/\\/g, "/");
     const normalizedImportPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
     const hmrPreamble = hmr ? `window.__HMR_FRAMEWORK__ = "angular";
 import "${hmrClientPath}";
@@ -4769,7 +5090,7 @@ var init_compileAngular = __esm(() => {
   init_stylePreprocessor();
   init_generatedDir();
   devClientDir = resolveDevClientDir();
-  hmrClientPath = join7(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath = join9(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
 });
@@ -4937,13 +5258,12 @@ var provideDeterministicEnv = (options = {}) => {
 // src/angular/pageHandler.ts
 init_constants();
 import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
-import { mkdir as mkdir3, symlink } from "fs/promises";
+import { mkdir as mkdir4, symlink } from "fs/promises";
 import { tmpdir } from "os";
-import { basename as basename4, dirname as dirname5, join as join8, resolve as resolve7 } from "path";
+import { basename as basename4, dirname as dirname6, join as join10, resolve as resolve8 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/core/islandPageContext.ts
-init_constants();
 var BOOTSTRAP_MANIFEST_KEY = "BootstrapClient";
 var ISLAND_MARKER = 'data-island="true"';
 var MANIFEST_MARKER = "__ABSOLUTE_MANIFEST__";
@@ -5064,61 +5384,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_TAG.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_TAG);
+    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 + streamChunkToString(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, streamChunkToString(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);
       }
@@ -5846,23 +6174,23 @@ var ensureAngularCompiler = () => {
   return compilerImportPromise;
 };
 var readAngularPageModule = (value) => isRecord5(value) ? value : null;
-var resolveAngularSsrOutDir = () => process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR ?? join8(tmpdir(), "absolutejs", "generated", "angular-ssr");
+var resolveAngularSsrOutDir = () => process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR ?? join10(tmpdir(), "absolutejs", "generated", "angular-ssr");
 var createAngularRuntimeCacheBuster = () => `${Date.now().toString(BASE_36_RADIX)}.${Math.random().toString(BASE_36_RADIX).substring(2, RANDOM_ID_END_INDEX)}`;
 var ensureAngularSsrNodeModules = async (outDir) => {
-  const outRoot = resolve7(dirname5(dirname5(outDir)));
-  const nodeModulesLink = join8(outRoot, "node_modules");
+  const outRoot = resolve8(dirname6(dirname6(outDir)));
+  const nodeModulesLink = join10(outRoot, "node_modules");
   if (process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR) {
     return;
   }
-  if (nodeModulesLink === resolve7(process.cwd(), "node_modules")) {
+  if (nodeModulesLink === resolve8(process.cwd(), "node_modules")) {
     return;
   }
   if (await Bun.file(nodeModulesLink).exists()) {
     return;
   }
-  await mkdir3(outRoot, { recursive: true });
+  await mkdir4(outRoot, { recursive: true });
   try {
-    await symlink(resolve7(process.cwd(), "node_modules"), nodeModulesLink, "dir");
+    await symlink(resolve8(process.cwd(), "node_modules"), nodeModulesLink, "dir");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") {
       throw error;
@@ -6018,5 +6346,5 @@ export {
   ABSOLUTE_HTTP_TRANSFER_CACHE_SKIP_HEADER
 };
 
-//# debugId=8E308DFD1FCF0BC964756E2164756E21
+//# debugId=5320D703F77AA47464756E2164756E21
 //# sourceMappingURL=server.js.map