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

package/dist/angular/server.js

@@ -1725,6 +1725,100 @@ var init_svelteServerModule = __esm(() => {
   });
 });
 
+// src/core/vueServerModule.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { dirname as dirname3, join as join5, relative as relative3, resolve as resolve5 } 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, "/");
+  return importPath.startsWith(".") ? importPath : `./${importPath}`;
+}, getCachedModulePath2 = (sourcePath) => {
+  const relativeSourcePath = relative3(process.cwd(), sourcePath).replace(/\\/g, "/");
+  const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
+  return join5(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
+}, writeIfChanged2 = async (path, content) => {
+  const targetFile = Bun.file(path);
+  if (await targetFile.exists()) {
+    const currentContent = await targetFile.text();
+    if (currentContent === content)
+      return;
+  }
+  await Bun.write(path, content);
+}, stripExports = (code) => code.replace(/export\s+default/, "const script ="), mergeVueImports = (code) => {
+  const lines = code.split(`
+`);
+  const specifierSet = new Set;
+  const vueImportRegex = /^import\s+{([^}]+)}\s+from\s+['"]vue['"];?$/;
+  lines.forEach((line) => {
+    const match = line.match(vueImportRegex);
+    if (match?.[1])
+      match[1].split(",").forEach((importSpecifier) => specifierSet.add(importSpecifier.trim()));
+  });
+  const nonVueLines = lines.filter((line) => !vueImportRegex.test(line));
+  return specifierSet.size ? [
+    `import { ${[...specifierSet].join(", ")} } from "vue";`,
+    ...nonVueLines
+  ].join(`
+`) : nonVueLines.join(`
+`);
+}, extractRelativeVueImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => typeof importPath === "string" && importPath.startsWith(".") && importPath.endsWith(".vue")), compileVueServerModule = async (sourcePath) => {
+  const cachedModulePath = compiledModuleCache2.get(sourcePath);
+  if (cachedModulePath)
+    return cachedModulePath;
+  const compiler = await import("@vue/compiler-sfc");
+  const source = await Bun.file(sourcePath).text();
+  const { descriptor } = compiler.parse(source, { filename: sourcePath });
+  const componentId = Bun.hash(sourcePath).toString(BASE_36_RADIX).slice(0, ISLAND_COMPONENT_ID_LENGTH);
+  const hasScript = descriptor.script || descriptor.scriptSetup;
+  const compiledScript = hasScript ? compiler.compileScript(descriptor, {
+    id: componentId,
+    inlineTemplate: false
+  }) : { bindings: {}, content: "export default {};" };
+  const renderCode = descriptor.template ? compiler.compileTemplate({
+    compilerOptions: {
+      bindingMetadata: compiledScript.bindings,
+      expressionPlugins: ["typescript"],
+      prefixIdentifiers: true,
+      isCustomElement: (tag) => tag === "absolute-island"
+    },
+    filename: sourcePath,
+    id: componentId,
+    scoped: descriptor.styles.some((styleBlock) => styleBlock.scoped),
+    source: descriptor.template.content,
+    ssr: true,
+    ssrCssVars: descriptor.cssVars
+  }).code : "const ssrRender = () => {};";
+  const childImportPaths = extractRelativeVueImports(compiledScript.content);
+  const compiledChildren = await Promise.all(childImportPaths.map(async (relativeImport) => ({
+    compiledPath: await compileVueServerModule(resolve5(dirname3(sourcePath), relativeImport)),
+    spec: relativeImport
+  })));
+  const strippedScript = stripExports(compiledScript.content);
+  const transpiledScript = transpiler2.transformSync(strippedScript);
+  const assembled = mergeVueImports([
+    transpiledScript,
+    renderCode,
+    "script.ssrRender = ssrRender;",
+    "export default script;"
+  ].join(`
+`));
+  const compiledModulePath = getCachedModulePath2(sourcePath);
+  let rewritten = assembled;
+  for (const child of compiledChildren) {
+    rewritten = rewritten.replaceAll(child.spec, ensureRelativeImportPath2(compiledModulePath, child.compiledPath));
+  }
+  await mkdir2(dirname3(compiledModulePath), { recursive: true });
+  await writeIfChanged2(compiledModulePath, rewritten);
+  compiledModuleCache2.set(sourcePath, compiledModulePath);
+  return compiledModulePath;
+};
+var init_vueServerModule = __esm(() => {
+  init_constants();
+  serverCacheRoot2 = join5(process.cwd(), ".absolutejs", "islands", "vue");
+  compiledModuleCache2 = new Map;
+  transpiler2 = new Transpiler({ loader: "ts", target: "browser" });
+});
+
 // src/core/islandManifest.ts
 var toIslandFrameworkSegment = (framework) => framework[0]?.toUpperCase() + framework.slice(1), collectFrameworkIslands = (manifest, prefix) => {
   const entries = {};
@@ -1811,9 +1905,17 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
   const loadPromise = loadAndCompileServerBuildComponent(buildReferencePath);
   resolvedServerBuildComponentCache.set(buildReferencePath, loadPromise);
   return loadPromise;
+}, resolveRuntimeImportTarget = async (resolvedModulePath) => {
+  if (resolvedModulePath.endsWith(".svelte")) {
+    return compileSvelteServerModule(resolvedModulePath);
+  }
+  if (resolvedModulePath.endsWith(".vue")) {
+    return compileVueServerModule(resolvedModulePath);
+  }
+  return resolvedModulePath;
 }, loadServerImportComponent = async (resolvedComponent, exportName) => {
   const resolvedModulePath = resolvedComponent.startsWith(".") ? new URL(resolvedComponent, import.meta.url).pathname : resolvedComponent;
-  const importTarget = resolvedModulePath.endsWith(".svelte") ? await compileSvelteServerModule(resolvedModulePath) : resolvedModulePath;
+  const importTarget = await resolveRuntimeImportTarget(resolvedModulePath);
   const loadedModule = await import(importTarget);
   if (exportName && exportName !== "default" && exportName in loadedModule) {
     return loadedModule[exportName];
@@ -1917,6 +2019,7 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
 var init_renderIslandMarkup = __esm(() => {
   init_islandSsr();
   init_svelteServerModule();
+  init_vueServerModule();
   init_islandMarkupAttributes();
   init_islands2();
   resolvedServerComponentCache = new Map;
@@ -2759,12 +2862,12 @@ var init_startupBanner = __esm(() => {
 // src/utils/logger.ts
 var colors2, frameworkColors, formatPath = (filePath) => {
   const cwd = process.cwd();
-  let relative3 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
-  relative3 = relative3.replace(/\\/g, "/");
-  if (!relative3.startsWith("/")) {
-    relative3 = `/${relative3}`;
+  let relative4 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+  relative4 = relative4.replace(/\\/g, "/");
+  if (!relative4.startsWith("/")) {
+    relative4 = `/${relative4}`;
   }
-  return relative3;
+  return relative4;
 }, getFrameworkColor = (framework) => frameworkColors[framework] || colors2.white, log = (action, options) => {
   const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
   const tag = `${colors2.cyan}[hmr]${colors2.reset}`;
@@ -3376,8 +3479,8 @@ __export(exports_generatedDir, {
   getGeneratedRoot: () => getGeneratedRoot,
   getFrameworkGeneratedDir: () => getFrameworkGeneratedDir
 });
-import { join as join5 } from "path";
-var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getGeneratedRoot = (projectRoot = process.cwd()) => join5(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME), getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join5(getGeneratedRoot(projectRoot), framework);
+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);
 var init_generatedDir = () => {};
 
 // src/build/compileAngular.ts
@@ -3389,17 +3492,17 @@ __export(exports_compileAngular, {
   compileAngular: () => compileAngular
 });
 import { existsSync as existsSync4, readFileSync as readFileSync4, promises as fs } from "fs";
-import { join as join6, basename as basename3, sep, dirname as dirname3, resolve as resolve5, relative as relative3 } from "path";
+import { join as join7, basename as basename3, sep, dirname as dirname4, resolve as resolve6, relative as relative4 } from "path";
 import ts from "typescript";
 var traceAngularPhase = async (name, fn, metadata) => {
   const tracePhase = globalThis.__absoluteBuildTracePhase;
   return tracePhase ? tracePhase(`compile/angular/${name}`, fn, metadata) : await fn();
 }, readTsconfigPathAliases = () => {
   try {
-    const configPath = resolve5(process.cwd(), "tsconfig.json");
+    const configPath = resolve6(process.cwd(), "tsconfig.json");
     const config = ts.readConfigFile(configPath, ts.sys.readFile).config;
     const compilerOptions = config?.compilerOptions ?? {};
-    const baseUrl = resolve5(process.cwd(), compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve6(process.cwd(), compilerOptions.baseUrl ?? ".");
     const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
     return { aliases, baseUrl };
   } catch {
@@ -3419,7 +3522,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(resolve5(baseUrl, candidate));
+      const resolved = resolveSourceFile(resolve6(baseUrl, candidate));
       if (resolved)
         return resolved;
     }
@@ -3431,20 +3534,20 @@ var traceAngularPhase = async (name, fn, metadata) => {
     `${candidate}.tsx`,
     `${candidate}.js`,
     `${candidate}.jsx`,
-    join6(candidate, "index.ts"),
-    join6(candidate, "index.tsx"),
-    join6(candidate, "index.js"),
-    join6(candidate, "index.jsx")
+    join7(candidate, "index.ts"),
+    join7(candidate, "index.tsx"),
+    join7(candidate, "index.js"),
+    join7(candidate, "index.jsx")
   ];
   return candidates.find((file) => existsSync4(file));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
-  const baseDir = resolve5(rootDir);
+  const baseDir = resolve6(rootDir);
   const tsconfigAliases = readTsconfigPathAliases();
-  const transpiler2 = new Bun.Transpiler({ loader: "tsx" });
+  const transpiler3 = new Bun.Transpiler({ loader: "tsx" });
   const scanCache = new Map;
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile(resolve5(fromDir, specifier));
+      return resolveSourceFile(resolve6(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile);
     if (aliased)
@@ -3453,7 +3556,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve5(resolved);
+      const absolute = resolve6(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile(absolute);
@@ -3469,7 +3572,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
         usesLegacyAnimations: false
       });
     }
-    const resolved = resolve5(actualPath);
+    const resolved = resolve6(actualPath);
     const cached = scanCache.get(resolved);
     if (cached)
       return cached;
@@ -3482,7 +3585,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
       }
       let imports;
       try {
-        imports = transpiler2.scanImports(sourceCode);
+        imports = transpiler3.scanImports(sourceCode);
       } catch {
         return { imports: [], usesLegacyAnimations: false };
       }
@@ -3498,7 +3601,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     const actualPath = resolveSourceFile(filePath);
     if (!actualPath)
       return false;
-    const resolved = resolve5(actualPath);
+    const resolved = resolve6(actualPath);
     if (visited.has(resolved))
       return false;
     visited.add(resolved);
@@ -3506,7 +3609,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     if (scan.usesLegacyAnimations)
       return true;
     for (const specifier of scan.imports) {
-      const importedPath = resolveLocalImport(specifier, dirname3(resolved));
+      const importedPath = resolveLocalImport(specifier, dirname4(resolved));
       if (importedPath && await visit(importedPath, visited)) {
         return true;
       }
@@ -3516,14 +3619,14 @@ var traceAngularPhase = async (name, fn, metadata) => {
   return (entryPath) => visit(entryPath);
 }, resolveDevClientDir = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve5(import.meta.dir, "../dev/client");
+  const fromSource = resolve6(import.meta.dir, "../dev/client");
   if (existsSync4(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve5(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve6(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync4(fromNodeModules))
     return fromNodeModules;
-  return resolve5(import.meta.dir, "./dev/client");
+  return resolve6(import.meta.dir, "./dev/client");
 }, devClientDir, hmrClientPath, formatDiagnosticMessage = (diagnostic) => {
   try {
     return ts.flattenDiagnosticMessageText(diagnostic.messageText, `
@@ -3565,12 +3668,12 @@ var traceAngularPhase = async (name, fn, metadata) => {
     return `${path.replace(/\.ts$/, ".js")}${query}`;
   if (hasJsLikeExtension(path))
     return `${path}${query}`;
-  const importerDir = dirname3(importerOutputPath);
-  const fileCandidate = resolve5(importerDir, `${path}.js`);
+  const importerDir = dirname4(importerOutputPath);
+  const fileCandidate = resolve6(importerDir, `${path}.js`);
   if (outputFiles?.has(fileCandidate) || existsSync4(fileCandidate)) {
     return `${path}.js${query}`;
   }
-  const indexCandidate = resolve5(importerDir, path, "index.js");
+  const indexCandidate = resolve6(importerDir, path, "index.js");
   if (outputFiles?.has(indexCandidate) || existsSync4(indexCandidate)) {
     return `${path}/index.js${query}`;
   }
@@ -3598,18 +3701,18 @@ var traceAngularPhase = async (name, fn, metadata) => {
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve5(dirname3(fromFile), specifier);
+  const basePath = resolve6(dirname4(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join6(basePath, "index.ts"),
-    join6(basePath, "index.tsx"),
-    join6(basePath, "index.mts"),
-    join6(basePath, "index.cts")
+    join7(basePath, "index.ts"),
+    join7(basePath, "index.tsx"),
+    join7(basePath, "index.mts"),
+    join7(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve5(candidate)).find((candidate) => existsSync4(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+  return candidates.map((candidate) => resolve6(candidate)).find((candidate) => existsSync4(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile2) => {
   const hostSource = readFile2?.(fileName);
   if (typeof hostSource === "string")
@@ -3633,18 +3736,18 @@ var traceAngularPhase = async (name, fn, metadata) => {
   const paths = [];
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1])
-    paths.push(join6(fileDir, templateUrlMatch[1]));
+    paths.push(join7(fileDir, templateUrlMatch[1]));
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (styleUrlMatch?.[1])
-    paths.push(join6(fileDir, styleUrlMatch[1]));
+    paths.push(join7(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(join6(fileDir, urlMatch.replace(/['"]/g, "")));
+      paths.push(join7(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
-  return paths.map((path) => resolve5(path));
+  return paths.map((path) => resolve6(path));
 }, readResourceCacheFile = async (cachePath) => {
   try {
     const entry = JSON.parse(await fs.readFile(cachePath, "utf-8"));
@@ -3656,13 +3759,13 @@ var traceAngularPhase = async (name, fn, metadata) => {
     return null;
   }
 }, writeResourceCacheFile = async (cachePath, source) => {
-  await fs.mkdir(dirname3(cachePath), { recursive: true });
+  await fs.mkdir(dirname4(cachePath), { recursive: true });
   await fs.writeFile(cachePath, JSON.stringify({
     source,
     version: 1
   }), "utf-8");
 }, resolveResourceTransformCachePath = async (filePath, source, stylePreprocessors) => {
-  const resourcePaths = collectAngularResourcePaths(source, dirname3(filePath));
+  const resourcePaths = collectAngularResourcePaths(source, dirname4(filePath));
   const resourceContents = await Promise.all(resourcePaths.map(async (resourcePath) => {
     const content = await fs.readFile(resourcePath, "utf-8");
     return `${resourcePath}\x00${content}`;
@@ -3675,7 +3778,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     safeStableStringify(stylePreprocessors ?? null)
   ].join("\x00");
   const cacheKey = Bun.hash(cacheInput).toString(BASE_36_RADIX);
-  return join6(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey}.json`);
+  return join7(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey}.json`);
 }, precomputeAotResourceTransforms = async (inputPaths, readFile2, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
@@ -3686,7 +3789,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     transformedFiles: 0
   };
   const transformFile = async (filePath) => {
-    const resolvedPath = resolve5(filePath);
+    const resolvedPath = resolve6(filePath);
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
@@ -3702,7 +3805,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
       transformedSource = cached.source;
     } else {
       stats.cacheMisses += 1;
-      const transformed = await inlineResources(source, dirname3(resolvedPath), stylePreprocessors);
+      const transformed = await inlineResources(source, dirname4(resolvedPath), stylePreprocessors);
       transformedSource = transformed.source;
       await writeResourceCacheFile(cachePath, transformedSource);
     }
@@ -3721,7 +3824,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 = resolve5(join6(outDir, relative3(process.cwd(), resolve5(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve6(join7(outDir, relative4(process.cwd(), resolve6(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
       buildIslandMetadataExports(readFileSync4(inputPath, "utf-8"))
@@ -3731,8 +3834,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 = dirname3(tsPath);
-    return tsRootDir.endsWith("lib") ? tsRootDir : resolve5(tsRootDir, "lib");
+    const tsRootDir = dirname4(tsPath);
+    return tsRootDir.endsWith("lib") ? tsRootDir : resolve6(tsRootDir, "lib");
   });
   const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
   const options = {
@@ -3768,13 +3871,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 = join6(tsLibDir, fileName);
+      const resolvedPath = join7(tsLibDir, fileName);
       return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
     }
     return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
   };
   const emitted = {};
-  const resolvedOutDir = resolve5(outDir);
+  const resolvedOutDir = resolve6(outDir);
   host.writeFile = (fileName, text) => {
     const relativePath = resolveRelativePath(fileName, resolvedOutDir, outDir);
     emitted[relativePath] = text;
@@ -3796,12 +3899,12 @@ var traceAngularPhase = async (name, fn, metadata) => {
     if (!fileName.endsWith(".ts") || fileName.endsWith(".d.ts")) {
       return source;
     }
-    const resolvedPath = resolve5(fileName);
+    const resolvedPath = resolve6(fileName);
     return transformedSources.get(resolvedPath) ?? source;
   };
   const originalGetSourceFileForCompile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
-    const source = transformedSources.get(resolve5(fileName));
+    const source = transformedSources.get(resolve6(fileName));
     if (source) {
       return ts.createSourceFile(fileName, source, languageVersion, true);
     }
@@ -3823,9 +3926,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: join6(outDir, fileName)
+      target: join7(outDir, fileName)
     }));
-    const outputFiles = new Set(rawEntries.map(({ target }) => resolve5(target)));
+    const outputFiles = new Set(rawEntries.map(({ target }) => resolve6(target)));
     return rawEntries.map(({ content, target }) => {
       let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
         const rewritten = rewriteRelativeJsSpecifier(target, path, outputFiles);
@@ -3840,12 +3943,12 @@ 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(resolve5(target)) ?? "";
+      processedContent += islandMetadataByOutputPath.get(resolve6(target)) ?? "";
       return { content: processedContent, target };
     });
   });
   await traceAngularPhase("aot/write-output", () => Promise.all(entries.map(async ({ target, content }) => {
-    await fs.mkdir(dirname3(target), { recursive: true });
+    await fs.mkdir(dirname4(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 });
@@ -3861,7 +3964,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
   }
   return null;
 }, resolveAngularDeferImportSpecifier = () => {
-  const sourceEntry = resolve5(import.meta.dir, "../angular/components/index.ts");
+  const sourceEntry = resolve6(import.meta.dir, "../angular/components/index.ts");
   if (existsSync4(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
@@ -3998,7 +4101,7 @@ ${fields}
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join6(fileDir, templateUrlMatch[1]);
+    const templatePath = join7(fileDir, templateUrlMatch[1]);
     if (!existsSync4(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -4029,7 +4132,7 @@ ${fields}
 }, inlineTemplateAndLowerDeferSync = (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join6(fileDir, templateUrlMatch[1]);
+    const templatePath = join7(fileDir, templateUrlMatch[1]);
     if (!existsSync4(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -4066,7 +4169,7 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join6(fileDir, styleUrl), stylePreprocessors);
+    return readAndEscapeFile(join7(fileDir, styleUrl), stylePreprocessors);
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -4077,7 +4180,7 @@ ${fields}
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join6(fileDir, styleUrlMatch[1]), stylePreprocessors);
+  const escaped = await readAndEscapeFile(join7(fileDir, styleUrlMatch[1]), stylePreprocessors);
   if (!escaped)
     return source;
   return source.slice(0, styleUrlMatch.index) + `styles: [\`${escaped}\`]` + source.slice(styleUrlMatch.index + styleUrlMatch[0].length);
@@ -4091,10 +4194,10 @@ ${fields}
     source: result
   };
 }, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors, cacheBuster) => {
-  const entryPath = resolve5(inputPath);
+  const entryPath = resolve6(inputPath);
   const allOutputs = [];
   const visited = new Set;
-  const baseDir = resolve5(rootDir ?? process.cwd());
+  const baseDir = resolve6(rootDir ?? process.cwd());
   let usesLegacyAnimations = false;
   const angularTranspiler = new Bun.Transpiler({
     loader: "ts",
@@ -4112,16 +4215,16 @@ ${fields}
       `${candidate}.tsx`,
       `${candidate}.js`,
       `${candidate}.jsx`,
-      join6(candidate, "index.ts"),
-      join6(candidate, "index.tsx"),
-      join6(candidate, "index.js"),
-      join6(candidate, "index.jsx")
+      join7(candidate, "index.ts"),
+      join7(candidate, "index.tsx"),
+      join7(candidate, "index.js"),
+      join7(candidate, "index.jsx")
     ];
     return candidates.find((file) => existsSync4(file));
   };
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile2(resolve5(fromDir, specifier));
+      return resolveSourceFile2(resolve6(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile2);
     if (aliased)
@@ -4130,7 +4233,7 @@ ${fields}
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve5(resolved);
+      const absolute = resolve6(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile2(absolute);
@@ -4139,10 +4242,10 @@ ${fields}
     }
   };
   const toOutputPath = (sourcePath) => {
-    const inputDir = dirname3(sourcePath);
+    const inputDir = dirname4(sourcePath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename3(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    return join6(outDir, relativeDir, fileBase);
+    return join7(outDir, relativeDir, fileBase);
   };
   const withCacheBuster = (specifier) => {
     if (!cacheBuster)
@@ -4179,13 +4282,13 @@ ${fields}
         return `${prefix}${dots}`;
       return `${prefix}../${dots}`;
     });
-    if (resolve5(actualPath) === entryPath) {
+    if (resolve6(actualPath) === entryPath) {
       processedContent += buildIslandMetadataExports(sourceCode);
     }
     return processedContent;
   };
   const transpileFile = async (filePath) => {
-    const resolved = resolve5(filePath);
+    const resolved = resolve6(filePath);
     if (visited.has(resolved))
       return;
     visited.add(resolved);
@@ -4195,12 +4298,12 @@ ${fields}
     if (!existsSync4(actualPath))
       return;
     let sourceCode = await fs.readFile(actualPath, "utf-8");
-    const inlined = await inlineResources(sourceCode, dirname3(actualPath), stylePreprocessors);
-    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname3(actualPath)).source;
-    const inputDir = dirname3(actualPath);
+    const inlined = await inlineResources(sourceCode, dirname4(actualPath), stylePreprocessors);
+    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname4(actualPath)).source;
+    const inputDir = dirname4(actualPath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename3(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    const targetDir = join6(outDir, relativeDir);
+    const targetDir = join7(outDir, relativeDir);
     const targetPath = toOutputPath(actualPath);
     const localImports = [];
     const importRewrites = new Map;
@@ -4222,12 +4325,12 @@ ${fields}
       const resolved2 = resolveLocalImport(specifier, inputDir);
       if (!resolved2)
         return null;
-      const relativeImport = relative3(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
+      const relativeImport = relative4(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 = resolve5(actualPath) === resolve5(entryPath);
+    const isEntry = resolve6(actualPath) === resolve6(entryPath);
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey = actualPath;
     const shouldWriteFile = cacheBuster && isEntry ? true : jitContentCache.get(cacheKey) !== contentHash || !existsSync4(targetPath);
@@ -4261,13 +4364,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join6(compiledParent, "indexes");
+  const indexesDir = join7(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) => resolve5(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
+  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve6(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
   const compileTasks = entryPoints.map(async (entry) => {
-    const resolvedEntry = resolve5(entry);
-    const relativeEntry = relative3(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
+    const resolvedEntry = resolve6(entry);
+    const relativeEntry = relative4(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
     const compileEntry = () => compileAngularFileJIT(resolvedEntry, compiledRoot, outRoot, stylePreprocessors);
     let outputs = hmr ? await traceAngularPhase("jit/compile-entry", compileEntry, {
       entry: resolvedEntry
@@ -4275,13 +4378,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const fileBase = basename3(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
     const compiledFallbackPaths = [
-      join6(compiledRoot, relativeEntry),
-      join6(compiledRoot, "pages", jsName),
-      join6(compiledRoot, jsName)
-    ].map((file) => resolve5(file));
+      join7(compiledRoot, relativeEntry),
+      join7(compiledRoot, "pages", jsName),
+      join7(compiledRoot, jsName)
+    ].map((file) => resolve6(file));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
-        ...candidatePaths.map((file) => resolve5(file)),
+        ...candidatePaths.map((file) => resolve6(file)),
         ...compiledFallbackPaths
       ];
       let candidate = normalizedCandidates.find((file) => existsSync4(file) && file.endsWith(`${sep}pages${sep}${jsName}`));
@@ -4322,7 +4425,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const usesLegacyAnimations = await traceAngularPhase("wrapper/detect-legacy-animations", () => usesLegacyAngularAnimations(resolvedEntry), { entry: resolvedEntry });
     const serverContentHash = Bun.hash(original).toString(BASE_36_RADIX);
     const cachedWrapper = wrapperOutputCache.get(resolvedEntry);
-    const clientFile = join6(indexesDir, jsName);
+    const clientFile = join7(indexesDir, jsName);
     if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync4(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
       return {
         clientPath: clientFile,
@@ -4349,7 +4452,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
 `;
     }
     await traceAngularPhase("wrapper/write-server-output", () => fs.writeFile(rawServerFile, rewritten, "utf-8"), { entry: resolvedEntry });
-    const relativePath = relative3(indexesDir, rawServerFile).replace(/\\/g, "/");
+    const relativePath = relative4(indexesDir, rawServerFile).replace(/\\/g, "/");
     const normalizedImportPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
     const hmrPreamble = hmr ? `window.__HMR_FRAMEWORK__ = "angular";
 import "${hmrClientPath}";
@@ -4553,7 +4656,7 @@ var init_compileAngular = __esm(() => {
   init_stylePreprocessor();
   init_generatedDir();
   devClientDir = resolveDevClientDir();
-  hmrClientPath = join6(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath = join7(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
 });
@@ -4721,9 +4824,9 @@ var provideDeterministicEnv = (options = {}) => {
 // src/angular/pageHandler.ts
 init_constants();
 import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
-import { mkdir as mkdir2, symlink } from "fs/promises";
+import { mkdir as mkdir3, symlink } from "fs/promises";
 import { tmpdir } from "os";
-import { basename as basename4, dirname as dirname4, join as join7, resolve as resolve6 } from "path";
+import { basename as basename4, dirname as dirname5, join as join8, resolve as resolve7 } from "path";
 import { pathToFileURL } from "url";
 
 // src/core/islandPageContext.ts
@@ -4984,16 +5087,22 @@ var setConventions = (map) => {
 };
 var isDev = () => true;
 var buildErrorProps = (error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  const stack = isDev() && error instanceof Error ? error.stack : undefined;
-  return { error: { message, stack } };
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      ...isDev() && error.stack ? { stack: error.stack } : {}
+    };
+  }
+  return { name: "Error", message: String(error) };
 };
 var renderReactError = async (conventionPath, errorProps) => {
   const { createElement } = await import("react");
   const { renderToReadableStream } = await import("react-dom/server");
   const mod = await import(conventionPath);
-  const [firstKey] = Object.keys(mod);
-  const ErrorComponent = mod.default ?? (firstKey ? mod[firstKey] : undefined);
+  const ErrorComponent = mod.default;
+  if (typeof ErrorComponent !== "function")
+    return null;
   const element = createElement(ErrorComponent, errorProps);
   const stream = await renderToReadableStream(element);
   return new Response(stream, {
@@ -5005,6 +5114,8 @@ var renderSvelteError = async (conventionPath, errorProps) => {
   const { render } = await import("svelte/server");
   const mod = await import(conventionPath);
   const ErrorComponent = mod.default;
+  if (!ErrorComponent)
+    return null;
   const { head, body } = render(ErrorComponent, {
     props: errorProps
   });
@@ -5027,6 +5138,8 @@ var renderVueError = async (conventionPath, errorProps) => {
   const { renderToString } = await import("vue/server-renderer");
   const mod = await import(conventionPath);
   const ErrorComponent = mod.default;
+  if (!ErrorComponent)
+    return null;
   const app = createSSRApp({
     render: () => h(ErrorComponent, errorProps)
   });
@@ -5040,10 +5153,20 @@ var renderVueError = async (conventionPath, errorProps) => {
 };
 var renderAngularError = async (conventionPath, errorProps) => {
   const mod = await import(conventionPath);
-  const renderError = mod.default ?? mod.renderError;
-  if (typeof renderError !== "function")
+  const renderFn = mod.default;
+  if (typeof renderFn !== "function")
     return null;
-  const html = renderError(errorProps);
+  const html = renderFn(errorProps);
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" },
+    status: 500
+  });
+};
+var escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+var replaceErrorTokens = (template, errorProps) => template.replace(/\{\{\s*name\s*\}\}/g, escapeHtml(errorProps.name)).replace(/\{\{\s*message\s*\}\}/g, escapeHtml(errorProps.message)).replace(/\{\{\s*stack\s*\}\}/g, errorProps.stack ? escapeHtml(errorProps.stack) : "");
+var renderHtmlError = async (conventionPath, errorProps) => {
+  const template = await Bun.file(conventionPath).text();
+  const html = replaceErrorTokens(template, errorProps);
   return new Response(html, {
     headers: { "Content-Type": "text/html" },
     status: 500
@@ -5062,11 +5185,12 @@ var renderEmberNotFound = async () => null;
 var ERROR_RENDERERS = {
   angular: renderAngularError,
   ember: renderEmberError,
+  html: renderHtmlError,
   react: renderReactError,
   svelte: renderSvelteError,
   vue: renderVueError
 };
-var renderConventionError = async (framework, pageName, error) => {
+var tryFrameworkErrorConvention = async (framework, pageName, errorProps, error) => {
   let conventionPath = resolveErrorConventionPath(framework, pageName);
   if (!conventionPath && error instanceof Error && error.stack) {
     for (const match of error.stack.matchAll(/^\s*at\s+([A-Za-z_$][\w$]*)/gm)) {
@@ -5080,7 +5204,6 @@ var renderConventionError = async (framework, pageName, error) => {
   }
   if (!conventionPath)
     return null;
-  const errorProps = buildErrorProps(error);
   const renderer = ERROR_RENDERERS[framework];
   if (!renderer)
     return null;
@@ -5091,12 +5214,25 @@ var renderConventionError = async (framework, pageName, error) => {
   }
   return null;
 };
+var renderConventionError = async (framework, pageName, error) => {
+  const errorProps = buildErrorProps(error);
+  const frameworkResponse = await tryFrameworkErrorConvention(framework, pageName, errorProps, error);
+  if (frameworkResponse)
+    return frameworkResponse;
+  if (framework !== "html") {
+    const htmlResponse = await tryFrameworkErrorConvention("html", pageName, errorProps, error);
+    if (htmlResponse)
+      return htmlResponse;
+  }
+  return null;
+};
 var renderReactNotFound = async (conventionPath) => {
   const { createElement } = await import("react");
   const { renderToReadableStream } = await import("react-dom/server");
   const mod = await import(conventionPath);
-  const [nfKey] = Object.keys(mod);
-  const NotFoundComponent = mod.default ?? (nfKey ? mod[nfKey] : undefined);
+  const NotFoundComponent = mod.default;
+  if (typeof NotFoundComponent !== "function")
+    return null;
   const element = createElement(NotFoundComponent);
   const stream = await renderToReadableStream(element);
   return new Response(stream, {
@@ -5108,6 +5244,8 @@ var renderSvelteNotFound = async (conventionPath) => {
   const { render } = await import("svelte/server");
   const mod = await import(conventionPath);
   const NotFoundComponent = mod.default;
+  if (!NotFoundComponent)
+    return null;
   const { head, body } = render(NotFoundComponent);
   const html = `<!DOCTYPE html><html><head>${head}</head><body>${body}</body></html>`;
   return new Response(html, {
@@ -5120,6 +5258,8 @@ var renderVueNotFound = async (conventionPath) => {
   const { renderToString } = await import("vue/server-renderer");
   const mod = await import(conventionPath);
   const NotFoundComponent = mod.default;
+  if (!NotFoundComponent)
+    return null;
   const app = createSSRApp({
     render: () => h(NotFoundComponent)
   });
@@ -5133,10 +5273,17 @@ var renderVueNotFound = async (conventionPath) => {
 };
 var renderAngularNotFound = async (conventionPath) => {
   const mod = await import(conventionPath);
-  const renderNotFound = mod.default ?? mod.renderNotFound;
-  if (typeof renderNotFound !== "function")
+  const renderFn = mod.default;
+  if (typeof renderFn !== "function")
     return null;
-  const html = renderNotFound();
+  const html = renderFn();
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" },
+    status: 404
+  });
+};
+var renderHtmlNotFound = async (conventionPath) => {
+  const html = await Bun.file(conventionPath).text();
   return new Response(html, {
     headers: { "Content-Type": "text/html" },
     status: 404
@@ -5145,6 +5292,7 @@ var renderAngularNotFound = async (conventionPath) => {
 var NOT_FOUND_RENDERERS = {
   angular: renderAngularNotFound,
   ember: renderEmberNotFound,
+  html: renderHtmlNotFound,
   react: renderReactNotFound,
   svelte: renderSvelteNotFound,
   vue: renderVueNotFound
@@ -5167,7 +5315,8 @@ var NOT_FOUND_PRIORITY = [
   "react",
   "svelte",
   "vue",
-  "angular"
+  "angular",
+  "html"
 ];
 var renderFirstNotFound = async () => {
   const renderNext = async (frameworks) => {
@@ -5352,7 +5501,7 @@ var lowerAngularServerIslands = async (html) => {
 init_devRouteRegistrationCallsite();
 
 // src/angular/ssrSanitizer.ts
-var escapeHtml = (str) => String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var escapeHtml2 = (str) => String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 var bypassValue = (value) => ({
   changingThisBreaksApplicationSecurity: value
 });
@@ -5378,7 +5527,7 @@ var getSsrSanitizer = (deps) => {
         if (isTrustedHtml) {
           return strValue;
         }
-        return escapeHtml(strValue);
+        return escapeHtml2(strValue);
       }
       return strValue;
     }
@@ -5543,23 +5692,23 @@ var ensureAngularCompiler = () => {
   return compilerImportPromise;
 };
 var readAngularPageModule = (value) => isRecord5(value) ? value : null;
-var resolveAngularSsrOutDir = () => process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR ?? join7(tmpdir(), "absolutejs", "generated", "angular-ssr");
+var resolveAngularSsrOutDir = () => process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR ?? join8(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 = resolve6(dirname4(dirname4(outDir)));
-  const nodeModulesLink = join7(outRoot, "node_modules");
+  const outRoot = resolve7(dirname5(dirname5(outDir)));
+  const nodeModulesLink = join8(outRoot, "node_modules");
   if (process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR) {
     return;
   }
-  if (nodeModulesLink === resolve6(process.cwd(), "node_modules")) {
+  if (nodeModulesLink === resolve7(process.cwd(), "node_modules")) {
     return;
   }
   if (await Bun.file(nodeModulesLink).exists()) {
     return;
   }
-  await mkdir2(outRoot, { recursive: true });
+  await mkdir3(outRoot, { recursive: true });
   try {
-    await symlink(resolve6(process.cwd(), "node_modules"), nodeModulesLink, "dir");
+    await symlink(resolve7(process.cwd(), "node_modules"), nodeModulesLink, "dir");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") {
       throw error;
@@ -5717,5 +5866,5 @@ export {
   ABSOLUTE_HTTP_TRANSFER_CACHE_SKIP_HEADER
 };
 
-//# debugId=3FD817D68DD9BDA264756E2164756E21
+//# debugId=73CF4660FF2BF51464756E2164756E21
 //# sourceMappingURL=server.js.map